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