librbd: pass specialized handler interface to deep-copy

The initial version mimics the existing ProgressContext callback
interface. Later commits will add additional deep-copy unique methods.

Signed-off-by: Jason Dillaman <dillaman@redhat.com>

diff --git a/src/librbd/DeepCopyRequest.cc b/src/librbd/DeepCopyRequest.cc
index 90fde47b71dbf9dc0ed9a618ae9c5865be15189c..33f1b245befd29697fb1560f6cbfc43664b212a5 100644 (file)
--- a/src/librbd/DeepCopyRequest.cc
+++ b/src/librbd/DeepCopyRequest.cc
@@ -33,13 +33,13 @@ DeepCopyRequest<I>::DeepCopyRequest(I *src_image_ctx, I *dst_image_ctx,
                                     bool flatten,
                                     const ObjectNumber &object_number,
                                     ContextWQ *work_queue, SnapSeqs *snap_seqs,
-                                    ProgressContext *prog_ctx,
+                                    deep_copy::Handler *handler,
                                     Context *on_finish)
   : RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
     m_dst_image_ctx(dst_image_ctx), m_src_snap_id_start(src_snap_id_start),
     m_src_snap_id_end(src_snap_id_end), m_dst_snap_id_start(dst_snap_id_start),
     m_flatten(flatten), m_object_number(object_number),
-    m_work_queue(work_queue), m_snap_seqs(snap_seqs), m_prog_ctx(prog_ctx),
+    m_work_queue(work_queue), m_snap_seqs(snap_seqs), m_handler(handler),
     m_on_finish(on_finish), m_cct(dst_image_ctx->cct),
     m_lock(ceph::make_mutex(unique_lock_name("DeepCopyRequest::m_lock", this))) {
 }
@@ -158,7 +158,7 @@ void DeepCopyRequest<I>::send_copy_image() {
     DeepCopyRequest<I>, &DeepCopyRequest<I>::handle_copy_image>(this);
   m_image_copy_request = ImageCopyRequest<I>::create(
     m_src_image_ctx, m_dst_image_ctx, m_src_snap_id_start, m_src_snap_id_end,
-    m_dst_snap_id_start, m_flatten, m_object_number, *m_snap_seqs, m_prog_ctx,
+    m_dst_snap_id_start, m_flatten, m_object_number, *m_snap_seqs, m_handler,
     ctx);
   m_image_copy_request->get();
   m_lock.unlock();

diff --git a/src/librbd/DeepCopyRequest.h b/src/librbd/DeepCopyRequest.h
index 0348246e72249d5a05786980391cf7a7295362ae..201c86f700fe1c45cf61a435b0a8f7ccbbee27d9 100644 (file)
--- a/src/librbd/DeepCopyRequest.h
+++ b/src/librbd/DeepCopyRequest.h
@@ -24,6 +24,7 @@ namespace deep_copy {
 
 template <typename> class ImageCopyRequest;
 template <typename> class SnapshotCopyRequest;
+struct Handler;
 
 }
 
@@ -39,11 +40,11 @@ public:
                                  const deep_copy::ObjectNumber &object_number,
                                  ContextWQ *work_queue,
                                  SnapSeqs *snap_seqs,
-                                 ProgressContext *prog_ctx,
+                                 deep_copy::Handler *handler,
                                  Context *on_finish) {
     return new DeepCopyRequest(src_image_ctx, dst_image_ctx, src_snap_id_start,
                                src_snap_id_end, dst_snap_id_start, flatten,
-                               object_number, work_queue, snap_seqs, prog_ctx,
+                               object_number, work_queue, snap_seqs, handler,
                                on_finish);
   }
 
@@ -53,7 +54,7 @@ public:
                   librados::snap_t dst_snap_id_start,
                   bool flatten, const deep_copy::ObjectNumber &object_number,
                   ContextWQ *work_queue, SnapSeqs *snap_seqs,
-                  ProgressContext *prog_ctx, Context *on_finish);
+                  deep_copy::Handler *handler, Context *on_finish);
   ~DeepCopyRequest();
 
   void send();
@@ -98,7 +99,7 @@ private:
   deep_copy::ObjectNumber m_object_number;
   ContextWQ *m_work_queue;
   SnapSeqs *m_snap_seqs;
-  ProgressContext *m_prog_ctx;
+  deep_copy::Handler *m_handler;
   Context *m_on_finish;
 
   CephContext *m_cct;

diff --git a/src/librbd/api/Image.cc b/src/librbd/api/Image.cc
index 7b7be14acf1c41ea770f2398feeff36dde5e31fc..6b95ac696bcb97a09d7ba1d1bd8151c39d292c85 100644 (file)
--- a/src/librbd/api/Image.cc
+++ b/src/librbd/api/Image.cc
@@ -16,6 +16,7 @@
 #include "librbd/Utils.h"
 #include "librbd/api/Config.h"
 #include "librbd/api/Trash.h"
+#include "librbd/deep_copy/Handler.h"
 #include "librbd/image/CloneRequest.h"
 #include "librbd/image/RemoveRequest.h"
 #include "librbd/image/PreRemoveRequest.h"
@@ -679,9 +680,10 @@ int Image<I>::deep_copy(I *src, I *dest, bool flatten,
 
   C_SaferCond cond;
   SnapSeqs snap_seqs;
-  auto req = DeepCopyRequest<I>::create(src, dest, snap_id_start, snap_id_end,
-                                        0U, flatten, boost::none, op_work_queue,
-                                        &snap_seqs, &prog_ctx, &cond);
+  deep_copy::ProgressHandler progress_handler{&prog_ctx};
+  auto req = DeepCopyRequest<I>::create(
+    src, dest, snap_id_start, snap_id_end, 0U, flatten, boost::none, op_work_queue,
+    &snap_seqs, &progress_handler, &cond);
   req->send();
   int r = cond.wait();
   if (r < 0) {

diff --git a/src/librbd/deep_copy/Handler.h b/src/librbd/deep_copy/Handler.h
new file mode 100644 (file)
index 0000000..cd4eb1d
--- /dev/null
+++ b/src/librbd/deep_copy/Handler.h
@@ -0,0 +1,45 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_LIBRBD_DEEP_COPY_HANDLER_H
+#define CEPH_LIBRBD_DEEP_COPY_HANDLER_H
+
+#include "include/int_types.h"
+#include "include/rbd/librbd.hpp"
+
+namespace librbd {
+namespace deep_copy {
+
+struct Handler {
+  virtual ~Handler() {}
+
+  virtual int update_progress(uint64_t object_number,
+                              uint64_t object_count) = 0;
+};
+
+struct NoOpHandler : public Handler {
+  int update_progress(uint64_t object_number,
+                      uint64_t object_count) override {
+    return 0;
+  }
+};
+
+class ProgressHandler : public NoOpHandler {
+public:
+  ProgressHandler(ProgressContext* progress_ctx)
+    : m_progress_ctx(progress_ctx) {
+  }
+
+  int update_progress(uint64_t object_number,
+                      uint64_t object_count) override {
+    return m_progress_ctx->update_progress(object_number, object_count);
+  }
+
+private:
+  librbd::ProgressContext* m_progress_ctx;
+};
+
+} // namespace deep_copy
+} // namespace librbd
+
+#endif // CEPH_LIBRBD_DEEP_COPY_HANDLER_H

diff --git a/src/librbd/deep_copy/ImageCopyRequest.cc b/src/librbd/deep_copy/ImageCopyRequest.cc
index 09d51169f1a3b409233537d5c7d1e0b13c0962ef..8b2b610300ff12c158112ade32ca01ab17c7f435 100644 (file)
--- a/src/librbd/deep_copy/ImageCopyRequest.cc
+++ b/src/librbd/deep_copy/ImageCopyRequest.cc
@@ -5,6 +5,7 @@
 #include "ObjectCopyRequest.h"
 #include "common/errno.h"
 #include "librbd/Utils.h"
+#include "librbd/deep_copy/Handler.h"
 #include "librbd/deep_copy/Utils.h"
 #include "librbd/image/CloseRequest.h"
 #include "librbd/image/OpenRequest.h"
@@ -30,13 +31,13 @@ ImageCopyRequest<I>::ImageCopyRequest(I *src_image_ctx, I *dst_image_ctx,
                                       bool flatten,
                                       const ObjectNumber &object_number,
                                       const SnapSeqs &snap_seqs,
-                                      ProgressContext *prog_ctx,
+                                      Handler *handler,
                                       Context *on_finish)
   : RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
     m_dst_image_ctx(dst_image_ctx), m_src_snap_id_start(src_snap_id_start),
     m_src_snap_id_end(src_snap_id_end), m_dst_snap_id_start(dst_snap_id_start),
     m_flatten(flatten), m_object_number(object_number), m_snap_seqs(snap_seqs),
-    m_prog_ctx(prog_ctx), m_on_finish(on_finish), m_cct(dst_image_ctx->cct),
+    m_handler(handler), m_on_finish(on_finish), m_cct(dst_image_ctx->cct),
     m_lock(ceph::make_mutex(unique_lock_name("ImageCopyRequest::m_lock", this))) {
 }
 
@@ -193,7 +194,7 @@ void ImageCopyRequest<I>::handle_object_copy(uint64_t object_no, int r) {
         uint64_t progress_object_no = *m_object_number + 1;
         m_updating_progress = true;
         m_lock.unlock();
-        m_prog_ctx->update_progress(progress_object_no, m_end_object_no);
+        m_handler->update_progress(progress_object_no, m_end_object_no);
         m_lock.lock();
         ceph_assert(m_updating_progress);
         m_updating_progress = false;

diff --git a/src/librbd/deep_copy/ImageCopyRequest.h b/src/librbd/deep_copy/ImageCopyRequest.h
index 45967fdaf2a548378b2b3c2617de00b1e74f6666..63b4bf3daaf4e77188d36e6b33a68a201d99ec82 100644 (file)
--- a/src/librbd/deep_copy/ImageCopyRequest.h
+++ b/src/librbd/deep_copy/ImageCopyRequest.h
@@ -22,10 +22,11 @@ class Context;
 namespace librbd {
 
 class ImageCtx;
-class ProgressContext;
 
 namespace deep_copy {
 
+class Handler;
+
 template <typename ImageCtxT = ImageCtx>
 class ImageCopyRequest : public RefCountedObject {
 public:
@@ -37,11 +38,11 @@ public:
                                   bool flatten,
                                   const ObjectNumber &object_number,
                                   const SnapSeqs &snap_seqs,
-                                  ProgressContext *prog_ctx,
+                                  Handler *handler,
                                   Context *on_finish) {
     return new ImageCopyRequest(src_image_ctx, dst_image_ctx, src_snap_id_start,
                                 src_snap_id_end, dst_snap_id_start, flatten,
-                                object_number, snap_seqs, prog_ctx, on_finish);
+                                object_number, snap_seqs, handler, on_finish);
   }
 
   ImageCopyRequest(ImageCtxT *src_image_ctx, ImageCtxT *dst_image_ctx,
@@ -49,7 +50,7 @@ public:
                    librados::snap_t src_snap_id_end,
                    librados::snap_t dst_snap_id_start,
                    bool flatten, const ObjectNumber &object_number,
-                   const SnapSeqs &snap_seqs, ProgressContext *prog_ctx,
+                   const SnapSeqs &snap_seqs, Handler *handler,
                    Context *on_finish);
 
   void send();
@@ -83,7 +84,7 @@ private:
   bool m_flatten;
   ObjectNumber m_object_number;
   SnapSeqs m_snap_seqs;
-  ProgressContext *m_prog_ctx;
+  Handler *m_handler;
   Context *m_on_finish;
 
   CephContext *m_cct;

diff --git a/src/test/librbd/deep_copy/test_mock_ImageCopyRequest.cc b/src/test/librbd/deep_copy/test_mock_ImageCopyRequest.cc
index a0a0c18b47b60c3145c518e4be8537e089b18744..95c157a10c2f00375df5bb434143187fd015c38a 100644 (file)
--- a/src/test/librbd/deep_copy/test_mock_ImageCopyRequest.cc
+++ b/src/test/librbd/deep_copy/test_mock_ImageCopyRequest.cc
@@ -7,6 +7,7 @@
 #include "librbd/ImageState.h"
 #include "librbd/internal.h"
 #include "librbd/Operations.h"
+#include "librbd/deep_copy/Handler.h"
 #include "librbd/deep_copy/ImageCopyRequest.h"
 #include "librbd/deep_copy/ObjectCopyRequest.h"
 #include "librbd/image/CloseRequest.h"
@@ -313,7 +314,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, SimpleImage) {
   expect_get_image_size(mock_src_image_ctx, 0);
   expect_object_copy_send(mock_object_copy_request);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -343,7 +344,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, FastDiff) {
   expect_get_image_size(mock_src_image_ctx, 1 << m_src_image_ctx->order);
   expect_get_image_size(mock_src_image_ctx, 0);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -380,12 +381,12 @@ TEST_F(TestMockDeepCopyImageCopyRequest, OutOfOrder) {
 
   EXPECT_CALL(mock_object_copy_request, send()).Times(object_count);
 
-  class ProgressContext : public librbd::ProgressContext {
+  class Handler : public librbd::deep_copy::NoOpHandler {
   public:
     uint64_t object_count;
     librbd::deep_copy::ObjectNumber expected_object_number;
 
-    ProgressContext(uint64_t object_count)
+    Handler(uint64_t object_count)
       : object_count(object_count) {
     }
 
@@ -401,13 +402,13 @@ TEST_F(TestMockDeepCopyImageCopyRequest, OutOfOrder) {
 
       return 0;
     }
-  } prog_ctx(object_count);
+  } handler(object_count);
 
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
                                           0, snap_id_end, 0, false, boost::none,
-                                          m_snap_seqs, &prog_ctx, &ctx);
+                                          m_snap_seqs, &handler, &ctx);
   request->send();
 
   std::map<uint64_t, Context*> copy_contexts;
@@ -449,7 +450,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, SnapshotSubset) {
   expect_get_image_size(mock_src_image_ctx, 0);
   expect_object_copy_send(mock_object_copy_request);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -481,7 +482,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, RestartPartialSync) {
   expect_get_image_size(mock_src_image_ctx, 0);
   expect_object_copy_send(mock_object_copy_request);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -517,7 +518,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, Cancel) {
   expect_get_image_size(mock_src_image_ctx, 0);
   expect_object_copy_send(mock_object_copy_request);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -556,20 +557,20 @@ TEST_F(TestMockDeepCopyImageCopyRequest, Cancel_Inflight_Sync) {
 
   EXPECT_CALL(mock_object_copy_request, send()).Times(6);
 
-  struct ProgressContext : public librbd::ProgressContext {
+  struct Handler : public librbd::deep_copy::NoOpHandler {
     librbd::deep_copy::ObjectNumber object_number;
 
     int update_progress(uint64_t object_no, uint64_t end_object_no) override {
       object_number = object_number ? *object_number + 1 : 0;
       return 0;
     }
-  } prog_ctx;
+  } handler;
 
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
                                           0, snap_id_end, 0, false, boost::none,
-                                          m_snap_seqs, &prog_ctx, &ctx);
+                                          m_snap_seqs, &handler, &ctx);
   request->send();
 
   ASSERT_EQ(m_snap_map, wait_for_snap_map(mock_object_copy_request));
@@ -587,14 +588,14 @@ TEST_F(TestMockDeepCopyImageCopyRequest, Cancel_Inflight_Sync) {
   cancel_ctx->complete(0);
 
   ASSERT_EQ(-ECANCELED, ctx.wait());
-  ASSERT_EQ(5u, prog_ctx.object_number.get());
+  ASSERT_EQ(5u, handler.object_number.get());
 }
 
 TEST_F(TestMockDeepCopyImageCopyRequest, MissingSnap) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -611,7 +612,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, MissingFromSnap) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -631,7 +632,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, EmptySnapMap) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,
@@ -650,7 +651,7 @@ TEST_F(TestMockDeepCopyImageCopyRequest, EmptySnapSeqs) {
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
 
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   C_SaferCond ctx;
   auto request = new MockImageCopyRequest(&mock_src_image_ctx,
                                           &mock_dst_image_ctx,

diff --git a/src/test/librbd/test_mock_DeepCopyRequest.cc b/src/test/librbd/test_mock_DeepCopyRequest.cc
index fa5f77e8f468e04c03fe537783dffe60d11153c8..340fe1e2a4d67bbe34537a690aaa8dbd60fafa5f 100644 (file)
--- a/src/test/librbd/test_mock_DeepCopyRequest.cc
+++ b/src/test/librbd/test_mock_DeepCopyRequest.cc
@@ -8,6 +8,7 @@
 #include "librbd/Operations.h"
 #include "librbd/internal.h"
 #include "librbd/api/Image.h"
+#include "librbd/deep_copy/Handler.h"
 #include "librbd/deep_copy/ImageCopyRequest.h"
 #include "librbd/deep_copy/MetadataCopyRequest.h"
 #include "librbd/deep_copy/SnapshotCopyRequest.h"
@@ -46,7 +47,7 @@ public:
       librados::snap_t src_snap_id_end,
       librados::snap_t dst_snap_id_start,
       bool flatten, const ObjectNumber &object_number,
-      const SnapSeqs &snap_seqs, ProgressContext *prog_ctx,
+      const SnapSeqs &snap_seqs, Handler *handler,
       Context *on_finish) {
     ceph_assert(s_instance != nullptr);
     s_instance->on_finish = on_finish;
@@ -266,7 +267,7 @@ TEST_F(TestMockDeepCopyRequest, SimpleCopy) {
 
   C_SaferCond ctx;
   librbd::SnapSeqs snap_seqs;
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
       &mock_src_image_ctx, &mock_dst_image_ctx, 0, CEPH_NOSNAP, 0, false,
       boost::none, m_work_queue, &snap_seqs, &no_op, &ctx);
@@ -284,7 +285,7 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnCopySnapshots) {
 
   C_SaferCond ctx;
   librbd::SnapSeqs snap_seqs;
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
       &mock_src_image_ctx, &mock_dst_image_ctx, 0, CEPH_NOSNAP, 0, false,
       boost::none, m_work_queue, &snap_seqs, &no_op, &ctx);
@@ -317,7 +318,7 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnRefreshObjectMap) {
 
   C_SaferCond ctx;
   librbd::SnapSeqs snap_seqs;
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
       &mock_src_image_ctx, &mock_dst_image_ctx, 0, CEPH_NOSNAP, 0, false,
       boost::none, m_work_queue, &snap_seqs, &no_op, &ctx);
@@ -337,7 +338,7 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnCopyImage) {
 
   C_SaferCond ctx;
   librbd::SnapSeqs snap_seqs;
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
       &mock_src_image_ctx, &mock_dst_image_ctx, 0, CEPH_NOSNAP, 0, false,
       boost::none, m_work_queue, &snap_seqs, &no_op, &ctx);
@@ -374,7 +375,7 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnCopyMetadata) {
 
   C_SaferCond ctx;
   librbd::SnapSeqs snap_seqs;
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
       &mock_src_image_ctx, &mock_dst_image_ctx, 0, CEPH_NOSNAP, 0, false,
       boost::none, m_work_queue, &snap_seqs, &no_op, &ctx);
@@ -415,7 +416,7 @@ TEST_F(TestMockDeepCopyRequest, Snap) {
 
   C_SaferCond ctx;
   librbd::SnapSeqs snap_seqs = {{m_src_image_ctx->snap_id, 123}};
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
       &mock_src_image_ctx, &mock_dst_image_ctx, 0, m_src_image_ctx->snap_id,
       0, false, boost::none, m_work_queue, &snap_seqs, &no_op, &ctx);
@@ -452,7 +453,7 @@ TEST_F(TestMockDeepCopyRequest, ErrorOnRollbackObjectMap) {
 
   C_SaferCond ctx;
   librbd::SnapSeqs snap_seqs = {{m_src_image_ctx->snap_id, 123}};
-  librbd::NoOpProgressContext no_op;
+  librbd::deep_copy::NoOpHandler no_op;
   auto request = librbd::DeepCopyRequest<librbd::MockTestImageCtx>::create(
       &mock_src_image_ctx, &mock_dst_image_ctx, 0, m_src_image_ctx->snap_id,
       0, false, boost::none, m_work_queue, &snap_seqs, &no_op, &ctx);

diff --git a/src/test/rbd_mirror/image_replayer/snapshot/test_mock_Replayer.cc b/src/test/rbd_mirror/image_replayer/snapshot/test_mock_Replayer.cc
index b2e95bad097e146e0d99d4d3d39afa0774638c38..cfbc675a6b2288ece01f99fffe82d253955dd52a 100644 (file)
--- a/src/test/rbd_mirror/image_replayer/snapshot/test_mock_Replayer.cc
+++ b/src/test/rbd_mirror/image_replayer/snapshot/test_mock_Replayer.cc
@@ -51,7 +51,7 @@ struct ImageCopyRequest<MockTestImageCtx> {
                                   bool flatten,
                                   const ObjectNumber &object_number,
                                   const SnapSeqs &snap_seqs,
-                                  ProgressContext *prog_ctx,
+                                  Handler *handler,
                                   Context *on_finish) {
     ceph_assert(s_instance != nullptr);
     s_instance->src_snap_id_start = src_snap_id_start;

diff --git a/src/test/rbd_mirror/test_mock_ImageSync.cc b/src/test/rbd_mirror/test_mock_ImageSync.cc
index 743418325ced0d1d65802ed057b3d3063d13453c..5b424718cb7384ef363d401b1c4b0667dcf0f7ee 100644 (file)
--- a/src/test/rbd_mirror/test_mock_ImageSync.cc
+++ b/src/test/rbd_mirror/test_mock_ImageSync.cc
@@ -36,7 +36,7 @@ public:
       librados::snap_t src_snap_id_start, librados::snap_t src_snap_id_end,
       librados::snap_t dst_snap_id_start, bool flatten,
       const librbd::deep_copy::ObjectNumber &object_number,
-      ContextWQ *work_queue, SnapSeqs *snap_seqs, ProgressContext *prog_ctx,
+      ContextWQ *work_queue, SnapSeqs *snap_seqs, deep_copy::Handler *handler,
       Context *on_finish) {
     ceph_assert(s_instance != nullptr);
     s_instance->on_finish = on_finish;
@@ -62,7 +62,6 @@ DeepCopyRequest<librbd::MockTestImageCtx>* DeepCopyRequest<librbd::MockTestImage
 } // namespace librbd
 
 // template definitions
-template class rbd::mirror::ImageSync<librbd::MockTestImageCtx>;
 #include "tools/rbd_mirror/ImageSync.cc"
 
 namespace rbd {

diff --git a/src/tools/rbd_mirror/ImageSync.cc b/src/tools/rbd_mirror/ImageSync.cc
index 2765b66bf29dbf58e9f0db825ea7fe3d2ab81817..a56723be2edad69cf0e04f5a36042ac913e58bc7 100644 (file)
--- a/src/tools/rbd_mirror/ImageSync.cc
+++ b/src/tools/rbd_mirror/ImageSync.cc
@@ -12,6 +12,7 @@
 #include "librbd/ImageState.h"
 #include "librbd/Utils.h"
 #include "librbd/internal.h"
+#include "librbd/deep_copy/Handler.h"
 #include "tools/rbd_mirror/Threads.h"
 #include "tools/rbd_mirror/image_sync/SyncPointCreateRequest.h"
 #include "tools/rbd_mirror/image_sync/SyncPointPruneRequest.h"
@@ -32,9 +33,10 @@ using librbd::util::create_context_callback;
 using librbd::util::unique_lock_name;
 
 template <typename I>
-class ImageSync<I>::ImageCopyProgressContext : public librbd::ProgressContext {
+class ImageSync<I>::ImageCopyProgressHandler
+  : public librbd::deep_copy::NoOpHandler {
 public:
-  ImageCopyProgressContext(ImageSync *image_sync) : image_sync(image_sync) {
+  ImageCopyProgressHandler(ImageSync *image_sync) : image_sync(image_sync) {
   }
 
   int update_progress(uint64_t object_no, uint64_t object_count) override {
@@ -73,7 +75,7 @@ ImageSync<I>::ImageSync(
 template <typename I>
 ImageSync<I>::~ImageSync() {
   ceph_assert(m_image_copy_request == nullptr);
-  ceph_assert(m_image_copy_prog_ctx == nullptr);
+  ceph_assert(m_image_copy_prog_handler == nullptr);
   ceph_assert(m_update_sync_ctx == nullptr);
 }
 
@@ -252,11 +254,11 @@ void ImageSync<I>::send_copy_image() {
 
   Context *ctx = create_context_callback<
     ImageSync<I>, &ImageSync<I>::handle_copy_image>(this);
-  m_image_copy_prog_ctx = new ImageCopyProgressContext(this);
+  m_image_copy_prog_handler = new ImageCopyProgressHandler(this);
   m_image_copy_request = librbd::DeepCopyRequest<I>::create(
       m_remote_image_ctx, m_local_image_ctx, snap_id_start, snap_id_end,
       0, false, object_number, m_threads->work_queue, &m_snap_seqs_copy,
-      m_image_copy_prog_ctx, ctx);
+      m_image_copy_prog_handler, ctx);
   m_image_copy_request->get();
   m_lock.unlock();
 
@@ -273,8 +275,8 @@ void ImageSync<I>::handle_copy_image(int r) {
     std::scoped_lock locker{m_threads->timer_lock, m_lock};
     m_image_copy_request->put();
     m_image_copy_request = nullptr;
-    delete m_image_copy_prog_ctx;
-    m_image_copy_prog_ctx = nullptr;
+    delete m_image_copy_prog_handler;
+    m_image_copy_prog_handler = nullptr;
     if (r == 0 && m_canceled) {
       r = -ECANCELED;
     }

diff --git a/src/tools/rbd_mirror/ImageSync.h b/src/tools/rbd_mirror/ImageSync.h
index 0662732327068777c303c1e3c2296fc96be0dbfb..b1d88b857e3bc0370822db18291f98d2268cec98 100644 (file)
--- a/src/tools/rbd_mirror/ImageSync.h
+++ b/src/tools/rbd_mirror/ImageSync.h
@@ -14,7 +14,6 @@
 class Context;
 class ContextWQ;
 namespace journal { class Journaler; }
-namespace librbd { class ProgressContext; }
 namespace librbd { template <typename> class DeepCopyRequest; }
 
 namespace rbd {
@@ -90,7 +89,7 @@ private:
    * @endverbatim
    */
 
-  class ImageCopyProgressContext;
+  class ImageCopyProgressHandler;
 
   Threads<ImageCtxT>* m_threads;
   ImageCtxT *m_local_image_ctx;
@@ -104,7 +103,7 @@ private:
   bool m_canceled = false;
 
   librbd::DeepCopyRequest<ImageCtxT> *m_image_copy_request = nullptr;
-  librbd::ProgressContext *m_image_copy_prog_ctx = nullptr;
+  ImageCopyProgressHandler *m_image_copy_prog_handler = nullptr;
 
   bool m_updating_sync_point = false;
   Context *m_update_sync_ctx = nullptr;

diff --git a/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.cc b/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.cc
index 69fb3d93af4d8355ac2a7997639c921eb1b62d23..5656b16a01de3c435fe58375fb443c434a0b0ca1 100644 (file)
--- a/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.cc
+++ b/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.cc
@@ -11,6 +11,7 @@
 #include "librbd/ImageCtx.h"
 #include "librbd/ImageState.h"
 #include "librbd/Utils.h"
+#include "librbd/deep_copy/Handler.h"
 #include "librbd/deep_copy/ImageCopyRequest.h"
 #include "librbd/deep_copy/SnapshotCopyRequest.h"
 #include "librbd/mirror/snapshot/CreateNonPrimaryRequest.h"
@@ -96,10 +97,10 @@ struct Replayer<I>::C_TrackedOp : public Context {
 };
 
 template <typename I>
-struct Replayer<I>::ProgressContext : public librbd::ProgressContext {
+struct Replayer<I>::DeepCopyHandler : public librbd::deep_copy::Handler {
   Replayer *replayer;
 
-  ProgressContext(Replayer* replayer) : replayer(replayer) {
+  DeepCopyHandler(Replayer* replayer) : replayer(replayer) {
   }
 
   int update_progress(uint64_t object_number, uint64_t object_count) override {
@@ -132,7 +133,7 @@ Replayer<I>::~Replayer() {
   dout(10) << dendl;
   ceph_assert(m_state == STATE_COMPLETE);
   ceph_assert(m_update_watch_ctx == nullptr);
-  ceph_assert(m_progress_ctx == nullptr);
+  ceph_assert(m_deep_copy_handler == nullptr);
 }
 
 template <typename I>
@@ -791,7 +792,7 @@ void Replayer<I>::copy_image() {
            << m_local_mirror_snap_ns.last_copied_object_number << ", "
            << "snap_seqs=" << m_local_mirror_snap_ns.snap_seqs << dendl;
 
-  m_progress_ctx = new ProgressContext(this);
+  m_deep_copy_handler = new DeepCopyHandler(this);
   auto ctx = create_context_callback<
     Replayer<I>, &Replayer<I>::handle_copy_image>(this);
   auto req = librbd::deep_copy::ImageCopyRequest<I>::create(
@@ -801,7 +802,7 @@ void Replayer<I>::copy_image() {
       librbd::deep_copy::ObjectNumber{
         m_local_mirror_snap_ns.last_copied_object_number} :
       librbd::deep_copy::ObjectNumber{}),
-    m_local_mirror_snap_ns.snap_seqs, m_progress_ctx, ctx);
+    m_local_mirror_snap_ns.snap_seqs, m_deep_copy_handler, ctx);
   req->send();
 }
 
@@ -809,8 +810,8 @@ template <typename I>
 void Replayer<I>::handle_copy_image(int r) {
   dout(10) << "r=" << r << dendl;
 
-  delete m_progress_ctx;
-  m_progress_ctx = nullptr;
+  delete m_deep_copy_handler;
+  m_deep_copy_handler = nullptr;
 
   if (r < 0) {
     derr << "failed to copy remote image to local image: " << cpp_strerror(r)

diff --git a/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.h b/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.h
index e7536f5a6fa26ea96694f7eaa23597221917d6db..ba49d7cd7991cfa4224e8d4f014c8ace222f4d2c 100644 (file)
--- a/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.h
+++ b/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.h
@@ -183,7 +183,7 @@ private:
 
   struct C_UpdateWatchCtx;
   struct C_TrackedOp;
-  struct ProgressContext;
+  struct DeepCopyHandler;
 
   Threads<ImageCtxT>* m_threads;
   InstanceWatcher<ImageCtxT>* m_instance_watcher;
@@ -220,7 +220,7 @@ private:
   cls::rbd::MirrorSnapshotNamespace m_remote_mirror_snap_ns;
 
   librbd::mirror::snapshot::ImageState m_image_state;
-  ProgressContext* m_progress_ctx = nullptr;
+  DeepCopyHandler* m_deep_copy_handler = nullptr;
 
   bool m_remote_image_updated = false;
   bool m_updating_sync_point = false;