update ceph source to reef 18.1.2

[ceph.git] / ceph / src / test / librbd / mock / MockImageCtx.h

diff --git a/ceph/src/test/librbd/mock/MockImageCtx.h b/ceph/src/test/librbd/mock/MockImageCtx.h
index 3e1483d2d02f93aac16039406c53492a4298c549..8da257f44ab0e5cf7e781a8a524d7e08b687ec88 100644 (file)
--- a/ceph/src/test/librbd/mock/MockImageCtx.h
+++ b/ceph/src/test/librbd/mock/MockImageCtx.h
@@ -30,6 +30,11 @@ namespace operation {
 template <typename> class ResizeRequest;
 }
 
+
+namespace crypto {
+  class MockEncryptionFormat;
+}
+
 struct MockImageCtx {
   static MockImageCtx *s_instance;
   static MockImageCtx *create(const std::string &image_name,
@@ -40,97 +45,8 @@ struct MockImageCtx {
     return s_instance;
   }
 
-  MockImageCtx(librbd::ImageCtx &image_ctx)
-    : image_ctx(&image_ctx),
-      cct(image_ctx.cct),
-      perfcounter(image_ctx.perfcounter),
-      snap_namespace(image_ctx.snap_namespace),
-      snap_name(image_ctx.snap_name),
-      snap_id(image_ctx.snap_id),
-      snap_exists(image_ctx.snap_exists),
-      snapc(image_ctx.snapc),
-      snaps(image_ctx.snaps),
-      snap_info(image_ctx.snap_info),
-      snap_ids(image_ctx.snap_ids),
-      old_format(image_ctx.old_format),
-      read_only(image_ctx.read_only),
-      read_only_flags(image_ctx.read_only_flags),
-      read_only_mask(image_ctx.read_only_mask),
-      clone_copy_on_read(image_ctx.clone_copy_on_read),
-      lockers(image_ctx.lockers),
-      exclusive_locked(image_ctx.exclusive_locked),
-      lock_tag(image_ctx.lock_tag),
-      asio_engine(image_ctx.asio_engine),
-      rados_api(image_ctx.rados_api),
-      owner_lock(image_ctx.owner_lock),
-      image_lock(image_ctx.image_lock),
-      timestamp_lock(image_ctx.timestamp_lock),
-      async_ops_lock(image_ctx.async_ops_lock),
-      copyup_list_lock(image_ctx.copyup_list_lock),
-      order(image_ctx.order),
-      size(image_ctx.size),
-      features(image_ctx.features),
-      flags(image_ctx.flags),
-      op_features(image_ctx.op_features),
-      operations_disabled(image_ctx.operations_disabled),
-      stripe_unit(image_ctx.stripe_unit),
-      stripe_count(image_ctx.stripe_count),
-      object_prefix(image_ctx.object_prefix),
-      header_oid(image_ctx.header_oid),
-      id(image_ctx.id),
-      name(image_ctx.name),
-      parent_md(image_ctx.parent_md),
-      format_string(image_ctx.format_string),
-      group_spec(image_ctx.group_spec),
-      layout(image_ctx.layout),
-      io_image_dispatcher(new io::MockImageDispatcher()),
-      io_object_dispatcher(new io::MockObjectDispatcher()),
-      op_work_queue(new MockContextWQ()),
-      plugin_registry(new MockPluginRegistry()),
-      readahead_max_bytes(image_ctx.readahead_max_bytes),
-      event_socket(image_ctx.event_socket),
-      parent(NULL), operations(new MockOperations()),
-      state(new MockImageState()),
-      image_watcher(NULL), object_map(NULL),
-      exclusive_lock(NULL), journal(NULL),
-      trace_endpoint(image_ctx.trace_endpoint),
-      sparse_read_threshold_bytes(image_ctx.sparse_read_threshold_bytes),
-      discard_granularity_bytes(image_ctx.discard_granularity_bytes),
-      mirroring_replay_delay(image_ctx.mirroring_replay_delay),
-      non_blocking_aio(image_ctx.non_blocking_aio),
-      blkin_trace_all(image_ctx.blkin_trace_all),
-      enable_alloc_hint(image_ctx.enable_alloc_hint),
-      alloc_hint_flags(image_ctx.alloc_hint_flags),
-      read_flags(image_ctx.read_flags),
-      ignore_migrating(image_ctx.ignore_migrating),
-      enable_sparse_copyup(image_ctx.enable_sparse_copyup),
-      mtime_update_interval(image_ctx.mtime_update_interval),
-      atime_update_interval(image_ctx.atime_update_interval),
-      cache(image_ctx.cache),
-      config(image_ctx.config)
-  {
-    md_ctx.dup(image_ctx.md_ctx);
-    data_ctx.dup(image_ctx.data_ctx);
-
-    if (image_ctx.image_watcher != NULL) {
-      image_watcher = new MockImageWatcher();
-    }
-  }
-
-  virtual ~MockImageCtx() {
-    wait_for_async_requests();
-    wait_for_async_ops();
-    image_ctx->md_ctx.aio_flush();
-    image_ctx->data_ctx.aio_flush();
-    image_ctx->op_work_queue->drain();
-    delete state;
-    delete operations;
-    delete image_watcher;
-    delete op_work_queue;
-    delete plugin_registry;
-    delete io_image_dispatcher;
-    delete io_object_dispatcher;
-  }
+  MockImageCtx(librbd::ImageCtx &image_ctx);
+  virtual ~MockImageCtx();
 
   void wait_for_async_ops();
   void wait_for_async_requests() {
@@ -153,7 +69,7 @@ struct MockImageCtx {
   MOCK_CONST_METHOD0(get_object_size, uint64_t());
   MOCK_CONST_METHOD0(get_current_size, uint64_t());
   MOCK_CONST_METHOD1(get_image_size, uint64_t(librados::snap_t));
-  MOCK_CONST_METHOD1(get_effective_image_size, uint64_t(librados::snap_t));
+  MOCK_CONST_METHOD1(get_area_size, uint64_t(io::ImageArea));
   MOCK_CONST_METHOD1(get_object_count, uint64_t(librados::snap_t));
   MOCK_CONST_METHOD1(get_read_flags, int(librados::snap_t));
   MOCK_CONST_METHOD2(get_flags, int(librados::snap_t in_snap_id,
@@ -169,9 +85,12 @@ struct MockImageCtx {
                                           cls::rbd::ParentImageSpec *pspec));
   MOCK_CONST_METHOD1(get_parent_info, const ParentImageInfo*(librados::snap_t));
   MOCK_CONST_METHOD2(get_parent_overlap, int(librados::snap_t in_snap_id,
-                                             uint64_t *overlap));
-  MOCK_CONST_METHOD2(prune_parent_extents, uint64_t(std::vector<std::pair<uint64_t,uint64_t> >& ,
-                                                    uint64_t));
+                                             uint64_t *raw_overlap));
+  MOCK_CONST_METHOD2(reduce_parent_overlap,
+                     std::pair<uint64_t, io::ImageArea>(uint64_t, bool));
+  MOCK_CONST_METHOD4(prune_parent_extents,
+                     uint64_t(std::vector<std::pair<uint64_t, uint64_t>>&,
+                              io::ImageArea, uint64_t, bool));
 
   MOCK_CONST_METHOD2(is_snap_protected, int(librados::snap_t in_snap_id,
                                             bool *is_protected));
@@ -317,7 +236,7 @@ struct MockImageCtx {
 
   ZTracer::Endpoint trace_endpoint;
 
-  crypto::CryptoInterface* crypto = nullptr;
+  std::unique_ptr<crypto::MockEncryptionFormat> encryption_format;
 
   uint64_t sparse_read_threshold_bytes;
   uint32_t discard_granularity_bytes;