src/ceph/src/test/rbd_mirror/test_fixture.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "cls/rbd/cls_rbd_types.h"
   5 #include "test/rbd_mirror/test_fixture.h"
   6 #include "include/stringify.h"
   7 #include "include/rbd/librbd.hpp"
   8 #include "librbd/ImageCtx.h"
   9 #include "librbd/ImageState.h"
  10 #include "librbd/Operations.h"
  11 #include "test/librados/test.h"
  12 #include "tools/rbd_mirror/Threads.h"
  13
  14 namespace rbd {
  15 namespace mirror {
  16
  17 std::string TestFixture::_local_pool_name;
  18 std::string TestFixture::_remote_pool_name;
  19 std::shared_ptr<librados::Rados> TestFixture::_rados;
  20 uint64_t TestFixture::_image_number = 0;
  21 std::string TestFixture::_data_pool;
  22
  23 TestFixture::TestFixture() {
  24 }
  25
  26 void TestFixture::SetUpTestCase() {
  27   _rados = std::shared_ptr<librados::Rados>(new librados::Rados());
  28   ASSERT_EQ("", connect_cluster_pp(*_rados.get()));
  29   ASSERT_EQ(0, _rados->conf_set("rbd_cache", "false"));
  30
  31   _local_pool_name = get_temp_pool_name("test-rbd-mirror-");
  32   ASSERT_EQ(0, _rados->pool_create(_local_pool_name.c_str()));
  33
  34   librados::IoCtx local_ioctx;
  35   ASSERT_EQ(0, _rados->ioctx_create(_local_pool_name.c_str(), local_ioctx));
  36   local_ioctx.application_enable("rbd", true);
  37
  38   _remote_pool_name = get_temp_pool_name("test-rbd-mirror-");
  39   ASSERT_EQ(0, _rados->pool_create(_remote_pool_name.c_str()));
  40
  41   librados::IoCtx remote_ioctx;
  42   ASSERT_EQ(0, _rados->ioctx_create(_remote_pool_name.c_str(), remote_ioctx));
  43   remote_ioctx.application_enable("rbd", true);
  44
  45   ASSERT_EQ(0, create_image_data_pool(_data_pool));
  46   if (!_data_pool.empty()) {
  47     printf("using image data pool: %s\n", _data_pool.c_str());
  48   }
  49 }
  50
  51 void TestFixture::TearDownTestCase() {
  52   if (!_data_pool.empty()) {
  53     ASSERT_EQ(0, _rados->pool_delete(_data_pool.c_str()));
  54   }
  55
  56   ASSERT_EQ(0, _rados->pool_delete(_remote_pool_name.c_str()));
  57   ASSERT_EQ(0, _rados->pool_delete(_local_pool_name.c_str()));
  58   _rados->shutdown();
  59 }
  60
  61 void TestFixture::SetUp() {
  62   static bool seeded = false;
  63   if (!seeded) {
  64     seeded = true;
  65     int seed = getpid();
  66     cout << "seed " << seed << std::endl;
  67     srand(seed);
  68   }
  69
  70   ASSERT_EQ(0, _rados->ioctx_create(_local_pool_name.c_str(), m_local_io_ctx));
  71   ASSERT_EQ(0, _rados->ioctx_create(_remote_pool_name.c_str(), m_remote_io_ctx));
  72   m_image_name = get_temp_image_name();
  73
  74   m_threads = new rbd::mirror::Threads<>(reinterpret_cast<CephContext*>(
  75     m_local_io_ctx.cct()));
  76 }
  77
  78 void TestFixture::TearDown() {
  79   for (auto image_ctx : m_image_ctxs) {
  80     image_ctx->state->close();
  81   }
  82
  83   m_remote_io_ctx.close();
  84   m_local_io_ctx.close();
  85
  86   delete m_threads;
  87 }
  88
  89 int TestFixture::create_image(librbd::RBD &rbd, librados::IoCtx &ioctx,
  90                               const std::string &name, uint64_t size) {
  91   int order = 18;
  92   return rbd.create2(ioctx, name.c_str(), size, RBD_FEATURES_ALL, &order);
  93 }
  94
  95 int TestFixture::open_image(librados::IoCtx &io_ctx,
  96                             const std::string &image_name,
  97                             librbd::ImageCtx **image_ctx) {
  98   *image_ctx = new librbd::ImageCtx(image_name.c_str(), "", NULL, io_ctx,
  99                                     false);
 100   m_image_ctxs.insert(*image_ctx);
 101   return (*image_ctx)->state->open(false);
 102 }
 103
 104 int TestFixture::create_snap(librbd::ImageCtx *image_ctx, const char* snap_name,
 105                              librados::snap_t *snap_id) {
 106   int r = image_ctx->operations->snap_create(cls::rbd::UserSnapshotNamespace(),
 107                                              snap_name);
 108   if (r < 0) {
 109     return r;
 110   }
 111
 112   r = image_ctx->state->refresh();
 113   if (r < 0) {
 114     return r;
 115   }
 116
 117   if (image_ctx->snap_ids.count({cls::rbd::UserSnapshotNamespace(),
 118                                  snap_name}) == 0) {
 119     return -ENOENT;
 120   }
 121
 122   if (snap_id != nullptr) {
 123     *snap_id = image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(),
 124                                     snap_name}];
 125   }
 126   return 0;
 127 }
 128
 129 std::string TestFixture::get_temp_image_name() {
 130   ++_image_number;
 131   return "image" + stringify(_image_number);
 132 }
 133
 134 int TestFixture::create_image_data_pool(std::string &data_pool) {
 135   std::string pool;
 136   int r = _rados->conf_get("rbd_default_data_pool", pool);
 137   if (r != 0) {
 138     return r;
 139   } else if (pool.empty()) {
 140     return 0;
 141   }
 142
 143   r = _rados->pool_create(pool.c_str());
 144   if (r < 0) {
 145     return r;
 146   }
 147
 148   librados::IoCtx data_ioctx;
 149   r = _rados->ioctx_create(pool.c_str(), data_ioctx);
 150   if (r < 0) {
 151     return r;
 152   }
 153
 154   data_ioctx.application_enable("rbd", true);
 155   data_pool = pool;
 156   return 0;
 157 }
 158
 159 } // namespace mirror
 160 } // namespace rbd