src/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 Mutex;
  17
  18 namespace journal {
  19
  20 struct ReplayHandler;
  21 struct Settings;
  22
  23 struct MockFuture {
  24   static MockFuture *s_instance;
  25   static MockFuture &get_instance() {
  26     assert(s_instance != nullptr);
  27     return *s_instance;
  28   }
  29
  30   MockFuture() {
  31     s_instance = this;
  32   }
  33
  34   MOCK_CONST_METHOD0(is_valid, bool());
  35   MOCK_METHOD1(flush, void(Context *));
  36   MOCK_METHOD1(wait, void(Context *));
  37 };
  38
  39 struct MockFutureProxy {
  40   bool is_valid() const {
  41     return MockFuture::get_instance().is_valid();
  42   }
  43
  44   void flush(Context *on_safe) {
  45     MockFuture::get_instance().flush(on_safe);
  46   }
  47
  48   void wait(Context *on_safe) {
  49     MockFuture::get_instance().wait(on_safe);
  50   }
  51 };
  52
  53 struct MockReplayEntry {
  54   static MockReplayEntry *s_instance;
  55   static MockReplayEntry &get_instance() {
  56     assert(s_instance != nullptr);
  57     return *s_instance;
  58   }
  59
  60   MockReplayEntry() {
  61     s_instance = this;
  62   }
  63
  64   MOCK_CONST_METHOD0(get_commit_tid, uint64_t());
  65   MOCK_METHOD0(get_data, bufferlist());
  66 };
  67
  68 struct MockReplayEntryProxy {
  69   uint64_t get_commit_tid() const {
  70     return MockReplayEntry::get_instance().get_commit_tid();
  71   }
  72
  73   bufferlist get_data() {
  74     return MockReplayEntry::get_instance().get_data();
  75   }
  76 };
  77
  78 struct MockJournaler {
  79   static MockJournaler *s_instance;
  80   static MockJournaler &get_instance() {
  81     assert(s_instance != nullptr);
  82     return *s_instance;
  83   }
  84
  85   MockJournaler() {
  86     s_instance = this;
  87   }
  88
  89   MOCK_METHOD0(construct, void());
  90
  91   MOCK_METHOD1(init, void(Context *));
  92   MOCK_METHOD0(shut_down, void());
  93   MOCK_METHOD1(shut_down, void(Context *));
  94   MOCK_CONST_METHOD0(is_initialized, bool());
  95
  96   MOCK_METHOD3(get_metadata, void(uint8_t *order, uint8_t *splay_width,
  97                                   int64_t *pool_id));
  98   MOCK_METHOD4(get_mutable_metadata, void(uint64_t*, uint64_t*,
  99                                           std::set<cls::journal::Client> *,
 100                                           Context*));
 101
 102   MOCK_METHOD2(register_client, void(const bufferlist &, Context *));
 103   MOCK_METHOD1(unregister_client, void(Context *));
 104   MOCK_METHOD3(get_client, void(const std::string &, cls::journal::Client *,
 105                                 Context *));
 106   MOCK_METHOD2(get_cached_client, int(const std::string&, cls::journal::Client*));
 107   MOCK_METHOD2(update_client, void(const bufferlist &, Context *));
 108
 109   MOCK_METHOD4(allocate_tag, void(uint64_t, const bufferlist &,
 110                                   cls::journal::Tag*, Context *));
 111   MOCK_METHOD3(get_tag, void(uint64_t, cls::journal::Tag *, Context *));
 112   MOCK_METHOD3(get_tags, void(uint64_t, journal::Journaler::Tags*, Context*));
 113   MOCK_METHOD4(get_tags, void(uint64_t, uint64_t, journal::Journaler::Tags*,
 114                               Context*));
 115
 116   MOCK_METHOD1(start_replay, void(::journal::ReplayHandler *replay_handler));
 117   MOCK_METHOD2(start_live_replay, void(ReplayHandler *, double));
 118   MOCK_METHOD1(try_pop_front, bool(MockReplayEntryProxy *));
 119   MOCK_METHOD2(try_pop_front, bool(MockReplayEntryProxy *, uint64_t *));
 120   MOCK_METHOD0(stop_replay, void());
 121   MOCK_METHOD1(stop_replay, void(Context *on_finish));
 122
 123   MOCK_METHOD3(start_append, void(int flush_interval, uint64_t flush_bytes,
 124                                   double flush_age));
 125   MOCK_CONST_METHOD0(get_max_append_size, uint64_t());
 126   MOCK_METHOD2(append, MockFutureProxy(uint64_t tag_id,
 127                                        const bufferlist &bl));
 128   MOCK_METHOD1(flush, void(Context *on_safe));
 129   MOCK_METHOD1(stop_append, void(Context *on_safe));
 130
 131   MOCK_METHOD1(committed, void(const MockReplayEntryProxy &));
 132   MOCK_METHOD1(committed, void(const MockFutureProxy &future));
 133   MOCK_METHOD1(flush_commit_position, void(Context*));
 134
 135   MOCK_METHOD1(add_listener, void(JournalMetadataListener *));
 136   MOCK_METHOD1(remove_listener, void(JournalMetadataListener *));
 137
 138 };
 139
 140 struct MockJournalerProxy {
 141   template <typename IoCtxT>
 142   MockJournalerProxy(IoCtxT &header_ioctx, const std::string &,
 143                      const std::string &, const Settings&) {
 144     MockJournaler::get_instance().construct();
 145   }
 146
 147   template <typename WorkQueue, typename Timer>
 148   MockJournalerProxy(WorkQueue *work_queue, Timer *timer, Mutex *timer_lock,
 149                      librados::IoCtx &header_ioctx,
 150                      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