From: Jason Dillaman <dillaman@redhat.com>
Date: Wed, 15 Jan 2020 21:44:51 +0000 (-0500)
Subject: rbd-mirror: pass remote pool meta through to bootstrap
X-Git-Tag: v15.1.0~175^2~3
X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=dab233dd5cf86e1496b766fe310e6e2dc83e0f51;p=ceph.git

rbd-mirror: pass remote pool meta through to bootstrap

The snapshot-based replaying logic will need the remote's
mirror peer uuid to find its snapshots in the remote images.

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

diff --git a/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc b/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc
index 9770c61378b..d63d596461a 100644
--- a/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc
+++ b/src/test/rbd_mirror/image_replayer/test_mock_BootstrapRequest.cc
@@ -536,6 +536,8 @@ public:
                                     mock_instance_watcher,
                                     global_image_id,
                                     local_mirror_uuid,
+                                    {"remote mirror uuid",
+                                     "remote mirror peer uuid"},
                                     nullptr, nullptr,
                                     &m_mock_state_builder,
                                     &m_do_resync, on_finish);
diff --git a/src/test/rbd_mirror/test_ImageReplayer.cc b/src/test/rbd_mirror/test_ImageReplayer.cc
index d3b0ad01b29..d06ba43c1d0 100644
--- a/src/test/rbd_mirror/test_ImageReplayer.cc
+++ b/src/test/rbd_mirror/test_ImageReplayer.cc
@@ -162,7 +162,7 @@ public:
                                     m_global_image_id, m_threads.get(),
                                     m_instance_watcher, m_local_status_updater,
                                     nullptr);
-    m_replayer->add_peer("peer uuid", m_remote_ioctx, nullptr);
+    m_replayer->add_peer({"peer uuid", m_remote_ioctx, {}, nullptr});
   }
 
   void start()
diff --git a/src/test/rbd_mirror/test_mock_ImageReplayer.cc b/src/test/rbd_mirror/test_mock_ImageReplayer.cc
index 183dca020f0..f2612d7f94c 100644
--- a/src/test/rbd_mirror/test_mock_ImageReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_ImageReplayer.cc
@@ -101,10 +101,11 @@ struct BootstrapRequest<librbd::MockTestImageCtx> {
   static BootstrapRequest* create(
       Threads<librbd::MockTestImageCtx>* threads,
       librados::IoCtx &local_io_ctx,
-      librados::IoCtx &remote_io_ctx,
+      librados::IoCtx& remote_io_ctx,
       rbd::mirror::InstanceWatcher<librbd::MockTestImageCtx> *instance_watcher,
       const std::string &global_image_id,
       const std::string &local_mirror_uuid,
+      const RemotePoolMeta& remote_pool_meta,
       ::journal::CacheManagerHandler *cache_manager_handler,
       rbd::mirror::ProgressContext *progress_ctx,
       StateBuilder<librbd::MockTestImageCtx>** state_builder,
@@ -354,8 +355,10 @@ public:
     m_image_replayer = new MockImageReplayer(
         m_local_io_ctx, "local_mirror_uuid", "global image id",
         &mock_threads, &m_instance_watcher, &m_local_status_updater, nullptr);
-    m_image_replayer->add_peer("peer_uuid", m_remote_io_ctx,
-                               &m_remote_status_updater);
+    m_image_replayer->add_peer({"peer_uuid", m_remote_io_ctx,
+                                {"remote mirror uuid",
+                                 "remote mirror peer uuid"},
+                                &m_remote_status_updater});
   }
 
   void wait_for_stopped() {
diff --git a/src/test/rbd_mirror/test_mock_InstanceReplayer.cc b/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
index 743c709bdda..002786108bd 100644
--- a/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_InstanceReplayer.cc
@@ -92,8 +92,7 @@ struct ImageReplayer<librbd::MockTestImageCtx> {
   MOCK_METHOD0(restart, void());
   MOCK_METHOD0(flush, void());
   MOCK_METHOD1(print_status, void(Formatter *));
-  MOCK_METHOD3(add_peer, void(const std::string &, librados::IoCtx &,
-                              MirrorStatusUpdater<librbd::MockTestImageCtx>*));
+  MOCK_METHOD1(add_peer, void(const Peer<librbd::MockTestImageCtx>& peer));
   MOCK_METHOD0(get_global_image_id, const std::string &());
   MOCK_METHOD0(get_local_image_id, const std::string &());
   MOCK_METHOD0(is_running, bool());
@@ -191,12 +190,12 @@ TEST_F(TestMockInstanceReplayer, AcquireReleaseImage) {
   Context *timer_ctx = nullptr;
   expect_add_event_after(mock_threads, &timer_ctx);
   instance_replayer.init();
-  instance_replayer.add_peer("peer_uuid", m_remote_io_ctx, nullptr);
+  instance_replayer.add_peer({"peer_uuid", m_remote_io_ctx, {}, nullptr});
 
   // Acquire
 
   C_SaferCond on_acquire;
-  EXPECT_CALL(mock_image_replayer, add_peer("peer_uuid", _, _));
+  EXPECT_CALL(mock_image_replayer, add_peer(_));
   EXPECT_CALL(mock_image_replayer, is_stopped()).WillOnce(Return(true));
   EXPECT_CALL(mock_image_replayer, is_blacklisted()).WillOnce(Return(false));
   EXPECT_CALL(mock_image_replayer, is_finished()).WillOnce(Return(false));
@@ -260,12 +259,12 @@ TEST_F(TestMockInstanceReplayer, RemoveFinishedImage) {
   Context *timer_ctx1 = nullptr;
   expect_add_event_after(mock_threads, &timer_ctx1);
   instance_replayer.init();
-  instance_replayer.add_peer("peer_uuid", m_remote_io_ctx, nullptr);
+  instance_replayer.add_peer({"peer_uuid", m_remote_io_ctx, {}, nullptr});
 
   // Acquire
 
   C_SaferCond on_acquire;
-  EXPECT_CALL(mock_image_replayer, add_peer("peer_uuid", _, _));
+  EXPECT_CALL(mock_image_replayer, add_peer(_));
   EXPECT_CALL(mock_image_replayer, is_stopped()).WillOnce(Return(true));
   EXPECT_CALL(mock_image_replayer, is_blacklisted()).WillOnce(Return(false));
   EXPECT_CALL(mock_image_replayer, is_finished()).WillOnce(Return(false));
@@ -333,11 +332,11 @@ TEST_F(TestMockInstanceReplayer, Reacquire) {
   Context *timer_ctx = nullptr;
   expect_add_event_after(mock_threads, &timer_ctx);
   instance_replayer.init();
-  instance_replayer.add_peer("peer_uuid", m_remote_io_ctx, nullptr);
+  instance_replayer.add_peer({"peer_uuid", m_remote_io_ctx, {}, nullptr});
 
   // Acquire
 
-  EXPECT_CALL(mock_image_replayer, add_peer("peer_uuid", _, _));
+  EXPECT_CALL(mock_image_replayer, add_peer(_));
   EXPECT_CALL(mock_image_replayer, is_stopped()).WillOnce(Return(true));
   EXPECT_CALL(mock_image_replayer, is_blacklisted()).WillOnce(Return(false));
   EXPECT_CALL(mock_image_replayer, is_finished()).WillOnce(Return(false));
diff --git a/src/test/rbd_mirror/test_mock_NamespaceReplayer.cc b/src/test/rbd_mirror/test_mock_NamespaceReplayer.cc
index 66d772cea8f..e395bf3d237 100644
--- a/src/test/rbd_mirror/test_mock_NamespaceReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_NamespaceReplayer.cc
@@ -113,8 +113,7 @@ struct InstanceReplayer<librbd::MockTestImageCtx> {
 
   MOCK_METHOD2(print_status, void(Formatter*, std::stringstream*));
 
-  MOCK_METHOD3(add_peer, void(const std::string&, librados::IoCtx&,
-                              MirrorStatusUpdater<librbd::MockTestImageCtx>*));
+  MOCK_METHOD1(add_peer, void(const Peer<librbd::MockTestImageCtx>&));
 
   MOCK_METHOD1(init, void(Context*));
   MOCK_METHOD1(shut_down, void(Context*));
@@ -316,8 +315,8 @@ public:
   }
 
   void expect_instance_replayer_add_peer(
-      MockInstanceReplayer& mock_instance_replayer, const std::string& uuid) {
-    EXPECT_CALL(mock_instance_replayer, add_peer(uuid, _, _));
+      MockInstanceReplayer& mock_instance_replayer) {
+    EXPECT_CALL(mock_instance_replayer, add_peer(_));
   }
 
   void expect_instance_replayer_release_all(
@@ -398,8 +397,8 @@ TEST_F(TestMockNamespaceReplayer, Init_LocalMirrorStatusUpdaterError) {
 
   MockNamespaceReplayer namespace_replayer(
       {}, m_local_io_ctx, m_remote_io_ctx, "local mirror uuid",
-      "remote mirror uuid", "siteA", m_mock_threads, nullptr, nullptr, nullptr,
-      nullptr);
+      "siteA", "local peer uuid", {"remote mirror uuid", ""}, m_mock_threads,
+      nullptr, nullptr, nullptr, nullptr);
 
   C_SaferCond on_init;
   namespace_replayer.init(&on_init);
@@ -420,8 +419,8 @@ TEST_F(TestMockNamespaceReplayer, Init_RemoteMirrorStatusUpdaterError) {
 
   MockNamespaceReplayer namespace_replayer(
       {}, m_local_io_ctx, m_remote_io_ctx, "local mirror uuid",
-      "remote mirror uuid", "siteA", m_mock_threads, nullptr, nullptr, nullptr,
-      nullptr);
+      "siteA", "local peer uuid", {"remote mirror uuid", ""}, m_mock_threads,
+      nullptr, nullptr, nullptr, nullptr);
 
   C_SaferCond on_init;
   namespace_replayer.init(&on_init);
@@ -445,8 +444,8 @@ TEST_F(TestMockNamespaceReplayer, Init_InstanceReplayerError) {
 
   MockNamespaceReplayer namespace_replayer(
       {}, m_local_io_ctx, m_remote_io_ctx, "local mirror uuid",
-      "remote mirror uuid", "siteA", m_mock_threads, nullptr, nullptr, nullptr,
-      nullptr);
+      "siteA", "local peer uuid", {"remote mirror uuid", ""}, m_mock_threads,
+      nullptr, nullptr, nullptr, nullptr);
 
   C_SaferCond on_init;
   namespace_replayer.init(&on_init);
@@ -464,8 +463,7 @@ TEST_F(TestMockNamespaceReplayer, Init_InstanceWatcherError) {
 
   auto mock_instance_replayer = new MockInstanceReplayer();
   expect_instance_replayer_init(*mock_instance_replayer, 0);
-  expect_instance_replayer_add_peer(*mock_instance_replayer,
-                                    "remote mirror uuid");
+  expect_instance_replayer_add_peer(*mock_instance_replayer);
 
   auto mock_instance_watcher = new MockInstanceWatcher();
   expect_instance_watcher_init(*mock_instance_watcher, -EINVAL);
@@ -476,8 +474,8 @@ TEST_F(TestMockNamespaceReplayer, Init_InstanceWatcherError) {
 
   MockNamespaceReplayer namespace_replayer(
       {}, m_local_io_ctx, m_remote_io_ctx, "local mirror uuid",
-      "remote mirror uuid", "siteA", m_mock_threads, nullptr, nullptr, nullptr,
-      nullptr);
+      "siteA", "local peer uuid", {"remote mirror uuid", ""}, m_mock_threads,
+      nullptr, nullptr, nullptr, nullptr);
 
   C_SaferCond on_init;
   namespace_replayer.init(&on_init);
@@ -495,8 +493,7 @@ TEST_F(TestMockNamespaceReplayer, Init) {
 
   auto mock_instance_replayer = new MockInstanceReplayer();
   expect_instance_replayer_init(*mock_instance_replayer, 0);
-  expect_instance_replayer_add_peer(*mock_instance_replayer,
-                                    "remote mirror uuid");
+  expect_instance_replayer_add_peer(*mock_instance_replayer);
 
   auto mock_instance_watcher = new MockInstanceWatcher();
   expect_instance_watcher_init(*mock_instance_watcher, 0);
@@ -504,8 +501,8 @@ TEST_F(TestMockNamespaceReplayer, Init) {
   MockServiceDaemon mock_service_daemon;
   MockNamespaceReplayer namespace_replayer(
       {}, m_local_io_ctx, m_remote_io_ctx, "local mirror uuid",
-      "remote mirror uuid", "siteA", m_mock_threads, nullptr, nullptr,
-      &mock_service_daemon, nullptr);
+      "siteA", "local peer uuid", {"remote mirror uuid", ""}, m_mock_threads,
+      nullptr, nullptr, &mock_service_daemon, nullptr);
 
   C_SaferCond on_init;
   namespace_replayer.init(&on_init);
@@ -535,8 +532,7 @@ TEST_F(TestMockNamespaceReplayer, AcuqireLeader) {
 
   auto mock_instance_replayer = new MockInstanceReplayer();
   expect_instance_replayer_init(*mock_instance_replayer, 0);
-  expect_instance_replayer_add_peer(*mock_instance_replayer,
-                                    "remote mirror uuid");
+  expect_instance_replayer_add_peer(*mock_instance_replayer);
 
   auto mock_instance_watcher = new MockInstanceWatcher();
   expect_instance_watcher_init(*mock_instance_watcher, 0);
@@ -544,8 +540,8 @@ TEST_F(TestMockNamespaceReplayer, AcuqireLeader) {
   MockServiceDaemon mock_service_daemon;
   MockNamespaceReplayer namespace_replayer(
       {}, m_local_io_ctx, m_remote_io_ctx, "local mirror uuid",
-      "remote mirror uuid", "siteA", m_mock_threads, nullptr, nullptr,
-      &mock_service_daemon, nullptr);
+      "siteA", "local peer uuid", {"remote mirror uuid", ""}, m_mock_threads,
+      nullptr, nullptr, &mock_service_daemon, nullptr);
 
   C_SaferCond on_init;
   namespace_replayer.init(&on_init);
diff --git a/src/test/rbd_mirror/test_mock_PoolReplayer.cc b/src/test/rbd_mirror/test_mock_PoolReplayer.cc
index 040ce633a6a..1d27fd0b1ea 100644
--- a/src/test/rbd_mirror/test_mock_PoolReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_PoolReplayer.cc
@@ -132,8 +132,9 @@ struct NamespaceReplayer<librbd::MockTestImageCtx> {
       librados::IoCtx &local_ioctx,
       librados::IoCtx &remote_ioctx,
       const std::string &local_mirror_uuid,
-      const std::string &remote_mirror_uuid,
       const std::string &site_name,
+      const std::string& local_mirror_peer_uuid,
+      const RemotePoolMeta& remote_pool_meta,
       Threads<librbd::MockTestImageCtx> *threads,
       Throttler<librbd::MockTestImageCtx> *image_sync_throttler,
       Throttler<librbd::MockTestImageCtx> *image_deletion_throttler,
diff --git a/src/tools/rbd_mirror/ImageReplayer.cc b/src/tools/rbd_mirror/ImageReplayer.cc
index eb030c664fd..dfd895491a6 100644
--- a/src/tools/rbd_mirror/ImageReplayer.cc
+++ b/src/tools/rbd_mirror/ImageReplayer.cc
@@ -265,16 +265,13 @@ image_replayer::HealthState ImageReplayer<I>::get_health_state() const {
 }
 
 template <typename I>
-void ImageReplayer<I>::add_peer(
-    const std::string &peer_uuid, librados::IoCtx &io_ctx,
-    MirrorStatusUpdater<I>* remote_status_updater) {
-  dout(10) << "peer_uuid=" << &peer_uuid << ", "
-           << "remote_status_updater=" << remote_status_updater << dendl;
+void ImageReplayer<I>::add_peer(const Peer<I>& peer) {
+  dout(10) << "peer=" << peer << dendl;
 
   std::lock_guard locker{m_lock};
-  auto it = m_peers.find({peer_uuid});
+  auto it = m_peers.find(peer);
   if (it == m_peers.end()) {
-    m_peers.insert({peer_uuid, io_ctx, remote_status_updater});
+    m_peers.insert(peer);
   }
 }
 
@@ -342,7 +339,7 @@ void ImageReplayer<I>::bootstrap() {
 
   // TODO need to support multiple remote images
   ceph_assert(!m_peers.empty());
-  m_remote_image = {*m_peers.begin()};
+  m_remote_image_peer = *m_peers.begin();
 
   if (on_start_interrupted(m_lock)) {
     return;
@@ -352,8 +349,9 @@ void ImageReplayer<I>::bootstrap() {
   auto ctx = create_context_callback<
       ImageReplayer, &ImageReplayer<I>::handle_bootstrap>(this);
   auto request = image_replayer::BootstrapRequest<I>::create(
-      m_threads, m_local_io_ctx, m_remote_image.io_ctx, m_instance_watcher,
-      m_global_image_id, m_local_mirror_uuid, m_cache_manager_handler,
+      m_threads, m_local_io_ctx, m_remote_image_peer.io_ctx, m_instance_watcher,
+      m_global_image_id, m_local_mirror_uuid,
+      m_remote_image_peer.remote_pool_meta, m_cache_manager_handler,
       &m_progress_cxt, &m_state_builder, &m_resync_requested, ctx);
 
   request->get();
@@ -784,8 +782,8 @@ void ImageReplayer<I>::set_mirror_image_status_update(
   dout(15) << "status=" << status << dendl;
   m_local_status_updater->set_mirror_image_status(m_global_image_id, status,
                                                   force);
-  if (m_remote_image.mirror_status_updater != nullptr) {
-    m_remote_image.mirror_status_updater->set_mirror_image_status(
+  if (m_remote_image_peer.mirror_status_updater != nullptr) {
+    m_remote_image_peer.mirror_status_updater->set_mirror_image_status(
       m_global_image_id, status, force);
   }
 
@@ -896,13 +894,13 @@ void ImageReplayer<I>::handle_shut_down(int r) {
     return;
   }
 
-  if (m_remote_image.mirror_status_updater != nullptr &&
-      m_remote_image.mirror_status_updater->exists(m_global_image_id)) {
+  if (m_remote_image_peer.mirror_status_updater != nullptr &&
+      m_remote_image_peer.mirror_status_updater->exists(m_global_image_id)) {
     dout(15) << "removing remote mirror image status" << dendl;
     auto ctx = new LambdaContext([this, r](int) {
         handle_shut_down(r);
       });
-    m_remote_image.mirror_status_updater->remove_mirror_image_status(
+    m_remote_image_peer.mirror_status_updater->remove_mirror_image_status(
       m_global_image_id, ctx);
     return;
   }
diff --git a/src/tools/rbd_mirror/ImageReplayer.h b/src/tools/rbd_mirror/ImageReplayer.h
index 9b94d3d7f37..bff9e2af9e1 100644
--- a/src/tools/rbd_mirror/ImageReplayer.h
+++ b/src/tools/rbd_mirror/ImageReplayer.h
@@ -89,8 +89,7 @@ public:
 
   image_replayer::HealthState get_health_state() const;
 
-  void add_peer(const std::string &peer_uuid, librados::IoCtx &remote_io_ctx,
-                MirrorStatusUpdater<ImageCtxT>* remote_status_updater);
+  void add_peer(const Peer<ImageCtxT>& peer);
 
   inline int64_t get_local_pool_id() const {
     return m_local_io_ctx.get_id();
@@ -156,16 +155,6 @@ private:
     STATE_STOPPED,
   };
 
-  struct RemoteImage {
-    librados::IoCtx io_ctx;
-    MirrorStatusUpdater<ImageCtxT>* mirror_status_updater = nullptr;
-
-    RemoteImage() {
-    }
-    RemoteImage(const Peer<ImageCtxT>& peer)
-      : io_ctx(peer.io_ctx), mirror_status_updater(peer.mirror_status_updater) {
-    }
-  };
   struct ReplayerListener;
 
   typedef boost::optional<State> OptionalState;
@@ -194,7 +183,7 @@ private:
   journal::CacheManagerHandler *m_cache_manager_handler;
 
   Peers m_peers;
-  RemoteImage m_remote_image;
+  Peer<ImageCtxT> m_remote_image_peer;
 
   std::string m_local_image_name;
   std::string m_image_spec;
diff --git a/src/tools/rbd_mirror/InstanceReplayer.cc b/src/tools/rbd_mirror/InstanceReplayer.cc
index ebf38eff174..21ff8da7257 100644
--- a/src/tools/rbd_mirror/InstanceReplayer.cc
+++ b/src/tools/rbd_mirror/InstanceReplayer.cc
@@ -104,14 +104,11 @@ void InstanceReplayer<I>::shut_down(Context *on_finish) {
 }
 
 template <typename I>
-void InstanceReplayer<I>::add_peer(
-    std::string peer_uuid, librados::IoCtx io_ctx,
-    MirrorStatusUpdater<I>* remote_status_updater) {
-  dout(10) << peer_uuid << dendl;
+void InstanceReplayer<I>::add_peer(const Peer<I>& peer) {
+  dout(10) << "peer=" << peer << dendl;
 
   std::lock_guard locker{m_lock};
-  auto result = m_peers.insert(
-    Peer(peer_uuid, io_ctx, remote_status_updater)).second;
+  auto result = m_peers.insert(peer).second;
   ceph_assert(result);
 }
 
@@ -162,8 +159,7 @@ void InstanceReplayer<I>::acquire_image(InstanceWatcher<I> *instance_watcher,
     // TODO only a single peer is currently supported
     ceph_assert(m_peers.size() == 1);
     auto peer = *m_peers.begin();
-    image_replayer->add_peer(peer.peer_uuid, peer.io_ctx,
-                             peer.mirror_status_updater);
+    image_replayer->add_peer(peer);
     start_image_replayer(image_replayer);
   } else {
     // A duplicate acquire notification implies (1) connection hiccup or
diff --git a/src/tools/rbd_mirror/InstanceReplayer.h b/src/tools/rbd_mirror/InstanceReplayer.h
index 8f32b23daca..2bd8d11f59d 100644
--- a/src/tools/rbd_mirror/InstanceReplayer.h
+++ b/src/tools/rbd_mirror/InstanceReplayer.h
@@ -55,8 +55,7 @@ public:
   void init(Context *on_finish);
   void shut_down(Context *on_finish);
 
-  void add_peer(std::string peer_uuid, librados::IoCtx io_ctx,
-                MirrorStatusUpdater<ImageCtxT>* remote_status_updater);
+  void add_peer(const Peer<ImageCtxT>& peer);
 
   void acquire_image(InstanceWatcher<ImageCtxT> *instance_watcher,
                      const std::string &global_image_id, Context *on_finish);
diff --git a/src/tools/rbd_mirror/NamespaceReplayer.cc b/src/tools/rbd_mirror/NamespaceReplayer.cc
index d89b9d27d10..437c939fc52 100644
--- a/src/tools/rbd_mirror/NamespaceReplayer.cc
+++ b/src/tools/rbd_mirror/NamespaceReplayer.cc
@@ -38,15 +38,17 @@ template <typename I>
 NamespaceReplayer<I>::NamespaceReplayer(
     const std::string &name,
     librados::IoCtx &local_io_ctx, librados::IoCtx &remote_io_ctx,
-    const std::string &local_mirror_uuid, const std::string &remote_mirror_uuid,
-    const std::string &local_site_name, Threads<I> *threads,
+    const std::string &local_mirror_uuid, const std::string &local_site_name,
+    const std::string& local_mirror_peer_uuid,
+    const RemotePoolMeta& remote_pool_meta, Threads<I> *threads,
     Throttler<I> *image_sync_throttler, Throttler<I> *image_deletion_throttler,
     ServiceDaemon<I> *service_daemon,
     journal::CacheManagerHandler *cache_manager_handler) :
   m_namespace_name(name),
   m_local_mirror_uuid(local_mirror_uuid),
-  m_remote_mirror_uuid(remote_mirror_uuid),
   m_local_site_name(local_site_name),
+  m_local_mirror_peer_uuid(local_mirror_peer_uuid),
+  m_remote_pool_meta(remote_pool_meta),
   m_threads(threads), m_image_sync_throttler(image_sync_throttler),
   m_image_deletion_throttler(image_deletion_throttler),
   m_service_daemon(service_daemon),
@@ -372,8 +374,9 @@ void NamespaceReplayer<I>::handle_init_instance_replayer(int r) {
     return;
   }
 
-  m_instance_replayer->add_peer(m_remote_mirror_uuid, m_remote_io_ctx,
-                                m_remote_status_updater.get());
+  m_instance_replayer->add_peer({m_local_mirror_peer_uuid, m_remote_io_ctx,
+                                 m_remote_pool_meta,
+                                 m_remote_status_updater.get()});
 
   init_instance_watcher();
 }
diff --git a/src/tools/rbd_mirror/NamespaceReplayer.h b/src/tools/rbd_mirror/NamespaceReplayer.h
index 53ae8c38811..be12f6af07e 100644
--- a/src/tools/rbd_mirror/NamespaceReplayer.h
+++ b/src/tools/rbd_mirror/NamespaceReplayer.h
@@ -47,16 +47,18 @@ public:
       librados::IoCtx &local_ioctx,
       librados::IoCtx &remote_ioctx,
       const std::string &local_mirror_uuid,
-      const std::string &remote_mirror_uuid,
       const std::string &local_site_name,
+      const std::string &local_mirror_peer_uuid,
+      const RemotePoolMeta& remote_pool_meta,
       Threads<ImageCtxT> *threads,
       Throttler<ImageCtxT> *image_sync_throttler,
       Throttler<ImageCtxT> *image_deletion_throttler,
       ServiceDaemon<ImageCtxT> *service_daemon,
       journal::CacheManagerHandler *cache_manager_handler) {
     return new NamespaceReplayer(name, local_ioctx, remote_ioctx,
-                                 local_mirror_uuid, remote_mirror_uuid,
-                                 local_site_name, threads, image_sync_throttler,
+                                 local_mirror_uuid, local_site_name,
+                                 local_mirror_peer_uuid, remote_pool_meta,
+                                 threads, image_sync_throttler,
                                  image_deletion_throttler, service_daemon,
                                  cache_manager_handler);
   }
@@ -65,8 +67,9 @@ public:
                     librados::IoCtx &local_ioctx,
                     librados::IoCtx &remote_ioctx,
                     const std::string &local_mirror_uuid,
-                    const std::string &remote_mirror_uuid,
                     const std::string &local_site_name,
+                    const std::string& local_mirror_peer_uuid,
+                    const RemotePoolMeta& remote_pool_meta,
                     Threads<ImageCtxT> *threads,
                     Throttler<ImageCtxT> *image_sync_throttler,
                     Throttler<ImageCtxT> *image_deletion_throttler,
@@ -264,8 +267,9 @@ private:
   librados::IoCtx m_local_io_ctx;
   librados::IoCtx m_remote_io_ctx;
   std::string m_local_mirror_uuid;
-  std::string m_remote_mirror_uuid;
   std::string m_local_site_name;
+  std::string m_local_mirror_peer_uuid;
+  RemotePoolMeta m_remote_pool_meta;
   Threads<ImageCtxT> *m_threads;
   Throttler<ImageCtxT> *m_image_sync_throttler;
   Throttler<ImageCtxT> *m_image_deletion_throttler;
diff --git a/src/tools/rbd_mirror/PoolReplayer.cc b/src/tools/rbd_mirror/PoolReplayer.cc
index 55a52280092..b48a5debf10 100644
--- a/src/tools/rbd_mirror/PoolReplayer.cc
+++ b/src/tools/rbd_mirror/PoolReplayer.cc
@@ -362,8 +362,8 @@ void PoolReplayer<I>::init(const std::string& site_name) {
   ceph_assert(!m_remote_pool_meta.mirror_uuid.empty());
 
   m_default_namespace_replayer.reset(NamespaceReplayer<I>::create(
-      "", m_local_io_ctx, m_remote_io_ctx, m_local_mirror_uuid, m_peer.uuid,
-      m_site_name, m_threads, m_image_sync_throttler.get(),
+      "", m_local_io_ctx, m_remote_io_ctx, m_local_mirror_uuid, m_site_name,
+      m_peer.uuid, m_remote_pool_meta, m_threads, m_image_sync_throttler.get(),
       m_image_deletion_throttler.get(), m_service_daemon,
       m_cache_manager_handler));
 
@@ -654,10 +654,10 @@ void PoolReplayer<I>::update_namespace_replayers() {
 
   for (auto &name : mirroring_namespaces) {
     auto namespace_replayer = NamespaceReplayer<I>::create(
-        name, m_local_io_ctx, m_remote_io_ctx, m_local_mirror_uuid, m_peer.uuid,
-        m_site_name, m_threads, m_image_sync_throttler.get(),
-        m_image_deletion_throttler.get(), m_service_daemon,
-        m_cache_manager_handler);
+        name, m_local_io_ctx, m_remote_io_ctx, m_local_mirror_uuid, m_site_name,
+        m_peer.uuid, m_remote_pool_meta, m_threads,
+        m_image_sync_throttler.get(), m_image_deletion_throttler.get(),
+        m_service_daemon, m_cache_manager_handler);
     auto on_init = new LambdaContext(
         [this, namespace_replayer, name, &mirroring_namespaces,
          ctx=gather_ctx->new_sub()](int r) {
diff --git a/src/tools/rbd_mirror/Types.h b/src/tools/rbd_mirror/Types.h
index 63e19586417..f2981713f93 100644
--- a/src/tools/rbd_mirror/Types.h
+++ b/src/tools/rbd_mirror/Types.h
@@ -55,10 +55,10 @@ typedef std::set<ImageId> ImageIds;
 
 struct RemotePoolMeta {
   RemotePoolMeta() {}
-  RemotePoolMeta(const std::string& remote_mirror_uuid,
-                 const std::string& remote_mirror_peer_uuid)
-    : mirror_uuid(remote_mirror_uuid),
-      mirror_peer_uuid(remote_mirror_peer_uuid) {
+  RemotePoolMeta(const std::string& mirror_uuid,
+                 const std::string& mirror_peer_uuid)
+    : mirror_uuid(mirror_uuid),
+      mirror_peer_uuid(mirror_peer_uuid) {
   }
 
   std::string mirror_uuid;
@@ -70,25 +70,32 @@ std::ostream& operator<<(std::ostream& lhs,
 
 template <typename I>
 struct Peer {
-  std::string peer_uuid;
-  librados::IoCtx io_ctx;
+  std::string uuid;
+  mutable librados::IoCtx io_ctx;
+  RemotePoolMeta remote_pool_meta;
   MirrorStatusUpdater<I>* mirror_status_updater = nullptr;
 
   Peer() {
   }
-  Peer(const std::string &peer_uuid) : peer_uuid(peer_uuid) {
-  }
-  Peer(const std::string &peer_uuid, librados::IoCtx& io_ctx,
+  Peer(const std::string& uuid,
+       librados::IoCtx& io_ctx,
+       const RemotePoolMeta& remote_pool_meta,
        MirrorStatusUpdater<I>* mirror_status_updater)
-    : peer_uuid(peer_uuid), io_ctx(io_ctx),
+    : io_ctx(io_ctx),
+      remote_pool_meta(remote_pool_meta),
       mirror_status_updater(mirror_status_updater) {
   }
 
   inline bool operator<(const Peer &rhs) const {
-    return peer_uuid < rhs.peer_uuid;
+    return uuid < rhs.uuid;
   }
 };
 
+template <typename I>
+std::ostream& operator<<(std::ostream& lhs, const Peer<I>& peer) {
+  return lhs << peer.remote_pool_meta;
+}
+
 struct PeerSpec {
   PeerSpec() = default;
   PeerSpec(const std::string &uuid, const std::string &cluster_name,
diff --git a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
index 9a8c0966989..442404c7cc2 100644
--- a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
+++ b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
@@ -52,6 +52,7 @@ BootstrapRequest<I>::BootstrapRequest(
     InstanceWatcher<I>* instance_watcher,
     const std::string& global_image_id,
     const std::string& local_mirror_uuid,
+    const RemotePoolMeta& remote_pool_meta,
     ::journal::CacheManagerHandler* cache_manager_handler,
     ProgressContext* progress_ctx,
     StateBuilder<I>** state_builder,
@@ -66,6 +67,7 @@ BootstrapRequest<I>::BootstrapRequest(
     m_instance_watcher(instance_watcher),
     m_global_image_id(global_image_id),
     m_local_mirror_uuid(local_mirror_uuid),
+    m_remote_pool_meta(remote_pool_meta),
     m_cache_manager_handler(cache_manager_handler),
     m_progress_ctx(progress_ctx),
     m_state_builder(state_builder),
diff --git a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h
index 6561495bbfa..b5f14c816c4 100644
--- a/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h
+++ b/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h
@@ -45,6 +45,7 @@ public:
       InstanceWatcher<ImageCtxT>* instance_watcher,
       const std::string& global_image_id,
       const std::string& local_mirror_uuid,
+      const RemotePoolMeta& remote_pool_meta,
       ::journal::CacheManagerHandler* cache_manager_handler,
       ProgressContext* progress_ctx,
       StateBuilder<ImageCtxT>** state_builder,
@@ -52,8 +53,8 @@ public:
       Context* on_finish) {
     return new BootstrapRequest(
       threads, local_io_ctx, remote_io_ctx, instance_watcher, global_image_id,
-      local_mirror_uuid,  cache_manager_handler, progress_ctx, state_builder,
-      do_resync, on_finish);
+      local_mirror_uuid, remote_pool_meta, cache_manager_handler, progress_ctx,
+      state_builder, do_resync, on_finish);
   }
 
   BootstrapRequest(
@@ -63,6 +64,7 @@ public:
       InstanceWatcher<ImageCtxT>* instance_watcher,
       const std::string& global_image_id,
       const std::string& local_mirror_uuid,
+      const RemotePoolMeta& remote_pool_meta,
       ::journal::CacheManagerHandler* cache_manager_handler,
       ProgressContext* progress_ctx,
       StateBuilder<ImageCtxT>** state_builder,
@@ -127,6 +129,7 @@ private:
   InstanceWatcher<ImageCtxT> *m_instance_watcher;
   std::string m_global_image_id;
   std::string m_local_mirror_uuid;
+  RemotePoolMeta m_remote_pool_meta;
   ::journal::CacheManagerHandler *m_cache_manager_handler;
   ProgressContext *m_progress_ctx;
   StateBuilder<ImageCtxT>** m_state_builder;