ceph/src/test/journal/test_JournalRecorder.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/JournalRecorder.h"
   5 #include "journal/Entry.h"
   6 #include "journal/JournalMetadata.h"
   7 #include "test/journal/RadosTestFixture.h"
   8 #include <limits>
   9 #include <list>
  10
  11 class TestJournalRecorder : public RadosTestFixture {
  12 public:
  13
  14   void TearDown() override {
  15     for (std::list<journal::JournalRecorder*>::iterator it = m_recorders.begin();
  16          it != m_recorders.end(); ++it) {
  17       delete *it;
  18     }
  19     RadosTestFixture::TearDown();
  20   }
  21
  22   journal::JournalRecorder *create_recorder(const std::string &oid,
  23                                             const journal::JournalMetadataPtr &metadata) {
  24     journal::JournalRecorder *recorder(new journal::JournalRecorder(
  25       m_ioctx, oid + ".", metadata, 0, std::numeric_limits<uint32_t>::max(), 0));
  26     m_recorders.push_back(recorder);
  27     return recorder;
  28   }
  29
  30   std::list<journal::JournalRecorder*> m_recorders;
  31
  32 };
  33
  34 TEST_F(TestJournalRecorder, Append) {
  35   std::string oid = get_temp_oid();
  36   ASSERT_EQ(0, create(oid, 12, 2));
  37   ASSERT_EQ(0, client_register(oid));
  38
  39   journal::JournalMetadataPtr metadata = create_metadata(oid);
  40   ASSERT_EQ(0, init_metadata(metadata));
  41
  42   journal::JournalRecorder *recorder = create_recorder(oid, metadata);
  43
  44   journal::Future future1 = recorder->append(123, create_payload("payload"));
  45
  46   C_SaferCond cond;
  47   future1.flush(&cond);
  48   ASSERT_EQ(0, cond.wait());
  49 }
  50
  51 TEST_F(TestJournalRecorder, AppendKnownOverflow) {
  52   std::string oid = get_temp_oid();
  53   ASSERT_EQ(0, create(oid, 12, 2));
  54   ASSERT_EQ(0, client_register(oid));
  55
  56   journal::JournalMetadataPtr metadata = create_metadata(oid);
  57   ASSERT_EQ(0, init_metadata(metadata));
  58   ASSERT_EQ(0U, metadata->get_active_set());
  59
  60   journal::JournalRecorder *recorder = create_recorder(oid, metadata);
  61
  62   recorder->append(123, create_payload(std::string(metadata->get_object_size() -
  63                                                    journal::Entry::get_fixed_size(), '1')));
  64   journal::Future future2 = recorder->append(123, create_payload(std::string(1, '2')));
  65
  66   C_SaferCond cond;
  67   future2.flush(&cond);
  68   ASSERT_EQ(0, cond.wait());
  69
  70   ASSERT_EQ(1U, metadata->get_active_set());
  71 }
  72
  73 TEST_F(TestJournalRecorder, AppendDelayedOverflow) {
  74   std::string oid = get_temp_oid();
  75   ASSERT_EQ(0, create(oid, 12, 2));
  76   ASSERT_EQ(0, client_register(oid));
  77
  78   journal::JournalMetadataPtr metadata = create_metadata(oid);
  79   ASSERT_EQ(0, init_metadata(metadata));
  80   ASSERT_EQ(0U, metadata->get_active_set());
  81
  82   journal::JournalRecorder *recorder1 = create_recorder(oid, metadata);
  83   journal::JournalRecorder *recorder2 = create_recorder(oid, metadata);
  84
  85   recorder1->append(234, create_payload(std::string(1, '1')));
  86   recorder2->append(123, create_payload(std::string(metadata->get_object_size() -
  87                                                     journal::Entry::get_fixed_size(), '2')));
  88
  89   journal::Future future = recorder2->append(123, create_payload(std::string(1, '3')));
  90
  91   C_SaferCond cond;
  92   future.flush(&cond);
  93   ASSERT_EQ(0, cond.wait());
  94
  95   ASSERT_EQ(1U, metadata->get_active_set());
  96 }
  97
  98 TEST_F(TestJournalRecorder, FutureFlush) {
  99   std::string oid = get_temp_oid();
 100   ASSERT_EQ(0, create(oid, 12, 2));
 101   ASSERT_EQ(0, client_register(oid));
 102
 103   journal::JournalMetadataPtr metadata = create_metadata(oid);
 104   ASSERT_EQ(0, init_metadata(metadata));
 105
 106   journal::JournalRecorder *recorder = create_recorder(oid, metadata);
 107
 108   journal::Future future1 = recorder->append(123, create_payload("payload1"));
 109   journal::Future future2 = recorder->append(123, create_payload("payload2"));
 110
 111   C_SaferCond cond;
 112   future2.flush(&cond);
 113   ASSERT_EQ(0, cond.wait());
 114   ASSERT_TRUE(future1.is_complete());
 115   ASSERT_TRUE(future2.is_complete());
 116 }
 117
 118 TEST_F(TestJournalRecorder, Flush) {
 119   std::string oid = get_temp_oid();
 120   ASSERT_EQ(0, create(oid, 12, 2));
 121   ASSERT_EQ(0, client_register(oid));
 122
 123   journal::JournalMetadataPtr metadata = create_metadata(oid);
 124   ASSERT_EQ(0, init_metadata(metadata));
 125
 126   journal::JournalRecorder *recorder = create_recorder(oid, metadata);
 127
 128   journal::Future future1 = recorder->append(123, create_payload("payload1"));
 129   journal::Future future2 = recorder->append(123, create_payload("payload2"));
 130
 131   C_SaferCond cond1;
 132   recorder->flush(&cond1);
 133   ASSERT_EQ(0, cond1.wait());
 134
 135   C_SaferCond cond2;
 136   future2.wait(&cond2);
 137   ASSERT_EQ(0, cond2.wait());
 138   ASSERT_TRUE(future1.is_complete());
 139   ASSERT_TRUE(future2.is_complete());
 140 }
 141
 142 TEST_F(TestJournalRecorder, OverflowCommitObjectNumber) {
 143   std::string oid = get_temp_oid();
 144   ASSERT_EQ(0, create(oid, 12, 2));
 145   ASSERT_EQ(0, client_register(oid));
 146
 147   journal::JournalMetadataPtr metadata = create_metadata(oid);
 148   ASSERT_EQ(0, init_metadata(metadata));
 149   ASSERT_EQ(0U, metadata->get_active_set());
 150
 151   journal::JournalRecorder *recorder = create_recorder(oid, metadata);
 152
 153   recorder->append(123, create_payload(std::string(metadata->get_object_size() -
 154                                                    journal::Entry::get_fixed_size(), '1')));
 155   journal::Future future2 = recorder->append(124, create_payload(std::string(1, '2')));
 156
 157   C_SaferCond cond;
 158   future2.flush(&cond);
 159   ASSERT_EQ(0, cond.wait());
 160
 161   ASSERT_EQ(1U, metadata->get_active_set());
 162
 163   uint64_t object_num;
 164   uint64_t tag_tid;
 165   uint64_t entry_tid;
 166   metadata->get_commit_entry(1, &object_num, &tag_tid, &entry_tid);
 167   ASSERT_EQ(0U, object_num);
 168   ASSERT_EQ(123U, tag_tid);
 169   ASSERT_EQ(0U, entry_tid);
 170
 171   metadata->get_commit_entry(2, &object_num, &tag_tid, &entry_tid);
 172   ASSERT_EQ(2U, object_num);
 173   ASSERT_EQ(124U, tag_tid);
 174   ASSERT_EQ(0U, entry_tid);
 175 }
 176