src/ceph/src/test/journal/RadosTestFixture.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 "test/journal/RadosTestFixture.h"
   5 #include "cls/journal/cls_journal_client.h"
   6 #include "include/stringify.h"
   7 #include "common/WorkQueue.h"
   8 #include "journal/Settings.h"
   9
  10 RadosTestFixture::RadosTestFixture()
  11   : m_timer_lock("m_timer_lock"), m_timer(NULL), m_listener(this) {
  12 }
  13
  14 void RadosTestFixture::SetUpTestCase() {
  15   _pool_name = get_temp_pool_name();
  16   ASSERT_EQ("", create_one_pool_pp(_pool_name, _rados));
  17
  18   CephContext* cct = reinterpret_cast<CephContext*>(_rados.cct());
  19   _thread_pool = new ThreadPool(cct, "RadosTestFixture::_thread_pool",
  20                                  "tp_test", 1);
  21   _thread_pool->start();
  22 }
  23
  24 void RadosTestFixture::TearDownTestCase() {
  25   _thread_pool->stop();
  26   delete _thread_pool;
  27
  28   ASSERT_EQ(0, destroy_one_pool_pp(_pool_name, _rados));
  29 }
  30
  31 std::string RadosTestFixture::get_temp_oid() {
  32   ++_oid_number;
  33   return "oid" + stringify(_oid_number);
  34 }
  35
  36 void RadosTestFixture::SetUp() {
  37   ASSERT_EQ(0, _rados.ioctx_create(_pool_name.c_str(), m_ioctx));
  38
  39   CephContext* cct = reinterpret_cast<CephContext*>(m_ioctx.cct());
  40   m_work_queue = new ContextWQ("RadosTestFixture::m_work_queue", 60,
  41                                _thread_pool);
  42
  43   m_timer = new SafeTimer(cct, m_timer_lock, true);
  44   m_timer->init();
  45 }
  46
  47 void RadosTestFixture::TearDown() {
  48   for (auto metadata : m_metadatas) {
  49     C_SaferCond ctx;
  50     metadata->shut_down(&ctx);
  51     ASSERT_EQ(0, ctx.wait());
  52   }
  53
  54   {
  55     Mutex::Locker locker(m_timer_lock);
  56     m_timer->shutdown();
  57   }
  58   delete m_timer;
  59
  60   m_work_queue->drain();
  61   delete m_work_queue;
  62 }
  63
  64 int RadosTestFixture::create(const std::string &oid, uint8_t order,
  65                              uint8_t splay_width) {
  66   return cls::journal::client::create(m_ioctx, oid, order, splay_width, -1);
  67 }
  68
  69 journal::JournalMetadataPtr RadosTestFixture::create_metadata(
  70     const std::string &oid, const std::string &client_id,
  71     double commit_interval, uint64_t max_fetch_bytes,
  72     int max_concurrent_object_sets) {
  73   journal::Settings settings;
  74   settings.commit_interval = commit_interval;
  75   settings.max_fetch_bytes = max_fetch_bytes;
  76   settings.max_concurrent_object_sets = max_concurrent_object_sets;
  77
  78   journal::JournalMetadataPtr metadata(new journal::JournalMetadata(
  79     m_work_queue, m_timer, &m_timer_lock, m_ioctx, oid, client_id, settings));
  80   m_metadatas.push_back(metadata);
  81   return metadata;
  82 }
  83
  84 int RadosTestFixture::append(const std::string &oid, const bufferlist &bl) {
  85   librados::ObjectWriteOperation op;
  86   op.append(bl);
  87   return m_ioctx.operate(oid, &op);
  88 }
  89
  90 int RadosTestFixture::client_register(const std::string &oid,
  91                                       const std::string &id,
  92                                       const std::string &description) {
  93   bufferlist data;
  94   data.append(description);
  95   return cls::journal::client::client_register(m_ioctx, oid, id, data);
  96 }
  97
  98 int RadosTestFixture::client_commit(const std::string &oid,
  99                                     const std::string &id,
 100                                     const cls::journal::ObjectSetPosition &commit_position) {
 101   librados::ObjectWriteOperation op;
 102   cls::journal::client::client_commit(&op, id, commit_position);
 103   return m_ioctx.operate(oid, &op);
 104 }
 105
 106 bufferlist RadosTestFixture::create_payload(const std::string &payload) {
 107   bufferlist bl;
 108   bl.append(payload);
 109   return bl;
 110 }
 111
 112 int RadosTestFixture::init_metadata(journal::JournalMetadataPtr metadata) {
 113   C_SaferCond cond;
 114   metadata->init(&cond);
 115   return cond.wait();
 116 }
 117
 118 bool RadosTestFixture::wait_for_update(journal::JournalMetadataPtr metadata) {
 119   Mutex::Locker locker(m_listener.mutex);
 120   while (m_listener.updates[metadata.get()] == 0) {
 121     if (m_listener.cond.WaitInterval(
 122           m_listener.mutex, utime_t(10, 0)) != 0) {
 123       return false;
 124     }
 125   }
 126   --m_listener.updates[metadata.get()];
 127   return true;
 128 }
 129
 130 std::string RadosTestFixture::_pool_name;
 131 librados::Rados RadosTestFixture::_rados;
 132 uint64_t RadosTestFixture::_oid_number = 0;
 133 ThreadPool *RadosTestFixture::_thread_pool = nullptr;