ceph/src/test/journal/mock/MockJournaler.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef TEST_RBD_MIRROR_MOCK_JOURNALER_H
   5 #define TEST_RBD_MIRROR_MOCK_JOURNALER_H
   6
   7 #include <gmock/gmock.h>
   8 #include "include/int_types.h"
   9 #include "include/rados/librados.hpp"
  10 #include "cls/journal/cls_journal_types.h"
  11 #include "journal/Journaler.h"
  12 #include <iosfwd>
  13 #include <string>
  14
  15 class Context;
  16 class ContextWQ;
  17 class Mutex;
  18 class SafeTimer;
  19
  20 namespace journal {
  21
  22 struct ReplayHandler;
  23 struct Settings;
  24
  25 struct MockFuture {
  26   static MockFuture *s_instance;
  27   static MockFuture &get_instance() {
  28     assert(s_instance != nullptr);
  29     return *s_instance;
  30   }
  31
  32   MockFuture() {
  33     s_instance = this;
  34   }
  35
  36   MOCK_CONST_METHOD0(is_valid, bool());
  37   MOCK_METHOD1(flush, void(Context *));
  38   MOCK_METHOD1(wait, void(Context *));
  39 };
  40
  41 struct MockFutureProxy {
  42   bool is_valid() const {
  43     return MockFuture::get_instance().is_valid();
  44   }
  45
  46   void flush(Context *on_safe) {
  47     MockFuture::get_instance().flush(on_safe);
  48   }
  49
  50   void wait(Context *on_safe) {
  51     MockFuture::get_instance().wait(on_safe);
  52   }
  53 };
  54
  55 struct MockReplayEntry {
  56   static MockReplayEntry *s_instance;
  57   static MockReplayEntry &get_instance() {
  58     assert(s_instance != nullptr);
  59     return *s_instance;
  60   }
  61
  62   MockReplayEntry() {
  63     s_instance = this;
  64   }
  65
  66   MOCK_CONST_METHOD0(get_commit_tid, uint64_t());
  67   MOCK_METHOD0(get_data, bufferlist());
  68 };
  69
  70 struct MockReplayEntryProxy {
  71   uint64_t get_commit_tid() const {
  72     return MockReplayEntry::get_instance().get_commit_tid();
  73   }
  74
  75   bufferlist get_data() {
  76     return MockReplayEntry::get_instance().get_data();
  77   }
  78 };
  79
  80 struct MockJournaler {
  81   static MockJournaler *s_instance;
  82   static MockJournaler &get_instance() {
  83     assert(s_instance != nullptr);
  84     return *s_instance;
  85   }
  86
  87   MockJournaler() {
  88     s_instance = this;
  89   }
  90
  91   MOCK_METHOD0(construct, void());
  92
  93   MOCK_METHOD1(init, void(Context *));
  94   MOCK_METHOD0(shut_down, void());
  95   MOCK_METHOD1(shut_down, void(Context *));
  96   MOCK_CONST_METHOD0(is_initialized, bool());
  97
  98   MOCK_METHOD3(get_metadata, void(uint8_t *order, uint8_t *splay_width,
  99                                   int64_t *pool_id));
 100   MOCK_METHOD4(get_mutable_metadata, void(uint64_t*, uint64_t*,
 101                                           std::set<cls::journal::Client> *,
 102                                           Context*));
 103
 104   MOCK_METHOD2(register_client, void(const bufferlist &, Context *));
 105   MOCK_METHOD1(unregister_client, void(Context *));
 106   MOCK_METHOD3(get_client, void(const std::string &, cls::journal::Client *,
 107                                 Context *));
 108   MOCK_METHOD2(get_cached_client, int(const std::string&, cls::journal::Client*));
 109   MOCK_METHOD2(update_client, void(const bufferlist &, Context *));
 110
 111   MOCK_METHOD4(allocate_tag, void(uint64_t, const bufferlist &,
 112                                   cls::journal::Tag*, Context *));
 113   MOCK_METHOD3(get_tag, void(uint64_t, cls::journal::Tag *, Context *));
 114   MOCK_METHOD3(get_tags, void(uint64_t, journal::Journaler::Tags*, Context*));
 115   MOCK_METHOD4(get_tags, void(uint64_t, uint64_t, journal::Journaler::Tags*,
 116                               Context*));
 117
 118   MOCK_METHOD1(start_replay, void(::journal::ReplayHandler *replay_handler));
 119   MOCK_METHOD2(start_live_replay, void(ReplayHandler *, double));
 120   MOCK_METHOD1(try_pop_front, bool(MockReplayEntryProxy *));
 121   MOCK_METHOD2(try_pop_front, bool(MockReplayEntryProxy *, uint64_t *));
 122   MOCK_METHOD0(stop_replay, void());
 123   MOCK_METHOD1(stop_replay, void(Context *on_finish));
 124
 125   MOCK_METHOD3(start_append, void(int flush_interval, uint64_t flush_bytes,
 126                                   double flush_age));
 127   MOCK_CONST_METHOD0(get_max_append_size, uint64_t());
 128   MOCK_METHOD2(append, MockFutureProxy(uint64_t tag_id,
 129                                        const bufferlist &bl));
 130   MOCK_METHOD1(flush, void(Context *on_safe));
 131   MOCK_METHOD1(stop_append, void(Context *on_safe));
 132
 133   MOCK_METHOD1(committed, void(const MockReplayEntryProxy &));
 134   MOCK_METHOD1(committed, void(const MockFutureProxy &future));
 135   MOCK_METHOD1(flush_commit_position, void(Context*));
 136
 137   MOCK_METHOD1(add_listener, void(JournalMetadataListener *));
 138   MOCK_METHOD1(remove_listener, void(JournalMetadataListener *));
 139
 140 };
 141
 142 struct MockJournalerProxy {
 143   template <typename IoCtxT>
 144   MockJournalerProxy(IoCtxT &header_ioctx, const std::string &,
 145                      const std::string &, const Settings&) {
 146     MockJournaler::get_instance().construct();
 147   }
 148
 149   MockJournalerProxy(ContextWQ *work_queue, SafeTimer *timer, Mutex *timer_lock,
 150                      librados::IoCtx &header_ioctx, const std::string &journal_id,
 151                      const std::string &client_id, const Settings&) {
 152     MockJournaler::get_instance().construct();
 153   }
 154
 155   void exists(Context *on_finish) const {
 156     on_finish->complete(-EINVAL);
 157   }
 158   void create(uint8_t order, uint8_t splay_width, int64_t pool_id, Context *on_finish) {
 159     on_finish->complete(-EINVAL);
 160   }
 161   void remove(bool force, Context *on_finish) {
 162     on_finish->complete(-EINVAL);
 163   }
 164   int register_client(const bufferlist &data) {
 165     return -EINVAL;
 166   }
 167
 168   void allocate_tag(uint64_t tag_class, const bufferlist &tag_data,
 169                     cls::journal::Tag* tag, Context *on_finish) {
 170     MockJournaler::get_instance().allocate_tag(tag_class, tag_data, tag,
 171                                                on_finish);
 172   }
 173
 174   void init(Context *on_finish) {
 175     MockJournaler::get_instance().init(on_finish);
 176   }
 177   void shut_down() {
 178     MockJournaler::get_instance().shut_down();
 179   }
 180   void shut_down(Context *on_finish) {
 181     MockJournaler::get_instance().shut_down(on_finish);
 182   }
 183   bool is_initialized() const {
 184     return MockJournaler::get_instance().is_initialized();
 185   }
 186
 187   void get_metadata(uint8_t *order, uint8_t *splay_width, int64_t *pool_id) {
 188     MockJournaler::get_instance().get_metadata(order, splay_width, pool_id);
 189   }
 190
 191   void get_mutable_metadata(uint64_t *min, uint64_t *active,
 192                             std::set<cls::journal::Client> *clients,
 193                             Context *on_finish) {
 194     MockJournaler::get_instance().get_mutable_metadata(min, active, clients,
 195                                                        on_finish);
 196   }
 197
 198   void register_client(const bufferlist &data, Context *on_finish) {
 199     MockJournaler::get_instance().register_client(data, on_finish);
 200   }
 201
 202   void unregister_client(Context *on_finish) {
 203     MockJournaler::get_instance().unregister_client(on_finish);
 204   }
 205
 206   void get_client(const std::string &client_id, cls::journal::Client *client,
 207                   Context *on_finish) {
 208     MockJournaler::get_instance().get_client(client_id, client, on_finish);
 209   }
 210
 211   int get_cached_client(const std::string& client_id,
 212                         cls::journal::Client* client) {
 213     return MockJournaler::get_instance().get_cached_client(client_id, client);
 214   }
 215
 216   void update_client(const bufferlist &client_data, Context *on_finish) {
 217     MockJournaler::get_instance().update_client(client_data, on_finish);
 218   }
 219
 220   void get_tag(uint64_t tag_tid, cls::journal::Tag *tag, Context *on_finish) {
 221     MockJournaler::get_instance().get_tag(tag_tid, tag, on_finish);
 222   }
 223
 224   void get_tags(uint64_t tag_class, journal::Journaler::Tags *tags,
 225                 Context *on_finish) {
 226     MockJournaler::get_instance().get_tags(tag_class, tags, on_finish);
 227   }
 228   void get_tags(uint64_t start_after_tag_tid, uint64_t tag_class,
 229                 journal::Journaler::Tags *tags, Context *on_finish) {
 230     MockJournaler::get_instance().get_tags(start_after_tag_tid, tag_class, tags,
 231                                            on_finish);
 232   }
 233
 234   void start_replay(::journal::ReplayHandler *replay_handler) {
 235     MockJournaler::get_instance().start_replay(replay_handler);
 236   }
 237
 238   void start_live_replay(ReplayHandler *handler, double interval) {
 239     MockJournaler::get_instance().start_live_replay(handler, interval);
 240   }
 241
 242   bool try_pop_front(MockReplayEntryProxy *replay_entry) {
 243     return MockJournaler::get_instance().try_pop_front(replay_entry);
 244   }
 245
 246   bool try_pop_front(MockReplayEntryProxy *entry, uint64_t *tag_tid) {
 247     return MockJournaler::get_instance().try_pop_front(entry, tag_tid);
 248   }
 249
 250   void stop_replay() {
 251     MockJournaler::get_instance().stop_replay();
 252   }
 253   void stop_replay(Context *on_finish) {
 254     MockJournaler::get_instance().stop_replay(on_finish);
 255   }
 256
 257   void start_append(int flush_interval, uint64_t flush_bytes, double flush_age) {
 258     MockJournaler::get_instance().start_append(flush_interval, flush_bytes,
 259                                                flush_age);
 260   }
 261
 262   uint64_t get_max_append_size() const {
 263     return MockJournaler::get_instance().get_max_append_size();
 264   }
 265
 266   MockFutureProxy append(uint64_t tag_id, const bufferlist &bl) {
 267     return MockJournaler::get_instance().append(tag_id, bl);
 268   }
 269
 270   void flush(Context *on_safe) {
 271     MockJournaler::get_instance().flush(on_safe);
 272   }
 273
 274   void stop_append(Context *on_safe) {
 275     MockJournaler::get_instance().stop_append(on_safe);
 276   }
 277
 278   void committed(const MockReplayEntryProxy &entry) {
 279     MockJournaler::get_instance().committed(entry);
 280   }
 281
 282   void committed(const MockFutureProxy &future) {
 283     MockJournaler::get_instance().committed(future);
 284   }
 285
 286   void flush_commit_position(Context *on_finish) {
 287     MockJournaler::get_instance().flush_commit_position(on_finish);
 288   }
 289
 290   void add_listener(JournalMetadataListener *listener) {
 291     MockJournaler::get_instance().add_listener(listener);
 292   }
 293
 294   void remove_listener(JournalMetadataListener *listener) {
 295     MockJournaler::get_instance().remove_listener(listener);
 296   }
 297 };
 298
 299 std::ostream &operator<<(std::ostream &os, const MockJournalerProxy &);
 300
 301 } // namespace journal
 302
 303 #endif // TEST_RBD_MIRROR_MOCK_JOURNALER_H