ceph/src/test/librgw_file_aw.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 #include <vector>
  19 #include <map>
  20 #include <random>
  21 #include "xxhash.h"
  22
  23 #include "include/rados/librgw.h"
  24 #include "include/rados/rgw_file.h"
  25
  26 #include "gtest/gtest.h"
  27 #include "common/ceph_argparse.h"
  28 #include "common/debug.h"
  29
  30 #define dout_context g_ceph_context
  31 #define dout_subsys ceph_subsys_rgw
  32
  33 namespace {
  34   librgw_t rgw = nullptr;
  35   string userid("testuser");
  36   string access_key("");
  37   string secret_key("");
  38   struct rgw_fs *fs = nullptr;
  39
  40   uint32_t owner_uid = 867;
  41   uint32_t owner_gid = 5309;
  42   uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
  43
  44   bool do_create = false;
  45   bool do_delete = false;
  46   bool do_large = false;
  47   bool do_verify = false;
  48   bool do_hexdump = false;
  49
  50   string bucket_name = "sorrydave";
  51   string object_name = "jocaml";
  52
  53   struct rgw_file_handle *bucket_fh = nullptr;
  54   struct rgw_file_handle *object_fh = nullptr;
  55
  56   typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
  57   std::vector<fid_type> fids;
  58
  59   std::uniform_int_distribution<uint8_t> uint_dist;
  60   std::mt19937 rng;
  61
  62   constexpr int iovcnt = 4;
  63   constexpr int page_size = /* 65536 */ 4 * 1024*1024;
  64   constexpr int seed = 8675309;
  65
  66   struct ZPage
  67   {
  68     char data[page_size];
  69     uint64_t cksum;
  70   }; /* ZPage */
  71
  72   struct ZPageSet
  73   {
  74     std::vector<ZPage*> pages;
  75     struct iovec* iovs;
  76
  77     explicit ZPageSet(int n) {
  78       pages.reserve(n);
  79       iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
  80       for (int page_ix = 0; page_ix < n; ++page_ix) {
  81         ZPage* p = new ZPage();
  82         for (int data_ix = 0; data_ix < page_size; ++data_ix) {
  83           p->data[data_ix] = uint_dist(rng);
  84         } // data_ix
  85         p->cksum = XXH64(p->data, page_size, seed);
  86         pages.emplace_back(p);
  87         // and iovs
  88         struct iovec* iov = &iovs[page_ix];
  89         iov->iov_base = p->data;
  90         iov->iov_len = page_size;
  91       } // page_ix
  92     }
  93
  94     int size() { return pages.size(); }
  95
  96     struct iovec* get_iovs() { return iovs; }
  97
  98     bool operator==(const ZPageSet& rhs) {
  99       int n = size();
 100       for (int page_ix = 0; page_ix < n; ++page_ix) {
 101         ZPage* p1 = pages[page_ix];
 102         ZPage* p2 = rhs.pages[page_ix];
 103         if (p1->cksum != p2->cksum)
 104           return false;
 105       }
 106       return true;
 107     }
 108
 109     bool operator==(const rgw_uio* uio) {
 110       uint64_t cksum;
 111       int vix = 0, off = 0;
 112       rgw_vio* vio = &uio->uio_vio[vix];
 113       int vio_len = vio->vio_len;
 114       char *data;
 115
 116       for (int ix = 0; ix < iovcnt; ++ix) {
 117         ZPage* p1 = pages[ix];
 118         data = static_cast<char*>(vio->vio_base) + off;
 119         cksum = XXH64(data, page_size, seed);
 120
 121         if (p1->cksum != cksum) {
 122           int r = memcmp(data, p1->data, page_size);
 123           std::cout << "problem at ix " << ix << " r " << r<< std::endl;
 124           return false;
 125         }
 126
 127         off += page_size;
 128         if (off >= vio_len) {
 129           vio = &uio->uio_vio[++vix];
 130           vio_len = vio->vio_len;
 131           off = 0;
 132         }
 133       }
 134       return true;
 135     }
 136
 137     void cksum() {
 138       int n = size();
 139       for (int page_ix = 0; page_ix < n; ++page_ix) {
 140         ZPage* p = pages[page_ix];
 141         p->cksum = XXH64(p->data, page_size, seed);
 142       }
 143     }
 144
 145     void reset_iovs() { // VOP_READ and VOP_WRITE update
 146       int n = size();
 147       for (int page_ix = 0; page_ix < n; ++page_ix) {
 148         ZPage* p = pages[page_ix];
 149         struct iovec* iov = &iovs[page_ix];
 150         iov->iov_base = p->data;
 151         iov->iov_len = page_size;
 152       }
 153     }
 154
 155     ~ZPageSet() {
 156       for (unsigned int ix = 0; ix < pages.size(); ++ix)
 157         delete pages[ix];
 158       free(iovs);
 159     }
 160   }; /* ZPageSet */
 161
 162   ZPageSet zp_set1{iovcnt}; // random data
 163   ZPageSet zp_set2{iovcnt}; // random data in 64K pages
 164
 165   struct {
 166     int argc;
 167     char **argv;
 168   } saved_args;
 169 }
 170
 171 TEST(LibRGW, INIT) {
 172   int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
 173   ASSERT_EQ(ret, 0);
 174   ASSERT_NE(rgw, nullptr);
 175 }
 176
 177 TEST(LibRGW, MOUNT) {
 178   int ret = rgw_mount2(rgw, userid.c_str(), access_key.c_str(),
 179                        secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
 180   ASSERT_EQ(ret, 0);
 181   ASSERT_NE(fs, nullptr);
 182 }
 183
 184 TEST(LibRGW, CREATE_BUCKET) {
 185   if (do_create) {
 186     struct stat st;
 187     struct rgw_file_handle *fh;
 188
 189     st.st_uid = owner_uid;
 190     st.st_gid = owner_gid;
 191     st.st_mode = 755;
 192
 193     int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
 194                         &fh, RGW_MKDIR_FLAG_NONE);
 195     ASSERT_EQ(ret, 0);
 196   }
 197 }
 198
 199 TEST(LibRGW, LOOKUP_BUCKET) {
 200   int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
 201                        nullptr, 0, RGW_LOOKUP_FLAG_NONE);
 202   ASSERT_EQ(ret, 0);
 203 }
 204
 205 TEST(LibRGW, LOOKUP_OBJECT) {
 206   int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
 207                        nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
 208   ASSERT_EQ(ret, 0);
 209 }
 210
 211 #if 0
 212 TEST(LibRGW, OPEN1) {
 213   int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
 214   ASSERT_EQ(ret, 0);
 215 }
 216
 217 TEST(LibRGW, PUT_OBJECT) {
 218   size_t nbytes;
 219   struct iovec *iovs = zp_set1.get_iovs();
 220   off_t offset = 0;
 221   for (int ix : {0, 1}) {
 222     struct iovec *iov = &iovs[ix];
 223     // quick check
 224     sprintf(static_cast<char*>(iov->iov_base), "::hi mom (%d)", ix);
 225     iov->iov_len = 14;
 226     int ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
 227                         iov->iov_base, RGW_WRITE_FLAG_NONE);
 228     offset += iov->iov_len;
 229     ASSERT_EQ(ret, 0);
 230     ASSERT_EQ(nbytes, iov->iov_len);
 231   }
 232 }
 233
 234 TEST(LibRGW, CLOSE1) {
 235   int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
 236   ASSERT_EQ(ret, 0);
 237 }
 238
 239 TEST(LibRGW, OPEN2) {
 240   int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
 241   ASSERT_EQ(ret, 0);
 242 }
 243
 244 TEST(LibRGW, GET_OBJECT) {
 245   size_t nread;
 246   off_t offset = 0;
 247   struct iovec *iovs = zp_set1.get_iovs();
 248   for (int ix : {2 , 3}) {
 249     struct iovec *iov = &iovs[ix];
 250     int ret = rgw_read(fs, object_fh, offset, iovs[ix-2].iov_len, &nread,
 251                        iov->iov_base, RGW_READ_FLAG_NONE);
 252     iov->iov_len = nread;
 253     offset += iov->iov_len;
 254     ASSERT_EQ(ret, 0);
 255     ASSERT_EQ(nread, iovs[ix-2].iov_len);
 256     std::cout << "read: " << static_cast<char*>(iov->iov_base) << std::endl;
 257   }
 258 }
 259
 260 TEST(LibRGW, CLOSE2) {
 261   int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
 262   ASSERT_EQ(ret, 0);
 263 }
 264 #endif
 265
 266 TEST (LibRGW, LARGE1) {
 267   if (do_large) {
 268     int ret;
 269
 270     ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
 271     ASSERT_EQ(ret, 0);
 272
 273     size_t nbytes;
 274     struct iovec *iovs = zp_set1.get_iovs();
 275     off_t offset = 0;
 276
 277     for (int ix = 0; ix < iovcnt; ++ix) {
 278       struct iovec *iov = &iovs[ix];
 279       // write iov->iov_len
 280       ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
 281                       iov->iov_base, RGW_WRITE_FLAG_NONE);
 282       offset += iov->iov_len;
 283       ASSERT_EQ(ret, 0);
 284       ASSERT_EQ(nbytes, iov->iov_len);
 285     }
 286
 287     ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
 288     ASSERT_EQ(ret, 0);
 289   } /* do_large */
 290 }
 291
 292 TEST (LibRGW, LARGE2) {
 293   if (do_large) {
 294     int ret;
 295     if (do_verify) {
 296       ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
 297       ASSERT_EQ(ret, 0);
 298
 299       size_t nread;
 300       off_t offset2 = 0;
 301       struct iovec *iovs2 = zp_set2.get_iovs();
 302       for (int ix = 0; ix < iovcnt; ++ix) {
 303         struct iovec *iov2 = &iovs2[ix];
 304         ret = rgw_read(fs, object_fh, offset2, iov2->iov_len, &nread,
 305                        iov2->iov_base, RGW_READ_FLAG_NONE);
 306         iov2->iov_len = nread;
 307         offset2 += iov2->iov_len;
 308         ASSERT_EQ(ret, 0);
 309       }
 310       zp_set1.cksum();
 311       zp_set2.cksum();
 312       ASSERT_TRUE(zp_set1 == zp_set2);
 313
 314       ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
 315       ASSERT_EQ(ret, 0);
 316     }
 317   } /* do_large */
 318 }
 319
 320 TEST(LibRGW, STAT_OBJECT) {
 321   struct stat st;
 322   int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
 323   ASSERT_EQ(ret, 0);
 324   dout(15) << "rgw_getattr on " << object_name << " size = "
 325            << st.st_size << dendl;
 326 }
 327
 328 TEST(LibRGW, DELETE_OBJECT) {
 329   if (do_delete) {
 330     int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
 331                          RGW_UNLINK_FLAG_NONE);
 332     ASSERT_EQ(ret, 0);
 333   }
 334 }
 335
 336 TEST(LibRGW, DELETE_BUCKET) {
 337   if (do_delete) {
 338     int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
 339                          RGW_UNLINK_FLAG_NONE);
 340     ASSERT_EQ(ret, 0);
 341   }
 342 }
 343
 344 TEST(LibRGW, CLEANUP) {
 345   int ret;
 346   if (object_fh) {
 347     ret = rgw_fh_rele(fs, object_fh, RGW_FH_RELE_FLAG_NONE);
 348     ASSERT_EQ(ret, 0);
 349   }
 350   ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
 351   ASSERT_EQ(ret, 0);
 352 }
 353
 354 TEST(LibRGW, UMOUNT) {
 355   if (! fs)
 356     return;
 357
 358   int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
 359   ASSERT_EQ(ret, 0);
 360 }
 361
 362 TEST(LibRGW, SHUTDOWN) {
 363   librgw_shutdown(rgw);
 364 }
 365
 366 int main(int argc, char *argv[])
 367 {
 368   char *v{nullptr};
 369   string val;
 370   vector<const char*> args;
 371
 372   argv_to_vec(argc, const_cast<const char**>(argv), args);
 373   env_to_vec(args);
 374
 375   v = getenv("AWS_ACCESS_KEY_ID");
 376   if (v) {
 377     access_key = v;
 378   }
 379
 380   v = getenv("AWS_SECRET_ACCESS_KEY");
 381   if (v) {
 382     secret_key = v;
 383   }
 384
 385   for (auto arg_iter = args.begin(); arg_iter != args.end();) {
 386     if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
 387                               (char*) nullptr)) {
 388       access_key = val;
 389     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
 390                                      (char*) nullptr)) {
 391       secret_key = val;
 392     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
 393                                      (char*) nullptr)) {
 394       userid = val;
 395     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
 396                                      (char*) nullptr)) {
 397       bucket_name = val;
 398     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
 399                                      (char*) nullptr)) {
 400       owner_uid = std::stoi(val);
 401     } else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
 402                                      (char*) nullptr)) {
 403       owner_gid = std::stoi(val);
 404     } else if (ceph_argparse_flag(args, arg_iter, "--verify",
 405                                             (char*) nullptr)) {
 406       do_verify = true;
 407     } else if (ceph_argparse_flag(args, arg_iter, "--create",
 408                                             (char*) nullptr)) {
 409       do_create = true;
 410     } else if (ceph_argparse_flag(args, arg_iter, "--delete",
 411                                             (char*) nullptr)) {
 412       do_delete = true;
 413     } else if (ceph_argparse_flag(args, arg_iter, "--large",
 414                                             (char*) nullptr)) {
 415       do_large = true;
 416     } else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
 417                                             (char*) nullptr)) {
 418       do_hexdump = true;
 419     } else {
 420       ++arg_iter;
 421     }
 422   }
 423
 424   /* don't accidentally run as anonymous */
 425   if ((access_key == "") ||
 426       (secret_key == "")) {
 427     std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
 428     return EPERM;
 429   }
 430
 431   saved_args.argc = argc;
 432   saved_args.argv = argv;
 433
 434   ::testing::InitGoogleTest(&argc, argv);
 435   return RUN_ALL_TESTS();
 436 }