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