ceph/src/test/librbd/mock/MockImageCtx.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 CEPH_TEST_LIBRBD_MOCK_IMAGE_CTX_H
   5 #define CEPH_TEST_LIBRBD_MOCK_IMAGE_CTX_H
   6
   7 #include "include/rados/librados.hpp"
   8 #include "test/librbd/mock/MockContextWQ.h"
   9 #include "test/librbd/mock/MockExclusiveLock.h"
  10 #include "test/librbd/mock/MockImageState.h"
  11 #include "test/librbd/mock/MockImageWatcher.h"
  12 #include "test/librbd/mock/MockJournal.h"
  13 #include "test/librbd/mock/MockObjectMap.h"
  14 #include "test/librbd/mock/MockOperations.h"
  15 #include "test/librbd/mock/MockPluginRegistry.h"
  16 #include "test/librbd/mock/MockReadahead.h"
  17 #include "test/librbd/mock/io/MockImageDispatcher.h"
  18 #include "test/librbd/mock/io/MockObjectDispatcher.h"
  19 #include "common/WorkQueue.h"
  20 #include "common/zipkin_trace.h"
  21 #include "librbd/ImageCtx.h"
  22 #include "gmock/gmock.h"
  23 #include <string>
  24
  25 class MockSafeTimer;
  26
  27 namespace librbd {
  28
  29 namespace operation {
  30 template <typename> class ResizeRequest;
  31 }
  32
  33
  34 namespace crypto {
  35   class MockEncryptionFormat;
  36 }
  37
  38 struct MockImageCtx {
  39   static MockImageCtx *s_instance;
  40   static MockImageCtx *create(const std::string &image_name,
  41                               const std::string &image_id,
  42                               const char *snap, librados::IoCtx& p,
  43                               bool read_only) {
  44     ceph_assert(s_instance != nullptr);
  45     return s_instance;
  46   }
  47
  48   MockImageCtx(librbd::ImageCtx &image_ctx);
  49   virtual ~MockImageCtx();
  50
  51   void wait_for_async_ops();
  52   void wait_for_async_requests() {
  53     async_ops_lock.lock();
  54     if (async_requests.empty()) {
  55       async_ops_lock.unlock();
  56       return;
  57     }
  58
  59     C_SaferCond ctx;
  60     async_requests_waiters.push_back(&ctx);
  61     async_ops_lock.unlock();
  62
  63     ctx.wait();
  64   }
  65
  66   MOCK_METHOD1(init_layout, void(int64_t));
  67
  68   MOCK_CONST_METHOD1(get_object_name, std::string(uint64_t));
  69   MOCK_CONST_METHOD0(get_object_size, uint64_t());
  70   MOCK_CONST_METHOD0(get_current_size, uint64_t());
  71   MOCK_CONST_METHOD1(get_image_size, uint64_t(librados::snap_t));
  72   MOCK_CONST_METHOD1(get_area_size, uint64_t(io::ImageArea));
  73   MOCK_CONST_METHOD1(get_object_count, uint64_t(librados::snap_t));
  74   MOCK_CONST_METHOD1(get_read_flags, int(librados::snap_t));
  75   MOCK_CONST_METHOD2(get_flags, int(librados::snap_t in_snap_id,
  76                      uint64_t *flags));
  77   MOCK_CONST_METHOD2(get_snap_id,
  78                      librados::snap_t(cls::rbd::SnapshotNamespace snap_namespace,
  79                                       std::string in_snap_name));
  80   MOCK_CONST_METHOD1(get_snap_info, const SnapInfo*(librados::snap_t));
  81   MOCK_CONST_METHOD2(get_snap_name, int(librados::snap_t, std::string *));
  82   MOCK_CONST_METHOD2(get_snap_namespace, int(librados::snap_t,
  83                                              cls::rbd::SnapshotNamespace *out_snap_namespace));
  84   MOCK_CONST_METHOD2(get_parent_spec, int(librados::snap_t in_snap_id,
  85                                           cls::rbd::ParentImageSpec *pspec));
  86   MOCK_CONST_METHOD1(get_parent_info, const ParentImageInfo*(librados::snap_t));
  87   MOCK_CONST_METHOD2(get_parent_overlap, int(librados::snap_t in_snap_id,
  88                                              uint64_t *raw_overlap));
  89   MOCK_CONST_METHOD2(reduce_parent_overlap,
  90                      std::pair<uint64_t, io::ImageArea>(uint64_t, bool));
  91   MOCK_CONST_METHOD4(prune_parent_extents,
  92                      uint64_t(std::vector<std::pair<uint64_t, uint64_t>>&,
  93                               io::ImageArea, uint64_t, bool));
  94
  95   MOCK_CONST_METHOD2(is_snap_protected, int(librados::snap_t in_snap_id,
  96                                             bool *is_protected));
  97   MOCK_CONST_METHOD2(is_snap_unprotected, int(librados::snap_t in_snap_id,
  98                                               bool *is_unprotected));
  99
 100   MOCK_CONST_METHOD0(get_create_timestamp, utime_t());
 101   MOCK_CONST_METHOD0(get_access_timestamp, utime_t());
 102   MOCK_CONST_METHOD0(get_modify_timestamp, utime_t());
 103
 104   MOCK_METHOD1(set_access_timestamp, void(const utime_t at));
 105   MOCK_METHOD1(set_modify_timestamp, void(const utime_t at));
 106
 107   MOCK_METHOD8(add_snap, void(cls::rbd::SnapshotNamespace in_snap_namespace,
 108                               std::string in_snap_name,
 109                               librados::snap_t id,
 110                               uint64_t in_size, const ParentImageInfo &parent,
 111                               uint8_t protection_status, uint64_t flags, utime_t timestamp));
 112   MOCK_METHOD3(rm_snap, void(cls::rbd::SnapshotNamespace in_snap_namespace,
 113                              std::string in_snap_name,
 114                              librados::snap_t id));
 115
 116   MOCK_METHOD0(user_flushed, void());
 117   MOCK_METHOD1(flush_copyup, void(Context *));
 118
 119   MOCK_CONST_METHOD1(test_features, bool(uint64_t test_features));
 120   MOCK_CONST_METHOD2(test_features, bool(uint64_t test_features,
 121                                          const ceph::shared_mutex &in_image_lock));
 122
 123   MOCK_CONST_METHOD1(test_op_features, bool(uint64_t op_features));
 124
 125   MOCK_METHOD1(cancel_async_requests, void(Context*));
 126
 127   MOCK_METHOD0(create_exclusive_lock, MockExclusiveLock*());
 128   MOCK_METHOD1(create_object_map, MockObjectMap*(uint64_t));
 129   MOCK_METHOD0(create_journal, MockJournal*());
 130
 131   MOCK_METHOD0(notify_update, void());
 132   MOCK_METHOD1(notify_update, void(Context *));
 133
 134   MOCK_CONST_METHOD0(get_exclusive_lock_policy, exclusive_lock::Policy*());
 135   MOCK_METHOD1(set_exclusive_lock_policy, void(exclusive_lock::Policy*));
 136   MOCK_CONST_METHOD0(get_journal_policy, journal::Policy*());
 137   MOCK_METHOD1(set_journal_policy, void(journal::Policy*));
 138
 139   MOCK_METHOD2(apply_metadata, int(const std::map<std::string, bufferlist> &,
 140                                    bool));
 141
 142   MOCK_CONST_METHOD0(get_stripe_count, uint64_t());
 143   MOCK_CONST_METHOD0(get_stripe_period, uint64_t());
 144
 145   MOCK_METHOD0(rebuild_data_io_context, void());
 146   IOContext get_data_io_context();
 147   IOContext duplicate_data_io_context();
 148
 149   static void set_timer_instance(MockSafeTimer *timer, ceph::mutex *timer_lock);
 150   static void get_timer_instance(CephContext *cct, MockSafeTimer **timer,
 151                                  ceph::mutex **timer_lock);
 152
 153   ImageCtx *image_ctx;
 154   CephContext *cct;
 155   PerfCounters *perfcounter;
 156
 157   cls::rbd::SnapshotNamespace snap_namespace;
 158   std::string snap_name;
 159   uint64_t snap_id;
 160   bool snap_exists;
 161
 162   ::SnapContext snapc;
 163   std::vector<librados::snap_t> snaps;
 164   std::map<librados::snap_t, SnapInfo> snap_info;
 165   std::map<ImageCtx::SnapKey, librados::snap_t, ImageCtx::SnapKeyComparator> snap_ids;
 166
 167   bool old_format;
 168   bool read_only;
 169   uint32_t read_only_flags;
 170   uint32_t read_only_mask;
 171
 172   bool clone_copy_on_read;
 173
 174   std::map<rados::cls::lock::locker_id_t,
 175            rados::cls::lock::locker_info_t> lockers;
 176   bool exclusive_locked;
 177   std::string lock_tag;
 178
 179   std::shared_ptr<AsioEngine> asio_engine;
 180   neorados::RADOS& rados_api;
 181
 182   librados::IoCtx md_ctx;
 183   librados::IoCtx data_ctx;
 184
 185   ceph::shared_mutex &owner_lock;
 186   ceph::shared_mutex &image_lock;
 187   ceph::shared_mutex &timestamp_lock;
 188   ceph::mutex &async_ops_lock;
 189   ceph::mutex &copyup_list_lock;
 190
 191   uint8_t order;
 192   uint64_t size;
 193   uint64_t features;
 194   uint64_t flags;
 195   uint64_t op_features;
 196   bool operations_disabled;
 197   uint64_t stripe_unit;
 198   uint64_t stripe_count;
 199   std::string object_prefix;
 200   std::string header_oid;
 201   std::string id;
 202   std::string name;
 203   ParentImageInfo parent_md;
 204   MigrationInfo migration_info;
 205   char *format_string;
 206   cls::rbd::GroupSpec group_spec;
 207
 208   file_layout_t layout;
 209
 210   xlist<operation::ResizeRequest<MockImageCtx>*> resize_reqs;
 211   xlist<AsyncRequest<MockImageCtx>*> async_requests;
 212   std::list<Context*> async_requests_waiters;
 213
 214   std::map<uint64_t, io::CopyupRequest<MockImageCtx>*> copyup_list;
 215
 216   io::MockImageDispatcher *io_image_dispatcher;
 217   io::MockObjectDispatcher *io_object_dispatcher;
 218   MockContextWQ *op_work_queue;
 219
 220   MockPluginRegistry* plugin_registry;
 221
 222   MockReadahead readahead;
 223   uint64_t readahead_max_bytes;
 224
 225   EventSocket &event_socket;
 226
 227   MockImageCtx *child = nullptr;
 228   MockImageCtx *parent;
 229   MockOperations *operations;
 230   MockImageState *state;
 231
 232   MockImageWatcher *image_watcher;
 233   MockObjectMap *object_map;
 234   MockExclusiveLock *exclusive_lock;
 235   MockJournal *journal;
 236
 237   ZTracer::Endpoint trace_endpoint;
 238
 239   std::unique_ptr<crypto::MockEncryptionFormat> encryption_format;
 240
 241   uint64_t sparse_read_threshold_bytes;
 242   uint32_t discard_granularity_bytes;
 243   int mirroring_replay_delay;
 244   bool non_blocking_aio;
 245   bool blkin_trace_all;
 246   bool enable_alloc_hint;
 247   uint32_t alloc_hint_flags;
 248   uint32_t read_flags;
 249   bool ignore_migrating;
 250   bool enable_sparse_copyup;
 251   uint64_t mtime_update_interval;
 252   uint64_t atime_update_interval;
 253   bool cache;
 254
 255   ConfigProxy config;
 256   std::set<std::string> config_overrides;
 257 };
 258
 259 } // namespace librbd
 260
 261 #endif // CEPH_TEST_LIBRBD_MOCK_IMAGE_CTX_H