ceph/src/test/librgw_file_cd.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 userid("testuser");
  32   string access_key("");
  33   string secret_key("");
  34   struct rgw_fs *fs = nullptr;
  35
  36   uint32_t owner_uid = 867;
  37   uint32_t owner_gid = 5309;
  38   uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
  39
  40   bool do_create = false;
  41   bool do_delete = false;
  42   bool do_multi = false;
  43   int multi_cnt = 10;
  44
  45   string bucket_name = "sorry_dave";
  46
  47   struct {
  48     int argc;
  49     char **argv;
  50   } saved_args;
  51 }
  52
  53 TEST(LibRGW, INIT) {
  54   int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
  55   ASSERT_EQ(ret, 0);
  56   ASSERT_NE(rgw, nullptr);
  57 }
  58
  59 TEST(LibRGW, MOUNT) {
  60   int ret = rgw_mount2(rgw, userid.c_str(), access_key.c_str(),
  61                        secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
  62   ASSERT_EQ(ret, 0);
  63   ASSERT_NE(fs, nullptr);
  64 }
  65
  66 TEST(LibRGW, CREATE_BUCKET) {
  67   if (do_create) {
  68     struct stat st;
  69     struct rgw_file_handle *fh;
  70
  71     st.st_uid = owner_uid;
  72     st.st_gid = owner_gid;
  73     st.st_mode = 755;
  74
  75     int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
  76                         &fh, RGW_MKDIR_FLAG_NONE);
  77     ASSERT_EQ(ret, 0);
  78   }
  79 }
  80
  81 TEST(LibRGW, DELETE_BUCKET) {
  82   if (do_delete) {
  83     int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
  84                          RGW_UNLINK_FLAG_NONE);
  85     ASSERT_EQ(ret, 0);
  86   }
  87 }
  88
  89 TEST(LibRGW, CREATE_BUCKET_MULTI) {
  90   if (do_multi) {
  91     int ret;
  92     struct stat st;
  93     struct rgw_file_handle *fh;
  94
  95     st.st_uid = owner_uid;
  96     st.st_gid = owner_gid;
  97     st.st_mode = 755;
  98
  99     for (int ix = 0; ix < multi_cnt; ++ix) {
 100       string bn = bucket_name;
 101       bn += to_string(ix);
 102       ret = rgw_mkdir(fs, fs->root_fh, bn.c_str(), &st, create_mask, &fh,
 103                       RGW_MKDIR_FLAG_NONE);
 104       ASSERT_EQ(ret, 0);
 105       std::cout << "created: " << bn << std::endl;
 106     }
 107   }
 108 }
 109
 110 TEST(LibRGW, DELETE_BUCKET_MULTI) {
 111   if (do_multi) {
 112     for (int ix = 0; ix < multi_cnt; ++ix) {
 113       string bn = bucket_name;
 114       bn += to_string(ix);
 115       int ret = rgw_unlink(fs, fs->root_fh, bn.c_str(),
 116                            RGW_UNLINK_FLAG_NONE);
 117       ASSERT_EQ(ret, 0);
 118     }
 119   }
 120 }
 121
 122 TEST(LibRGW, CLEANUP) {
 123   // do nothing
 124 }
 125
 126 TEST(LibRGW, UMOUNT) {
 127   if (! fs)
 128     return;
 129
 130   int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
 131   ASSERT_EQ(ret, 0);
 132 }
 133
 134 TEST(LibRGW, SHUTDOWN) {
 135   librgw_shutdown(rgw);
 136 }
 137
 138 int main(int argc, char *argv[])
 139 {
 140   char *v{nullptr};
 141   string val;
 142   vector<const char*> args;
 143
 144   argv_to_vec(argc, const_cast<const char**>(argv), args);
 145   env_to_vec(args);
 146
 147   v = getenv("AWS_ACCESS_KEY_ID");
 148   if (v) {
 149     access_key = v;
 150   }
 151
 152   v = getenv("AWS_SECRET_ACCESS_KEY");
 153   if (v) {
 154     secret_key = v;
 155   }
 156
 157   for (auto arg_iter = args.begin(); arg_iter != args.end();) {
 158     if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
 159                               (char*) nullptr)) {
 160       access_key = val;
 161     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
 162                                      (char*) nullptr)) {
 163       secret_key = val;
 164     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
 165                                      (char*) nullptr)) {
 166       userid = val;
 167     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
 168                                      (char*) nullptr)) {
 169       bucket_name = val;
 170     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
 171                                      (char*) nullptr)) {
 172       owner_uid = std::stoi(val);
 173     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
 174                                      (char*) nullptr)) {
 175       owner_gid = std::stoi(val);
 176     } else if (ceph_argparse_flag(args, arg_iter, "--create",
 177                                             (char*) nullptr)) {
 178       do_create = true;
 179     } else if (ceph_argparse_flag(args, arg_iter, "--delete",
 180                                             (char*) nullptr)) {
 181       do_delete = true;
 182     } else if (ceph_argparse_flag(args, arg_iter, "--multi",
 183                                             (char*) nullptr)) {
 184       do_multi = true;
 185     } else {
 186       ++arg_iter;
 187     }
 188   }
 189
 190   /* dont accidentally run as anonymous */
 191   if ((access_key == "") ||
 192       (secret_key == "")) {
 193     std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
 194     return EPERM;
 195   }
 196
 197   saved_args.argc = argc;
 198   saved_args.argv = argv;
 199
 200   ::testing::InitGoogleTest(&argc, argv);
 201   return RUN_ALL_TESTS();
 202 }