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 namespace {
  30   librgw_t rgw = nullptr;
  31   string uid("testuser");
  32   string access_key("");
  33   string secret_key("");
  34   struct rgw_fs *fs = nullptr;
  35   typedef std::tuple<string, uint64_t, struct rgw_file_handle*> fid_type; //in c++2014 can alias...
  36   typedef std::tuple<fid_type, std::vector<fid_type>> bucket_type;
  37
  38   std::vector<fid_type> fids1;
  39   std::vector<bucket_type> bucket_matrix;
  40
  41   bool do_getattr = false;
  42
  43   struct {
  44     int argc;
  45     char **argv;
  46   } saved_args;
  47 }
  48
  49 TEST(LibRGW, INIT) {
  50   int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
  51   ASSERT_EQ(ret, 0);
  52   ASSERT_NE(rgw, nullptr);
  53 }
  54
  55 TEST(LibRGW, MOUNT) {
  56   int ret = rgw_mount(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
  57                       &fs, RGW_MOUNT_FLAG_NONE);
  58   ASSERT_EQ(ret, 0);
  59   ASSERT_NE(fs, nullptr);
  60 }
  61
  62 TEST(LibRGW, GETATTR_ROOT) {
  63   if (do_getattr) {
  64     using std::get;
  65
  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                     uint32_t flags) {
  78     // don't need arg--it would point to fids1
  79     fids1.push_back(fid_type(name, offset, nullptr /* handle */));
  80     return true; /* XXX ? */
  81   }
  82 }
  83
  84 TEST(LibRGW, LIST_BUCKETS) {
  85   /* list buckets via readdir in fs root */
  86   using std::get;
  87
  88   if (! fs)
  89     return;
  90
  91   bool eof = false;
  92   uint64_t offset = 0;
  93   int ret = rgw_readdir(fs, fs->root_fh, &offset, r1_cb, &fids1, &eof,
  94                         RGW_READDIR_FLAG_NONE);
  95   for (auto& fid : fids1) {
  96     std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
  97               << std::endl;
  98     /* push row for bucket into bucket_matrix */
  99     bucket_matrix.push_back(bucket_type(fid, std::vector<fid_type>()));
 100   }
 101   ASSERT_EQ(ret, 0);
 102 }
 103
 104 TEST(LibRGW, LOOKUP_BUCKETS) {
 105   using std::get;
 106
 107   if (! fs)
 108     return;
 109
 110   for (auto& fid_row : bucket_matrix) {
 111     auto& fid = get<0>(fid_row);
 112     // auto& obj_vector = get<1>(fid_row);
 113     struct rgw_file_handle *rgw_fh = nullptr;
 114     ASSERT_EQ(0, rgw_lookup(fs, fs->root_fh, get<0>(fid).c_str(), &rgw_fh,
 115                             0 /* flags */));
 116     get<2>(fid) = rgw_fh;
 117     ASSERT_NE(get<2>(fid), nullptr);
 118   }
 119 }
 120
 121 TEST(LibRGW, GETATTR_BUCKETS) {
 122   if (do_getattr) {
 123     using std::get;
 124
 125     if (! fs)
 126       return;
 127
 128     struct stat st;
 129
 130     for (auto& fid_row : bucket_matrix) {
 131       auto& fid = get<0>(fid_row);
 132       struct rgw_file_handle *rgw_fh = get<2>(fid);
 133       ASSERT_EQ(0, rgw_getattr(fs, rgw_fh, &st, RGW_GETATTR_FLAG_NONE));
 134     }
 135   }
 136 }
 137
 138 extern "C" {
 139   static bool r2_cb(const char* name, void *arg, uint64_t offset,
 140                     uint32_t flags) {
 141     std::vector<fid_type>& obj_vector = *(static_cast<std::vector<fid_type>*>(arg));
 142     obj_vector.push_back(fid_type(name, offset, nullptr));
 143     return true; /* XXX ? */
 144   }
 145 }
 146
 147 TEST(LibRGW, LIST_OBJECTS) {
 148   /* list objects via readdir, bucketwise */
 149   using std::get;
 150
 151   if (! fs)
 152     return;
 153
 154   for (auto& fid_row : bucket_matrix) {
 155     auto& fid = get<0>(fid_row); // bucket
 156     std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
 157     struct rgw_file_handle *bucket_fh = get<2>(fid);
 158
 159     ldout(g_ceph_context, 0) << __func__ << " readdir on bucket " << get<0>(fid)
 160                              << dendl;
 161
 162     bool eof = false;
 163     uint64_t offset = 0;
 164     int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &obj_vector, &eof,
 165                           RGW_READDIR_FLAG_NONE);
 166     for (auto& obj : obj_vector) {
 167       std::cout << "fname: " << get<0>(obj) << " fid: " << get<1>(obj)
 168                 << std::endl;
 169     }
 170     ASSERT_EQ(ret, 0);
 171   }
 172 }
 173
 174 extern bool global_stop;
 175
 176 TEST(LibRGW, GETATTR_OBJECTS) {
 177   if (do_getattr) {
 178     using std::get;
 179     struct stat st;
 180     int ret;
 181
 182     global_stop = true;
 183
 184     for (auto& fid_row : bucket_matrix) {
 185       auto& fid = get<0>(fid_row); // bucket
 186       std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
 187       struct rgw_file_handle *bucket_fh = get<2>(fid);
 188
 189       for (auto& obj : obj_vector) {
 190         struct rgw_file_handle *obj_fh = nullptr;
 191         std::string object_name = get<0>(obj);
 192         ret = rgw_lookup(fs, bucket_fh, get<0>(obj).c_str(), &obj_fh,
 193                         0 /* flags */);
 194         ASSERT_EQ(ret, 0);
 195         get<2>(obj) = obj_fh; // stash obj_fh for cleanup
 196         ASSERT_NE(get<2>(obj), nullptr);
 197         ret = rgw_getattr(fs, obj_fh, &st,
 198                           RGW_GETATTR_FLAG_NONE); // now, getattr
 199         ASSERT_EQ(ret, 0);
 200       }
 201     }
 202   }
 203 }
 204
 205 TEST(LibRGW, CLEANUP) {
 206   int ret = 0;
 207   using std::get;
 208
 209   /* release file handles */
 210   for (auto& fid_row : bucket_matrix) {
 211     auto& bucket = get<0>(fid_row); // bucket
 212     std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
 213     for (auto& obj : obj_vector) {
 214       struct rgw_file_handle *obj_fh = get<2>(obj);
 215       if (obj_fh) {
 216         ret = rgw_fh_rele(fs, obj_fh, 0 /* flags */);
 217         ASSERT_EQ(ret, 0);
 218       }
 219     }
 220     // now the bucket
 221     struct rgw_file_handle *bucket_fh = get<2>(bucket);
 222     if (bucket_fh) {
 223       ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
 224       ASSERT_EQ(ret, 0);
 225     }
 226   }
 227 }
 228
 229 TEST(LibRGW, UMOUNT) {
 230   if (! fs)
 231     return;
 232
 233   int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
 234   ASSERT_EQ(ret, 0);
 235 }
 236
 237 TEST(LibRGW, SHUTDOWN) {
 238   librgw_shutdown(rgw);
 239 }
 240
 241 int main(int argc, char *argv[])
 242 {
 243   char *v{nullptr};
 244   string val;
 245   vector<const char*> args;
 246
 247   argv_to_vec(argc, const_cast<const char**>(argv), args);
 248   env_to_vec(args);
 249
 250   v = getenv("AWS_ACCESS_KEY_ID");
 251   if (v) {
 252     access_key = v;
 253   }
 254
 255   v = getenv("AWS_SECRET_ACCESS_KEY");
 256   if (v) {
 257     secret_key = v;
 258   }
 259
 260   for (auto arg_iter = args.begin(); arg_iter != args.end();) {
 261     if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
 262                               (char*) nullptr)) {
 263       access_key = val;
 264     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
 265                                      (char*) nullptr)) {
 266       secret_key = val;
 267     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
 268                                      (char*) nullptr)) {
 269       uid = val;
 270     } else if (ceph_argparse_flag(args, arg_iter, "--getattr",
 271                                             (char*) nullptr)) {
 272       do_getattr = true;
 273     } else {
 274       ++arg_iter;
 275     }
 276   }
 277
 278   /* dont accidentally run as anonymous */
 279   if ((access_key == "") ||
 280       (secret_key == "")) {
 281     std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
 282     return EPERM;
 283   }
 284
 285   saved_args.argc = argc;
 286   saved_args.argv = argv;
 287
 288   ::testing::InitGoogleTest(&argc, argv);
 289   return RUN_ALL_TESTS();
 290 }