rbd-mirror: simplified acquire/release notification messages

The other instances should already know about the possible peers, so
we can co-opt these messages for use by the policy mapper.

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

diff --git a/src/test/rbd_mirror/test_mock_InstanceReplayer.cc b/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
index 10f58232249c9df6934354834b154c7d40e46f49..accd0c7b20cccff10a8eb8c71da5ab15beb54a60 100644 (file)
--- a/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
@@ -186,7 +186,6 @@ TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
   EXPECT_CALL(mock_image_replayer, start(nullptr, false));
 
   instance_replayer.acquire_image(&mock_instance_watcher, global_image_id,
-                                  "remote_mirror_uuid", "remote_image_id",
                                   &on_acquire);
   ASSERT_EQ(0, on_acquire.wait());
 
@@ -208,8 +207,7 @@ TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
     .WillOnce(Return(true));
   EXPECT_CALL(mock_image_replayer, destroy());
 
-  instance_replayer.release_image("global_image_id", "remote_mirror_uuid",
-                                  "remote_image_id", false, &on_release);
+  instance_replayer.release_image("global_image_id", &on_release);
   ASSERT_EQ(0, on_release.wait());
 
   instance_replayer.shut_down();

diff --git a/src/test/rbd_mirror/test_mock_InstanceWatcher.cc b/src/test/rbd_mirror/test_mock_InstanceWatcher.cc
index b9d869fdc9d488a5cbf303fc761a8c6896267747..69497d3918cebc18959085f1a24de43df67b1394 100644 (file)
--- a/src/test/rbd_mirror/test_mock_InstanceWatcher.cc
+++ b/src/test/rbd_mirror/test_mock_InstanceWatcher.cc
@@ -76,11 +76,9 @@ struct Threads<librbd::MockTestImageCtx> {
 
 template <>
 struct InstanceReplayer<librbd::MockTestImageCtx> {
-  MOCK_METHOD5(acquire_image, void(InstanceWatcher<librbd::MockTestImageCtx> *,
-                                   const std::string &, const std::string &,
+  MOCK_METHOD3(acquire_image, void(InstanceWatcher<librbd::MockTestImageCtx> *,
                                    const std::string &, Context *));
-  MOCK_METHOD5(release_image, void(const std::string &, const std::string &,
-                                   const std::string &, bool, Context *));
+  MOCK_METHOD2(release_image, void(const std::string &, Context *));
   MOCK_METHOD3(remove_peer_image, void(const std::string&, const std::string&,
                                        Context *));
 };
@@ -367,38 +365,32 @@ TEST_F(TestMockInstanceWatcher, ImageAcquireRelease) {
 
   // Acquire Image on the the same instance
   EXPECT_CALL(mock_instance_replayer1, acquire_image(instance_watcher1, "gid",
-                                                     "uuid", "id", _))
-      .WillOnce(WithArg<4>(CompleteContext(0)));
+                                                     _))
+      .WillOnce(WithArg<2>(CompleteContext(0)));
   C_SaferCond on_acquire1;
-  instance_watcher1->notify_image_acquire(instance_id1, "gid", "uuid", "id",
-                                          &on_acquire1);
+  instance_watcher1->notify_image_acquire(instance_id1, "gid", &on_acquire1);
   ASSERT_EQ(0, on_acquire1.wait());
 
   // Acquire Image on the other instance
   EXPECT_CALL(mock_instance_replayer2, acquire_image(instance_watcher2, "gid",
-                                                     "uuid", "id", _))
-      .WillOnce(WithArg<4>(CompleteContext(0)));
+                                                     _))
+      .WillOnce(WithArg<2>(CompleteContext(0)));
   C_SaferCond on_acquire2;
-  instance_watcher1->notify_image_acquire(instance_id2, "gid", "uuid", "id",
-                                          &on_acquire2);
+  instance_watcher1->notify_image_acquire(instance_id2, "gid", &on_acquire2);
   ASSERT_EQ(0, on_acquire2.wait());
 
   // Release Image on the the same instance
-  EXPECT_CALL(mock_instance_replayer1, release_image("gid", "uuid", "id", true,
-                                                     _))
-      .WillOnce(WithArg<4>(CompleteContext(0)));
+  EXPECT_CALL(mock_instance_replayer1, release_image("gid", _))
+      .WillOnce(WithArg<1>(CompleteContext(0)));
   C_SaferCond on_release1;
-  instance_watcher1->notify_image_release(instance_id1, "gid", "uuid", "id",
-                                          true, &on_release1);
+  instance_watcher1->notify_image_release(instance_id1, "gid", &on_release1);
   ASSERT_EQ(0, on_release1.wait());
 
   // Release Image on the other instance
-  EXPECT_CALL(mock_instance_replayer2, release_image("gid", "uuid", "id", true,
-                                                     _))
-      .WillOnce(WithArg<4>(CompleteContext(0)));
+  EXPECT_CALL(mock_instance_replayer2, release_image("gid", _))
+      .WillOnce(WithArg<1>(CompleteContext(0)));
   C_SaferCond on_release2;
-  instance_watcher1->notify_image_release(instance_id2, "gid", "uuid", "id",
-                                          true, &on_release2);
+  instance_watcher1->notify_image_release(instance_id2, "gid", &on_release2);
   ASSERT_EQ(0, on_release2.wait());
 
   // Shutdown instance watcher 1
@@ -521,8 +513,7 @@ TEST_F(TestMockInstanceWatcher, ImageAcquireReleaseCancel) {
                   }));
 
   C_SaferCond on_acquire;
-  instance_watcher->notify_image_acquire("other", "gid", "uuid", "id",
-                                         &on_acquire);
+  instance_watcher->notify_image_acquire("other", "gid", &on_acquire);
   ASSERT_EQ(-ECANCELED, on_acquire.wait());
 
   // Send Release Image and cancel
@@ -543,8 +534,7 @@ TEST_F(TestMockInstanceWatcher, ImageAcquireReleaseCancel) {
                   }));
 
   C_SaferCond on_release;
-  instance_watcher->notify_image_release("other", "gid", "uuid", "id",
-                                         true, &on_release);
+  instance_watcher->notify_image_release("other", "gid", &on_release);
   ASSERT_EQ(-ECANCELED, on_release.wait());
 
   // Shutdown

diff --git a/src/tools/rbd_mirror/InstanceReplayer.cc b/src/tools/rbd_mirror/InstanceReplayer.cc
index d6c922ac10514b977b15422023872f157982096a..1df9a44f5f55abe4a9576f8cb47c1b45b3eea451 100644 (file)
--- a/src/tools/rbd_mirror/InstanceReplayer.cc
+++ b/src/tools/rbd_mirror/InstanceReplayer.cc
@@ -132,11 +132,8 @@ void InstanceReplayer<I>::release_all(Context *on_finish) {
 template <typename I>
 void InstanceReplayer<I>::acquire_image(InstanceWatcher<I> *instance_watcher,
                                         const std::string &global_image_id,
-                                        const std::string &peer_mirror_uuid,
-                                        const std::string &peer_image_id,
                                         Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << ", peer_mirror_uuid="
-           << peer_mirror_uuid << ", peer_image_id=" << peer_image_id << dendl;
+  dout(20) << "global_image_id=" << global_image_id << dendl;
 
   Mutex::Locker locker(m_lock);
 
@@ -166,15 +163,10 @@ void InstanceReplayer<I>::acquire_image(InstanceWatcher<I> *instance_watcher,
 
 template <typename I>
 void InstanceReplayer<I>::release_image(const std::string &global_image_id,
-                                        const std::string &peer_mirror_uuid,
-                                        const std::string &peer_image_id,
-                                        bool schedule_delete,
                                         Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << ", peer_mirror_uuid="
-           << peer_mirror_uuid << ", peer_image_id=" << peer_image_id << dendl;
+  dout(20) << "global_image_id=" << global_image_id << dendl;
 
   Mutex::Locker locker(m_lock);
-
   assert(m_on_shut_down == nullptr);
 
   auto it = m_image_replayers.find(global_image_id);

diff --git a/src/tools/rbd_mirror/InstanceReplayer.h b/src/tools/rbd_mirror/InstanceReplayer.h
index d5c59748a9355099437d1a93e203a75bf8b15fee..4721f742a3ae08405deb99d14e0c8f3736271ac1 100644 (file)
--- a/src/tools/rbd_mirror/InstanceReplayer.h
+++ b/src/tools/rbd_mirror/InstanceReplayer.h
@@ -55,14 +55,8 @@ public:
   void add_peer(std::string peer_uuid, librados::IoCtx io_ctx);
 
   void acquire_image(InstanceWatcher<ImageCtxT> *instance_watcher,
-                     const std::string &global_image_id,
-                     const std::string &peer_mirror_uuid,
-                     const std::string &peer_image_id,
-                     Context *on_finish);
-  void release_image(const std::string &global_image_id,
-                     const std::string &peer_mirror_uuid,
-                     const std::string &peer_image_id,
-                     bool schedule_delete, Context *on_finish);
+                     const std::string &global_image_id, Context *on_finish);
+  void release_image(const std::string &global_image_id, Context *on_finish);
   void remove_peer_image(const std::string &global_image_id,
                          const std::string &peer_mirror_uuid,
                          Context *on_finish);

diff --git a/src/tools/rbd_mirror/InstanceWatcher.cc b/src/tools/rbd_mirror/InstanceWatcher.cc
index 69b860a906d6e918cabfe0f5daadb2fc3fdf35ca..0c82c3007fc73f4af29ba3a5dd27d536799a3572 100644 (file)
--- a/src/tools/rbd_mirror/InstanceWatcher.cc
+++ b/src/tools/rbd_mirror/InstanceWatcher.cc
@@ -397,8 +397,7 @@ void InstanceWatcher<I>::remove(Context *on_finish) {
 template <typename I>
 void InstanceWatcher<I>::notify_image_acquire(
     const std::string &instance_id, const std::string &global_image_id,
-    const std::string &peer_mirror_uuid, const std::string &peer_image_id,
-  Context *on_notify_ack) {
+    Context *on_notify_ack) {
   dout(20) << "instance_id=" << instance_id << ", global_image_id="
            << global_image_id << dendl;
 
@@ -407,13 +406,12 @@ void InstanceWatcher<I>::notify_image_acquire(
   assert(m_on_finish == nullptr);
 
   if (instance_id == m_instance_id) {
-    handle_image_acquire(global_image_id, peer_mirror_uuid, peer_image_id,
-                         on_notify_ack);
+    handle_image_acquire(global_image_id, on_notify_ack);
   } else {
     uint64_t request_id = ++m_request_seq;
     bufferlist bl;
-    ::encode(NotifyMessage{ImageAcquirePayload{
-        request_id, global_image_id, peer_mirror_uuid, peer_image_id}}, bl);
+    ::encode(NotifyMessage{ImageAcquirePayload{request_id, global_image_id}},
+             bl);
     auto req = new C_NotifyInstanceRequest(this, instance_id, request_id,
                                            std::move(bl), on_notify_ack);
     req->send();
@@ -422,9 +420,8 @@ void InstanceWatcher<I>::notify_image_acquire(
 
 template <typename I>
 void InstanceWatcher<I>::notify_image_release(
-  const std::string &instance_id, const std::string &global_image_id,
-  const std::string &peer_mirror_uuid, const std::string &peer_image_id,
-  bool schedule_delete, Context *on_notify_ack) {
+    const std::string &instance_id, const std::string &global_image_id,
+    Context *on_notify_ack) {
   dout(20) << "instance_id=" << instance_id << ", global_image_id="
            << global_image_id << dendl;
 
@@ -433,14 +430,12 @@ void InstanceWatcher<I>::notify_image_release(
   assert(m_on_finish == nullptr);
 
   if (instance_id == m_instance_id) {
-    handle_image_release(global_image_id, peer_mirror_uuid, peer_image_id,
-                         schedule_delete, on_notify_ack);
+    handle_image_release(global_image_id, on_notify_ack);
   } else {
     uint64_t request_id = ++m_request_seq;
     bufferlist bl;
-    ::encode(NotifyMessage{ImageReleasePayload{
-        request_id, global_image_id, peer_mirror_uuid, peer_image_id,
-        schedule_delete}}, bl);
+    ::encode(NotifyMessage{ImageReleasePayload{request_id, global_image_id}},
+             bl);
     auto req = new C_NotifyInstanceRequest(this, instance_id, request_id,
                                            std::move(bl), on_notify_ack);
     req->send();
@@ -1125,16 +1120,12 @@ void InstanceWatcher<I>::handle_notify(uint64_t notify_id, uint64_t handle,
 
 template <typename I>
 void InstanceWatcher<I>::handle_image_acquire(
-  const std::string &global_image_id, const std::string &peer_mirror_uuid,
-  const std::string &peer_image_id, Context *on_finish) {
+    const std::string &global_image_id, Context *on_finish) {
   dout(20) << "global_image_id=" << global_image_id << dendl;
 
   auto ctx = new FunctionContext(
-      [this, global_image_id, peer_mirror_uuid, peer_image_id,
-       on_finish] (int r) {
-        m_instance_replayer->acquire_image(this, global_image_id,
-                                           peer_mirror_uuid, peer_image_id,
-                                           on_finish);
+      [this, global_image_id, on_finish] (int r) {
+        m_instance_replayer->acquire_image(this, global_image_id, on_finish);
         m_notify_op_tracker.finish_op();
       });
 
@@ -1144,16 +1135,12 @@ void InstanceWatcher<I>::handle_image_acquire(
 
 template <typename I>
 void InstanceWatcher<I>::handle_image_release(
-  const std::string &global_image_id,  const std::string &peer_mirror_uuid,
-  const std::string &peer_image_id, bool schedule_delete, Context *on_finish) {
+    const std::string &global_image_id, Context *on_finish) {
   dout(20) << "global_image_id=" << global_image_id << dendl;
 
   auto ctx = new FunctionContext(
-      [this, global_image_id, peer_mirror_uuid, peer_image_id, schedule_delete,
-       on_finish] (int r) {
-        m_instance_replayer->release_image(global_image_id, peer_mirror_uuid,
-                                           peer_image_id, schedule_delete,
-                                           on_finish);
+      [this, global_image_id, on_finish] (int r) {
+        m_instance_replayer->release_image(global_image_id, on_finish);
         m_notify_op_tracker.finish_op();
       });
 
@@ -1241,8 +1228,7 @@ void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
   auto on_finish = prepare_request(instance_id, payload.request_id,
                                    on_notify_ack);
   if (on_finish != nullptr) {
-    handle_image_acquire(payload.global_image_id, payload.peer_mirror_uuid,
-                         payload.peer_image_id, on_finish);
+    handle_image_acquire(payload.global_image_id, on_finish);
   }
 }
 
@@ -1256,9 +1242,7 @@ void InstanceWatcher<I>::handle_payload(const std::string &instance_id,
   auto on_finish = prepare_request(instance_id, payload.request_id,
                                    on_notify_ack);
   if (on_finish != nullptr) {
-    handle_image_release(payload.global_image_id, payload.peer_mirror_uuid,
-                         payload.peer_image_id, payload.schedule_delete,
-                         on_finish);
+    handle_image_release(payload.global_image_id, on_finish);
   }
 }
 

diff --git a/src/tools/rbd_mirror/InstanceWatcher.h b/src/tools/rbd_mirror/InstanceWatcher.h
index e04a358df0c191b577ea34eec7a4a20ea6f6e788..be90f10e213736dd635bfbd5e51d64c60760a033 100644 (file)
--- a/src/tools/rbd_mirror/InstanceWatcher.h
+++ b/src/tools/rbd_mirror/InstanceWatcher.h
@@ -65,14 +65,10 @@ public:
 
   void notify_image_acquire(const std::string &instance_id,
                             const std::string &global_image_id,
-                            const std::string &peer_mirror_uuid,
-                            const std::string &peer_image_id,
                             Context *on_notify_ack);
   void notify_image_release(const std::string &instance_id,
                             const std::string &global_image_id,
-                            const std::string &peer_mirror_uuid,
-                            const std::string &peer_image_id,
-                           bool schedule_delete, Context *on_notify_ack);
+                           Context *on_notify_ack);
   void notify_peer_image_removed(const std::string &instance_id,
                                  const std::string &global_image_id,
                                  const std::string &peer_mirror_uuid,
@@ -229,13 +225,9 @@ private:
                      uint64_t notifier_id, bufferlist &bl) override;
 
   void handle_image_acquire(const std::string &global_image_id,
-                            const std::string &peer_mirror_uuid,
-                            const std::string &peer_image_id,
                             Context *on_finish);
   void handle_image_release(const std::string &global_image_id,
-                            const std::string &peer_mirror_uuid,
-                            const std::string &peer_image_id,
-                            bool schedule_delete, Context *on_finish);
+                            Context *on_finish);
   void handle_peer_image_removed(const std::string &global_image_id,
                                  const std::string &peer_mirror_uuid,
                                  Context *on_finish);

diff --git a/src/tools/rbd_mirror/PoolReplayer.cc b/src/tools/rbd_mirror/PoolReplayer.cc
index 4bfd1fc629f0322eb60ba8d6ae23bf6c39618d42..6c3b228dd58aa55a8e2e090ca42f44542a2f6810 100644 (file)
--- a/src/tools/rbd_mirror/PoolReplayer.cc
+++ b/src/tools/rbd_mirror/PoolReplayer.cc
@@ -632,7 +632,6 @@ void PoolReplayer::handle_update(const std::string &mirror_uuid,
     // for now always send to myself (the leader)
     std::string &instance_id = m_instance_watcher->get_instance_id();
     m_instance_watcher->notify_image_acquire(instance_id, image_id.global_id,
-                                             mirror_uuid, image_id.id,
                                              gather_ctx->new_sub());
   }
 

diff --git a/src/tools/rbd_mirror/instance_watcher/Types.cc b/src/tools/rbd_mirror/instance_watcher/Types.cc
index 100096e6348a1346b6b73a286d0851010fcf9f16..69b84e1580ddc6c4627bfdb3222fc7a74f5d6ab7 100644 (file)
--- a/src/tools/rbd_mirror/instance_watcher/Types.cc
+++ b/src/tools/rbd_mirror/instance_watcher/Types.cc
@@ -73,37 +73,16 @@ void PayloadBase::dump(Formatter *f) const {
 void ImagePayloadBase::encode(bufferlist &bl) const {
   PayloadBase::encode(bl);
   ::encode(global_image_id, bl);
-  ::encode(peer_mirror_uuid, bl);
-  ::encode(peer_image_id, bl);
 }
 
 void ImagePayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
   PayloadBase::decode(version, iter);
   ::decode(global_image_id, iter);
-  ::decode(peer_mirror_uuid, iter);
-  ::decode(peer_image_id, iter);
 }
 
 void ImagePayloadBase::dump(Formatter *f) const {
   PayloadBase::dump(f);
   f->dump_string("global_image_id", global_image_id);
-  f->dump_string("peer_mirror_uuid", peer_mirror_uuid);
-  f->dump_string("peer_image_id", peer_image_id);
-}
-
-void ImageReleasePayload::encode(bufferlist &bl) const {
-  ImagePayloadBase::encode(bl);
-  ::encode(schedule_delete, bl);
-}
-
-void ImageReleasePayload::decode(__u8 version, bufferlist::iterator &iter) {
-  ImagePayloadBase::decode(version, iter);
-  ::decode(schedule_delete, iter);
-}
-
-void ImageReleasePayload::dump(Formatter *f) const {
-  ImagePayloadBase::dump(f);
-  f->dump_bool("schedule_delete", schedule_delete);
 }
 
 void PeerImageRemovedPayload::encode(bufferlist &bl) const {
@@ -193,11 +172,10 @@ void NotifyMessage::dump(Formatter *f) const {
 
 void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
   o.push_back(new NotifyMessage(ImageAcquirePayload()));
-  o.push_back(new NotifyMessage(ImageAcquirePayload(1, "gid", "uuid", "id")));
+  o.push_back(new NotifyMessage(ImageAcquirePayload(1, "gid")));
 
   o.push_back(new NotifyMessage(ImageReleasePayload()));
-  o.push_back(new NotifyMessage(ImageReleasePayload(1, "gid", "uuid", "id",
-                                                    true)));
+  o.push_back(new NotifyMessage(ImageReleasePayload(1, "gid")));
 
   o.push_back(new NotifyMessage(PeerImageRemovedPayload()));
   o.push_back(new NotifyMessage(PeerImageRemovedPayload(1, "gid", "uuid")));

diff --git a/src/tools/rbd_mirror/instance_watcher/Types.h b/src/tools/rbd_mirror/instance_watcher/Types.h
index d330f9b4ae78009b74c99daabf213735cafacf1d..70af2f79112b4b5af15ff2d3666a3271732d3634 100644 (file)
--- a/src/tools/rbd_mirror/instance_watcher/Types.h
+++ b/src/tools/rbd_mirror/instance_watcher/Types.h
@@ -42,17 +42,12 @@ struct PayloadBase {
 
 struct ImagePayloadBase : public PayloadBase {
   std::string global_image_id;
-  std::string peer_mirror_uuid;
-  std::string peer_image_id;
 
   ImagePayloadBase() : PayloadBase() {
   }
 
-  ImagePayloadBase(uint64_t request_id, const std::string &global_image_id,
-                   const std::string &peer_mirror_uuid,
-                   const std::string &peer_image_id)
-    : PayloadBase(request_id), global_image_id(global_image_id),
-      peer_mirror_uuid(peer_mirror_uuid), peer_image_id(peer_image_id) {
+  ImagePayloadBase(uint64_t request_id, const std::string &global_image_id)
+    : PayloadBase(request_id), global_image_id(global_image_id) {
   }
 
   void encode(bufferlist &bl) const;
@@ -63,36 +58,21 @@ struct ImagePayloadBase : public PayloadBase {
 struct ImageAcquirePayload : public ImagePayloadBase {
   static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_ACQUIRE;
 
-  ImageAcquirePayload() : ImagePayloadBase() {
+  ImageAcquirePayload() {
   }
-
-  ImageAcquirePayload(uint64_t request_id, const std::string &global_image_id,
-                      const std::string &peer_mirror_uuid,
-                      const std::string &peer_image_id)
-    : ImagePayloadBase(request_id, global_image_id, peer_mirror_uuid,
-                       peer_image_id) {
+  ImageAcquirePayload(uint64_t request_id, const std::string &global_image_id)
+    : ImagePayloadBase(request_id, global_image_id) {
   }
 };
 
 struct ImageReleasePayload : public ImagePayloadBase {
   static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_RELEASE;
 
-  bool schedule_delete;
-
-  ImageReleasePayload() : ImagePayloadBase(), schedule_delete(false) {
+  ImageReleasePayload() {
   }
-
-  ImageReleasePayload(uint64_t request_id, const std::string &global_image_id,
-                      const std::string &peer_mirror_uuid,
-                      const std::string &peer_image_id, bool schedule_delete)
-    : ImagePayloadBase(request_id, global_image_id, peer_mirror_uuid,
-                       peer_image_id),
-      schedule_delete(schedule_delete) {
+  ImageReleasePayload(uint64_t request_id, const std::string &global_image_id)
+    : ImagePayloadBase(request_id, global_image_id) {
   }
-
-  void encode(bufferlist &bl) const;
-  void decode(__u8 version, bufferlist::iterator &iter);
-  void dump(Formatter *f) const;
 };
 
 struct PeerImageRemovedPayload : public PayloadBase {