From a8048bae584a63835424b10498e983f9f4feeee7 Mon Sep 17 00:00:00 2001 From: Prasanna Kumar Kalever Date: Fri, 22 Nov 2024 21:56:20 +0530 Subject: [PATCH] cls/rbd: proposed changes Changes proposed by 'N Balachandran' Signed-off-by: N Balachandran Signed-off-by: Prasanna Kumar Kalever --- src/cls/rbd/cls_rbd.cc | 211 ++++++++----------------------- src/cls/rbd/cls_rbd_client.cc | 66 ---------- src/cls/rbd/cls_rbd_client.h | 27 +--- src/cls/rbd/cls_rbd_types.cc | 85 ++++++++----- src/cls/rbd/cls_rbd_types.h | 69 +++++----- src/librbd/api/Group.cc | 8 +- src/librbd/api/Snapshot.cc | 4 +- src/test/cls_rbd/test_cls_rbd.cc | 63 +++++---- 8 files changed, 193 insertions(+), 340 deletions(-) diff --git a/src/cls/rbd/cls_rbd.cc b/src/cls/rbd/cls_rbd.cc index 771641aab8e85..726895e96f75b 100644 --- a/src/cls/rbd/cls_rbd.cc +++ b/src/cls/rbd/cls_rbd.cc @@ -2395,7 +2395,7 @@ int snapshot_add(cls_method_context_t hctx, bufferlist *in, bufferlist *out) }; r = image::snapshot::iterate(hctx, pre_check_lambda); - if (r < 0 && r != -EEXIST) { + if (r < 0) { return r; } @@ -4674,11 +4674,6 @@ std::string group_global_key(const string &global_id) { return GROUP_GLOBAL_KEY_PREFIX + global_id; } -std::string group_resync_key(const std::string& global_group_id, - const std::string& group_name) { - return group_name + "_" + global_group_id; -} - std::string group_remote_status_global_key(const std::string& global_id, const std::string& mirror_uuid) { return GROUP_REMOTE_STATUS_GLOBAL_KEY_PREFIX + global_id + "_" + mirror_uuid; @@ -5898,6 +5893,7 @@ int group_set(cls_method_context_t hctx, const string &group_id, std::string group_id; r = read_key(hctx, global_id_key, &group_id); if (r >= 0) { + CLS_ERR("global group id key exists: '%s'", global_id_key.c_str()); return -EEXIST; } else if (r != -ENOENT) { CLS_ERR("error reading global group id: '%s': '%s'", group_id.c_str(), @@ -5917,6 +5913,7 @@ int group_set(cls_method_context_t hctx, const string &group_id, } else if (existing_group.global_group_id != group.global_group_id) { // cannot change the global id + CLS_ERR("group exists with a different global id: '%s'", group_id.c_str()); return -EINVAL; } @@ -5940,55 +5937,10 @@ int group_set(cls_method_context_t hctx, const string &group_id, return 0; } -int mirror_remote_namespace_get(cls_method_context_t hctx, bufferlist *in, - bufferlist *out) { - std::string mirror_ns_decode; - int r = read_key(hctx, mirror::REMOTE_NAMESPACE, &mirror_ns_decode); - if (r < 0) { - return r; - } - - encode(mirror_ns_decode, *out); - return 0; -} - -int mirror_remote_namespace_set(cls_method_context_t hctx, bufferlist *in, - bufferlist *out) { - std::string mirror_namespace; - try { - auto bl_it = in->cbegin(); - decode(mirror_namespace, bl_it); - } catch (const ceph::buffer::error &err) { - return -EINVAL; - } - - uint32_t mirror_mode; - int r = read_key(hctx, mirror::MODE, &mirror_mode); - if (r < 0 && r != -ENOENT) { - return r; - } else if (r == 0 && (mirror_mode != cls::rbd::MIRROR_MODE_DISABLED && - mirror_mode != cls::rbd::MIRROR_MODE_INIT_ONLY)) { - CLS_ERR("cannot set mirror remote namespace while mirroring enabled"); - return -EINVAL; - } - - bufferlist bl; - encode(mirror_namespace, bl); - - r = cls_cxx_map_set_val(hctx, mirror::REMOTE_NAMESPACE, &bl); - if (r < 0) { - CLS_ERR("error setting mirror remote namespace: %s", - cpp_strerror(r).c_str()); - return r; - } - return 0; -} - int group_status_remove(cls_method_context_t hctx, const string &global_group_id); int group_remove(cls_method_context_t hctx, const string &group_id) { - bufferlist bl; cls::rbd::MirrorGroup group; int r = group_get(hctx, group_id, &group); if (r < 0) { @@ -5999,13 +5951,9 @@ int group_remove(cls_method_context_t hctx, const string &group_id) { return r; } - /* disable_group/group_remove at the time of force promote while the remote is alive - * will hit below, hence commenting for now. */ - /* if (group.state != cls::rbd::MIRROR_GROUP_STATE_DISABLING) { return -EBUSY; } - */ r = cls_cxx_map_remove_key(hctx, group_key(group_id)); if (r < 0) { @@ -6727,6 +6675,53 @@ int mirror_mode_set(cls_method_context_t hctx, bufferlist *in, return r; } } + + return 0; +} + +int mirror_remote_namespace_get(cls_method_context_t hctx, bufferlist *in, + bufferlist *out) { + std::string mirror_ns_decode; + int r = read_key(hctx, mirror::REMOTE_NAMESPACE, &mirror_ns_decode); + if (r < 0) { + CLS_ERR("error getting mirror remote namespace: %s", + cpp_strerror(r).c_str()); + return r; + } + + encode(mirror_ns_decode, *out); + return 0; +} + +int mirror_remote_namespace_set(cls_method_context_t hctx, bufferlist *in, + bufferlist *out) { + std::string mirror_namespace; + try { + auto bl_it = in->cbegin(); + decode(mirror_namespace, bl_it); + } catch (const ceph::buffer::error &err) { + return -EINVAL; + } + + uint32_t mirror_mode; + int r = read_key(hctx, mirror::MODE, &mirror_mode); + if (r < 0 && r != -ENOENT) { + return r; + } else if (r == 0 && (mirror_mode != cls::rbd::MIRROR_MODE_DISABLED && + mirror_mode != cls::rbd::MIRROR_MODE_INIT_ONLY)) { + CLS_ERR("cannot set mirror remote namespace while mirroring enabled"); + return -EINVAL; + } + + bufferlist bl; + encode(mirror_namespace, bl); + + r = cls_cxx_map_set_val(hctx, mirror::REMOTE_NAMESPACE, &bl); + if (r < 0) { + CLS_ERR("error setting mirror remote namespace: %s", + cpp_strerror(r).c_str()); + return r; + } return 0; } @@ -7014,7 +7009,7 @@ int mirror_image_list(cls_method_context_t hctx, bufferlist *in, return -EIO; } - if (mirror_image.group_spec.is_valid() && !all) { + if (mirror_image.type == cls::rbd::MIRROR_IMAGE_TYPE_GROUP && !all) { continue; } mirror_images[image_id] = mirror_image.global_image_id; @@ -7662,96 +7657,6 @@ int mirror_group_list(cls_method_context_t hctx, bufferlist *in, return 0; } -/** - * Input: - * @param global_group_id (std::string) - * @param global_name (std::string) - * - * Output: - * @param group_id (std::string) - * @returns 0 on success, negative error code on failure - */ -int mirror_group_resync_get(cls_method_context_t hctx, bufferlist *in, - bufferlist *out) { - std::string global_group_id; - std::string group_name; - try { - auto it = in->cbegin(); - decode(global_group_id, it); - decode(group_name, it); - } catch (const ceph::buffer::error &err) { - return -EINVAL; - } - - std::string search = mirror::group_resync_key(global_group_id, group_name); - std::string last_read = group_name; - int max_read = 5; - bool more = true; - do { - std::set keys; - int r = cls_cxx_map_get_keys(hctx, last_read, max_read, &keys, &more); - if (r < 0) { - CLS_ERR("error reading group resync keys, global_id '%s': '%s'", - global_group_id.c_str(), cpp_strerror(r).c_str()); - return r; - } - - for (auto& key : keys) { - if (key == search) { - r = cls_cxx_map_get_val(hctx, key, out); - if (r < 0) { - CLS_ERR("error reading group_id for group resync, global_id '%s': '%s'", - global_group_id.c_str(), cpp_strerror(r).c_str()); - return r; - } - return 0; - } - } - - if (!keys.empty()) { - last_read = *keys.rbegin(); - } - } while (more); - - // shouldn't reach here - return -EINVAL; -} - -/** - * Input: - * @param global_group_id (std::string) - * @param global_name (std::string) - * @param group_id (std::string) - * - * Output: - * @returns 0 on success, negative error code on failure - */ -int mirror_group_resync_set(cls_method_context_t hctx, bufferlist *in, - bufferlist *out) { - std::string global_group_id; - std::string group_name; - std::string group_id; - try { - auto it = in->cbegin(); - decode(global_group_id, it); - decode(group_name, it); - decode(group_id, it); - } catch (const ceph::buffer::error &err) { - return -EINVAL; - } - std::string key = mirror::group_resync_key(global_group_id, group_name); - bufferlist val_bl; - encode(group_id, val_bl); - int r = cls_cxx_map_set_val(hctx, key, &val_bl); - if (r < 0) { - CLS_ERR("error setting key %s on mirror group resync object: %s", - key.c_str(), cpp_strerror(r).c_str()); - return r; - } - - return 0; -} - /** * Input: * @param global_id (std::string) @@ -8769,7 +8674,7 @@ int group_snap_set(cls_method_context_t hctx, r = cls_cxx_map_get_val(hctx, key, &snap_bl); if (r < 0 && r != -ENOENT) { return r; - } else if (r >= 0 && r != -EEXIST) { + } else if (r >= 0 && r != -EEXIST) { CLS_ERR("snap key already exists : %s", key.c_str()); return r; } @@ -9669,8 +9574,6 @@ CLS_INIT(rbd) cls_method_handle_t h_mirror_image_snapshot_unlink_peer; cls_method_handle_t h_mirror_image_snapshot_set_copy_progress; cls_method_handle_t h_mirror_group_list; - cls_method_handle_t h_mirror_group_resync_get; - cls_method_handle_t h_mirror_group_resync_set; cls_method_handle_t h_mirror_group_get_group_id; cls_method_handle_t h_mirror_group_get; cls_method_handle_t h_mirror_group_set; @@ -9954,11 +9857,11 @@ CLS_INIT(rbd) CLS_METHOD_RD | CLS_METHOD_WR, mirror_mode_set, &h_mirror_mode_set); cls_register_cxx_method(h_class, "mirror_remote_namespace_get", - CLS_METHOD_RD, mirror::mirror_remote_namespace_get, + CLS_METHOD_RD, mirror_remote_namespace_get, &h_mirror_remote_namespace_get); cls_register_cxx_method(h_class, "mirror_remote_namespace_set", CLS_METHOD_RD | CLS_METHOD_WR, - mirror::mirror_remote_namespace_set, + mirror_remote_namespace_set, &h_mirror_remote_namespace_set); cls_register_cxx_method(h_class, "mirror_peer_ping", CLS_METHOD_RD | CLS_METHOD_WR, @@ -10047,12 +9950,6 @@ CLS_INIT(rbd) &h_mirror_image_snapshot_set_copy_progress); cls_register_cxx_method(h_class, "mirror_group_list", CLS_METHOD_RD, mirror_group_list, &h_mirror_group_list); - cls_register_cxx_method(h_class, "mirror_group_resync_get", CLS_METHOD_RD, - mirror_group_resync_get, - &h_mirror_group_resync_get); - cls_register_cxx_method(h_class, "mirror_group_resync_set", - CLS_METHOD_RD | CLS_METHOD_WR, - mirror_group_resync_set, &h_mirror_group_resync_set); cls_register_cxx_method(h_class, "mirror_group_get_group_id", CLS_METHOD_RD, mirror_group_get_group_id, &h_mirror_group_get_group_id); diff --git a/src/cls/rbd/cls_rbd_client.cc b/src/cls/rbd/cls_rbd_client.cc index 7d142574a1fa7..e565c94e02d0a 100644 --- a/src/cls/rbd/cls_rbd_client.cc +++ b/src/cls/rbd/cls_rbd_client.cc @@ -2642,72 +2642,6 @@ int mirror_group_list(librados::IoCtx *ioctx, return mirror_group_list_finish(&bl_it, groups); } -void mirror_group_resync_get_start(librados::ObjectReadOperation *op, - const std::string &global_group_id, - const std::string &group_name) -{ - bufferlist in_bl; - encode(global_group_id, in_bl); - encode(group_name, in_bl); - op->exec("rbd", "mirror_group_resync_get", in_bl); -} - -int mirror_group_resync_get_finish(bufferlist::const_iterator *it, - std::string *group_id) { - try { - decode(*group_id, *it); - } catch (const ceph::buffer::error &err) { - return -EBADMSG; - } - return 0; -} - -int mirror_group_resync_get(librados::IoCtx *ioctx, - const std::string &oid, - const std::string &global_group_id, - const std::string &group_name, - std::string *group_id) -{ - librados::ObjectReadOperation op; - mirror_group_resync_get_start(&op, global_group_id, group_name); - - bufferlist out_bl; - int r = ioctx->operate(oid, &op, &out_bl); - if (r < 0) { - return r; - } - - auto bl_it = out_bl.cbegin(); - return mirror_group_resync_get_finish(&bl_it, group_id); -} - -void mirror_group_resync_set(librados::ObjectWriteOperation *op, - const std::string &global_group_id, - const std::string &group_name, - const std::string &group_id) { - bufferlist bl; - encode(global_group_id, bl); - encode(group_name, bl); - encode(group_id, bl); - - op->exec("rbd", "mirror_group_resync_set", bl); -} - -int mirror_group_resync_set(librados::IoCtx *ioctx, - const std::string &oid, - const std::string &global_group_id, - const std::string &group_name, - const std::string &group_id) { - librados::ObjectWriteOperation op; - mirror_group_resync_set(&op, global_group_id, group_name, group_id); - - int r = ioctx->operate(oid, &op); - if (r < 0) { - return r; - } - return 0; -} - void mirror_group_get_group_id_start(librados::ObjectReadOperation *op, const std::string &global_group_id) { bufferlist in_bl; diff --git a/src/cls/rbd/cls_rbd_client.h b/src/cls/rbd/cls_rbd_client.h index ef89a28e006af..edb3dd38fb7f1 100644 --- a/src/cls/rbd/cls_rbd_client.h +++ b/src/cls/rbd/cls_rbd_client.h @@ -562,25 +562,6 @@ int mirror_group_list_finish(ceph::buffer::list::const_iterator *it, int mirror_group_list(librados::IoCtx *ioctx, const std::string &start, uint64_t max_return, std::map *groups); -void mirror_group_resync_get_start(librados::ObjectReadOperation *op, - const std::string &global_group_id, - const std::string &group_name); -int mirror_group_resync_get_finish(bufferlist::const_iterator *it, - std::string *group_id); -int mirror_group_resync_get(librados::IoCtx *ioctx, - const std::string &oid, - const std::string &global_group_id, - const std::string &group_name, - std::string *group_id); -void mirror_group_resync_set(librados::ObjectWriteOperation *op, - const std::string &global_group_id, - const std::string &group_name, - const std::string &group_id); -int mirror_group_resync_set(librados::IoCtx *ioctx, - const std::string &oid, - const std::string &global_group_id, - const std::string &group_name, - const std::string &group_id); void mirror_group_get_group_id_start(librados::ObjectReadOperation *op, const std::string &global_group_id); int mirror_group_get_group_id_finish(ceph::buffer::list::const_iterator *it, @@ -714,6 +695,10 @@ void group_snap_unlink(librados::ObjectWriteOperation *op, int group_snap_unlink(librados::IoCtx *ioctx, const std::string &oid, const std::string &group_snap_id, const cls::rbd::ImageSnapshotSpec &image_snap); +void group_snap_get_by_id_start(librados::ObjectReadOperation *op, + const std::string &snap_id); +int group_snap_get_by_id_finish(ceph::buffer::list::const_iterator *iter, + cls::rbd::GroupSnapshot *snapshot); int group_snap_get_by_id(librados::IoCtx *ioctx, const std::string &oid, const std::string &snap_id, cls::rbd::GroupSnapshot *snapshot); @@ -722,10 +707,6 @@ void group_snap_list_start(librados::ObjectReadOperation *op, uint64_t max_return); int group_snap_list_finish(ceph::buffer::list::const_iterator *iter, std::vector *snapshots); -void group_snap_get_by_id_start(librados::ObjectReadOperation *op, - const std::string &snap_id); -int group_snap_get_by_id_finish(ceph::buffer::list::const_iterator *iter, - cls::rbd::GroupSnapshot *snapshot); int group_snap_list(librados::IoCtx *ioctx, const std::string &oid, const cls::rbd::GroupSnapshot &start, uint64_t max_return, diff --git a/src/cls/rbd/cls_rbd_types.cc b/src/cls/rbd/cls_rbd_types.cc index 7adb257bbbfec..efcda7a27274c 100644 --- a/src/cls/rbd/cls_rbd_types.cc +++ b/src/cls/rbd/cls_rbd_types.cc @@ -137,7 +137,7 @@ void MirrorImage::encode(bufferlist &bl) const { encode(global_image_id, bl); encode(static_cast(state), bl); encode(static_cast(mode), bl); - encode(group_spec, bl); + encode(static_cast(type), bl); ENCODE_FINISH(bl); } @@ -153,7 +153,9 @@ void MirrorImage::decode(bufferlist::const_iterator &it) { mode = static_cast(int_mode); } if (struct_v >= 3) { - decode(group_spec, it); + uint8_t int_type; + decode(int_type, it); + type = static_cast(int_type); } DECODE_FINISH(it); } @@ -161,25 +163,23 @@ void MirrorImage::decode(bufferlist::const_iterator &it) { void MirrorImage::dump(Formatter *f) const { f->dump_stream("mode") << mode; f->dump_string("global_image_id", global_image_id); - if (group_spec.is_valid()) { - f->open_object_section("group"); - group_spec.dump(f); - f->close_section(); - } f->dump_stream("state") << state; + f->dump_stream("type") << type; } void MirrorImage::generate_test_instances(std::list &o) { o.push_back(new MirrorImage()); - o.push_back(new MirrorImage(MIRROR_IMAGE_MODE_JOURNAL, "uuid-123", {}, + o.push_back(new MirrorImage(MIRROR_IMAGE_MODE_JOURNAL, "uuid-123", + MIRROR_IMAGE_TYPE_STANDALONE, MIRROR_IMAGE_STATE_ENABLED)); - o.push_back(new MirrorImage(MIRROR_IMAGE_MODE_SNAPSHOT, "uuid-abc", {"g1", 1}, + o.push_back(new MirrorImage(MIRROR_IMAGE_MODE_SNAPSHOT, "uuid-abc", + MIRROR_IMAGE_TYPE_GROUP, MIRROR_IMAGE_STATE_DISABLING)); } bool MirrorImage::operator==(const MirrorImage &rhs) const { return mode == rhs.mode && global_image_id == rhs.global_image_id && - group_spec == rhs.group_spec && state == rhs.state; + type == rhs.type && state == rhs.state; } bool MirrorImage::operator<(const MirrorImage &rhs) const { @@ -189,8 +189,8 @@ bool MirrorImage::operator<(const MirrorImage &rhs) const { if (global_image_id != rhs.global_image_id) { return global_image_id < rhs.global_image_id; } - if (group_spec != rhs.group_spec) { - return group_spec < rhs.group_spec; + if (type != rhs.type) { + return type < rhs.type; } return state < rhs.state; } @@ -231,12 +231,27 @@ std::ostream& operator<<(std::ostream& os, const MirrorImageState& mirror_state) return os; } +std::ostream& operator<<(std::ostream& os, const MirrorImageType& mirror_type) { + switch (mirror_type) { + case MIRROR_IMAGE_TYPE_STANDALONE: + os << "image"; + break; + case MIRROR_IMAGE_TYPE_GROUP: + os << "group"; + break; + default: + os << "unknown (" << static_cast(mirror_type) << ")"; + break; + } + return os; +} + std::ostream& operator<<(std::ostream& os, const MirrorImage& mirror_image) { os << "[" << "mode=" << mirror_image.mode << ", " << "global_image_id=" << mirror_image.global_image_id << ", " - << "group_spec=" << mirror_image.group_spec << ", " - << "state=" << mirror_image.state << "]"; + << "state=" << mirror_image.state << ", " + << "type=" << mirror_image.type << "]"; return os; } @@ -1086,14 +1101,14 @@ std::ostream& operator<<(std::ostream& os, const GroupSpec& gs) { return os; } -void GroupImageSnapshotNamespace::encode(bufferlist& bl) const { +void ImageSnapshotNamespaceGroup::encode(bufferlist& bl) const { using ceph::encode; encode(group_pool, bl); encode(group_id, bl); encode(group_snapshot_id, bl); } -void GroupImageSnapshotNamespace::decode(uint8_t version, +void ImageSnapshotNamespaceGroup::decode(uint8_t version, bufferlist::const_iterator& it) { using ceph::decode; decode(group_pool, it); @@ -1101,7 +1116,7 @@ void GroupImageSnapshotNamespace::decode(uint8_t version, decode(group_snapshot_id, it); } -void GroupImageSnapshotNamespace::dump(Formatter *f) const { +void ImageSnapshotNamespaceGroup::dump(Formatter *f) const { f->dump_int("group_pool", group_pool); f->dump_string("group_id", group_id); f->dump_string("group_snapshot_id", group_snapshot_id); @@ -1280,7 +1295,7 @@ void SnapshotInfo::generate_test_instances(std::list &o) { o.push_back(new SnapshotInfo(1ULL, UserSnapshotNamespace{}, "snap1", 123, {123456, 0}, 12)); o.push_back(new SnapshotInfo(2ULL, - GroupImageSnapshotNamespace{567, "group1", "snap1"}, + ImageSnapshotNamespaceGroup{567, "group1", "snap1"}, "snap1", 123, {123456, 0}, 987)); o.push_back(new SnapshotInfo(3ULL, TrashSnapshotNamespace{ @@ -1312,7 +1327,7 @@ void SnapshotNamespace::decode(bufferlist::const_iterator &p) *this = UserSnapshotNamespace(); break; case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_GROUP: - *this = GroupImageSnapshotNamespace(); + *this = ImageSnapshotNamespaceGroup(); break; case cls::rbd::SNAPSHOT_NAMESPACE_TYPE_TRASH: *this = TrashSnapshotNamespace(); @@ -1334,9 +1349,9 @@ void SnapshotNamespace::dump(Formatter *f) const { void SnapshotNamespace::generate_test_instances(std::list &o) { o.push_back(new SnapshotNamespace(UserSnapshotNamespace())); - o.push_back(new SnapshotNamespace(GroupImageSnapshotNamespace(0, "10152ae8944a", + o.push_back(new SnapshotNamespace(ImageSnapshotNamespaceGroup(0, "10152ae8944a", "2118643c9732"))); - o.push_back(new SnapshotNamespace(GroupImageSnapshotNamespace(5, "1018643c9869", + o.push_back(new SnapshotNamespace(ImageSnapshotNamespaceGroup(5, "1018643c9869", "33352be8933c"))); o.push_back(new SnapshotNamespace(TrashSnapshotNamespace())); o.push_back(new SnapshotNamespace(MirrorSnapshotNamespace(MIRROR_SNAPSHOT_STATE_PRIMARY, @@ -1386,7 +1401,7 @@ std::ostream& operator<<(std::ostream& os, const UserSnapshotNamespace& ns) { } std::ostream& operator<<(std::ostream& os, - const GroupImageSnapshotNamespace& ns) { + const ImageSnapshotNamespaceGroup& ns) { os << "[" << SNAPSHOT_NAMESPACE_TYPE_GROUP << " " << "group_pool=" << ns.group_pool << ", " << "group_id=" << ns.group_id << ", " @@ -1450,7 +1465,7 @@ std::ostream& operator<<(std::ostream& os, MirrorSnapshotState state) { return os; } -void MirrorGroupSnapshotNamespace::encode(bufferlist& bl) const { +void GroupSnapshotNamespaceMirror::encode(bufferlist& bl) const { using ceph::encode; encode(state, bl); encode(mirror_peer_uuids, bl); @@ -1458,7 +1473,7 @@ void MirrorGroupSnapshotNamespace::encode(bufferlist& bl) const { encode(primary_snap_id, bl); } -void MirrorGroupSnapshotNamespace::decode(uint8_t version, +void GroupSnapshotNamespaceMirror::decode(uint8_t version, bufferlist::const_iterator& it) { using ceph::decode; decode(state, it); @@ -1467,7 +1482,7 @@ void MirrorGroupSnapshotNamespace::decode(uint8_t version, decode(primary_snap_id, it); } -void MirrorGroupSnapshotNamespace::dump(Formatter *f) const { +void GroupSnapshotNamespaceMirror::dump(Formatter *f) const { f->dump_stream("state") << state; f->open_array_section("mirror_peer_uuids"); for (auto &peer : mirror_peer_uuids) { @@ -1559,13 +1574,13 @@ void GroupSnapshotNamespace::decode(bufferlist::const_iterator &p) decode(snap_type, p); switch (snap_type) { case cls::rbd::GROUP_SNAPSHOT_NAMESPACE_TYPE_USER: - *this = UserGroupSnapshotNamespace(); + *this = GroupSnapshotNamespaceUser(); break; case cls::rbd::GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR: - *this = MirrorGroupSnapshotNamespace(); + *this = GroupSnapshotNamespaceMirror(); break; default: - *this = UnknownGroupSnapshotNamespace(); + *this = GroupSnapshotNamespaceUnknown(); break; } visit(DecodeGroupSnapshotNamespaceVisitor(struct_v, p)); @@ -1578,8 +1593,8 @@ void GroupSnapshotNamespace::dump(Formatter *f) const { void GroupSnapshotNamespace::generate_test_instances( std::list &o) { - o.push_back(new GroupSnapshotNamespace(UserGroupSnapshotNamespace())); - o.push_back(new GroupSnapshotNamespace(MirrorGroupSnapshotNamespace( + o.push_back(new GroupSnapshotNamespace(GroupSnapshotNamespaceUser())); + o.push_back(new GroupSnapshotNamespace(GroupSnapshotNamespaceMirror( MIRROR_SNAPSHOT_STATE_PRIMARY, {"peer uuid"}, "", ""))); } @@ -1599,13 +1614,13 @@ std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceType& typ return os; } -std::ostream& operator<<(std::ostream& os, const UserGroupSnapshotNamespace& ns) { +std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceUser& ns) { os << "[" << GROUP_SNAPSHOT_NAMESPACE_TYPE_USER << "]"; return os; } std::ostream& operator<<(std::ostream& os, - const MirrorGroupSnapshotNamespace& ns) { + const GroupSnapshotNamespaceMirror& ns) { os << "[" << GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR << " " << "state=" << ns.state << ", " << "mirror_peer_uuids=" << ns.mirror_peer_uuids; @@ -1618,7 +1633,7 @@ std::ostream& operator<<(std::ostream& os, return os; } -std::ostream& operator<<(std::ostream& os, const UnknownGroupSnapshotNamespace& ns) { +std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceUnknown& ns) { os << "[unknown]"; return os; } @@ -1706,11 +1721,11 @@ void GroupSnapshot::dump(Formatter *f) const { } void GroupSnapshot::generate_test_instances(std::list &o) { - o.push_back(new GroupSnapshot("10152ae8944a", UserGroupSnapshotNamespace{}, + o.push_back(new GroupSnapshot("10152ae8944a", GroupSnapshotNamespaceUser{}, "groupsnapshot1", GROUP_SNAPSHOT_STATE_INCOMPLETE)); o.push_back(new GroupSnapshot("1018643c9869", - MirrorGroupSnapshotNamespace{ + GroupSnapshotNamespaceMirror{ MIRROR_SNAPSHOT_STATE_NON_PRIMARY, {}, "uuid", "id"}, "groupsnapshot2", diff --git a/src/cls/rbd/cls_rbd_types.h b/src/cls/rbd/cls_rbd_types.h index cfdf1b55517f3..49ee56038daec 100644 --- a/src/cls/rbd/cls_rbd_types.h +++ b/src/cls/rbd/cls_rbd_types.h @@ -182,18 +182,24 @@ enum MirrorImageState { MIRROR_IMAGE_STATE_CREATING = 3, }; +// Indicates whether the image was mirrored enabled as part of a group +enum MirrorImageType { + MIRROR_IMAGE_TYPE_STANDALONE = 0, + MIRROR_IMAGE_TYPE_GROUP = 1, +}; + struct MirrorImage { MirrorImage() { } MirrorImage(MirrorImageMode mode, const std::string &global_image_id, - const GroupSpec &group_spec, MirrorImageState state) - : mode(mode), global_image_id(global_image_id), group_spec(group_spec), + MirrorImageType type, MirrorImageState state) + : mode(mode), global_image_id(global_image_id), type(type), state(state) { } MirrorImageMode mode = MIRROR_IMAGE_MODE_JOURNAL; std::string global_image_id; - GroupSpec group_spec; + MirrorImageType type = MIRROR_IMAGE_TYPE_STANDALONE; MirrorImageState state = MIRROR_IMAGE_STATE_DISABLING; void encode(ceph::buffer::list &bl) const; @@ -208,6 +214,7 @@ struct MirrorImage { 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 MirrorImageType& mirror_type); std::ostream& operator<<(std::ostream& os, const MirrorImage& mirror_image); WRITE_CLASS_ENCODER(MirrorImage); @@ -653,13 +660,13 @@ struct UserSnapshotNamespace { } }; -struct GroupImageSnapshotNamespace { +struct ImageSnapshotNamespaceGroup { static const SnapshotNamespaceType SNAPSHOT_NAMESPACE_TYPE = SNAPSHOT_NAMESPACE_TYPE_GROUP; - GroupImageSnapshotNamespace() {} + ImageSnapshotNamespaceGroup() {} - GroupImageSnapshotNamespace(int64_t _group_pool, + ImageSnapshotNamespaceGroup(int64_t _group_pool, const std::string &_group_id, const std::string &_group_snapshot_id) : group_id(_group_id), group_pool(_group_pool), @@ -674,17 +681,17 @@ struct GroupImageSnapshotNamespace { void dump(ceph::Formatter *f) const; - inline bool operator==(const GroupImageSnapshotNamespace& gsn) const { + inline bool operator==(const ImageSnapshotNamespaceGroup& gsn) const { return group_pool == gsn.group_pool && group_id == gsn.group_id && group_snapshot_id == gsn.group_snapshot_id; } - inline bool operator!=(const GroupImageSnapshotNamespace& gsn) const { + inline bool operator!=(const ImageSnapshotNamespaceGroup& gsn) const { return !operator==(gsn); } - inline bool operator<(const GroupImageSnapshotNamespace& gsn) const { + inline bool operator<(const ImageSnapshotNamespaceGroup& gsn) const { if (group_pool != gsn.group_pool) { return group_pool < gsn.group_pool; } @@ -880,13 +887,13 @@ struct UnknownSnapshotNamespace { std::ostream& operator<<(std::ostream& os, const SnapshotNamespaceType& type); std::ostream& operator<<(std::ostream& os, const UserSnapshotNamespace& ns); -std::ostream& operator<<(std::ostream& os, const GroupImageSnapshotNamespace& ns); +std::ostream& operator<<(std::ostream& os, const ImageSnapshotNamespaceGroup& ns); std::ostream& operator<<(std::ostream& os, const TrashSnapshotNamespace& ns); std::ostream& operator<<(std::ostream& os, const MirrorSnapshotNamespace& ns); std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns); typedef std::variant SnapshotNamespaceVariant; @@ -947,11 +954,11 @@ enum GroupSnapshotNamespaceType { GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR = 1, }; -struct UserGroupSnapshotNamespace { +struct GroupSnapshotNamespaceUser { static const GroupSnapshotNamespaceType GROUP_SNAPSHOT_NAMESPACE_TYPE = GROUP_SNAPSHOT_NAMESPACE_TYPE_USER; - UserGroupSnapshotNamespace() {} + GroupSnapshotNamespaceUser() {} void encode(ceph::buffer::list& bl) const { } @@ -960,16 +967,16 @@ struct UserGroupSnapshotNamespace { void dump(ceph::Formatter *f) const { } - inline bool operator==(const UserGroupSnapshotNamespace& usn) const { + inline bool operator==(const GroupSnapshotNamespaceUser& usn) const { return true; } - inline bool operator<(const UserGroupSnapshotNamespace& usn) const { + inline bool operator<(const GroupSnapshotNamespaceUser& usn) const { return false; } }; -struct MirrorGroupSnapshotNamespace { +struct GroupSnapshotNamespaceMirror { static const GroupSnapshotNamespaceType GROUP_SNAPSHOT_NAMESPACE_TYPE = GROUP_SNAPSHOT_NAMESPACE_TYPE_MIRROR; @@ -979,9 +986,9 @@ struct MirrorGroupSnapshotNamespace { std::string primary_mirror_uuid; std::string primary_snap_id; - MirrorGroupSnapshotNamespace() { + GroupSnapshotNamespaceMirror() { } - MirrorGroupSnapshotNamespace(MirrorSnapshotState state, + GroupSnapshotNamespaceMirror(MirrorSnapshotState state, const std::set &mirror_peer_uuids, const std::string &primary_mirror_uuid, const std::string &primary_snap_id) @@ -1016,14 +1023,14 @@ struct MirrorGroupSnapshotNamespace { void dump(ceph::Formatter *f) const; - inline bool operator==(const MirrorGroupSnapshotNamespace& rhs) const { + inline bool operator==(const GroupSnapshotNamespaceMirror& 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 { + inline bool operator<(const GroupSnapshotNamespaceMirror& rhs) const { if (state != rhs.state) { return state < rhs.state; } else if (mirror_peer_uuids != rhs.mirror_peer_uuids) { @@ -1036,11 +1043,11 @@ struct MirrorGroupSnapshotNamespace { } }; -struct UnknownGroupSnapshotNamespace { +struct GroupSnapshotNamespaceUnknown { static const GroupSnapshotNamespaceType GROUP_SNAPSHOT_NAMESPACE_TYPE = static_cast(-1); - UnknownGroupSnapshotNamespace() {} + GroupSnapshotNamespaceUnknown() {} void encode(ceph::buffer::list& bl) const { } @@ -1049,23 +1056,23 @@ struct UnknownGroupSnapshotNamespace { void dump(ceph::Formatter *f) const { } - inline bool operator==(const UnknownGroupSnapshotNamespace& gsn) const { + inline bool operator==(const GroupSnapshotNamespaceUnknown& gsn) const { return true; } - inline bool operator<(const UnknownGroupSnapshotNamespace& gsn) const { + inline bool operator<(const GroupSnapshotNamespaceUnknown& 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); +std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceUser& ns); +std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceMirror& ns); +std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespaceUnknown& ns); -typedef std::variant GroupSnapshotNamespaceVariant; +typedef std::variant GroupSnapshotNamespaceVariant; struct GroupSnapshotNamespace : public GroupSnapshotNamespaceVariant { using GroupSnapshotNamespaceVariant::GroupSnapshotNamespaceVariant; @@ -1146,7 +1153,7 @@ WRITE_CLASS_ENCODER(ImageSnapshotSpec); struct GroupSnapshot { std::string id; - GroupSnapshotNamespace snapshot_namespace = {UserGroupSnapshotNamespace{}}; + GroupSnapshotNamespace snapshot_namespace = {GroupSnapshotNamespaceUser{}}; std::string name; GroupSnapshotState state = GROUP_SNAPSHOT_STATE_INCOMPLETE; diff --git a/src/librbd/api/Group.cc b/src/librbd/api/Group.cc index 2c19fd43538e8..bad53f5f73382 100644 --- a/src/librbd/api/Group.cc +++ b/src/librbd/api/Group.cc @@ -46,12 +46,12 @@ template snap_t get_group_snap_id(I* ictx, const cls::rbd::SnapshotNamespace& in_snap_namespace) { ceph_assert(ceph_mutex_is_locked(ictx->image_lock)); - auto it = ictx->snap_ids.lower_bound({cls::rbd::GroupImageSnapshotNamespace{}, + auto it = ictx->snap_ids.lower_bound({cls::rbd::ImageSnapshotNamespaceGroup{}, ""}); for (; it != ictx->snap_ids.end(); ++it) { if (it->first.first == in_snap_namespace) { return it->second; - } else if (!std::holds_alternative( + } else if (!std::holds_alternative( it->first.first)) { break; } @@ -110,7 +110,7 @@ int group_snap_rollback_by_record(librados::IoCtx& group_ioctx, std::vector on_finishes; int r, ret_code; - cls::rbd::GroupImageSnapshotNamespace ne{group_ioctx.get_id(), group_id, + cls::rbd::ImageSnapshotNamespaceGroup ne{group_ioctx.get_id(), group_id, group_snap.id}; ldout(cct, 20) << "Rolling back snapshots" << dendl; @@ -761,7 +761,7 @@ int Group::snap_create(librados::IoCtx& group_ioctx, group_snap.state = cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE; group_snap.snaps = image_snaps; - cls::rbd::GroupImageSnapshotNamespace ne{group_ioctx.get_id(), group_id, + cls::rbd::ImageSnapshotNamespaceGroup ne{group_ioctx.get_id(), group_id, group_snap.id}; r = cls_client::group_snap_set(&group_ioctx, group_header_oid, group_snap); diff --git a/src/librbd/api/Snapshot.cc b/src/librbd/api/Snapshot.cc index 657dd0e970fbb..efe862b7b43a7 100644 --- a/src/librbd/api/Snapshot.cc +++ b/src/librbd/api/Snapshot.cc @@ -38,12 +38,12 @@ public: template inline int operator()(const T&) const { - // ignore other than GroupImageSnapshotNamespace types. + // ignore other than ImageSnapshotNamespaceGroup types. return -EINVAL; } inline int operator()( - const cls::rbd::GroupImageSnapshotNamespace& snap_namespace) { + const cls::rbd::ImageSnapshotNamespaceGroup& snap_namespace) { IoCtx group_ioctx; int r = util::create_ioctx(*image_ioctx, "group", snap_namespace.group_pool, {}, &group_ioctx); diff --git a/src/test/cls_rbd/test_cls_rbd.cc b/src/test/cls_rbd/test_cls_rbd.cc index 331de059d3b6c..e1df16b512d7d 100644 --- a/src/test/cls_rbd/test_cls_rbd.cc +++ b/src/test/cls_rbd/test_cls_rbd.cc @@ -1746,11 +1746,17 @@ TEST_F(TestClsRbd, mirror_image) { ASSERT_EQ(-ENOENT, mirror_image_list(&ioctx, "", 0, false, &mirror_image_ids)); - cls::rbd::MirrorImage image1(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid1", {}, + cls::rbd::MirrorImage image1(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid1", + cls::rbd::MIRROR_IMAGE_TYPE_STANDALONE, cls::rbd::MIRROR_IMAGE_STATE_ENABLED); - cls::rbd::MirrorImage image2(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid2", {}, + cls::rbd::MirrorImage image2(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid2", + cls::rbd::MIRROR_IMAGE_TYPE_STANDALONE, cls::rbd::MIRROR_IMAGE_STATE_DISABLING); - cls::rbd::MirrorImage image3(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid3", {}, + cls::rbd::MirrorImage image3(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid3", + cls::rbd::MIRROR_IMAGE_TYPE_STANDALONE, + cls::rbd::MIRROR_IMAGE_STATE_ENABLED); + cls::rbd::MirrorImage image4(cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "uuid4", + cls::rbd::MIRROR_IMAGE_TYPE_GROUP, cls::rbd::MIRROR_IMAGE_STATE_ENABLED); ASSERT_EQ(0, mirror_image_set(&ioctx, "image_id1", image1)); @@ -1762,6 +1768,7 @@ TEST_F(TestClsRbd, mirror_image) { ASSERT_EQ(-EINVAL, mirror_image_set(&ioctx, "image_id1", image2)); ASSERT_EQ(-EEXIST, mirror_image_set(&ioctx, "image_id3", image2)); ASSERT_EQ(0, mirror_image_set(&ioctx, "image_id3", image3)); + ASSERT_EQ(0, mirror_image_set(&ioctx, "image_id4", image4)); std::string image_id; ASSERT_EQ(0, mirror_image_get_image_id(&ioctx, "uuid2", &image_id)); @@ -1774,17 +1781,24 @@ TEST_F(TestClsRbd, mirror_image) { ASSERT_EQ(read_image, image2); ASSERT_EQ(0, mirror_image_get(&ioctx, "image_id3", &read_image)); ASSERT_EQ(read_image, image3); + ASSERT_EQ(0, mirror_image_get(&ioctx, "image_id4", &read_image)); + ASSERT_EQ(read_image, image4); ASSERT_EQ(0, mirror_image_list(&ioctx, "", 1, false, &mirror_image_ids)); std::map expected_mirror_image_ids = { {"image_id1", "uuid1"}}; ASSERT_EQ(expected_mirror_image_ids, mirror_image_ids); - ASSERT_EQ(0, mirror_image_list(&ioctx, "image_id1", 2, false, + ASSERT_EQ(0, mirror_image_list(&ioctx, "image_id1", 3, false, &mirror_image_ids)); expected_mirror_image_ids = {{"image_id2", "uuid2"}, {"image_id3", "uuid3"}}; ASSERT_EQ(expected_mirror_image_ids, mirror_image_ids); + ASSERT_EQ(0, mirror_image_list(&ioctx, "image_id1", 3, true, + &mirror_image_ids)); + expected_mirror_image_ids = {{"image_id2", "uuid2"}, {"image_id3", "uuid3"}, {"image_id4", "uuid4"}}; + ASSERT_EQ(expected_mirror_image_ids, mirror_image_ids); + ASSERT_EQ(0, mirror_image_remove(&ioctx, "image_id2")); ASSERT_EQ(-ENOENT, mirror_image_get_image_id(&ioctx, "uuid2", &image_id)); ASSERT_EQ(-EBUSY, mirror_image_remove(&ioctx, "image_id1")); @@ -1793,6 +1807,10 @@ TEST_F(TestClsRbd, mirror_image) { expected_mirror_image_ids = {{"image_id1", "uuid1"}, {"image_id3", "uuid3"}}; ASSERT_EQ(expected_mirror_image_ids, mirror_image_ids); + ASSERT_EQ(0, mirror_image_list(&ioctx, "", 3, true, &mirror_image_ids)); + expected_mirror_image_ids = {{"image_id1", "uuid1"}, {"image_id3", "uuid3"}, {"image_id4", "uuid4"}}; + ASSERT_EQ(expected_mirror_image_ids, mirror_image_ids); + image1.state = cls::rbd::MIRROR_IMAGE_STATE_DISABLING; image3.state = cls::rbd::MIRROR_IMAGE_STATE_DISABLING; ASSERT_EQ(0, mirror_image_set(&ioctx, "image_id1", image1)); @@ -3039,7 +3057,7 @@ TEST_F(TestClsRbd, group_snap_set_empty_name) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, "", + cls::rbd::GroupSnapshotNamespaceUser{}, "", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EINVAL, group_snap_set(&ioctx, group_id, snap)); } @@ -3052,7 +3070,7 @@ 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 = {"", cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshot snap = {"", cls::rbd::GroupSnapshotNamespaceUser{}, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EINVAL, group_snap_set(&ioctx, group_id, snap)); @@ -3067,13 +3085,13 @@ TEST_F(TestClsRbd, group_snap_set_duplicate_id) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); cls::rbd::GroupSnapshot snap1 = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "snap_name1", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EEXIST, group_snap_set(&ioctx, group_id, snap1)); @@ -3088,14 +3106,14 @@ TEST_F(TestClsRbd, group_snap_set_duplicate_name) { string snap_id1 = "snap_id1"; cls::rbd::GroupSnapshot snap = {snap_id1, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "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, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EEXIST, group_snap_set(&ioctx, group_id, snap1)); @@ -3110,7 +3128,7 @@ TEST_F(TestClsRbd, group_snap_set) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -3134,21 +3152,21 @@ TEST_F(TestClsRbd, group_snap_list) { string snap_id1 = "snap_id1"; cls::rbd::GroupSnapshot snap1 = {snap_id1, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "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, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "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, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot2", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap2)); @@ -3180,7 +3198,7 @@ TEST_F(TestClsRbd, group_snap_list) { string snap_id4 = "snap_id4"; cls::rbd::GroupSnapshot snap4 = {snap_id4, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot4", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap4)); @@ -3210,7 +3228,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{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot" + hexify(i), cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -3245,7 +3263,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{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot" + hexify(i), cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -3270,7 +3288,7 @@ TEST_F(TestClsRbd, group_snap_remove) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -3303,7 +3321,7 @@ TEST_F(TestClsRbd, group_snap_remove_without_order) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -3339,7 +3357,7 @@ TEST_F(TestClsRbd, group_snap_unlink) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); @@ -3385,12 +3403,13 @@ TEST_F(TestClsRbd, group_snap_get_by_id) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, - cls::rbd::UserGroupSnapshotNamespace{}, + cls::rbd::GroupSnapshotNamespaceUser{}, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; - ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); cls::rbd::GroupSnapshot received_snap; + ASSERT_EQ(-ENOENT, group_snap_get_by_id(&ioctx, group_id, snap_id, &received_snap)); + ASSERT_EQ(0, group_snap_set(&ioctx, group_id, snap)); ASSERT_EQ(0, group_snap_get_by_id(&ioctx, group_id, snap_id, &received_snap)); ASSERT_EQ(snap.id, received_snap.id); -- 2.39.5