From e97c67589fa9f046105658ac477ac2bf03621a10 Mon Sep 17 00:00:00 2001 From: Mykola Golub Date: Sun, 6 Dec 2020 13:12:39 +0000 Subject: [PATCH] cls/rbd: add group snapshot namespace Signed-off-by: Mykola Golub Signed-off-by: Prasanna Kumar Kalever --- src/cls/rbd/cls_rbd_types.cc | 223 ++++++++++++++++++++++++++++++- src/cls/rbd/cls_rbd_types.h | 198 +++++++++++++++++++++++++-- src/test/cls_rbd/test_cls_rbd.cc | 61 +++++++-- 3 files changed, 449 insertions(+), 33 deletions(-) diff --git a/src/cls/rbd/cls_rbd_types.cc b/src/cls/rbd/cls_rbd_types.cc index 5d8edb509ef99..bec10a0cd5912 100644 --- a/src/cls/rbd/cls_rbd_types.cc +++ b/src/cls/rbd/cls_rbd_types.cc @@ -2,6 +2,7 @@ // vim: ts=8 sw=2 smarttab #include +#include #include "cls/rbd/cls_rbd_types.h" #include "common/Formatter.h" @@ -1034,8 +1035,8 @@ std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns) { return os; } -std::ostream& operator<<(std::ostream& os, MirrorSnapshotState type) { - switch (type) { +std::ostream& operator<<(std::ostream& os, MirrorSnapshotState state) { + switch (state) { case MIRROR_SNAPSHOT_STATE_PRIMARY: os << "primary"; break; @@ -1055,6 +1056,194 @@ std::ostream& operator<<(std::ostream& os, MirrorSnapshotState type) { return os; } +void MirrorGroupSnapshotNamespace::encode(bufferlist& bl) const { + using ceph::encode; + encode(state, bl); + encode(mirror_peer_uuids, bl); + encode(primary_mirror_uuid, bl); + encode(primary_snap_id, bl); +} + +void MirrorGroupSnapshotNamespace::decode(uint8_t version, + bufferlist::const_iterator& it) { + using ceph::decode; + decode(state, it); + decode(mirror_peer_uuids, it); + decode(primary_mirror_uuid, it); + decode(primary_snap_id, it); +} + +void MirrorGroupSnapshotNamespace::dump(Formatter *f) const { + f->dump_stream("state") << state; + f->open_array_section("mirror_peer_uuids"); + for (auto &peer : mirror_peer_uuids) { + f->dump_string("mirror_peer_uuid", peer); + } + f->close_section(); + if (is_non_primary()) { + f->dump_string("primary_mirror_uuid", primary_mirror_uuid); + f->dump_string("primary_snap_id", primary_snap_id); + } +} + +class EncodeGroupSnapshotNamespaceVisitor : public boost::static_visitor { +public: + explicit EncodeGroupSnapshotNamespaceVisitor(bufferlist &bl) : m_bl(bl) { + } + + template + inline void operator()(const T& t) const { + using ceph::encode; + encode(static_cast(T::GROUP_SNAPSHOT_NAMESPACE_TYPE), m_bl); + t.encode(m_bl); + } + +private: + bufferlist &m_bl; +}; + +class DecodeGroupSnapshotNamespaceVisitor : public boost::static_visitor { +public: + DecodeGroupSnapshotNamespaceVisitor(uint8_t version, + bufferlist::const_iterator &iter) + : m_version(version), m_iter(iter) { + } + + template + inline void operator()(T& t) const { + t.decode(m_version, m_iter); + } +private: + uint8_t m_version; + bufferlist::const_iterator &m_iter; +}; + +class DumpGroupSnapshotNamespaceVisitor : public boost::static_visitor { +public: + explicit DumpGroupSnapshotNamespaceVisitor(Formatter *formatter, + const std::string &key) + : m_formatter(formatter), m_key(key) { + } + + template + inline void operator()(const T& t) const { + auto type = T::GROUP_SNAPSHOT_NAMESPACE_TYPE; + m_formatter->dump_stream(m_key.c_str()) << type; + t.dump(m_formatter); + } +private: + ceph::Formatter *m_formatter; + std::string m_key; +}; + +class GetGroupSnapshotNamespaceTypeVisitor + : public boost::static_visitor { +public: + template + inline GroupSnapshotNamespaceType operator()(const T&) const { + return static_cast( + T::GROUP_SNAPSHOT_NAMESPACE_TYPE); + } +}; + +GroupSnapshotNamespaceType get_group_snap_namespace_type( + const GroupSnapshotNamespace& snapshot_namespace) { + return static_cast(snapshot_namespace.visit( + GetGroupSnapshotNamespaceTypeVisitor())); +} + +void GroupSnapshotNamespace::encode(bufferlist& bl) const { + ENCODE_START(1, 1, bl); + visit(EncodeGroupSnapshotNamespaceVisitor(bl)); + ENCODE_FINISH(bl); +} + +void GroupSnapshotNamespace::decode(bufferlist::const_iterator &p) +{ + DECODE_START(1, p); + uint32_t snap_type; + decode(snap_type, p); + switch (snap_type) { + case cls::rbd::GROUP_SNAPSHOT_NAMESPACE_TYPE_USER: + *this = UserGroupSnapshotNamespace(); + break; + case cls::rbd::GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR: + *this = MirrorGroupSnapshotNamespace(); + break; + default: + *this = UnknownGroupSnapshotNamespace(); + break; + } + visit(DecodeGroupSnapshotNamespaceVisitor(struct_v, p)); + DECODE_FINISH(p); +} + +void GroupSnapshotNamespace::dump(Formatter *f) const { + visit(DumpGroupSnapshotNamespaceVisitor(f, "snapshot_namespace_type")); +} + +void GroupSnapshotNamespace::generate_test_instances( + std::list &o) { + o.push_back(new GroupSnapshotNamespace(UserGroupSnapshotNamespace())); + o.push_back(new GroupSnapshotNamespace(MirrorGroupSnapshotNamespace( + MIRROR_SNAPSHOT_STATE_PRIMARY, + {"peer uuid"}, "", ""))); +} + +std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceType& type) { + switch (type) { + case GROUP_SNAPSHOT_NAMESPACE_TYPE_USER: + os << "user"; + break; + case GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR: + os << "mirror"; + break; + default: + os << "unknown"; + break; + } + return os; +} + +std::ostream& operator<<(std::ostream& os, const UserGroupSnapshotNamespace& ns) { + os << "[" << GROUP_SNAPSHOT_NAMESPACE_TYPE_USER << "]"; + return os; +} + +std::ostream& operator<<(std::ostream& os, + const MirrorGroupSnapshotNamespace& ns) { + os << "[" << GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR << " " + << "state=" << ns.state << ", " + << "mirror_peer_uuids=" << ns.mirror_peer_uuids; + if (ns.is_non_primary()) { + os << ", " + << "primary_mirror_uuid=" << ns.primary_mirror_uuid << ", " + << "primary_snap_id=" << ns.primary_snap_id; + } + os << "]"; + return os; +} + +std::ostream& operator<<(std::ostream& os, const UnknownGroupSnapshotNamespace& ns) { + os << "[unknown]"; + return os; +} + +std::ostream& operator<<(std::ostream& os, GroupSnapshotState state) { + switch (state) { + case GROUP_SNAPSHOT_STATE_INCOMPLETE: + os << "incomplete"; + break; + case GROUP_SNAPSHOT_STATE_COMPLETE: + os << "complete"; + break; + default: + os << "unknown (" << static_cast(state) << ")"; + break; + } + return os; +} + void ImageSnapshotSpec::encode(bufferlist& bl) const { using ceph::encode; ENCODE_START(1, 1, bl); @@ -1086,34 +1275,54 @@ void ImageSnapshotSpec::generate_test_instances(std::list & void GroupSnapshot::encode(bufferlist& bl) const { using ceph::encode; - ENCODE_START(1, 1, bl); + ENCODE_START(2, 1, bl); encode(id, bl); encode(name, bl); encode(state, bl); encode(snaps, bl); + encode(snapshot_namespace, bl); ENCODE_FINISH(bl); } void GroupSnapshot::decode(bufferlist::const_iterator& it) { using ceph::decode; - DECODE_START(1, it); + DECODE_START(2, it); decode(id, it); decode(name, it); decode(state, it); decode(snaps, it); + if (struct_v >= 2) { + decode(snapshot_namespace, it); + } DECODE_FINISH(it); } void GroupSnapshot::dump(Formatter *f) const { f->dump_string("id", id); + f->open_object_section("namespace"); + snapshot_namespace.visit(DumpGroupSnapshotNamespaceVisitor(f, "type")); + f->close_section(); f->dump_string("name", name); - f->dump_int("state", state); + f->dump_stream("state") << state; + f->open_array_section("image_snapshots"); + for (auto &snap : snaps) { + snap.dump(f); + } + f->close_section(); } void GroupSnapshot::generate_test_instances(std::list &o) { - o.push_back(new GroupSnapshot("10152ae8944a", "groupsnapshot1", GROUP_SNAPSHOT_STATE_INCOMPLETE)); - o.push_back(new GroupSnapshot("1018643c9869", "groupsnapshot2", GROUP_SNAPSHOT_STATE_COMPLETE)); + o.push_back(new GroupSnapshot("10152ae8944a", UserGroupSnapshotNamespace{}, + "groupsnapshot1", + GROUP_SNAPSHOT_STATE_INCOMPLETE)); + o.push_back(new GroupSnapshot("1018643c9869", + MirrorGroupSnapshotNamespace{ + MIRROR_SNAPSHOT_STATE_NON_PRIMARY, {}, + "uuid", "id"}, + "groupsnapshot2", + GROUP_SNAPSHOT_STATE_COMPLETE)); } + void TrashImageSpec::encode(bufferlist& bl) const { ENCODE_START(2, 1, bl); encode(source, bl); diff --git a/src/cls/rbd/cls_rbd_types.h b/src/cls/rbd/cls_rbd_types.h index 2f80718207ba8..d865bacd7c5e7 100644 --- a/src/cls/rbd/cls_rbd_types.h +++ b/src/cls/rbd/cls_rbd_types.h @@ -546,7 +546,7 @@ inline void decode(MirrorSnapshotState &state, ceph::buffer::list::const_iterato state = static_cast(int_state); } -std::ostream& operator<<(std::ostream& os, MirrorSnapshotState type); +std::ostream& operator<<(std::ostream& os, MirrorSnapshotState state); typedef std::map SnapSeqs; @@ -736,6 +736,153 @@ struct SnapshotInfo { }; WRITE_CLASS_ENCODER(SnapshotInfo); +enum GroupSnapshotNamespaceType { + GROUP_SNAPSHOT_NAMESPACE_TYPE_USER = 0, + GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR = 1, +}; + +struct UserGroupSnapshotNamespace { + static const GroupSnapshotNamespaceType GROUP_SNAPSHOT_NAMESPACE_TYPE = + GROUP_SNAPSHOT_NAMESPACE_TYPE_USER; + + UserGroupSnapshotNamespace() {} + + void encode(ceph::buffer::list& bl) const { + } + void decode(uint8_t version, ceph::buffer::list::const_iterator& it) { + } + void dump(ceph::Formatter *f) const { + } + + inline bool operator==(const UserGroupSnapshotNamespace& usn) const { + return true; + } + + inline bool operator<(const UserGroupSnapshotNamespace& usn) const { + return false; + } +}; + +struct MirrorGroupSnapshotNamespace { + static const GroupSnapshotNamespaceType GROUP_SNAPSHOT_NAMESPACE_TYPE = + GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR; + + MirrorSnapshotState state = MIRROR_SNAPSHOT_STATE_NON_PRIMARY; + std::set mirror_peer_uuids; + + std::string primary_mirror_uuid; + std::string primary_snap_id; + + MirrorGroupSnapshotNamespace() { + } + MirrorGroupSnapshotNamespace(MirrorSnapshotState state, + const std::set &mirror_peer_uuids, + const std::string &primary_mirror_uuid, + const std::string &primary_snap_id) + : state(state), mirror_peer_uuids(mirror_peer_uuids), + primary_mirror_uuid(primary_mirror_uuid), + primary_snap_id(primary_snap_id) { + } + + inline bool is_primary() const { + return (state == MIRROR_SNAPSHOT_STATE_PRIMARY || + state == MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED); + } + + inline bool is_non_primary() const { + return (state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY || + state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED); + } + + inline bool is_demoted() const { + return (state == MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED || + state == MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED); + } + + inline bool is_orphan() const { + return (is_non_primary() && + primary_mirror_uuid.empty() && + primary_snap_id.empty()); + } + + void encode(ceph::buffer::list& bl) const; + void decode(uint8_t version, ceph::buffer::list::const_iterator& it); + + void dump(ceph::Formatter *f) const; + + inline bool operator==(const MirrorGroupSnapshotNamespace& rhs) const { + return state == rhs.state && + mirror_peer_uuids == rhs.mirror_peer_uuids && + primary_mirror_uuid == rhs.primary_mirror_uuid && + primary_snap_id == rhs.primary_snap_id; + } + + inline bool operator<(const MirrorGroupSnapshotNamespace& rhs) const { + if (state != rhs.state) { + return state < rhs.state; + } else if (mirror_peer_uuids != rhs.mirror_peer_uuids) { + return mirror_peer_uuids < rhs.mirror_peer_uuids; + } else if (primary_mirror_uuid != rhs.primary_mirror_uuid) { + return primary_mirror_uuid < rhs.primary_mirror_uuid; + } else { + return primary_snap_id < rhs.primary_snap_id; + } + } +}; + +struct UnknownGroupSnapshotNamespace { + static const GroupSnapshotNamespaceType GROUP_SNAPSHOT_NAMESPACE_TYPE = + static_cast(-1); + + UnknownGroupSnapshotNamespace() {} + + void encode(ceph::buffer::list& bl) const { + } + void decode(uint8_t version, ceph::buffer::list::const_iterator& it) { + } + void dump(ceph::Formatter *f) const { + } + + inline bool operator==(const UnknownGroupSnapshotNamespace& gsn) const { + return true; + } + + inline bool operator<(const UnknownGroupSnapshotNamespace& gsn) const { + return false; + } +}; + +std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceType& type); +std::ostream& operator<<(std::ostream& os, const UserGroupSnapshotNamespace& ns); +std::ostream& operator<<(std::ostream& os, const MirrorGroupSnapshotNamespace& ns); +std::ostream& operator<<(std::ostream& os, const UnknownGroupSnapshotNamespace& ns); + +typedef std::variant GroupSnapshotNamespaceVariant; + +struct GroupSnapshotNamespace : public GroupSnapshotNamespaceVariant { + using GroupSnapshotNamespaceVariant::GroupSnapshotNamespaceVariant; + + void encode(ceph::buffer::list& bl) const; + void decode(ceph::buffer::list::const_iterator& it); + void dump(ceph::Formatter *f) const; + + template + decltype(auto) visit(F&& f) const & { + return std::visit(std::forward(f), static_cast(*this)); + } + template + decltype(auto) visit(F&& f) & { + return std::visit(std::forward(f), static_cast(*this)); + } + static void generate_test_instances(std::list &o); +}; +WRITE_CLASS_ENCODER(GroupSnapshotNamespace); + +GroupSnapshotNamespaceType get_group_snap_namespace_type( + const GroupSnapshotNamespace& snapshot_namespace); + enum GroupSnapshotState { GROUP_SNAPSHOT_STATE_INCOMPLETE = 0, GROUP_SNAPSHOT_STATE_COMPLETE = 1, @@ -755,17 +902,17 @@ inline void decode(GroupSnapshotState &state, ceph::buffer::list::const_iterator state = static_cast(int_state); } +std::ostream& operator<<(std::ostream& os, GroupSnapshotState state); + struct ImageSnapshotSpec { int64_t pool; std::string image_id; snapid_t snap_id; ImageSnapshotSpec() {} - ImageSnapshotSpec(int64_t _pool, - std::string _image_id, - snapid_t _snap_id) : pool(_pool), - image_id(_image_id), - snap_id(_snap_id) {} + ImageSnapshotSpec(int64_t pool, std::string image_id, snapid_t snap_id) + : pool(pool), image_id(image_id), snap_id(snap_id) { + } void encode(ceph::buffer::list& bl) const; void decode(ceph::buffer::list::const_iterator& it); @@ -778,25 +925,50 @@ WRITE_CLASS_ENCODER(ImageSnapshotSpec); struct GroupSnapshot { std::string id; + GroupSnapshotNamespace snapshot_namespace = {UserGroupSnapshotNamespace{}}; std::string name; + GroupSnapshotState state = GROUP_SNAPSHOT_STATE_INCOMPLETE; + std::vector snaps; GroupSnapshot() {} - GroupSnapshot(std::string _id, - std::string _name, - GroupSnapshotState _state) : id(_id), - name(_name), - state(_state) {} - - std::vector snaps; + GroupSnapshot(const std::string &id, + const GroupSnapshotNamespace &snapshot_namespace, + const std::string &name, GroupSnapshotState state) + : id(id), snapshot_namespace(snapshot_namespace), name(name), state(state) { + } void encode(ceph::buffer::list& bl) const; void decode(ceph::buffer::list::const_iterator& it); void dump(ceph::Formatter *f) const; + inline bool operator==(const GroupSnapshot& rhs) const { + return id == rhs.id && + snapshot_namespace == rhs.snapshot_namespace && + name == rhs.name && + state == rhs.state && + snaps == rhs.snaps; + } + inline bool operator<(const GroupSnapshot& rhs) const { + if (id != rhs.id) { + return id < rhs.id; + } + if (snapshot_namespace != rhs.snapshot_namespace) { + return snapshot_namespace < rhs.snapshot_namespace; + } + if (name != rhs.name) { + return name < rhs.name; + } + if (state != rhs.state) { + return state < rhs.state; + } + return snaps < rhs.snaps; + } + static void generate_test_instances(std::list &o); }; WRITE_CLASS_ENCODER(GroupSnapshot); + enum TrashImageSource { TRASH_IMAGE_SOURCE_USER = 0, TRASH_IMAGE_SOURCE_MIRRORING = 1, diff --git a/src/test/cls_rbd/test_cls_rbd.cc b/src/test/cls_rbd/test_cls_rbd.cc index 4dcf20f4a78b8..a6ac979e8db85 100644 --- a/src/test/cls_rbd/test_cls_rbd.cc +++ b/src/test/cls_rbd/test_cls_rbd.cc @@ -2617,7 +2617,9 @@ TEST_F(TestClsRbd, group_snap_set_empty_name) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, "", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EINVAL, group_snap_set(&ioctx, group_id, snap)); } @@ -2629,7 +2631,9 @@ TEST_F(TestClsRbd, group_snap_set_empty_id) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {"", "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap = {"", cls::rbd::UserGroupSnapshotNamespace{}, + "snap_name", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EINVAL, group_snap_set(&ioctx, group_id, snap)); } @@ -2641,10 +2645,16 @@ TEST_F(TestClsRbd, group_snap_set_duplicate_id) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, + "snap_name", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); - cls::rbd::GroupSnapshot snap1 = {snap_id, "snap_name1", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap1 = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, + "snap_name1", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EEXIST, group_snap_set(&ioctx, group_id, snap1)); } @@ -2656,11 +2666,17 @@ TEST_F(TestClsRbd, group_snap_set_duplicate_name) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id1 = "snap_id1"; - cls::rbd::GroupSnapshot snap = {snap_id1, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap = {snap_id1, + cls::rbd::UserGroupSnapshotNamespace{}, + "snap_name", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); string snap_id2 = "snap_id2"; - cls::rbd::GroupSnapshot snap1 = {snap_id2, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap1 = {snap_id2, + cls::rbd::UserGroupSnapshotNamespace{}, + "snap_name", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EEXIST, group_snap_set(&ioctx, group_id, snap1)); } @@ -2672,7 +2688,10 @@ TEST_F(TestClsRbd, group_snap_set) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, + "test_snapshot", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); set keys; @@ -2693,17 +2712,23 @@ TEST_F(TestClsRbd, group_snap_list) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id1 = "snap_id1"; - cls::rbd::GroupSnapshot snap1 = {snap_id1, "test_snapshot1", + cls::rbd::GroupSnapshot snap1 = {snap_id1, + cls::rbd::UserGroupSnapshotNamespace{}, + "test_snapshot1", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap1)); string snap_id0 = "snap_id0"; - cls::rbd::GroupSnapshot snap0 = {snap_id0, "test_snapshot0", + cls::rbd::GroupSnapshot snap0 = {snap_id0, + cls::rbd::UserGroupSnapshotNamespace{}, + "test_snapshot0", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap0)); string snap_id2 = "snap_id2"; - cls::rbd::GroupSnapshot snap2 = {snap_id2, "test_snapshot2", + cls::rbd::GroupSnapshot snap2 = {snap_id2, + cls::rbd::UserGroupSnapshotNamespace{}, + "test_snapshot2", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap2)); @@ -2733,7 +2758,9 @@ TEST_F(TestClsRbd, group_snap_list) { ASSERT_EQ(2, snap_orders[snap_id0]); string snap_id4 = "snap_id4"; - cls::rbd::GroupSnapshot snap4 = {snap_id4, "test_snapshot4", + cls::rbd::GroupSnapshot snap4 = {snap_id4, + cls::rbd::UserGroupSnapshotNamespace{}, + "test_snapshot4", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap4)); @@ -2762,6 +2789,7 @@ TEST_F(TestClsRbd, group_snap_list_max_return) { for (int i = 0; i < 15; ++i) { string snap_id = "snap_id" + hexify(i); cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, "test_snapshot" + hexify(i), cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -2796,6 +2824,7 @@ TEST_F(TestClsRbd, group_snap_list_max_read) { for (int i = 0; i < 150; ++i) { string snap_id = "snap_id" + hexify(i); cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, "test_snapshot" + hexify(i), cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -2819,7 +2848,10 @@ TEST_F(TestClsRbd, group_snap_remove) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; + cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, + "test_snapshot", + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); set keys; @@ -2849,7 +2881,9 @@ TEST_F(TestClsRbd, group_snap_remove_without_order) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", + cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, + "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -2883,6 +2917,7 @@ TEST_F(TestClsRbd, group_snap_get_by_id) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, + cls::rbd::UserGroupSnapshotNamespace{}, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); -- 2.39.5