ceph/src/test/librgw_file.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2015 Red Hat, Inc.
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #include <stdint.h>
  16 #include <tuple>
  17 #include <iostream>
  18
  19 #include "include/rados/librgw.h"
  20 #include "include/rados/rgw_file.h"
  21
  22 #include "gtest/gtest.h"
  23 #include "common/ceph_argparse.h"
  24 #include "common/debug.h"
  25 #include "global/global_init.h"
  26
  27 #define dout_subsys ceph_subsys_rgw
  28
  29 using namespace std;
  30
  31 namespace {
  32   librgw_t rgw = nullptr;
  33   string uid("testuser");
  34   string access_key("");
  35   string secret_key("");
  36   struct rgw_fs *fs = nullptr;
  37   typedef std::tuple<string, uint64_t, struct rgw_file_handle*> fid_type; //in c++2014 can alias...
  38   typedef std::tuple<fid_type, std::vector<fid_type>> bucket_type;
  39
  40   std::vector<fid_type> fids1;
  41   std::vector<bucket_type> bucket_matrix;
  42
  43   bool do_getattr = false;
  44
  45   struct {
  46     int argc;
  47     char **argv;
  48   } saved_args;
  49 }
  50
  51 TEST(LibRGW, INIT) {
  52   int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
  53   ASSERT_EQ(ret, 0);
  54   ASSERT_NE(rgw, nullptr);
  55 }
  56
  57 TEST(LibRGW, MOUNT) {
  58   int ret = rgw_mount2(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
  59                        "/", &fs, RGW_MOUNT_FLAG_NONE);
  60   ASSERT_EQ(ret, 0);
  61   ASSERT_NE(fs, nullptr);
  62 }
  63
  64 TEST(LibRGW, GETATTR_ROOT) {
  65   if (do_getattr) {
  66     if (! fs)
  67       return;
  68
  69     struct stat st;
  70     int ret = rgw_getattr(fs, fs->root_fh, &st, RGW_GETATTR_FLAG_NONE);
  71     ASSERT_EQ(ret, 0);
  72   }
  73 }
  74
  75 extern "C" {
  76   static bool r1_cb(const char* name, void *arg, uint64_t offset,
  77                     struct stat* st, uint32_t st_mask,
  78                     uint32_t flags) {
  79     // don't need arg--it would point to fids1
  80     fids1.push_back(fid_type(name, offset, nullptr /* handle */));
  81     return true; /* XXX ? */
  82   }
  83 }
  84
  85 TEST(LibRGW, LIST_BUCKETS) {
  86   /* list buckets via readdir in fs root */
  87   using std::get;
  88
  89   if (! fs)
  90     return;
  91
  92   bool eof = false;
  93   uint64_t offset = 0;
  94   int ret = rgw_readdir(fs, fs->root_fh, &offset, r1_cb, &fids1, &eof,
  95                         RGW_READDIR_FLAG_NONE);
  96   for (auto& fid : fids1) {
  97     std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
  98               << std::endl;
  99     /* push row for bucket into bucket_matrix */
 100     bucket_matrix.push_back(bucket_type(fid, std::vector<fid_type>()));
 101   }
 102   ASSERT_EQ(ret, 0);
 103 }
 104
 105 TEST(LibRGW, LOOKUP_BUCKETS) {
 106   using std::get;
 107
 108   if (! fs)
 109     return;
 110
 111   for (auto& fid_row : bucket_matrix) {
 112     auto& fid = get<0>(fid_row);
 113     // auto& obj_vector = get<1>(fid_row);
 114     struct rgw_file_handle *rgw_fh = nullptr;
 115     ASSERT_EQ(0, rgw_lookup(fs, fs->root_fh, get<0>(fid).c_str(), &rgw_fh,
 116                             nullptr /* stat */, 0 /* mask */, 0 /* flags */));
 117     get<2>(fid) = rgw_fh;
 118     ASSERT_NE(get<2>(fid), nullptr);
 119   }
 120 }
 121
 122 TEST(LibRGW, GETATTR_BUCKETS) {
 123   if (do_getattr) {
 124     using std::get;
 125
 126     if (! fs)
 127       return;
 128
 129     struct stat st;
 130
 131     for (auto& fid_row : bucket_matrix) {
 132       auto& fid = get<0>(fid_row);
 133       struct rgw_file_handle *rgw_fh = get<2>(fid);
 134       ASSERT_EQ(0, rgw_getattr(fs, rgw_fh, &st, RGW_GETATTR_FLAG_NONE));
 135     }
 136   }
 137 }
 138
 139 extern "C" {
 140   static bool r2_cb(const char* name, void *arg, uint64_t offset,
 141                     struct stat* st, uint32_t st_mask,
 142                     uint32_t flags) {
 143     std::vector<fid_type>& obj_vector = *(static_cast<std::vector<fid_type>*>(arg));
 144     obj_vector.push_back(fid_type(name, offset, nullptr));
 145     return true; /* XXX ? */
 146   }
 147 }
 148
 149 TEST(LibRGW, LIST_OBJECTS) {
 150   /* list objects via readdir, bucketwise */
 151   using std::get;
 152
 153   if (! fs)
 154     return;
 155
 156   for (auto& fid_row : bucket_matrix) {
 157     auto& fid = get<0>(fid_row); // bucket
 158     std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
 159     struct rgw_file_handle *bucket_fh = get<2>(fid);
 160
 161     ldout(g_ceph_context, 0) << __func__ << " readdir on bucket " << get<0>(fid)
 162                              << dendl;
 163
 164     bool eof = false;
 165     uint64_t offset = 0;
 166     int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &obj_vector, &eof,
 167                           RGW_READDIR_FLAG_NONE);
 168     for (auto& obj : obj_vector) {
 169       std::cout << "fname: " << get<0>(obj) << " fid: " << get<1>(obj)
 170                 << std::endl;
 171     }
 172     ASSERT_EQ(ret, 0);
 173   }
 174 }
 175
 176 extern bool global_stop;
 177
 178 TEST(LibRGW, GETATTR_OBJECTS) {
 179   if (do_getattr) {
 180     using std::get;
 181     struct stat st;
 182     int ret;
 183
 184     global_stop = true;
 185
 186     for (auto& fid_row : bucket_matrix) {
 187       auto& fid = get<0>(fid_row); // bucket
 188       std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
 189       struct rgw_file_handle *bucket_fh = get<2>(fid);
 190
 191       for (auto& obj : obj_vector) {
 192         struct rgw_file_handle *obj_fh = nullptr;
 193         std::string object_name = get<0>(obj);
 194         ret = rgw_lookup(fs, bucket_fh, get<0>(obj).c_str(), &obj_fh,
 195                          nullptr /* stat */, 0 /* mask */, 0 /* flags */);
 196         ASSERT_EQ(ret, 0);
 197         get<2>(obj) = obj_fh; // stash obj_fh for cleanup
 198         ASSERT_NE(get<2>(obj), nullptr);
 199         ret = rgw_getattr(fs, obj_fh, &st,
 200                           RGW_GETATTR_FLAG_NONE); // now, getattr
 201         ASSERT_EQ(ret, 0);
 202       }
 203     }
 204   }
 205 }
 206
 207 TEST(LibRGW, CLEANUP) {
 208   int ret = 0;
 209   using std::get;
 210
 211   /* release file handles */
 212   for (auto& fid_row : bucket_matrix) {
 213     auto& bucket = get<0>(fid_row); // bucket
 214     std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
 215     for (auto& obj : obj_vector) {
 216       struct rgw_file_handle *obj_fh = get<2>(obj);
 217       if (obj_fh) {
 218         ret = rgw_fh_rele(fs, obj_fh, 0 /* flags */);
 219         ASSERT_EQ(ret, 0);
 220       }
 221     }
 222     // now the bucket
 223     struct rgw_file_handle *bucket_fh = get<2>(bucket);
 224     if (bucket_fh) {
 225       ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
 226       ASSERT_EQ(ret, 0);
 227     }
 228   }
 229 }
 230
 231 TEST(LibRGW, UMOUNT) {
 232   if (! fs)
 233     return;
 234
 235   int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
 236   ASSERT_EQ(ret, 0);
 237 }
 238
 239 TEST(LibRGW, SHUTDOWN) {
 240   librgw_shutdown(rgw);
 241 }
 242
 243 int main(int argc, char *argv[])
 244 {
 245   auto args = argv_to_vec(argc, argv);
 246   env_to_vec(args);
 247
 248   char* v = getenv("AWS_ACCESS_KEY_ID");
 249   if (v) {
 250     access_key = v;
 251   }
 252
 253   v = getenv("AWS_SECRET_ACCESS_KEY");
 254   if (v) {
 255     secret_key = v;
 256   }
 257
 258   string val;
 259   for (auto arg_iter = args.begin(); arg_iter != args.end();) {
 260     if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
 261                               (char*) nullptr)) {
 262       access_key = val;
 263     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
 264                                      (char*) nullptr)) {
 265       secret_key = val;
 266     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
 267                                      (char*) nullptr)) {
 268       uid = val;
 269     } else if (ceph_argparse_flag(args, arg_iter, "--getattr",
 270                                             (char*) nullptr)) {
 271       do_getattr = true;
 272     } else {
 273       ++arg_iter;
 274     }
 275   }
 276
 277   /* don't accidentally run as anonymous */
 278   if ((access_key == "") ||
 279       (secret_key == "")) {
 280     std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
 281     return EPERM;
 282   }
 283
 284   saved_args.argc = argc;
 285   saved_args.argv = argv;
 286
 287   ::testing::InitGoogleTest(&argc, argv);
 288   return RUN_ALL_TESTS();
 289 }