rbd-mirror: remove recently added public peer image types

They were supposed to be used to pass a list of peer images.
It has turned out unnecessary.

Signed-off-by: Mykola Golub <mgolub@mirantis.com>

diff --git a/src/test/rbd_mirror/test_mock_InstanceReplayer.cc b/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
index 2fef054477324931d95809a4a87513869add7863..d406d9f57fa8474b56d9922d8fca6cc172e03ab6 100644 (file)
--- a/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
@@ -69,7 +69,9 @@ struct ImageReplayer<librbd::MockTestImageCtx> {
   MOCK_METHOD0(restart, void());
   MOCK_METHOD0(flush, void());
   MOCK_METHOD2(print_status, void(Formatter *, stringstream *));
-  MOCK_METHOD1(set_remote_images, void(const PeerImages &));
+  MOCK_METHOD3(add_remote_image, void(const std::string &,
+                                      const std::string &,
+                                      librados::IoCtx &));
   MOCK_METHOD2(remove_remote_image, void(const std::string &,
                                          const std::string &));
   MOCK_METHOD0(remote_images_empty, bool());
@@ -142,8 +144,6 @@ TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
     "local_mirror_uuid", m_local_io_ctx.get_id());
 
   std::string global_image_id("global_image_id");
-  rbd::mirror::instance_watcher::PeerImageIds peer_image_ids =
-    {{"remote_mirror_uuid", "remote_image_id"}};
 
   EXPECT_CALL(mock_image_replayer, get_global_image_id())
     .WillRepeatedly(ReturnRef(global_image_id));
@@ -153,18 +153,20 @@ TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
   InSequence seq;
 
   instance_replayer.init();
-  instance_replayer.set_peers({{"remote_mirror_uuid", m_remote_io_ctx}});
+  instance_replayer.add_peer("remote_mirror_uuid", m_remote_io_ctx);
 
   // Acquire
 
   C_SaferCond on_acquire;
 
-  EXPECT_CALL(mock_image_replayer, set_remote_images(_));
+  EXPECT_CALL(mock_image_replayer, add_remote_image("remote_mirror_uuid",
+                                                    "remote_image_id", _));
   EXPECT_CALL(mock_image_replayer, is_stopped())
     .WillOnce(Return(true));
   EXPECT_CALL(mock_image_replayer, start(nullptr, false));
 
-  instance_replayer.acquire_image(global_image_id, peer_image_ids, &on_acquire);
+  instance_replayer.acquire_image(global_image_id, "remote_mirror_uuid",
+                                  "remote_image_id", &on_acquire);
   ASSERT_EQ(0, on_acquire.wait());
 
   // Release
@@ -189,8 +191,8 @@ TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
     .WillOnce(Return(true));
   EXPECT_CALL(mock_image_replayer, destroy());
 
-  instance_replayer.release_image("global_image_id", peer_image_ids, false,
-                                  &on_release);
+  instance_replayer.release_image("global_image_id", "remote_mirror_uuid",
+                                  "remote_image_id", false, &on_release);
   ASSERT_EQ(0, on_release.wait());
 
   instance_replayer.shut_down();

diff --git a/src/tools/rbd_mirror/CMakeLists.txt b/src/tools/rbd_mirror/CMakeLists.txt
index 4f1acbcbd4f2e2732f8792fbbfd1919401e2180e..8086d0e58154447bae572a01fc92c33332c52915 100644 (file)
--- a/src/tools/rbd_mirror/CMakeLists.txt
+++ b/src/tools/rbd_mirror/CMakeLists.txt
@@ -1,5 +1,4 @@
 add_library(rbd_mirror_types STATIC
-  instance_watcher/Types.cc
   leader_watcher/Types.cc)
 
 set(rbd_mirror_internal

diff --git a/src/tools/rbd_mirror/ImageReplayer.cc b/src/tools/rbd_mirror/ImageReplayer.cc
index c89e9305b07442063e0f858742e2a08ed5fb47a2..0a58a6b72c6b9bdd27cce3941e5b89abfdda43cf 100644 (file)
--- a/src/tools/rbd_mirror/ImageReplayer.cc
+++ b/src/tools/rbd_mirror/ImageReplayer.cc
@@ -326,7 +326,7 @@ void ImageReplayer<I>::add_remote_image(const std::string &mirror_uuid,
                                         librados::IoCtx &io_ctx) {
   Mutex::Locker locker(m_lock);
 
-  PeerImage remote_image(mirror_uuid, io_ctx, image_id);
+  RemoteImage remote_image(mirror_uuid, image_id, io_ctx);
   auto it = m_remote_images.find(remote_image);
   if (it == m_remote_images.end()) {
     m_remote_images.insert(remote_image);
@@ -340,12 +340,6 @@ void ImageReplayer<I>::remove_remote_image(const std::string &mirror_uuid,
   m_remote_images.erase({mirror_uuid, image_id});
 }
 
-template <typename I>
-void ImageReplayer<I>::set_remote_images(const PeerImages &remote_images) {
-  Mutex::Locker locker(m_lock);
-  m_remote_images = remote_images;
-}
-
 template <typename I>
 bool ImageReplayer<I>::remote_images_empty() const {
   Mutex::Locker locker(m_lock);

diff --git a/src/tools/rbd_mirror/ImageReplayer.h b/src/tools/rbd_mirror/ImageReplayer.h
index 81d16e1be101e0f44a25f538dc8a9e96d39f7798..87902dae9fb5b1cf9f11fe04beca4e137f101c9e 100644 (file)
--- a/src/tools/rbd_mirror/ImageReplayer.h
+++ b/src/tools/rbd_mirror/ImageReplayer.h
@@ -110,8 +110,6 @@ public:
                         librados::IoCtx &remote_io_ctx);
   void remove_remote_image(const std::string &remote_mirror_uuid,
                            const std::string &remote_image_id);
-  void set_remote_images(const PeerImages &remote_images);
-
   bool remote_images_empty() const;
 
   inline int64_t get_local_pool_id() const {
@@ -220,6 +218,37 @@ protected:
   bool on_replay_interrupted();
 
 private:
+  struct RemoteImage {
+    std::string mirror_uuid;
+    std::string image_id;
+    librados::IoCtx io_ctx;
+
+    RemoteImage() {
+    }
+    RemoteImage(const std::string &mirror_uuid,
+                const std::string &image_id)
+      : mirror_uuid(mirror_uuid), image_id(image_id) {
+    }
+    RemoteImage(const std::string &mirror_uuid,
+                const std::string &image_id,
+                librados::IoCtx &io_ctx)
+      : mirror_uuid(mirror_uuid), image_id(image_id), io_ctx(io_ctx) {
+    }
+
+    inline bool operator<(const RemoteImage &rhs) const {
+      if (mirror_uuid != rhs.mirror_uuid) {
+        return mirror_uuid < rhs.mirror_uuid;
+      } else {
+        return image_id < rhs.image_id;
+      }
+    }
+    inline bool operator==(const RemoteImage &rhs) const {
+      return (mirror_uuid == rhs.mirror_uuid && image_id == rhs.image_id);
+    }
+  };
+
+  typedef std::set<RemoteImage> RemoteImages;
+
   typedef typename librbd::journal::TypeTraits<ImageCtxT>::Journaler Journaler;
   typedef boost::optional<State> OptionalState;
 
@@ -259,8 +288,8 @@ private:
   std::shared_ptr<ImageDeleter> m_image_deleter;
   ImageSyncThrottlerRef<ImageCtxT> m_image_sync_throttler;
 
-  PeerImages m_remote_images;
-  PeerImage m_remote_image;
+  RemoteImages m_remote_images;
+  RemoteImage m_remote_image;
 
   RadosRef m_local;
   std::string m_local_mirror_uuid;

diff --git a/src/tools/rbd_mirror/InstanceReplayer.cc b/src/tools/rbd_mirror/InstanceReplayer.cc
index b1dd697309ba6bf08ed9431627ee3999961b480e..359e2c66bbb6806c03a595ed8998146b74f2b607 100644 (file)
--- a/src/tools/rbd_mirror/InstanceReplayer.cc
+++ b/src/tools/rbd_mirror/InstanceReplayer.cc
@@ -90,11 +90,22 @@ void InstanceReplayer<I>::shut_down(Context *on_finish) {
 }
 
 template <typename I>
-void InstanceReplayer<I>::set_peers(const Peers &peers) {
-  dout(20) << dendl;
+void InstanceReplayer<I>::add_peer(std::string mirror_uuid,
+                                   librados::IoCtx io_ctx) {
+  dout(20) << mirror_uuid << dendl;
 
   Mutex::Locker locker(m_lock);
-  m_peers = peers;
+  auto result = m_peers.insert(Peer(mirror_uuid, io_ctx)).second;
+  assert(result);
+}
+
+template <typename I>
+void InstanceReplayer<I>::remove_peer(std::string mirror_uuid) {
+  dout(20) << mirror_uuid << dendl;
+
+  Mutex::Locker locker(m_lock);
+  auto result = m_peers.erase(Peer(mirror_uuid));
+  assert(result > 0);
 }
 
 template <typename I>
@@ -119,10 +130,12 @@ void InstanceReplayer<I>::release_all(Context *on_finish) {
 }
 
 template <typename I>
-void InstanceReplayer<I>::acquire_image(
-    const std::string &global_image_id,
-    const instance_watcher::PeerImageIds &peers, Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << dendl;
+void InstanceReplayer<I>::acquire_image(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;
 
   Mutex::Locker locker(m_lock);
 
@@ -144,15 +157,11 @@ void InstanceReplayer<I>::acquire_image(
 
   auto image_replayer = it->second;
 
-  PeerImages remote_images;
-  for (auto &peer : peers) {
-    auto it = m_peers.find(Peer(peer.mirror_uuid));
-    assert(it != m_peers.end());
-    auto io_ctx = it->io_ctx;
-    remote_images.insert({peer.mirror_uuid, io_ctx, peer.image_id});
-  }
+  auto iter = m_peers.find(Peer(peer_mirror_uuid));
+  assert(iter != m_peers.end());
+  auto io_ctx = iter->io_ctx;
 
-  image_replayer->set_remote_images(remote_images);
+  image_replayer->add_remote_image(peer_mirror_uuid, peer_image_id, io_ctx);
 
   start_image_replayer(image_replayer);
 
@@ -160,12 +169,13 @@ void InstanceReplayer<I>::acquire_image(
 }
 
 template <typename I>
-void InstanceReplayer<I>::release_image(
-    const std::string &global_image_id,
-    const instance_watcher::PeerImageIds &peers, bool schedule_delete,
-    Context *on_finish) {
-  dout(20) << "global_image_id=" << global_image_id << ", "
-           << "schedule_delete=" << schedule_delete << dendl;
+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;
 
   Mutex::Locker locker(m_lock);
 
@@ -181,9 +191,7 @@ void InstanceReplayer<I>::release_image(
 
   auto image_replayer = it->second;
 
-  for (auto &peer : peers) {
-    image_replayer->remove_remote_image(peer.mirror_uuid, peer.image_id);
-  }
+  image_replayer->remove_remote_image(peer_mirror_uuid, peer_image_id);
 
   if (!image_replayer->remote_images_empty()) {
     dout(20) << global_image_id << ": still has remote images" << dendl;

diff --git a/src/tools/rbd_mirror/InstanceReplayer.h b/src/tools/rbd_mirror/InstanceReplayer.h
index 5d521ec2bb73bf55f66a50835934575125343392..252a23bf95c7e0659a2c6996bbe63179d0707e8f 100644 (file)
--- a/src/tools/rbd_mirror/InstanceReplayer.h
+++ b/src/tools/rbd_mirror/InstanceReplayer.h
@@ -10,7 +10,6 @@
 #include "common/AsyncOpTracker.h"
 #include "common/Formatter.h"
 #include "common/Mutex.h"
-#include "tools/rbd_mirror/instance_watcher/Types.h"
 #include "types.h"
 
 namespace librbd { class ImageCtx; }
@@ -50,13 +49,16 @@ public:
   void init(Context *on_finish);
   void shut_down(Context *on_finish);
 
-  void set_peers(const Peers &peers);
+  void add_peer(std::string mirror_uuid, librados::IoCtx io_ctx);
+  void remove_peer(std::string mirror_uuid);
 
   void acquire_image(const std::string &global_image_id,
-                     const instance_watcher::PeerImageIds &peers,
+                     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 instance_watcher::PeerImageIds &peers,
+                     const std::string &peer_mirror_uuid,
+                     const std::string &peer_image_id,
                      bool schedule_delete, Context *on_finish);
   void release_all(Context *on_finish);
 
@@ -81,6 +83,30 @@ private:
    * @endverbatim
    */
 
+  struct Peer {
+    std::string mirror_uuid;
+    librados::IoCtx io_ctx;
+
+    Peer() {
+    }
+
+    Peer(const std::string &mirror_uuid) : mirror_uuid(mirror_uuid) {
+    }
+
+    Peer(const std::string &mirror_uuid, librados::IoCtx &io_ctx)
+      : mirror_uuid(mirror_uuid), io_ctx(io_ctx) {
+    }
+
+    inline bool operator<(const Peer &rhs) const {
+      return mirror_uuid < rhs.mirror_uuid;
+    }
+    inline bool operator==(const Peer &rhs) const {
+      return mirror_uuid == rhs.mirror_uuid;
+    }
+  };
+
+  typedef std::set<Peer> Peers;
+
   Threads<ImageCtxT> *m_threads;
   std::shared_ptr<ImageDeleter> m_image_deleter;
   ImageSyncThrottlerRef<ImageCtxT> m_image_sync_throttler;

diff --git a/src/tools/rbd_mirror/Replayer.cc b/src/tools/rbd_mirror/Replayer.cc
index f178af50989a95d61caa8d11f78f31f906741f14..826e78563d4875311bc3f9d39d5013967540b715 100644 (file)
--- a/src/tools/rbd_mirror/Replayer.cc
+++ b/src/tools/rbd_mirror/Replayer.cc
@@ -325,6 +325,7 @@ int Replayer::init()
                                m_image_sync_throttler, m_local_rados,
                                local_mirror_uuid, m_local_pool_id));
   m_instance_replayer->init();
+  m_instance_replayer->add_peer(m_peer.uuid, m_remote_io_ctx);
 
   m_leader_watcher.reset(new LeaderWatcher<>(m_threads, m_local_io_ctx,
                                              &m_leader_listener));
@@ -558,7 +559,11 @@ void Replayer::handle_update(const std::string &mirror_uuid,
     return;
   }
 
-  m_instance_replayer->set_peers({{mirror_uuid, m_remote_io_ctx}});
+  if (m_peer.uuid != mirror_uuid) {
+    m_instance_replayer->remove_peer(m_peer.uuid);
+    m_instance_replayer->add_peer(mirror_uuid, m_remote_io_ctx);
+    m_peer.uuid = mirror_uuid;
+  }
 
   // first callback will be a full directory -- so see if we need to remove
   // any local images that no longer exist on the remote side
@@ -590,15 +595,14 @@ void Replayer::handle_update(const std::string &mirror_uuid,
   C_Gather *gather_ctx = new C_Gather(g_ceph_context, ctx);
 
   for (auto &image_id : removed_image_ids) {
-    m_instance_replayer->release_image(image_id.global_id,
-                                       {{mirror_uuid, image_id.id}}, true,
+    m_instance_replayer->release_image(image_id.global_id, mirror_uuid,
+                                       image_id.id, true,
                                        gather_ctx->new_sub());
   }
 
   for (auto &image_id : added_image_ids) {
-    m_instance_replayer->acquire_image(image_id.global_id,
-                                       {{mirror_uuid, image_id.id}},
-                                       gather_ctx->new_sub());
+    m_instance_replayer->acquire_image(image_id.global_id, mirror_uuid,
+                                       image_id.id, gather_ctx->new_sub());
   }
 
   gather_ctx->activate();

diff --git a/src/tools/rbd_mirror/instance_watcher/Types.cc b/src/tools/rbd_mirror/instance_watcher/Types.cc
deleted file mode 100644 (file)
index 1fe5316..0000000
--- a/src/tools/rbd_mirror/instance_watcher/Types.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-
-#include "Types.h"
-#include "common/Formatter.h"
-
-namespace rbd {
-namespace mirror {
-namespace instance_watcher {
-
-void PeerImageId::encode(bufferlist &bl) const {
-  ::encode(mirror_uuid, bl);
-  ::encode(image_id, bl);
-}
-
-void PeerImageId::decode(bufferlist::iterator &iter) {
-  ::decode(mirror_uuid, iter);
-  ::decode(image_id, iter);
-}
-
-void PeerImageId::dump(Formatter *f) const {
-  f->dump_string("mirror_uuid", mirror_uuid);
-  f->dump_string("image_id", image_id);
-}
-
-} // namespace instance_watcher
-} // namespace mirror
-} // namespace rbd

diff --git a/src/tools/rbd_mirror/instance_watcher/Types.h b/src/tools/rbd_mirror/instance_watcher/Types.h
deleted file mode 100644 (file)
index f4e08e3..0000000
--- a/src/tools/rbd_mirror/instance_watcher/Types.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-
-#ifndef RBD_MIRROR_INSTANCE_WATCHER_TYPES_H
-#define RBD_MIRROR_INSTANCE_WATCHER_TYPES_H
-
-#include <string>
-#include <set>
-#include <boost/variant.hpp>
-
-#include "include/buffer_fwd.h"
-#include "include/encoding.h"
-#include "include/int_types.h"
-
-namespace ceph { class Formatter; }
-
-namespace rbd {
-namespace mirror {
-namespace instance_watcher {
-
-struct PeerImageId {
-  std::string mirror_uuid;
-  std::string image_id;
-
-  inline bool operator<(const PeerImageId &rhs) const {
-    return mirror_uuid < rhs.mirror_uuid;
-  }
-
-  inline bool operator==(const PeerImageId &rhs) const {
-    return (mirror_uuid == rhs.mirror_uuid && image_id == rhs.image_id);
-  }
-
-  void encode(bufferlist& bl) const;
-  void decode(bufferlist::iterator& it);
-  void dump(Formatter *f) const;
-};
-
-WRITE_CLASS_ENCODER(PeerImageId);
-
-typedef std::set<PeerImageId> PeerImageIds;
-
-} // namespace instance_watcher
-} // namespace mirror
-} // namespace librbd
-
-#endif // RBD_MIRROR_INSTANCE_WATCHER_TYPES_H

diff --git a/src/tools/rbd_mirror/types.h b/src/tools/rbd_mirror/types.h
index e0be7d5ba7cd56605358c78c74c84fe6af80f717..617effd21cf0df0052864a7f8ea965b80219e9be 100644 (file)
--- a/src/tools/rbd_mirror/types.h
+++ b/src/tools/rbd_mirror/types.h
@@ -51,57 +51,6 @@ std::ostream &operator<<(std::ostream &, const ImageId &image_id);
 
 typedef std::set<ImageId> ImageIds;
 
-struct Peer {
-  std::string mirror_uuid;
-  librados::IoCtx io_ctx;
-
-  Peer() {
-  }
-
-  Peer(const std::string &mirror_uuid) : mirror_uuid(mirror_uuid) {
-  }
-
-  Peer(const std::string &mirror_uuid, librados::IoCtx &io_ctx)
-    : mirror_uuid(mirror_uuid), io_ctx(io_ctx) {
-  }
-
-  inline bool operator<(const Peer &rhs) const {
-    return mirror_uuid < rhs.mirror_uuid;
-  }
-  inline bool operator==(const Peer &rhs) const {
-    return mirror_uuid == rhs.mirror_uuid;
-  }
-};
-
-typedef std::set<Peer> Peers;
-
-struct PeerImage : public Peer {
-  std::string image_id;
-
-  PeerImage() {
-  }
-  PeerImage(const std::string &mirror_uuid, const std::string &image_id)
-    : Peer(mirror_uuid), image_id(image_id) {
-  }
-  PeerImage(const std::string &mirror_uuid, librados::IoCtx &io_ctx,
-            const std::string &image_id)
-    : Peer(mirror_uuid, io_ctx), image_id(image_id) {
-  }
-
-  inline bool operator<(const PeerImage &rhs) const {
-    if (mirror_uuid != rhs.mirror_uuid) {
-      return mirror_uuid < rhs.mirror_uuid;
-    } else {
-      return image_id < rhs.image_id;
-    }
-  }
-  inline bool operator==(const PeerImage &rhs) const {
-    return (mirror_uuid == rhs.mirror_uuid && image_id == rhs.image_id);
-  }
-};
-
-typedef std::set<PeerImage> PeerImages;
-
 struct peer_t {
   peer_t() = default;
   peer_t(const std::string &uuid, const std::string &cluster_name,