From cfb0c070ac96043a9781619a67fcffb89fb698a9 Mon Sep 17 00:00:00 2001 From: Mykola Golub Date: Mon, 4 Nov 2019 09:59:32 +0000 Subject: [PATCH] cls/rbd: add mode (journal/snapshot) to mirror image Signed-off-by: Mykola Golub --- src/cls/rbd/cls_rbd_types.cc | 70 ++++++++++++++----- src/cls/rbd/cls_rbd_types.h | 24 +++++-- src/include/rbd/librbd.h | 6 +- src/include/rbd/librbd.hpp | 4 +- src/librbd/api/Snapshot.cc | 5 +- src/librbd/librbd.cc | 18 ++--- src/librbd/mirror/EnableRequest.cc | 3 +- src/pybind/rbd/rbd.pyx | 26 +++---- src/test/cls_rbd/test_cls_rbd.cc | 21 ++++-- .../librbd/mirror/test_mock_DisableRequest.cc | 66 ++++++++--------- .../test_mock_PrepareLocalImageRequest.cc | 6 +- src/test/rbd_mirror/test_ImageDeleter.cc | 7 +- .../image_replayer/IsPrimaryRequest.cc | 8 ++- 13 files changed, 164 insertions(+), 100 deletions(-) diff --git a/src/cls/rbd/cls_rbd_types.cc b/src/cls/rbd/cls_rbd_types.cc index cfdde40dd7287..85402cf1587fe 100644 --- 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(state), bl); + encode(static_cast(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(int_state); + if (struct_v >= 2) { + uint8_t int_mode; + decode(int_mode, it); + mode = static_cast(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 &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(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(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 { @@ -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 d4da0bd13e7fd..8f7ab37295ba6 100644 --- 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 mirror_peers; + std::set mirror_peer_uuids; MirrorPrimarySnapshotNamespace() { } MirrorPrimarySnapshotNamespace(bool demoted, - const std::set &mirror_peers) - : demoted(demoted), mirror_peers(mirror_peers) { + const std::set &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 bcb215acdeece..31976d98e9a6d 100644 --- 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 5511bad38a9bb..5a6b801f6d13b 100644 --- a/src/include/rbd/librbd.hpp +++ b/src/include/rbd/librbd.hpp @@ -75,14 +75,14 @@ namespace librbd { typedef struct { bool demoted; - std::set mirror_peers; + std::set 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 75864bae59395..8954973b91f0f 100644 --- 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 75a854a768e5e..661845ed0b08b 100644 --- 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 a5c5b1255fac8..b0f7ea18725b8 100644 --- a/src/librbd/mirror/EnableRequest.cc +++ b/src/librbd/mirror/EnableRequest.cc @@ -166,8 +166,7 @@ void EnableRequest::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 7d835336f5308..c0602af974f2c 100644 --- 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 30e4affbda941..39d84dbefeafe 100644 --- 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 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 7001c0dffc002..84ef7cab2c6b4 100644 --- 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 64e0697e6af4f..b758a973c27c2 100644 --- 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 0add0612cd875..9bd2658daedb4 100644 --- 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 54636fdb369ba..67cfade97e845 100644 --- a/src/tools/rbd_mirror/image_replayer/IsPrimaryRequest.cc +++ b/src/tools/rbd_mirror/image_replayer/IsPrimaryRequest.cc @@ -60,7 +60,13 @@ void IsPrimaryRequest::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; -- 2.39.5