cls/rbd: add mode (journal/snapshot) to mirror image

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

diff --git a/src/cls/rbd/cls_rbd_types.cc b/src/cls/rbd/cls_rbd_types.cc
index cfdde40dd7287c84e130d2387df0cec3081c956b..85402cf1587fea909b4eb6eb38e4edf2ea9159d1 100644 (file)
--- a/src/cls/rbd/cls_rbd_types.cc
+++ b/src/cls/rbd/cls_rbd_types.cc
@@ -120,39 +120,69 @@ std::ostream& operator<<(std::ostream& os, const MirrorPeer& peer) {
 }
 
 void MirrorImage::encode(bufferlist &bl) const {
-  ENCODE_START(1, 1, bl);
+  ENCODE_START(2, 1, bl);
   encode(global_image_id, bl);
   encode(static_cast<uint8_t>(state), bl);
+  encode(static_cast<uint8_t>(mode), bl);
   ENCODE_FINISH(bl);
 }
 
 void MirrorImage::decode(bufferlist::const_iterator &it) {
   uint8_t int_state;
-  DECODE_START(1, it);
+  DECODE_START(2, it);
   decode(global_image_id, it);
   decode(int_state, it);
   state = static_cast<MirrorImageState>(int_state);
+  if (struct_v >= 2) {
+    uint8_t int_mode;
+    decode(int_mode, it);
+    mode = static_cast<MirrorImageMode>(int_mode);
+  }
   DECODE_FINISH(it);
 }
 
 void MirrorImage::dump(Formatter *f) const {
+  f->dump_stream("mode") << mode;
   f->dump_string("global_image_id", global_image_id);
-  f->dump_int("state", state);
+  f->dump_stream("state") << state;
 }
 
 void MirrorImage::generate_test_instances(std::list<MirrorImage*> &o) {
   o.push_back(new MirrorImage());
-  o.push_back(new MirrorImage("uuid-123", MIRROR_IMAGE_STATE_ENABLED));
-  o.push_back(new MirrorImage("uuid-abc", MIRROR_IMAGE_STATE_DISABLING));
+  o.push_back(new MirrorImage(MIRROR_IMAGE_MODE_JOURNAL, "uuid-123",
+                              MIRROR_IMAGE_STATE_ENABLED));
+  o.push_back(new MirrorImage(MIRROR_IMAGE_MODE_SNAPSHOT, "uuid-abc",
+                              MIRROR_IMAGE_STATE_DISABLING));
 }
 
 bool MirrorImage::operator==(const MirrorImage &rhs) const {
-  return global_image_id == rhs.global_image_id && state == rhs.state;
+  return mode == rhs.mode && global_image_id == rhs.global_image_id &&
+         state == rhs.state;
 }
 
 bool MirrorImage::operator<(const MirrorImage &rhs) const {
-  return global_image_id < rhs.global_image_id ||
-       (global_image_id == rhs.global_image_id  && state < rhs.state);
+  if (mode != rhs.mode) {
+    return mode < rhs.mode;
+  }
+  if (global_image_id != rhs.global_image_id) {
+    return global_image_id < rhs.global_image_id;
+  }
+  return state < rhs.state;
+}
+
+std::ostream& operator<<(std::ostream& os, const MirrorImageMode& mirror_mode) {
+  switch (mirror_mode) {
+  case MIRROR_IMAGE_MODE_JOURNAL:
+    os << "journal";
+    break;
+  case MIRROR_IMAGE_MODE_SNAPSHOT:
+    os << "snapshot";
+    break;
+  default:
+    os << "unknown (" << static_cast<uint32_t>(mirror_mode) << ")";
+    break;
+  }
+  return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const MirrorImageState& mirror_state) {
@@ -163,6 +193,9 @@ std::ostream& operator<<(std::ostream& os, const MirrorImageState& mirror_state)
   case MIRROR_IMAGE_STATE_ENABLED:
     os << "enabled";
     break;
+  case MIRROR_IMAGE_STATE_DISABLED:
+    os << "disabled";
+    break;
   default:
     os << "unknown (" << static_cast<uint32_t>(mirror_state) << ")";
     break;
@@ -172,6 +205,7 @@ std::ostream& operator<<(std::ostream& os, const MirrorImageState& mirror_state)
 
 std::ostream& operator<<(std::ostream& os, const MirrorImage& mirror_image) {
   os << "["
+     << "mode=" << mirror_image.mode << ", "
      << "global_image_id=" << mirror_image.global_image_id << ", "
      << "state=" << mirror_image.state << "]";
   return os;
@@ -687,20 +721,20 @@ void TrashSnapshotNamespace::dump(Formatter *f) const {
 void MirrorPrimarySnapshotNamespace::encode(bufferlist& bl) const {
   using ceph::encode;
   encode(demoted, bl);
-  encode(mirror_peers, bl);
+  encode(mirror_peer_uuids, bl);
 }
 
 void MirrorPrimarySnapshotNamespace::decode(bufferlist::const_iterator& it) {
   using ceph::decode;
   decode(demoted, it);
-  decode(mirror_peers, it);
+  decode(mirror_peer_uuids, it);
 }
 
 void MirrorPrimarySnapshotNamespace::dump(Formatter *f) const {
   f->dump_bool("demoted", demoted);
-  f->open_array_section("mirror_peers");
-  for (auto &peer : mirror_peers) {
-    f->dump_string("mirror_peer", peer);
+  f->open_array_section("mirror_peer_uuids");
+  for (auto &peer : mirror_peer_uuids) {
+    f->dump_string("mirror_peer_uuid", peer);
   }
   f->close_section();
 }
@@ -710,7 +744,7 @@ void MirrorNonPrimarySnapshotNamespace::encode(bufferlist& bl) const {
   encode(primary_mirror_uuid, bl);
   encode(primary_snap_id, bl);
   encode(copied, bl);
-  encode(copy_progress, bl);
+  encode(last_copied_object_number, bl);
 }
 
 void MirrorNonPrimarySnapshotNamespace::decode(bufferlist::const_iterator& it) {
@@ -718,14 +752,14 @@ void MirrorNonPrimarySnapshotNamespace::decode(bufferlist::const_iterator& it) {
   decode(primary_mirror_uuid, it);
   decode(primary_snap_id, it);
   decode(copied, it);
-  decode(copy_progress, it);
+  decode(last_copied_object_number, it);
 }
 
 void MirrorNonPrimarySnapshotNamespace::dump(Formatter *f) const {
   f->dump_string("primary_mirror_uuid", primary_mirror_uuid);
   f->dump_unsigned("primary_snap_id", primary_snap_id);
   f->dump_bool("copied", copied);
-  f->dump_unsigned("copy_progress", copy_progress);
+  f->dump_unsigned("last_copied_object_number", last_copied_object_number);
 }
 
 class EncodeSnapshotNamespaceVisitor : public boost::static_visitor<void> {
@@ -940,7 +974,7 @@ std::ostream& operator<<(std::ostream& os,
                          const MirrorPrimarySnapshotNamespace& ns) {
   os << "[" << SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY << " "
      << "demoted=" << ns.demoted << ", "
-     << "mirror_peers=" << ns.mirror_peers
+     << "mirror_peer_uuids=" << ns.mirror_peer_uuids
      << "]";
   return os;
 }
@@ -951,7 +985,7 @@ std::ostream& operator<<(std::ostream& os,
      << "primary_mirror_uuid=" << ns.primary_mirror_uuid << ", "
      << "primary_snap_id=" << ns.primary_snap_id << ", "
      << "copied=" << ns.copied << ", "
-     << "copy_progress=" << ns.copy_progress
+     << "last_copied_object_number=" << ns.last_copied_object_number
      << "]";
   return os;
 }

diff --git a/src/cls/rbd/cls_rbd_types.h b/src/cls/rbd/cls_rbd_types.h
index d4da0bd13e7fdbad3a0ff1ca58967b4e65144974..8f7ab37295ba611b5a1c61ae507f2a763074a066 100644 (file)
--- a/src/cls/rbd/cls_rbd_types.h
+++ b/src/cls/rbd/cls_rbd_types.h
@@ -131,6 +131,11 @@ std::ostream& operator<<(std::ostream& os, const MirrorPeer& peer);
 
 WRITE_CLASS_ENCODER(MirrorPeer);
 
+enum MirrorImageMode {
+  MIRROR_IMAGE_MODE_JOURNAL  = 0,
+  MIRROR_IMAGE_MODE_SNAPSHOT = 1,
+};
+
 enum MirrorImageState {
   MIRROR_IMAGE_STATE_DISABLING = 0,
   MIRROR_IMAGE_STATE_ENABLED   = 1,
@@ -138,10 +143,14 @@ enum MirrorImageState {
 };
 
 struct MirrorImage {
-  MirrorImage() {}
-  MirrorImage(const std::string &global_image_id, MirrorImageState state)
-    : global_image_id(global_image_id), state(state) {}
+  MirrorImage() {
+  }
+  MirrorImage(MirrorImageMode mode, const std::string &global_image_id,
+              MirrorImageState state)
+    : mode(mode), global_image_id(global_image_id), state(state) {
+  }
 
+  MirrorImageMode mode = MIRROR_IMAGE_MODE_JOURNAL;
   std::string global_image_id;
   MirrorImageState state = MIRROR_IMAGE_STATE_DISABLING;
 
@@ -155,6 +164,7 @@ struct MirrorImage {
   bool operator<(const MirrorImage &rhs) const;
 };
 
+std::ostream& operator<<(std::ostream& os, const MirrorImageMode& mirror_mode);
 std::ostream& operator<<(std::ostream& os, const MirrorImageState& mirror_state);
 std::ostream& operator<<(std::ostream& os, const MirrorImage& mirror_image);
 
@@ -502,13 +512,13 @@ struct MirrorPrimarySnapshotNamespace {
     SNAPSHOT_NAMESPACE_TYPE_MIRROR_PRIMARY;
 
   bool demoted = false;
-  std::set<std::string> mirror_peers;
+  std::set<std::string> mirror_peer_uuids;
 
   MirrorPrimarySnapshotNamespace() {
   }
   MirrorPrimarySnapshotNamespace(bool demoted,
-                                 const std::set<std::string> &mirror_peers)
-    : demoted(demoted), mirror_peers(mirror_peers) {
+                                 const std::set<std::string> &mirror_peer_uuids)
+    : demoted(demoted), mirror_peer_uuids(mirror_peer_uuids) {
   }
 
   void encode(bufferlist& bl) const;
@@ -536,7 +546,7 @@ struct MirrorNonPrimarySnapshotNamespace {
   std::string primary_mirror_uuid;
   snapid_t primary_snap_id = CEPH_NOSNAP;
   bool copied = false;
-  uint64_t copy_progress = 0;
+  uint64_t last_copied_object_number = 0;
 
   MirrorNonPrimarySnapshotNamespace() {
   }

diff --git a/src/include/rbd/librbd.h b/src/include/rbd/librbd.h
index bcb215acdeece6585283969c16bf06fdc3acbecd..31976d98e9a6d515ab1354d13bddf146978c3c0b 100644 (file)
--- a/src/include/rbd/librbd.h
+++ b/src/include/rbd/librbd.h
@@ -251,15 +251,15 @@ typedef struct {
 
 typedef struct {
   bool demoted;
-  size_t mirror_peers_count;
-  char *mirror_peers;
+  size_t mirror_peer_uuids_count;
+  char *mirror_peer_uuids;
 } rbd_snap_mirror_primary_namespace_t;
 
 typedef struct {
   char *primary_mirror_uuid;
   uint64_t primary_snap_id;
   bool copied;
-  uint64_t copy_progress;
+  uint64_t last_copied_object_number;
 } rbd_snap_mirror_non_primary_namespace_t;
 
 typedef enum {

diff --git a/src/include/rbd/librbd.hpp b/src/include/rbd/librbd.hpp
index 5511bad38a9bb439a00f2089eba4d4f0f95a98c2..5a6b801f6d13bd46a9c1358ebdaf763b204b5fb2 100644 (file)
--- a/src/include/rbd/librbd.hpp
+++ b/src/include/rbd/librbd.hpp
@@ -75,14 +75,14 @@ namespace librbd {
 
   typedef struct {
     bool demoted;
-    std::set<std::string> mirror_peers;
+    std::set<std::string> mirror_peer_uuids;
   } snap_mirror_primary_namespace_t;
 
   typedef struct {
     std::string primary_mirror_uuid;
     uint64_t primary_snap_id;
     bool copied;
-    uint64_t copy_progress;
+    uint64_t last_copied_object_number;
   } snap_mirror_non_primary_namespace_t;
 
   typedef struct {

diff --git a/src/librbd/api/Snapshot.cc b/src/librbd/api/Snapshot.cc
index 75864bae59395e47d5c84c923c884c876b735126..8954973b91f0f1cbf977b2f7c4a56d66d2797a24 100644 (file)
--- a/src/librbd/api/Snapshot.cc
+++ b/src/librbd/api/Snapshot.cc
@@ -111,7 +111,7 @@ public:
   inline int operator()(
       const cls::rbd::MirrorPrimarySnapshotNamespace& snap_namespace) {
     mirror_snap->demoted = snap_namespace.demoted;
-    mirror_snap->mirror_peers = snap_namespace.mirror_peers;
+    mirror_snap->mirror_peer_uuids = snap_namespace.mirror_peer_uuids;
     return 0;
   }
 };
@@ -135,7 +135,8 @@ public:
     mirror_snap->primary_mirror_uuid = snap_namespace.primary_mirror_uuid;
     mirror_snap->primary_snap_id = snap_namespace.primary_snap_id;
     mirror_snap->copied = snap_namespace.copied;
-    mirror_snap->copy_progress = snap_namespace.copy_progress;
+    mirror_snap->last_copied_object_number =
+      snap_namespace.last_copied_object_number;
     return 0;
   }
 };

diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc
index 75a854a768e5ede266d6b2e71e99bd34486a471c..661845ed0b08bae09b66d2641cd5a4355eebc737 100644 (file)
--- a/src/librbd/librbd.cc
+++ b/src/librbd/librbd.cc
@@ -6859,14 +6859,15 @@ extern "C" int rbd_snap_get_mirror_primary_namespace(
   }
 
   mirror_snap->demoted = mirror_namespace.demoted;
-  mirror_snap->mirror_peers_count = mirror_namespace.mirror_peers.size();
+  mirror_snap->mirror_peer_uuids_count =
+    mirror_namespace.mirror_peer_uuids.size();
   size_t len = 0;
-  for (auto &peer : mirror_namespace.mirror_peers) {
+  for (auto &peer : mirror_namespace.mirror_peer_uuids) {
     len += peer.size() + 1;
   }
-  mirror_snap->mirror_peers = (char *)malloc(len);
-  char *p = mirror_snap->mirror_peers;
-  for (auto &peer : mirror_namespace.mirror_peers) {
+  mirror_snap->mirror_peer_uuids = (char *)malloc(len);
+  char *p = mirror_snap->mirror_peer_uuids;
+  for (auto &peer : mirror_namespace.mirror_peer_uuids) {
     strncpy(p, peer.c_str(), peer.size() + 1);
     p += peer.size() + 1;
   }
@@ -6881,7 +6882,7 @@ extern "C" int rbd_snap_mirror_primary_namespace_cleanup(
     return -ERANGE;
   }
 
-  free(mirror_snap->mirror_peers);
+  free(mirror_snap->mirror_peer_uuids);
   return 0;
 }
 
@@ -6903,10 +6904,11 @@ extern "C" int rbd_snap_get_mirror_non_primary_namespace(
   }
 
   mirror_snap->primary_mirror_uuid =
-      strdup(mirror_namespace.primary_mirror_uuid.c_str());
+    strdup(mirror_namespace.primary_mirror_uuid.c_str());
   mirror_snap->primary_snap_id = mirror_namespace.primary_snap_id;
   mirror_snap->copied = mirror_namespace.copied;
-  mirror_snap->copy_progress = mirror_namespace.copy_progress;
+  mirror_snap->last_copied_object_number =
+    mirror_namespace.last_copied_object_number;
 
   return 0;
 }

diff --git a/src/librbd/mirror/EnableRequest.cc b/src/librbd/mirror/EnableRequest.cc
index a5c5b1255fac8c57dddb233981ac9833267994e2..b0f7ea18725b825210b2c613d0578176ffbd9b8a 100644 (file)
--- a/src/librbd/mirror/EnableRequest.cc
+++ b/src/librbd/mirror/EnableRequest.cc
@@ -166,8 +166,7 @@ void EnableRequest<I>::send_notify_mirroring_watcher() {
     klass, &klass::handle_notify_mirroring_watcher>(this);
 
   MirroringWatcher<>::notify_image_updated(m_io_ctx,
-                                           cls::rbd::MIRROR_IMAGE_STATE_ENABLED,
-                                           m_image_id,
+                                           m_mirror_image.state, m_image_id,
                                            m_mirror_image.global_image_id, ctx);
 }
 

diff --git a/src/pybind/rbd/rbd.pyx b/src/pybind/rbd/rbd.pyx
index 7d835336f53080c0d041df49a3cc1878b2c9e082..c0602af974f2cfa8bfd2f79fb1ffa013e7b9533c 100644 (file)
--- a/src/pybind/rbd/rbd.pyx
+++ b/src/pybind/rbd/rbd.pyx
@@ -129,14 +129,14 @@ cdef extern from "rbd/librbd.h" nogil:
 
     ctypedef struct rbd_snap_mirror_primary_namespace_t:
         bint demoted
-        size_t mirror_peers_count
-        char *mirror_peers
+        size_t mirror_peer_uuids_count
+        char *mirror_peer_uuids
 
     ctypedef struct rbd_snap_mirror_non_primary_namespace_t:
         char *primary_mirror_uuid
         uint64_t primary_snap_id
         bint copied
-        uint64_t copy_progress
+        uint64_t last_copied_object_number
 
     ctypedef struct rbd_group_info_t:
         char *name
@@ -5079,7 +5079,7 @@ written." % (self.name, ret, length))
 
             * ``demoted`` (bool) - True if snapshot is in demoted state
 
-            * ``mirror_peers`` (list) - mirror peer uuids
+            * ``mirror_peer_uuids`` (list) - mirror peer uuids
         """
         cdef:
             rbd_snap_mirror_primary_namespace_t sn
@@ -5092,15 +5092,15 @@ written." % (self.name, ret, length))
             raise make_ex(ret, 'error getting snapshot mirror primary '
                                'namespace for image: %s, snap_id: %d' %
                                (self.name, snap_id))
-        peers = []
-        p = sn.mirror_peers
-        for i in range(sn.mirror_peers_count):
-            peer = decode_cstr(p)
-            peers.append(peer)
-            p += len(peer) + 1
+        uuids = []
+        cdef char *p = sn.mirror_peer_uuids
+        for i in range(sn.mirror_peer_uuids_count):
+            uuid = decode_cstr(p)
+            uuids.append(uuid)
+            p += len(uuid) + 1
         info = {
                 'demoted' : sn.demoted,
-                'mirror_peers' : peers,
+                'mirror_peer_uuids' : uuids,
             }
         rbd_snap_mirror_primary_namespace_cleanup(
             &sn, sizeof(rbd_snap_mirror_primary_namespace_t))
@@ -5119,7 +5119,7 @@ written." % (self.name, ret, length))
 
             * ``copied`` (bool) - True if snapsho is copied
 
-           *  ``copy_progress`` (int) - copy progress
+           *  ``last_copied_object_number`` (int) - last copied object number
         """
         cdef:
             rbd_snap_mirror_non_primary_namespace_t sn
@@ -5136,7 +5136,7 @@ written." % (self.name, ret, length))
                 'primary_mirror_uuid' : decode_cstr(sn.primary_mirror_uuid),
                 'primary_snap_id' : sn.primary_snap_id,
                 'copied' : sn.copied,
-                'copy_progress' : sn.copy_progress,
+                'last_copied_object_number' : sn.last_copied_object_number,
             }
         rbd_snap_mirror_non_primary_namespace_cleanup(
             &sn, sizeof(rbd_snap_mirror_non_primary_namespace_t))

diff --git a/src/test/cls_rbd/test_cls_rbd.cc b/src/test/cls_rbd/test_cls_rbd.cc
index 30e4affbda9419fea109032d2bc54e66af685c6a..39d84dbefeafe5ca6ff160f8494016d9bc1698d4 100644 (file)
--- a/src/test/cls_rbd/test_cls_rbd.cc
+++ b/src/test/cls_rbd/test_cls_rbd.cc
@@ -1733,9 +1733,12 @@ TEST_F(TestClsRbd, mirror_image) {
   std::map<std::string, std::string> mirror_image_ids;
   ASSERT_EQ(-ENOENT, mirror_image_list(&ioctx, "", 0, &mirror_image_ids));
 
-  cls::rbd::MirrorImage image1("uuid1", cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
-  cls::rbd::MirrorImage image2("uuid2", cls::rbd::MIRROR_IMAGE_STATE_DISABLING);
-  cls::rbd::MirrorImage image3("uuid3", cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
+  cls::rbd::MirrorImage image1(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid1",
+                               cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
+  cls::rbd::MirrorImage image2(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid2",
+                               cls::rbd::MIRROR_IMAGE_STATE_DISABLING);
+  cls::rbd::MirrorImage image3(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid3",
+                               cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
 
   ASSERT_EQ(0, mirror_image_set(&ioctx, "image_id1", image1));
   ASSERT_EQ(-ENOENT, mirror_image_set(&ioctx, "image_id2", image2));
@@ -1824,9 +1827,12 @@ TEST_F(TestClsRbd, mirror_image_status) {
 
   // Test status set
 
-  cls::rbd::MirrorImage image1("uuid1", cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
-  cls::rbd::MirrorImage image2("uuid2", cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
-  cls::rbd::MirrorImage image3("uuid3", cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
+  cls::rbd::MirrorImage image1(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid1",
+                               cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
+  cls::rbd::MirrorImage image2(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid2",
+                               cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
+  cls::rbd::MirrorImage image3(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid3",
+                               cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
 
   ASSERT_EQ(0, mirror_image_set(&ioctx, "image_id1", image1));
   ASSERT_EQ(0, mirror_image_set(&ioctx, "image_id2", image2));
@@ -2090,7 +2096,8 @@ TEST_F(TestClsRbd, mirror_image_status) {
   for (size_t i = 0; i < N; i++) {
     std::string id = "id" + stringify(i);
     std::string uuid = "uuid" + stringify(i);
-    cls::rbd::MirrorImage image(uuid, cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
+    cls::rbd::MirrorImage image(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, uuid,
+                                cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
     cls::rbd::MirrorImageSiteStatus status(
       "", cls::rbd::MIRROR_IMAGE_STATUS_STATE_UNKNOWN, "");
     ASSERT_EQ(0, mirror_image_set(&ioctx, id, image));

diff --git a/src/test/librbd/mirror/test_mock_DisableRequest.cc b/src/test/librbd/mirror/test_mock_DisableRequest.cc
index 7001c0dffc002fc2656f9ebcf1409fa908ded803..84ef7cab2c6b462a55320d2f411879abb7cc3a61 100644 (file)
--- a/src/test/librbd/mirror/test_mock_DisableRequest.cc
+++ b/src/test/librbd/mirror/test_mock_DisableRequest.cc
@@ -223,9 +223,9 @@ TEST_F(TestMockMirrorDisableRequest, Success) {
   expect_snap_remove(mock_image_ctx, "snap 2", 0);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,
@@ -267,9 +267,9 @@ TEST_F(TestMockMirrorDisableRequest, SuccessNoRemove) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,
@@ -297,9 +297,9 @@ TEST_F(TestMockMirrorDisableRequest, SuccessNonPrimary) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, false, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,
@@ -331,9 +331,9 @@ TEST_F(TestMockMirrorDisableRequest, NonPrimaryError) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, false, 0);
 
   C_SaferCond ctx;
@@ -374,9 +374,9 @@ TEST_F(TestMockMirrorDisableRequest, IsTagOwnerError) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, -EBADMSG);
 
   C_SaferCond ctx;
@@ -397,9 +397,9 @@ TEST_F(TestMockMirrorDisableRequest, MirrorImageSetError) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, 0);
   expect_set_mirror_image(mock_image_ctx, -ENOENT);
 
@@ -423,9 +423,9 @@ TEST_F(TestMockMirrorDisableRequest, JournalPromoteError) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, false, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,
@@ -452,9 +452,9 @@ TEST_F(TestMockMirrorDisableRequest, JournalClientListError) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,
@@ -483,9 +483,9 @@ TEST_F(TestMockMirrorDisableRequest, SnapRemoveError) {
   expect_snap_remove(mock_image_ctx, "snap 2", -EPERM);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,
@@ -523,9 +523,9 @@ TEST_F(TestMockMirrorDisableRequest, JournalClientUnregisterError) {
   expect_snap_remove(mock_image_ctx, "snap 2", 0);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,
@@ -562,9 +562,9 @@ TEST_F(TestMockMirrorDisableRequest, MirrorImageRemoveError) {
   expect_op_work_queue(mock_image_ctx);
 
   InSequence seq;
-  expect_get_mirror_image(mock_image_ctx,
-                          {"global id", cls::rbd::MIRROR_IMAGE_STATE_ENABLED},
-                          0);
+  expect_get_mirror_image(
+    mock_image_ctx, {cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "global id",
+                     cls::rbd::MIRROR_IMAGE_STATE_ENABLED}, 0);
   expect_is_tag_owner(mock_image_ctx, mock_journal, true, 0);
   expect_set_mirror_image(mock_image_ctx, 0);
   expect_notify_image_updated(mock_image_ctx, mock_mirroring_watcher,

diff --git a/src/test/rbd_mirror/image_replayer/test_mock_PrepareLocalImageRequest.cc b/src/test/rbd_mirror/image_replayer/test_mock_PrepareLocalImageRequest.cc
index 64e0697e6af4f82e434e8244fde5b5f3ecb2be08..b758a973c27c2b33462ea02d01fb06a093c02318 100644 (file)
--- a/src/test/rbd_mirror/image_replayer/test_mock_PrepareLocalImageRequest.cc
+++ b/src/test/rbd_mirror/image_replayer/test_mock_PrepareLocalImageRequest.cc
@@ -136,7 +136,8 @@ TEST_F(TestMockImageReplayerPrepareLocalImageRequest, Success) {
   expect_get_mirror_image_id(mock_get_mirror_image_id_request, "local image id",
                              0);
   expect_dir_get_name(m_local_io_ctx, "local image name", 0);
-  expect_mirror_image_get(m_local_io_ctx, cls::rbd::MIRROR_IMAGE_STATE_ENABLED,
+  expect_mirror_image_get(m_local_io_ctx,
+                          cls::rbd::MIRROR_IMAGE_STATE_ENABLED,
                           "global image id", 0);
 
   librbd::MockJournal mock_journal;
@@ -236,7 +237,8 @@ TEST_F(TestMockImageReplayerPrepareLocalImageRequest, TagOwnerError) {
   expect_get_mirror_image_id(mock_get_mirror_image_id_request, "local image id",
                              0);
   expect_dir_get_name(m_local_io_ctx, "local image name", 0);
-  expect_mirror_image_get(m_local_io_ctx, cls::rbd::MIRROR_IMAGE_STATE_ENABLED,
+  expect_mirror_image_get(m_local_io_ctx,
+                          cls::rbd::MIRROR_IMAGE_STATE_ENABLED,
                           "global image id", 0);
 
   librbd::MockJournal mock_journal;

diff --git a/src/test/rbd_mirror/test_ImageDeleter.cc b/src/test/rbd_mirror/test_ImageDeleter.cc
index 0add0612cd8755f32157a0c79aef0f7f22fc1ce9..9bd2658daedb4c0f48b17072f89ad7d8f8a44255 100644 (file)
--- a/src/test/rbd_mirror/test_ImageDeleter.cc
+++ b/src/test/rbd_mirror/test_ImageDeleter.cc
@@ -43,6 +43,7 @@
 using rbd::mirror::RadosRef;
 using rbd::mirror::TestFixture;
 using namespace librbd;
+using cls::rbd::MirrorImageMode;
 using cls::rbd::MirrorImageState;
 
 
@@ -79,7 +80,8 @@ public:
                                 m_remote_mirror_uuid, true));
 
     cls::rbd::MirrorImage mirror_image(
-      GLOBAL_IMAGE_ID, MirrorImageState::MIRROR_IMAGE_STATE_ENABLED);
+      MirrorImageMode::MIRROR_IMAGE_MODE_JOURNAL, GLOBAL_IMAGE_ID,
+      MirrorImageState::MIRROR_IMAGE_STATE_ENABLED);
     EXPECT_EQ(0, cls_client::mirror_image_set(&m_local_io_ctx, m_local_image_id,
                                               mirror_image));
   }
@@ -204,7 +206,8 @@ public:
                                GLOBAL_CLONE_IMAGE_ID, m_remote_mirror_uuid));
 
     cls::rbd::MirrorImage mirror_image(
-      GLOBAL_CLONE_IMAGE_ID, MirrorImageState::MIRROR_IMAGE_STATE_ENABLED);
+      MirrorImageMode::MIRROR_IMAGE_MODE_JOURNAL, GLOBAL_CLONE_IMAGE_ID,
+      MirrorImageState::MIRROR_IMAGE_STATE_ENABLED);
     EXPECT_EQ(0, cls_client::mirror_image_set(&m_local_io_ctx, clone_id,
                                               mirror_image));
     EXPECT_EQ(0, ictx->state->close());

diff --git a/src/tools/rbd_mirror/image_replayer/IsPrimaryRequest.cc b/src/tools/rbd_mirror/image_replayer/IsPrimaryRequest.cc
index 54636fdb369baaacc5a412f681f0ef5c6ff53c82..67cfade97e84539dafe78d634130d27021c32250 100644 (file)
--- a/src/tools/rbd_mirror/image_replayer/IsPrimaryRequest.cc
+++ b/src/tools/rbd_mirror/image_replayer/IsPrimaryRequest.cc
@@ -60,7 +60,13 @@ void IsPrimaryRequest<I>::handle_get_mirror_state(int r) {
     r = librbd::cls_client::mirror_image_get_finish(&iter, &mirror_image);
     if (r == 0) {
       if (mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_ENABLED) {
-        send_is_tag_owner();
+        if (mirror_image.mode == cls::rbd::MIRROR_IMAGE_MODE_JOURNAL) {
+          send_is_tag_owner();
+        } else if (mirror_image.mode == cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT) {
+          // TODO: get primary state from mirroring snapshots
+          ceph_abort();
+          finish(0);
+        }
         return;
       } else if (mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_DISABLING) {
         dout(5) << ": image mirroring is being disabled" << dendl;