}
std::string remote_status_global_key(const std::string& global_id,
- const std::string& fsid) {
- return REMOTE_STATUS_GLOBAL_KEY_PREFIX + global_id + "_" + fsid;
+ const std::string& mirror_uuid) {
+ return REMOTE_STATUS_GLOBAL_KEY_PREFIX + global_id + "_" + mirror_uuid;
}
std::string status_global_key(const std::string& global_id,
- const std::string& fsid) {
- if (fsid == cls::rbd::MirrorImageSiteStatus::LOCAL_FSID) {
+ const std::string& mirror_uuid) {
+ if (mirror_uuid == cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID) {
return STATUS_GLOBAL_KEY_PREFIX + global_id;
} else {
- return remote_status_global_key(global_id, fsid);
+ return remote_status_global_key(global_id, mirror_uuid);
}
}
}
int peer_ping(cls_method_context_t hctx, const std::string& site_name,
- const std::string& fsid) {
+ const std::string& mirror_uuid) {
int r = check_mirroring_enabled(hctx);
if (r < 0) {
return r;
}
- if (site_name.empty() || fsid.empty()) {
+ if (site_name.empty() || mirror_uuid.empty()) {
return -EINVAL;
}
return (peer.site_name == site_name);
});
- auto fsid_it = peers.end();
+ auto mirror_uuid_it = peers.end();
if (site_it == peers.end() ||
- (!site_it->fsid.empty() && site_it->fsid != fsid)) {
- // search for existing peer w/ same fsid
- fsid_it = std::find_if(peers.begin(), peers.end(),
- [&fsid](auto& peer) {
- return (peer.fsid == fsid);
+ (!site_it->mirror_uuid.empty() && site_it->mirror_uuid != mirror_uuid)) {
+ // search for existing peer w/ same mirror_uuid
+ mirror_uuid_it = std::find_if(peers.begin(), peers.end(),
+ [&mirror_uuid](auto& peer) {
+ return (peer.mirror_uuid == mirror_uuid);
});
}
auto it = peers.end();
- if (site_it != peers.end() && fsid_it != peers.end()) {
- // implies two peers -- match by fsid but don't update site name
- it = fsid_it;
- } else if (fsid_it != peers.end()) {
+ if (site_it != peers.end() && mirror_uuid_it != peers.end()) {
+ // implies two peers -- match by mirror_uuid but don't update site name
+ it = mirror_uuid_it;
+ } else if (mirror_uuid_it != peers.end()) {
// implies site name has been updated in remote
- fsid_it->site_name = site_name;
- it = fsid_it;
+ mirror_uuid_it->site_name = site_name;
+ it = mirror_uuid_it;
} else if (site_it != peers.end()) {
- // implies empty fsid in peer
- site_it->fsid = fsid;
+ // implies empty mirror_uuid in peer
+ site_it->mirror_uuid = mirror_uuid;
it = site_it;
} else {
CLS_LOG(10, "auto-generating new TX-only peer: %s", site_name.c_str());
mirror_peer.mirror_peer_direction = cls::rbd::MIRROR_PEER_DIRECTION_TX;
mirror_peer.site_name = site_name;
- mirror_peer.fsid = fsid;
+ mirror_peer.mirror_uuid = mirror_uuid;
}
if (it != peers.end()) {
CLS_ERR("peer site name '%s' already exists",
peer.site_name.c_str());
return -EEXIST;
- } else if (!mirror_peer.fsid.empty() && peer.fsid == mirror_peer.fsid) {
- CLS_ERR("peer fsid '%s' already exists",
- peer.fsid.c_str());
+ } else if (!mirror_peer.mirror_uuid.empty() &&
+ peer.mirror_uuid == mirror_peer.mirror_uuid) {
+ CLS_ERR("peer mirror uuid '%s' already exists",
+ peer.mirror_uuid.c_str());
return -EEXIST;
}
}
int image_status_set(cls_method_context_t hctx, const string &global_image_id,
const cls::rbd::MirrorImageSiteStatus &status) {
cls::rbd::MirrorImageSiteStatusOnDisk ondisk_status(status);
- ondisk_status.fsid = ""; // fsid stored in key
+ ondisk_status.mirror_uuid = ""; // mirror_uuid stored in key
ondisk_status.up = false;
ondisk_status.last_update = ceph_clock_now();
encode(ondisk_status, bl, cls_get_features(hctx));
r = cls_cxx_map_set_val(hctx, status_global_key(global_image_id,
- status.fsid), &bl);
+ status.mirror_uuid), &bl);
if (r < 0) {
CLS_ERR("error setting status for mirrored image, global id '%s', "
- "site '%s': %s", global_image_id.c_str(), status.fsid.c_str(),
+ "site '%s': %s", global_image_id.c_str(),
+ status.mirror_uuid.c_str(),
cpp_strerror(r).c_str());
return r;
}
return 0;
}
-int get_remote_image_status_fsids(cls_method_context_t hctx,
- const std::string& global_image_id,
- std::set<std::string>* fsids) {
+int get_remote_image_status_mirror_uuids(cls_method_context_t hctx,
+ const std::string& global_image_id,
+ std::set<std::string>* mirror_uuids) {
std::string filter = remote_status_global_key(global_image_id, "");
std::string last_read = filter;
int max_read = 4; // we don't expect lots of peers
break;
}
- fsids->insert(key.substr(filter.length()));
+ mirror_uuids->insert(key.substr(filter.length()));
}
if (!keys.empty()) {
int image_status_remove(cls_method_context_t hctx,
const string &global_image_id) {
// remove all local/remote image statuses
- std::set<std::string> fsids;
- int r = get_remote_image_status_fsids(hctx, global_image_id, &fsids);
+ std::set<std::string> mirror_uuids;
+ int r = get_remote_image_status_mirror_uuids(hctx, global_image_id,
+ &mirror_uuids);
if (r < 0 && r != -ENOENT) {
return r;
}
- fsids.insert(cls::rbd::MirrorImageSiteStatus::LOCAL_FSID);
- for (auto& fsid : fsids) {
- CLS_LOG(20, "removing status object for fsid %s", fsid.c_str());
- auto key = status_global_key(global_image_id, fsid);
+ mirror_uuids.insert(cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID);
+ for (auto& mirror_uuid : mirror_uuids) {
+ CLS_LOG(20, "removing status object for mirror_uuid %s",
+ mirror_uuid.c_str());
+ auto key = status_global_key(global_image_id, mirror_uuid);
r = cls_cxx_map_remove_key(hctx, key);
if (r < 0 && r != -ENOENT) {
CLS_ERR("error removing stale status for key '%s': %s",
}
int image_status_get(cls_method_context_t hctx, const string &global_image_id,
- const std::string& fsid, const bufferlist& bl,
+ const std::string& mirror_uuid, const bufferlist& bl,
const std::set<entity_inst_t> &watchers,
cls::rbd::MirrorImageStatus* status) {
cls::rbd::MirrorImageSiteStatusOnDisk ondisk_status;
} catch (const buffer::error &err) {
CLS_ERR("could not decode status for mirrored image, global id '%s', "
"site '%s'",
- global_image_id.c_str(), fsid.c_str());
+ global_image_id.c_str(), mirror_uuid.c_str());
return -EIO;
}
auto site_status = static_cast<cls::rbd::MirrorImageSiteStatus>(
ondisk_status);
site_status.up = (watchers.find(ondisk_status.origin) != watchers.end());
- site_status.fsid = fsid;
+ site_status.mirror_uuid = mirror_uuid;
status->mirror_image_site_statuses.push_back(site_status);
return 0;
}
bufferlist bl;
int r = cls_cxx_map_get_val(
hctx, status_global_key(global_image_id,
- cls::rbd::MirrorImageSiteStatus::LOCAL_FSID), &bl);
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID),
+ &bl);
if (r == -ENOENT) {
return 0;
} else if (r < 0) {
CLS_ERR("error reading status for mirrored image, global id '%s', "
"site '%s': '%s'",
global_image_id.c_str(),
- cls::rbd::MirrorImageSiteStatus::LOCAL_FSID.c_str(),
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID.c_str(),
cpp_strerror(r).c_str());
return r;
}
return image_status_get(hctx, global_image_id,
- cls::rbd::MirrorImageSiteStatus::LOCAL_FSID,
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID,
bl, watchers, status);
}
}
for (auto& it : vals) {
- auto fsid = it.first.substr(filter.length());
- CLS_LOG(20, "fsid = '%s'", fsid.c_str());
- r = image_status_get(hctx, global_image_id, fsid, it.second, watchers,
- status);
+ auto mirror_uuid = it.first.substr(filter.length());
+ CLS_LOG(20, "mirror_uuid = '%s'", mirror_uuid.c_str());
+ r = image_status_get(hctx, global_image_id, mirror_uuid, it.second,
+ watchers, status);
if (r < 0) {
return r;
}
cls::rbd::MirrorImageStatusState compute_image_status_summary_state(
cls::rbd::MirrorPeerDirection mirror_peer_direction,
- const std::set<std::string>& tx_peer_fsids,
+ const std::set<std::string>& tx_peer_mirror_uuids,
const cls::rbd::MirrorImageStatus& status) {
std::optional<cls::rbd::MirrorImageStatusState> state = {};
[[fallthrough]];
case cls::rbd::MIRROR_PEER_DIRECTION_TX:
// if we are TX-only, summary is based on remote status
- unmatched_tx_peers = tx_peer_fsids.size();
+ unmatched_tx_peers = tx_peer_mirror_uuids.size();
for (auto& remote_status : status.mirror_image_site_statuses) {
- if (remote_status.fsid == cls::rbd::MirrorImageSiteStatus::LOCAL_FSID) {
+ if (remote_status.mirror_uuid ==
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID) {
continue;
}
if (unmatched_tx_peers > 0 &&
- tx_peer_fsids.count(remote_status.fsid) > 0) {
+ tx_peer_mirror_uuids.count(remote_status.mirror_uuid) > 0) {
--unmatched_tx_peers;
}
int image_status_get_summary(
cls_method_context_t hctx,
cls::rbd::MirrorPeerDirection mirror_peer_direction,
- const std::set<std::string>& tx_peer_fsids,
+ const std::set<std::string>& tx_peer_mirror_uuids,
std::map<cls::rbd::MirrorImageStatusState, int> *states) {
std::set<entity_inst_t> watchers;
int r = list_watchers(hctx, &watchers);
}
auto state = compute_image_status_summary_state(
- mirror_peer_direction, tx_peer_fsids, status);
+ mirror_peer_direction, tx_peer_mirror_uuids, status);
(*states)[state]++;
}
bufferlist bl;
int r = cls_cxx_map_get_val(
hctx, status_global_key(global_image_id,
- cls::rbd::MirrorImageSiteStatus::LOCAL_FSID),
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID),
&bl);
if (r < 0) {
if (r != -ENOENT) {
/**
* Input:
* @param unique peer site name (std::string)
- * @param fsid (std::string)
+ * @param mirror_uuid (std::string)
* @param direction (MirrorPeerDirection) -- future use
*
* Output:
int mirror_peer_ping(cls_method_context_t hctx, bufferlist *in,
bufferlist *out) {
std::string site_name;
- std::string fsid;
+ std::string mirror_uuid;
cls::rbd::MirrorPeerDirection mirror_peer_direction;
try {
auto it = in->cbegin();
decode(site_name, it);
- decode(fsid, it);
+ decode(mirror_uuid, it);
uint8_t direction;
decode(direction, it);
return -EINVAL;
}
- int r = mirror::peer_ping(hctx, site_name, fsid);
+ int r = mirror::peer_ping(hctx, site_name, mirror_uuid);
if (r < 0) {
return r;
}
mirror_peer_direction = peers.begin()->mirror_peer_direction;
}
- std::set<std::string> tx_peer_fsids;
+ std::set<std::string> tx_peer_mirror_uuids;
for (auto& peer : peers) {
if (peer.mirror_peer_direction == cls::rbd::MIRROR_PEER_DIRECTION_RX) {
continue;
}
- tx_peer_fsids.insert(peer.fsid);
+ tx_peer_mirror_uuids.insert(peer.mirror_uuid);
if (mirror_peer_direction != cls::rbd::MIRROR_PEER_DIRECTION_RX_TX &&
mirror_peer_direction != peer.mirror_peer_direction) {
mirror_peer_direction = cls::rbd::MIRROR_PEER_DIRECTION_RX_TX;
std::map<cls::rbd::MirrorImageStatusState, int> states;
int r = mirror::image_status_get_summary(hctx, mirror_peer_direction,
- tx_peer_fsids, &states);
+ tx_peer_mirror_uuids, &states);
if (r < 0) {
return r;
}
// v2
encode(static_cast<uint8_t>(mirror_peer_direction), bl);
- encode(fsid, bl);
+ encode(mirror_uuid, bl);
encode(last_seen, bl);
ENCODE_FINISH(bl);
}
uint8_t mpd;
decode(mpd, it);
mirror_peer_direction = static_cast<MirrorPeerDirection>(mpd);
- decode(fsid, it);
+ decode(mirror_uuid, it);
decode(last_seen, it);
}
f->dump_string("uuid", uuid);
f->dump_stream("direction") << mirror_peer_direction;
f->dump_string("site_name", site_name);
- f->dump_string("fsid", fsid);
+ f->dump_string("mirror_uuid", mirror_uuid);
f->dump_string("client_name", client_name);
f->dump_stream("last_seen") << last_seen;
}
o.push_back(new MirrorPeer("uuid-123", MIRROR_PEER_DIRECTION_RX, "site A",
"client name", ""));
o.push_back(new MirrorPeer("uuid-234", MIRROR_PEER_DIRECTION_TX, "site B",
- "", "fsid"));
+ "", "mirror_uuid"));
o.push_back(new MirrorPeer("uuid-345", MIRROR_PEER_DIRECTION_RX_TX, "site C",
- "client name", "fsid"));
+ "client name", "mirror_uuid"));
}
bool MirrorPeer::operator==(const MirrorPeer &rhs) const {
mirror_peer_direction == rhs.mirror_peer_direction &&
site_name == rhs.site_name &&
client_name == rhs.client_name &&
- fsid == rhs.fsid &&
+ mirror_uuid == rhs.mirror_uuid &&
last_seen == rhs.last_seen);
}
<< "direction=" << peer.mirror_peer_direction << ", "
<< "site_name=" << peer.site_name << ", "
<< "client_name=" << peer.client_name << ", "
- << "fsid=" << peer.fsid << ", "
+ << "mirror_uuid=" << peer.mirror_uuid << ", "
<< "last_seen=" << peer.last_seen
<< "]";
return os;
return os;
}
-const std::string MirrorImageSiteStatus::LOCAL_FSID(""); // empty fsid
+const std::string MirrorImageSiteStatus::LOCAL_MIRROR_UUID(""); // empty mirror uuid
void MirrorImageSiteStatus::encode_meta(uint8_t version, bufferlist &bl) const {
if (version >= 2) {
- ceph::encode(fsid, bl);
+ ceph::encode(mirror_uuid, bl);
}
cls::rbd::encode(state, bl);
ceph::encode(description, bl);
void MirrorImageSiteStatus::decode_meta(uint8_t version,
bufferlist::const_iterator &it) {
if (version < 2) {
- fsid = LOCAL_FSID;
+ mirror_uuid = LOCAL_MIRROR_UUID;
} else {
- ceph::decode(fsid, it);
+ ceph::decode(mirror_uuid, it);
}
cls::rbd::decode(state, it);
void MirrorImageSiteStatus::encode(bufferlist &bl) const {
// break compatibility when site-name is provided
- uint8_t version = (fsid == LOCAL_FSID ? 1 : 2);
+ uint8_t version = (mirror_uuid == LOCAL_MIRROR_UUID ? 1 : 2);
ENCODE_START(version, version, bl);
encode_meta(version, bl);
ENCODE_FINISH(bl);
mirror_image_site_statuses.begin(),
mirror_image_site_statuses.end(),
[](const MirrorImageSiteStatus& status) {
- return status.fsid == MirrorImageSiteStatus::LOCAL_FSID;
+ return status.mirror_uuid == MirrorImageSiteStatus::LOCAL_MIRROR_UUID;
});
if (it == mirror_image_site_statuses.end()) {
return -ENOENT;
encode(n, bl);
for (auto& status : mirror_image_site_statuses) {
- if (status.fsid == MirrorImageSiteStatus::LOCAL_FSID) {
+ if (status.mirror_uuid == MirrorImageSiteStatus::LOCAL_MIRROR_UUID) {
continue;
}
status.encode_meta(2, bl);
f->open_array_section("remotes");
for (auto& status : mirror_image_site_statuses) {
- if (status.fsid == MirrorImageSiteStatus::LOCAL_FSID) {
+ if (status.mirror_uuid == MirrorImageSiteStatus::LOCAL_MIRROR_UUID) {
continue;
}
os << "remotes=[";
for (auto& remote_status : status.mirror_image_site_statuses) {
- if (remote_status.fsid == MirrorImageSiteStatus::LOCAL_FSID) {
+ if (remote_status.mirror_uuid == MirrorImageSiteStatus::LOCAL_MIRROR_UUID) {
continue;
}
os << "{"
- << "fsid=" << remote_status.fsid << ", "
+ << "mirror_uuid=" << remote_status.mirror_uuid<< ", "
<< "state=" << remote_status.state_to_string() << ", "
<< "description=" << remote_status.description << ", "
<< "last_update=" << remote_status.last_update
MirrorPeerDirection mirror_peer_direction,
const std::string& site_name,
const std::string& client_name,
- const std::string& fsid)
+ const std::string& mirror_uuid)
: uuid(uuid), mirror_peer_direction(mirror_peer_direction),
- site_name(site_name), client_name(client_name), fsid(fsid) {
+ site_name(site_name), client_name(client_name),
+ mirror_uuid(mirror_uuid) {
}
std::string uuid;
MirrorPeerDirection mirror_peer_direction = MIRROR_PEER_DIRECTION_RX_TX;
std::string site_name;
std::string client_name; // RX property
- std::string fsid;
+ std::string mirror_uuid;
utime_t last_seen;
inline bool is_valid() const {
std::ostream& operator<<(std::ostream& os, const MirrorImageStatusState& state);
struct MirrorImageSiteStatus {
- static const std::string LOCAL_FSID;
+ static const std::string LOCAL_MIRROR_UUID;
MirrorImageSiteStatus() {}
- MirrorImageSiteStatus(const std::string& fsid,
+ MirrorImageSiteStatus(const std::string& mirror_uuid,
MirrorImageStatusState state,
const std::string &description)
- : fsid(fsid), state(state), description(description) {
+ : mirror_uuid(mirror_uuid), state(state), description(description) {
}
- std::string fsid = LOCAL_FSID;
+ std::string mirror_uuid = LOCAL_MIRROR_UUID;
MirrorImageStatusState state = MIRROR_IMAGE_STATUS_STATE_UNKNOWN;
std::string description;
utime_t last_update;
#define RBD_FLAG_OBJECT_MAP_INVALID (1<<0)
#define RBD_FLAG_FAST_DIFF_INVALID (1<<1)
-#define RBD_MIRROR_IMAGE_STATUS_LOCAL_FSID ""
+#define RBD_MIRROR_IMAGE_STATUS_LOCAL_MIRROR_UUID ""
typedef void *rbd_image_t;
typedef void *rbd_image_options_t;
char *uuid;
rbd_mirror_peer_direction_t direction;
char *site_name;
- char *fsid;
+ char *mirror_uuid;
char *client_name;
time_t last_seen;
} rbd_mirror_peer_site_t;
} rbd_mirror_image_status_t CEPH_RBD_DEPRECATED;
typedef struct {
- char *fsid;
+ char *mirror_uuid;
rbd_mirror_image_status_state_t state;
char *description;
time_t last_update;
std::string uuid;
mirror_peer_direction_t direction;
std::string site_name;
- std::string fsid;
+ std::string mirror_uuid;
std::string client_name;
time_t last_seen;
} mirror_peer_site_t;
} mirror_image_status_t CEPH_RBD_DEPRECATED;
typedef struct {
- std::string fsid;
+ std::string mirror_uuid;
mirror_image_status_state_t state;
std::string description;
time_t last_update;
for (auto& site_status :
mirror_image_status_internal.mirror_image_site_statuses) {
mirror_image_global_status->site_statuses.push_back({
- site_status.fsid,
+ site_status.mirror_uuid,
static_cast<mirror_image_status_state_t>(site_status.state),
site_status.description, site_status.last_update.sec(),
site_status.up});
peer.direction = static_cast<mirror_peer_direction_t>(
mirror_peer.mirror_peer_direction);
peer.site_name = mirror_peer.site_name;
- peer.fsid = mirror_peer.fsid;
+ peer.mirror_uuid = mirror_peer.mirror_uuid;
peer.client_name = mirror_peer.client_name;
peer.last_seen = mirror_peer.last_seen.sec();
peers->push_back(peer);
status.mirror_image_site_statuses.size());
for (auto& site_status : status.mirror_image_site_statuses) {
global_status.site_statuses.push_back(mirror_image_site_status_t{
- site_status.fsid,
+ site_status.mirror_uuid,
static_cast<mirror_image_status_state_t>(site_status.state),
site_status.state == cls::rbd::MIRROR_IMAGE_STATUS_STATE_UNKNOWN ?
STATUS_NOT_FOUND : site_status.description,
} else {
// older OSD that only returns local status
global_status.site_statuses.push_back(mirror_image_site_status_t{
- cls::rbd::MirrorImageSiteStatus::LOCAL_FSID,
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID,
MIRROR_IMAGE_STATUS_STATE_UNKNOWN, STATUS_NOT_FOUND, 0, false});
}
}
auto it = std::find_if(status.site_statuses.begin(),
status.site_statuses.end(),
[](const librbd::mirror_image_site_status_t& s) {
- return (s.fsid == cls::rbd::MirrorImageSiteStatus::LOCAL_FSID);
+ return (s.mirror_uuid ==
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID);
});
if (it == status.site_statuses.end()) {
return -ENOENT;
for (auto it = cpp_status.site_statuses.begin();
it != cpp_status.site_statuses.end(); ++it) {
auto& s_status = c_status->site_statuses[idx++];
- s_status.fsid = strdup(it->fsid.c_str());
+ s_status.mirror_uuid = strdup(it->mirror_uuid.c_str());
s_status.state = it->state;
s_status.description = strdup(it->description.c_str());
s_status.last_update = it->last_update;
images->clear();
for (auto &[id, global_status] : global_statuses) {
if (global_status.site_statuses.empty() ||
- global_status.site_statuses[0].fsid !=
- cls::rbd::MirrorImageSiteStatus::LOCAL_FSID) {
+ global_status.site_statuses[0].mirror_uuid !=
+ cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID) {
continue;
}
peers[i].uuid = strdup(peer_vector[i].uuid.c_str());
peers[i].direction = peer_vector[i].direction;
peers[i].site_name = strdup(peer_vector[i].site_name.c_str());
- peers[i].fsid = strdup(peer_vector[i].fsid.c_str());
+ peers[i].mirror_uuid = strdup(peer_vector[i].mirror_uuid.c_str());
peers[i].client_name = strdup(peer_vector[i].client_name.c_str());
}
*max_peers = static_cast<int>(peer_vector.size());
for (int i = 0; i < max_peers; ++i) {
free(peers[i].uuid);
free(peers[i].site_name);
- free(peers[i].fsid);
+ free(peers[i].mirror_uuid);
free(peers[i].client_name);
}
}
free(global_status->name);
rbd_mirror_image_get_info_cleanup(&global_status->info);
for (auto idx = 0U; idx < global_status->site_statuses_count; ++idx) {
- free(global_status->site_statuses[idx].fsid);
+ free(global_status->site_statuses[idx].mirror_uuid);
free(global_status->site_statuses[idx].description);
}
free(global_status->site_statuses);
template <typename I>
void GetStatusRequest<I>::send() {
*m_mirror_image_status = cls::rbd::MirrorImageStatus(
- {{cls::rbd::MirrorImageSiteStatus::LOCAL_FSID,
+ {{cls::rbd::MirrorImageSiteStatus::LOCAL_MIRROR_UUID,
cls::rbd::MIRROR_IMAGE_STATUS_STATE_UNKNOWN, "status not found"}});
get_info();
char *uuid
rbd_mirror_peer_direction_t direction
char *site_name
- char *fsid
+ char *mirror_uuid
char *client_name
time_t last_seen
_MIRROR_IMAGE_STATUS_STATE_STOPPED "MIRROR_IMAGE_STATUS_STATE_STOPPED"
ctypedef struct rbd_mirror_image_site_status_t:
- char *fsid
+ char *mirror_uuid
rbd_mirror_image_status_state_t state
char *description
time_t last_update
* ``site_name`` (str) - cluster name of the peer
- * ``fsid`` (str) - fsid of the peer
+ * ``mirror_uuid`` (str) - mirror uuid of the peer
* ``client_name`` (str) - client name of the peer
"""
'direction' : int(self.peers[i].direction),
'site_name' : decode_cstr(self.peers[i].site_name),
'cluster_name' : decode_cstr(self.peers[i].site_name),
- 'fsid' : decode_cstr(self.peers[i].fsid),
+ 'mirror_uuid' : decode_cstr(self.peers[i].mirror_uuid),
'client_name' : decode_cstr(self.peers[i].client_name),
}
* ``remote_statuses`` (array) -
- * ``fsid`` (str) - remote fsid
+ * ``mirror uuid`` (str) - remote mirror uuid
* ``state`` (int) - status mirror state
'last_update' : datetime.utcfromtimestamp(s_status.last_update),
'up' : s_status.up,
}
- fsid = decode_cstr(s_status.fsid)
- if fsid == '':
+ mirror_uuid = decode_cstr(s_status.mirror_uuid)
+ if mirror_uuid == '':
local_status = site_status
else:
- site_status['fsid'] = fsid
+ site_status['mirror_uuid'] = mirror_uuid
site_statuses += site_status
status = {
* ``remote_statuses`` (array) -
- * ``fsid`` (str) - remote fsid
+ * ``mirror_uuid`` (str) - remote mirror uuid
* ``state`` (int) - status mirror state
'last_update' : datetime.utcfromtimestamp(s_status.last_update),
'up' : s_status.up,
}
- fsid = decode_cstr(s_status.fsid)
- if fsid == '':
+ mirror_uuid = decode_cstr(s_status.mirror_uuid)
+ if mirror_uuid == '':
local_status = site_status
else:
- site_statuses['fsid'] = fsid
+ site_statuses['mirror_uuid'] = mirror_uuid
site_statuses += site_status
status = {
'name': decode_cstr(c_status.name),
std::string uuid;
ASSERT_EQ(-ENOENT, mirror_uuid_get(&ioctx, &uuid));
ASSERT_EQ(-EINVAL, mirror_peer_add(&ioctx, {"uuid1", MIRROR_PEER_DIRECTION_RX,
- "siteA", "client", "fsid"}));
- ASSERT_EQ(-EINVAL, mirror_peer_ping(&ioctx, "siteA", "fsid"));
+ "siteA", "client",
+ "mirror uuid"}));
+ ASSERT_EQ(-EINVAL, mirror_peer_ping(&ioctx, "siteA", "mirror uuid"));
cls::rbd::MirrorMode mirror_mode;
ASSERT_EQ(0, mirror_mode_get(&ioctx, &mirror_mode));
MIRROR_PEER_DIRECTION_RX, "siteA",
"client", ""}));
ASSERT_EQ(-EINVAL, mirror_peer_add(&ioctx, {"uuid1", MIRROR_PEER_DIRECTION_TX,
- "siteA", "client", "fsid"}));
+ "siteA", "client",
+ "mirror uuid"}));
ASSERT_EQ(0, mirror_peer_add(&ioctx, {"uuid1", MIRROR_PEER_DIRECTION_RX,
"siteA", "client", "fsidA"}));
ASSERT_EQ(0, mirror_peer_add(&ioctx, {"uuid2", MIRROR_PEER_DIRECTION_RX,
{"uuid3", MIRROR_PEER_DIRECTION_RX, "new site", "admin", ""}};
ASSERT_EQ(expected_peers, peers);
- ASSERT_EQ(-EINVAL, mirror_peer_ping(&ioctx, "", "fsid"));
+ ASSERT_EQ(-EINVAL, mirror_peer_ping(&ioctx, "", "mirror uuid"));
ASSERT_EQ(-EINVAL, mirror_peer_ping(&ioctx, "new site", ""));
- ASSERT_EQ(0, mirror_peer_ping(&ioctx, "new site", "fsid"));
+ ASSERT_EQ(0, mirror_peer_ping(&ioctx, "new site", "mirror uuid"));
ASSERT_EQ(0, mirror_peer_list(&ioctx, &peers));
ASSERT_EQ(1U, peers.size());
ASSERT_LT(utime_t{}, peers[0].last_seen);
expected_peers = {
- {"uuid3", MIRROR_PEER_DIRECTION_RX_TX, "new site", "admin", "fsid"}};
+ {"uuid3", MIRROR_PEER_DIRECTION_RX_TX, "new site", "admin", "mirror uuid"}};
expected_peers[0].last_seen = peers[0].last_seen;
ASSERT_EQ(expected_peers, peers);
ASSERT_EQ(0, mirror_peer_remove(&ioctx, "uuid3"));
- ASSERT_EQ(0, mirror_peer_ping(&ioctx, "siteA", "fsid"));
+ ASSERT_EQ(0, mirror_peer_ping(&ioctx, "siteA", "mirror uuid"));
ASSERT_EQ(0, mirror_peer_list(&ioctx, &peers));
ASSERT_EQ(1U, peers.size());
ASSERT_FALSE(peers[0].uuid.empty());
ASSERT_LT(utime_t{}, peers[0].last_seen);
expected_peers = {
- {peers[0].uuid, MIRROR_PEER_DIRECTION_TX, "siteA", "", "fsid"}};
+ {peers[0].uuid, MIRROR_PEER_DIRECTION_TX, "siteA", "", "mirror uuid"}};
expected_peers[0].last_seen = peers[0].last_seen;
ASSERT_EQ(expected_peers, peers);
expect_can_create_primary_snapshot(mock_utils, false, false, true);
expect_get_mirror_peers(mock_image_ctx,
{{"uuid", cls::rbd::MIRROR_PEER_DIRECTION_TX, "ceph",
- "mirror", "fsid"}}, 0);
+ "mirror", "mirror uuid"}}, 0);
expect_create_snapshot(mock_image_ctx, 0);
C_SaferCond ctx;
expect_can_create_primary_snapshot(mock_utils, false, false, true);
expect_get_mirror_peers(mock_image_ctx,
{{"uuid", cls::rbd::MIRROR_PEER_DIRECTION_TX, "ceph",
- "mirror", "fsid"}}, -EINVAL);
+ "mirror", "mirror uuid"}}, -EINVAL);
C_SaferCond ctx;
auto req = new MockCreatePrimaryRequest(&mock_image_ctx, "gid", 0U, nullptr,
expect_can_create_primary_snapshot(mock_utils, false, false, true);
expect_get_mirror_peers(mock_image_ctx,
{{"uuid", cls::rbd::MIRROR_PEER_DIRECTION_TX, "ceph",
- "mirror", "fsid"}}, 0);
+ "mirror", "mirror uuid"}}, 0);
expect_create_snapshot(mock_image_ctx, -EINVAL);
C_SaferCond ctx;
expect_can_create_primary_snapshot(mock_utils, false, false, true);
expect_get_mirror_peers(mock_image_ctx,
{{"uuid", cls::rbd::MIRROR_PEER_DIRECTION_TX, "ceph",
- "mirror", "fsid"}}, 0);
+ "mirror", "mirror uuid"}}, 0);
expect_create_snapshot(mock_image_ctx, 0);
MockUnlinkPeerRequest mock_unlink_peer_request;
auto it = mock_image_ctx.snap_info.rbegin();
auto it = std::find_if(status.site_statuses.begin(),
status.site_statuses.end(),
[](auto& site_status) {
- return (site_status.fsid == RBD_MIRROR_IMAGE_STATUS_LOCAL_FSID);
+ return (site_status.mirror_uuid ==
+ RBD_MIRROR_IMAGE_STATUS_LOCAL_MIRROR_UUID);
});
if (it == status.site_statuses.end()) {
return -ENOENT;
'direction': RBD_MIRROR_PEER_DIRECTION_RX_TX,
'site_name' : site_name,
'cluster_name' : site_name,
- 'fsid': '',
+ 'mirror_uuid': '',
'client_name' : client_name,
}
eq([peer], list(self.rbd.mirror_peer_list(ioctx)))
'direction': RBD_MIRROR_PEER_DIRECTION_RX_TX,
'site_name' : cluster_name,
'cluster_name' : cluster_name,
- 'fsid': '',
+ 'mirror_uuid': '',
'client_name' : client_name,
}
eq([peer], list(self.rbd.mirror_peer_list(ioctx)))
void expect_mirror_status_update(
const MirrorImageSiteStatuses& mirror_image_site_statuses,
- const std::string& fsid, int r) {
+ const std::string& mirror_uuid, int r) {
EXPECT_CALL(*m_mock_local_io_ctx, aio_operate(_, _, _, _, _))
.WillOnce(Invoke([this](auto&&... args) {
int r = m_mock_local_io_ctx->do_aio_operate(decltype(args)(args)...);
for (auto [global_image_id, mirror_image_status] :
mirror_image_site_statuses) {
- mirror_image_status.fsid = fsid;
+ mirror_image_status.mirror_uuid = mirror_uuid;
expect_mirror_status_update(global_image_id, mirror_image_status, r);
if (r < 0) {
break;
}
TEST_F(TestMockMirrorStatusUpdater, MirrorPeerSitePing) {
- std::string fsid;
- ASSERT_EQ(0, _rados->cluster_fsid(&fsid));
-
MockMirrorStatusUpdater mock_mirror_status_updater(m_local_io_ctx,
- m_mock_threads, fsid);
+ m_mock_threads,
+ "mirror uuid");
MockMirrorStatusWatcher* mock_mirror_status_watcher =
new MockMirrorStatusWatcher();
Context* update_task = nullptr;
fire_timer_event(&timer_event, &update_task);
- expect_mirror_status_update(mirror_image_site_statuses, fsid, 0);
+ expect_mirror_status_update(mirror_image_site_statuses, "mirror uuid", 0);
update_task->complete(0);
shut_down_mirror_status_updater(mock_mirror_status_updater,
static MirrorStatusUpdater *create(librados::IoCtx &io_ctx,
Threads<librbd::MockTestImageCtx> *threads,
- const std::string& fsid) {
- ceph_assert(s_instance[fsid] != nullptr);
- return s_instance[fsid];
+ const std::string& local_mirror_uuid) {
+ ceph_assert(s_instance[local_mirror_uuid] != nullptr);
+ return s_instance[local_mirror_uuid];
}
- MirrorStatusUpdater(const std::string_view& fsid) {
- s_instance[std::string{fsid}] = this;
+ MirrorStatusUpdater(const std::string_view& local_mirror_uuid) {
+ s_instance[std::string{local_mirror_uuid}] = this;
}
MOCK_METHOD1(init, void(Context *));
class TestMockNamespaceReplayer : public TestMockFixture {
public:
- static constexpr const std::string_view FSID = "00000000-1111-2222-3333-444444444444";
-
typedef NamespaceReplayer<librbd::MockTestImageCtx> MockNamespaceReplayer;
typedef ImageDeleter<librbd::MockTestImageCtx> MockImageDeleter;
typedef ImageMap<librbd::MockTestImageCtx> MockImageMap;
auto mock_local_mirror_status_updater = new MockMirrorStatusUpdater{""};
expect_mirror_status_updater_init(*mock_local_mirror_status_updater, 0);
- auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{FSID};
+ auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{
+ "local mirror uuid"};
expect_mirror_status_updater_init(*mock_remote_mirror_status_updater,
-EINVAL);
auto mock_local_mirror_status_updater = new MockMirrorStatusUpdater{""};
expect_mirror_status_updater_init(*mock_local_mirror_status_updater, 0);
- auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{FSID};
+ auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{
+ "local mirror uuid"};
expect_mirror_status_updater_init(*mock_remote_mirror_status_updater, 0);
auto mock_instance_replayer = new MockInstanceReplayer();
auto mock_local_mirror_status_updater = new MockMirrorStatusUpdater{""};
expect_mirror_status_updater_init(*mock_local_mirror_status_updater, 0);
- auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{FSID};
+ auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{
+ "local mirror uuid"};
expect_mirror_status_updater_init(*mock_remote_mirror_status_updater, 0);
auto mock_instance_replayer = new MockInstanceReplayer();
auto mock_local_mirror_status_updater = new MockMirrorStatusUpdater{""};
expect_mirror_status_updater_init(*mock_local_mirror_status_updater, 0);
- auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{FSID};
+ auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{
+ "local mirror uuid"};
expect_mirror_status_updater_init(*mock_remote_mirror_status_updater, 0);
auto mock_instance_replayer = new MockInstanceReplayer();
auto mock_local_mirror_status_updater = new MockMirrorStatusUpdater{""};
expect_mirror_status_updater_init(*mock_local_mirror_status_updater, 0);
- auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{FSID};
+ auto mock_remote_mirror_status_updater = new MockMirrorStatusUpdater{
+ "local mirror uuid"};
expect_mirror_status_updater_init(*mock_remote_mirror_status_updater, 0);
auto mock_instance_replayer = new MockInstanceReplayer();
Threads<librbd::MockTestImageCtx>* threads,
librados::IoCtx& remote_io_ctx,
const std::string& local_site_name,
- const std::string& local_fsid,
+ const std::string& local_mirror_uuid,
remote_pool_poller::Listener& listener) {
ceph_assert(s_instance != nullptr);
s_instance->listener = &listener;
auto it = std::find_if(status.site_statuses.begin(),
status.site_statuses.end(),
[](auto& site_status) {
- return (site_status.fsid == RBD_MIRROR_IMAGE_STATUS_LOCAL_FSID);
+ return (site_status.mirror_uuid ==
+ RBD_MIRROR_IMAGE_STATUS_LOCAL_MIRROR_UUID);
});
if (it == status.site_statuses.end()) {
return -ENOENT;
}
}
-void get_mirror_peer_fsid_to_names(
+void get_mirror_peer_mirror_uuids_to_names(
const std::vector<librbd::mirror_peer_site_t>& mirror_peers,
- std::map<std::string, std::string>* fsid_to_name) {
- fsid_to_name->clear();
+ std::map<std::string, std::string>* mirror_uuids_to_name) {
+ mirror_uuids_to_name->clear();
for (auto& peer : mirror_peers) {
- if (!peer.fsid.empty() && !peer.site_name.empty()) {
- (*fsid_to_name)[peer.fsid] = peer.site_name;
+ if (!peer.mirror_uuid.empty() && !peer.site_name.empty()) {
+ (*mirror_uuids_to_name)[peer.mirror_uuid] = peer.site_name;
}
}
}
void populate_unknown_mirror_image_site_statuses(
const std::vector<librbd::mirror_peer_site_t>& mirror_peers,
librbd::mirror_image_global_status_t* global_status) {
- std::set<std::string> missing_fsids;
+ std::set<std::string> missing_mirror_uuids;
librbd::mirror_peer_direction_t mirror_peer_direction =
RBD_MIRROR_PEER_DIRECTION_RX_TX;
for (auto& peer : mirror_peers) {
mirror_peer_direction = RBD_MIRROR_PEER_DIRECTION_RX_TX;
}
- if (!peer.fsid.empty() && peer.direction != RBD_MIRROR_PEER_DIRECTION_TX) {
- missing_fsids.insert(peer.fsid);
+ if (!peer.mirror_uuid.empty() &&
+ peer.direction != RBD_MIRROR_PEER_DIRECTION_TX) {
+ missing_mirror_uuids.insert(peer.mirror_uuid);
}
}
if (mirror_peer_direction != RBD_MIRROR_PEER_DIRECTION_TX) {
- missing_fsids.insert(RBD_MIRROR_IMAGE_STATUS_LOCAL_FSID);
+ missing_mirror_uuids.insert(RBD_MIRROR_IMAGE_STATUS_LOCAL_MIRROR_UUID);
}
std::vector<librbd::mirror_image_site_status_t> site_statuses;
- site_statuses.reserve(missing_fsids.size());
+ site_statuses.reserve(missing_mirror_uuids.size());
for (auto& site_status : global_status->site_statuses) {
- if (missing_fsids.count(site_status.fsid) > 0) {
- missing_fsids.erase(site_status.fsid);
+ if (missing_mirror_uuids.count(site_status.mirror_uuid) > 0) {
+ missing_mirror_uuids.erase(site_status.mirror_uuid);
site_statuses.push_back(site_status);
}
}
- for (auto& fsid : missing_fsids) {
- site_statuses.push_back({fsid, MIRROR_IMAGE_STATUS_STATE_UNKNOWN,
+ for (auto& mirror_uuid : missing_mirror_uuids) {
+ site_statuses.push_back({mirror_uuid, MIRROR_IMAGE_STATUS_STATE_UNKNOWN,
"status not found", 0, false});
}
void get_mirror_peer_sites(
librados::IoCtx& io_ctx,
std::vector<librbd::mirror_peer_site_t>* mirror_peers);
-void get_mirror_peer_fsid_to_names(
+void get_mirror_peer_mirror_uuids_to_names(
const std::vector<librbd::mirror_peer_site_t>& mirror_peers,
std::map<std::string, std::string>* fsid_to_name);
void populate_unknown_mirror_image_site_statuses(
std::vector<librbd::mirror_peer_site_t> mirror_peers;
utils::get_mirror_peer_sites(default_ns_io_ctx, &mirror_peers);
- std::map<std::string, std::string> peer_fsid_to_name;
- utils::get_mirror_peer_fsid_to_names(mirror_peers, &peer_fsid_to_name);
+ std::map<std::string, std::string> peer_mirror_uuids_to_name;
+ utils::get_mirror_peer_mirror_uuids_to_names(mirror_peers,
+ &peer_mirror_uuids_to_name);
librbd::mirror_image_global_status_t status;
r = image.mirror_image_get_global_status(&status, sizeof(status));
std::remove_if(status.site_statuses.begin(),
status.site_statuses.end(),
[](auto& status) {
- return (status.fsid == RBD_MIRROR_IMAGE_STATUS_LOCAL_FSID);
+ return (status.mirror_uuid ==
+ RBD_MIRROR_IMAGE_STATUS_LOCAL_MIRROR_UUID);
}),
status.site_statuses.end());
for (auto& status : status.site_statuses) {
formatter->open_object_section("peer_site");
- auto name_it = peer_fsid_to_name.find(status.fsid);
+ auto name_it = peer_mirror_uuids_to_name.find(status.mirror_uuid);
formatter->dump_string("site_name",
- (name_it != peer_fsid_to_name.end() ? name_it->second : ""));
- formatter->dump_string("fsid", status.fsid);
+ (name_it != peer_mirror_uuids_to_name.end() ? name_it->second : ""));
+ formatter->dump_string("mirror_uuids", status.mirror_uuid);
formatter->dump_string("state", utils::mirror_image_site_status_state(
status));
}
first_site = false;
- auto name_it = peer_fsid_to_name.find(site.fsid);
+ auto name_it = peer_mirror_uuids_to_name.find(site.mirror_uuid);
std::cout << " name: "
- << (name_it != peer_fsid_to_name.end() ? name_it->second :
- site.fsid)
+ << (name_it != peer_mirror_uuids_to_name.end() ?
+ name_it->second : site.mirror_uuid)
<< std::endl
<< " state: " << utils::mirror_image_site_status_state(
site) << std::endl
formatter->dump_string("uuid", peer.uuid);
formatter->dump_string("direction", direction);
formatter->dump_string("site_name", peer.site_name);
- formatter->dump_string("fsid", peer.fsid);
+ formatter->dump_string("mirror_uuid", peer.mirror_uuid);
formatter->dump_string("client_name", peer.client_name);
for (auto& pair : attributes) {
formatter->dump_string(pair.first.c_str(), pair.second);
<< "UUID: " << peer.uuid << std::endl
<< "Name: " << peer.site_name << std::endl;
if (peer.direction != RBD_MIRROR_PEER_DIRECTION_RX ||
- !peer.fsid.empty()) {
- std::cout << "FSID: " << peer.fsid << std::endl;
+ !peer.mirror_uuid.empty()) {
+ std::cout << "Mirror UUID: " << peer.mirror_uuid << std::endl;
}
std::cout << "Direction: " << direction << std::endl;
if (peer.direction != RBD_MIRROR_PEER_DIRECTION_TX ||
const std::string &image_name,
const std::map<std::string, std::string> &instance_ids,
const std::vector<librbd::mirror_peer_site_t>& mirror_peers,
- const std::map<std::string, std::string> &peer_fsid_to_name,
+ const std::map<std::string, std::string> &peer_mirror_uuids_to_name,
const MirrorDaemonServiceInfo &daemon_service_info,
at::Format::Formatter formatter)
: ImageRequestBase(io_ctx, throttle, image_name),
m_instance_ids(instance_ids), m_mirror_peers(mirror_peers),
- m_peer_fsid_to_name(peer_fsid_to_name),
+ m_peer_mirror_uuids_to_name(peer_mirror_uuids_to_name),
m_daemon_service_info(daemon_service_info), m_formatter(formatter) {
}
std::remove_if(m_mirror_image_global_status.site_statuses.begin(),
m_mirror_image_global_status.site_statuses.end(),
[](auto& status) {
- return (status.fsid == RBD_MIRROR_IMAGE_STATUS_LOCAL_FSID);
+ return (status.mirror_uuid ==
+ RBD_MIRROR_IMAGE_STATUS_LOCAL_MIRROR_UUID);
}),
m_mirror_image_global_status.site_statuses.end());
for (auto& status : m_mirror_image_global_status.site_statuses) {
m_formatter->open_object_section("peer_site");
- auto name_it = m_peer_fsid_to_name.find(status.fsid);
+ auto name_it = m_peer_mirror_uuids_to_name.find(status.mirror_uuid);
m_formatter->dump_string("site_name",
- (name_it != m_peer_fsid_to_name.end() ? name_it->second : ""));
- m_formatter->dump_string("fsid", status.fsid);
+ (name_it != m_peer_mirror_uuids_to_name.end() ?
+ name_it->second : ""));
+ m_formatter->dump_string("mirror_uuids", status.mirror_uuid);
m_formatter->dump_string(
"state", utils::mirror_image_site_status_state(status));
}
first_site = false;
- auto name_it = m_peer_fsid_to_name.find(site.fsid);
+ auto name_it = m_peer_mirror_uuids_to_name.find(site.mirror_uuid);
std::cout << " name: "
- << (name_it != m_peer_fsid_to_name.end() ? name_it->second :
- site.fsid)
+ << (name_it != m_peer_mirror_uuids_to_name.end() ?
+ name_it->second : site.mirror_uuid)
<< std::endl
<< " state: " << utils::mirror_image_site_status_state(
site) << std::endl
private:
const std::map<std::string, std::string> &m_instance_ids;
const std::vector<librbd::mirror_peer_site_t> &m_mirror_peers;
- const std::map<std::string, std::string> &m_peer_fsid_to_name;
+ const std::map<std::string, std::string> &m_peer_mirror_uuids_to_name;
const MirrorDaemonServiceInfo &m_daemon_service_info;
at::Format::Formatter m_formatter;
std::string m_image_id;
std::vector<librbd::mirror_peer_site_t> mirror_peers;
utils::get_mirror_peer_sites(default_ns_io_ctx, &mirror_peers);
- std::map<std::string, std::string> peer_fsid_to_name;
- utils::get_mirror_peer_fsid_to_names(mirror_peers, &peer_fsid_to_name);
+ std::map<std::string, std::string> peer_mirror_uuids_to_name;
+ utils::get_mirror_peer_mirror_uuids_to_names(mirror_peers,
+ &peer_mirror_uuids_to_name);
if (formatter != nullptr) {
formatter->open_array_section("images");
}
ImageRequestGenerator<StatusImageRequest> generator(
- io_ctx, instance_ids, mirror_peers, peer_fsid_to_name,
+ io_ctx, instance_ids, mirror_peers, peer_mirror_uuids_to_name,
daemon_service_info, formatter);
ret = generator.execute();
template <typename I>
MirrorStatusUpdater<I>::MirrorStatusUpdater(
- librados::IoCtx& io_ctx, Threads<I> *threads, const std::string& fsid)
- : m_io_ctx(io_ctx), m_threads(threads), m_fsid(fsid),
+ librados::IoCtx& io_ctx, Threads<I> *threads,
+ const std::string& local_mirror_uuid)
+ : m_io_ctx(io_ctx), m_threads(threads),
+ m_local_mirror_uuid(local_mirror_uuid),
m_lock(ceph::make_mutex("rbd::mirror::MirrorStatusUpdater " +
stringify(m_io_ctx.get_id()))) {
- dout(10) << "fsid=" << fsid << ", "
+ dout(10) << "local_mirror_uuid=" << local_mirror_uuid << ", "
<< "pool_id=" << m_io_ctx.get_id() << dendl;
}
continue;
}
- status_it->second.fsid = m_fsid;
+ status_it->second.mirror_uuid = m_local_mirror_uuid;
librbd::cls_client::mirror_image_status_set(&op, global_image_id,
status_it->second);
++op_count;
static MirrorStatusUpdater* create(librados::IoCtx& io_ctx,
Threads<ImageCtxT> *threads,
- const std::string& fsid) {
- return new MirrorStatusUpdater(io_ctx, threads, fsid);
+ const std::string& local_mirror_uuid) {
+ return new MirrorStatusUpdater(io_ctx, threads, local_mirror_uuid);
}
MirrorStatusUpdater(librados::IoCtx& io_ctx, Threads<ImageCtxT> *threads,
- const std::string& fsid);
+ const std::string& local_mirror_uuid);
~MirrorStatusUpdater();
void init(Context* on_finish);
librados::IoCtx m_io_ctx;
Threads<ImageCtxT>* m_threads;
- std::string m_fsid;
+ std::string m_local_mirror_uuid;
Context* m_timer_task = nullptr;
ceph_assert(ceph_mutex_is_locked(m_lock));
ceph_assert(!m_remote_status_updater);
- librados::Rados rados(m_local_io_ctx);
- std::string local_fsid;
- int r = rados.cluster_fsid(&local_fsid);
- if (r < 0) {
- derr << "failed to retrieve local fsid: " << cpp_strerror(r) << dendl;
- m_ret_val = r;
- shut_down_local_status_updater();
- return;
- }
-
m_remote_status_updater.reset(MirrorStatusUpdater<I>::create(
- m_remote_io_ctx, m_threads, local_fsid));
+ m_remote_io_ctx, m_threads, m_local_mirror_uuid));
auto ctx = create_context_callback<
NamespaceReplayer<I>,
&NamespaceReplayer<I>::handle_init_remote_status_updater>(this);
m_image_deletion_throttler.reset(
Throttler<I>::create(cct, "rbd_mirror_concurrent_image_deletions"));
- std::string local_fsid;
- r = m_local_rados->cluster_fsid(&local_fsid);
- if (r < 0) {
- derr << "failed to retrieve local fsid: " << cpp_strerror(r) << dendl;
- return;
- }
-
m_remote_pool_poller_listener.reset(new RemotePoolPollerListener(this));
m_remote_pool_poller.reset(RemotePoolPoller<I>::create(
- m_threads, m_remote_io_ctx, m_site_name, local_fsid,
+ m_threads, m_remote_io_ctx, m_site_name, m_local_mirror_uuid,
*m_remote_pool_poller_listener));
C_SaferCond on_pool_poller_init;
dout(10) << dendl;
librados::ObjectWriteOperation op;
- librbd::cls_client::mirror_peer_ping(&op, m_site_name, m_local_fsid);
+ librbd::cls_client::mirror_peer_ping(&op, m_site_name, m_local_mirror_uuid);
auto aio_comp = create_rados_callback<
RemotePoolPoller<I>, &RemotePoolPoller<I>::handle_mirror_peer_ping>(this);
continue;
}
- if (peer.fsid == m_local_fsid) {
+ if (peer.mirror_uuid == m_local_mirror_uuid) {
matched_peer = &peer;
break;
} else if (peer.site_name == m_site_name) {
Threads<ImageCtxT>* threads,
librados::IoCtx& remote_io_ctx,
const std::string& site_name,
- const std::string& local_fsid,
+ const std::string& local_mirror_uuid,
remote_pool_poller::Listener& listener) {
- return new RemotePoolPoller(threads, remote_io_ctx, site_name, local_fsid,
- listener);
+ return new RemotePoolPoller(threads, remote_io_ctx, site_name,
+ local_mirror_uuid, listener);
}
RemotePoolPoller(
Threads<ImageCtxT>* threads,
librados::IoCtx& remote_io_ctx,
const std::string& site_name,
- const std::string& local_fsid,
+ const std::string& local_mirror_uuid,
remote_pool_poller::Listener& listener)
: m_threads(threads),
m_remote_io_ctx(remote_io_ctx),
m_site_name(site_name),
- m_local_fsid(local_fsid),
+ m_local_mirror_uuid(local_mirror_uuid),
m_listener(listener) {
}
~RemotePoolPoller();
Threads<ImageCtxT>* m_threads;
librados::IoCtx& m_remote_io_ctx;
std::string m_site_name;
- std::string m_local_fsid;
+ std::string m_local_mirror_uuid;
remote_pool_poller::Listener& m_listener;
bufferlist m_out_bl;
projects / ceph-ci.git / commitdiff