ceph/src/test/journal/test_Journaler.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 "journal/Journaler.h"
   5 #include "journal/Settings.h"
   6 #include "include/stringify.h"
   7 #include "gtest/gtest.h"
   8 #include "test/librados/test.h"
   9 #include "test/journal/RadosTestFixture.h"
  10 #include "include/stringify.h"
  11
  12 class TestJournaler : public RadosTestFixture {
  13 public:
  14
  15   static const std::string CLIENT_ID;
  16
  17   static std::string get_temp_journal_id() {
  18     return stringify(++_journal_id);
  19   }
  20
  21   void SetUp() override {
  22     RadosTestFixture::SetUp();
  23     m_journal_id = get_temp_journal_id();
  24     m_journaler = new journal::Journaler(m_work_queue, m_timer, &m_timer_lock,
  25                                          m_ioctx, m_journal_id, CLIENT_ID, {});
  26   }
  27
  28   void TearDown() override {
  29     delete m_journaler;
  30     RadosTestFixture::TearDown();
  31   }
  32
  33   int create_journal(uint8_t order, uint8_t splay_width) {
  34     C_SaferCond cond;
  35     m_journaler->create(order, splay_width, -1, &cond);
  36     return cond.wait();
  37   }
  38
  39   int init_journaler() {
  40     C_SaferCond cond;
  41     m_journaler->init(&cond);
  42     return cond.wait();
  43   }
  44
  45   int shut_down_journaler() {
  46     C_SaferCond ctx;
  47     m_journaler->shut_down(&ctx);
  48     return ctx.wait();
  49   }
  50
  51   int register_client(const std::string &client_id, const std::string &desc) {
  52     journal::Journaler journaler(m_work_queue, m_timer, &m_timer_lock,
  53                                  m_ioctx, m_journal_id, client_id, {});
  54     bufferlist data;
  55     data.append(desc);
  56     C_SaferCond cond;
  57     journaler.register_client(data, &cond);
  58     return cond.wait();
  59   }
  60
  61   int update_client(const std::string &client_id, const std::string &desc) {
  62     journal::Journaler journaler(m_work_queue, m_timer, &m_timer_lock,
  63                                  m_ioctx, m_journal_id, client_id, {});
  64     bufferlist data;
  65     data.append(desc);
  66     C_SaferCond cond;
  67     journaler.update_client(data, &cond);
  68     return cond.wait();
  69   }
  70
  71   int unregister_client(const std::string &client_id) {
  72     journal::Journaler journaler(m_work_queue, m_timer, &m_timer_lock,
  73                                  m_ioctx, m_journal_id, client_id, {});
  74     C_SaferCond cond;
  75     journaler.unregister_client(&cond);
  76     return cond.wait();
  77   }
  78
  79   static uint64_t _journal_id;
  80
  81   std::string m_journal_id;
  82   journal::Journaler *m_journaler;
  83 };
  84
  85 const std::string TestJournaler::CLIENT_ID = "client1";
  86 uint64_t TestJournaler::_journal_id = 0;
  87
  88 TEST_F(TestJournaler, Create) {
  89   ASSERT_EQ(0, create_journal(12, 8));
  90 }
  91
  92 TEST_F(TestJournaler, CreateDuplicate) {
  93   ASSERT_EQ(0, create_journal(12, 8));
  94   ASSERT_EQ(-EEXIST, create_journal(12, 8));
  95 }
  96
  97 TEST_F(TestJournaler, CreateInvalidParams) {
  98   ASSERT_EQ(-EDOM, create_journal(1, 8));
  99   ASSERT_EQ(-EDOM, create_journal(123, 8));
 100   ASSERT_EQ(-EINVAL, create_journal(12, 0));
 101 }
 102
 103 TEST_F(TestJournaler, Init) {
 104   ASSERT_EQ(0, create_journal(12, 8));
 105   ASSERT_EQ(0, register_client(CLIENT_ID, "foo"));
 106   ASSERT_EQ(0, init_journaler());
 107   ASSERT_EQ(0, shut_down_journaler());
 108 }
 109
 110 TEST_F(TestJournaler, InitDNE) {
 111   ASSERT_EQ(-ENOENT, init_journaler());
 112   ASSERT_EQ(0, shut_down_journaler());
 113 }
 114
 115 TEST_F(TestJournaler, RegisterClientDuplicate) {
 116   ASSERT_EQ(0, create_journal(12, 8));
 117   ASSERT_EQ(0, register_client(CLIENT_ID, "foo"));
 118   ASSERT_EQ(-EEXIST, register_client(CLIENT_ID, "foo2"));
 119 }
 120
 121 TEST_F(TestJournaler, UpdateClient) {
 122   ASSERT_EQ(0, create_journal(12, 8));
 123   ASSERT_EQ(0, register_client(CLIENT_ID, "foo"));
 124   ASSERT_EQ(0, update_client(CLIENT_ID, "foo2"));
 125 }
 126
 127 TEST_F(TestJournaler, UpdateClientDNE) {
 128   ASSERT_EQ(0, create_journal(12, 8));
 129   ASSERT_EQ(-ENOENT, update_client(CLIENT_ID, "foo"));
 130 }
 131
 132 TEST_F(TestJournaler, UnregisterClient) {
 133   ASSERT_EQ(0, create_journal(12, 8));
 134   ASSERT_EQ(0, register_client(CLIENT_ID, "foo"));
 135   ASSERT_EQ(0, unregister_client(CLIENT_ID));
 136   // Test it does not exist and can be registered again
 137   ASSERT_EQ(-ENOENT, update_client(CLIENT_ID, "foo"));
 138   ASSERT_EQ(0, register_client(CLIENT_ID, "foo"));
 139 }
 140
 141 TEST_F(TestJournaler, UnregisterClientDNE) {
 142   ASSERT_EQ(0, create_journal(12, 8));
 143   ASSERT_EQ(-ENOENT, unregister_client(CLIENT_ID));
 144 }
 145
 146 TEST_F(TestJournaler, AllocateTag) {
 147   ASSERT_EQ(0, create_journal(12, 8));
 148
 149   cls::journal::Tag tag;
 150
 151   bufferlist data;
 152   data.append(std::string(128, '1'));
 153
 154   // allocate a new tag class
 155   C_SaferCond ctx1;
 156   m_journaler->allocate_tag(data, &tag, &ctx1);
 157   ASSERT_EQ(0, ctx1.wait());
 158   ASSERT_EQ(cls::journal::Tag(0, 0, data), tag);
 159
 160   // re-use an existing tag class
 161   C_SaferCond ctx2;
 162   m_journaler->allocate_tag(tag.tag_class, bufferlist(), &tag, &ctx2);
 163   ASSERT_EQ(0, ctx2.wait());
 164   ASSERT_EQ(cls::journal::Tag(1, 0, bufferlist()), tag);
 165 }
 166
 167 TEST_F(TestJournaler, GetTags) {
 168   ASSERT_EQ(0, create_journal(12, 8));
 169   ASSERT_EQ(0, register_client(CLIENT_ID, "foo"));
 170
 171   std::list<cls::journal::Tag> expected_tags;
 172   for (size_t i = 0; i < 256; ++i) {
 173     C_SaferCond ctx;
 174     cls::journal::Tag tag;
 175     if (i < 2) {
 176       m_journaler->allocate_tag(bufferlist(), &tag, &ctx);
 177     } else {
 178       m_journaler->allocate_tag(i % 2, bufferlist(), &tag, &ctx);
 179     }
 180     ASSERT_EQ(0, ctx.wait());
 181
 182     if (i % 2 == 0) {
 183       expected_tags.push_back(tag);
 184     }
 185   }
 186
 187   std::list<cls::journal::Tag> tags;
 188   C_SaferCond ctx;
 189   m_journaler->get_tags(0, &tags, &ctx);
 190   ASSERT_EQ(0, ctx.wait());
 191   ASSERT_EQ(expected_tags, tags);
 192 }