cephfs-mirror: identify a ceph filesystem using (id, name)

Signed-off-by: Venky Shankar <vshankar@redhat.com>

diff --git a/src/tools/cephfs_mirror/ClusterWatcher.cc b/src/tools/cephfs_mirror/ClusterWatcher.cc
index 895324ad9e9c13de652cfc82c7a659648c5dd58a..c40ada88c1f5eeef9755bdd87302c4a46d1bf44b 100644 (file)
--- a/src/tools/cephfs_mirror/ClusterWatcher.cc
+++ b/src/tools/cephfs_mirror/ClusterWatcher.cc
@@ -74,31 +74,42 @@ void ClusterWatcher::handle_fsmap(const cref_t<MFSMap> &m) {
   auto fsmap = m->get_fsmap();
   auto filesystems = fsmap.get_filesystems();
 
-  std::vector<std::string> mirroring_enabled;
-  std::vector<std::string> mirroring_disabled;
-  std::map<std::string, Peers> peers_added;
-  std::map<std::string, Peers> peers_removed;
-  std::map<std::string, uint64_t> fs_metadata_pools;
+  std::vector<Filesystem> mirroring_enabled;
+  std::vector<Filesystem> mirroring_disabled;
+  std::map<Filesystem, Peers> peers_added;
+  std::map<Filesystem, Peers> peers_removed;
+  std::map<Filesystem, uint64_t> fs_metadata_pools;
   {
     std::scoped_lock locker(m_lock);
+    // deleted filesystems are considered mirroring disabled
+    for (auto it = m_filesystem_peers.begin(); it != m_filesystem_peers.end();) {
+      if (!fsmap.filesystem_exists(it->first.fscid)) {
+        mirroring_disabled.emplace_back(it->first);
+        it = m_filesystem_peers.erase(it);
+        continue;
+      }
+      ++it;
+    }
+
     for (auto &filesystem : filesystems) {
-      auto fs_name = filesystem->mds_map.get_fs_name();
+      auto fs = Filesystem{filesystem->fscid,
+                           std::string(filesystem->mds_map.get_fs_name())};
       auto pool_id = filesystem->mds_map.get_metadata_pool();
       auto &mirror_info = filesystem->mirror_info;
 
       if (!mirror_info.is_mirrored()) {
-        auto it = m_filesystem_peers.find(fs_name);
+        auto it = m_filesystem_peers.find(fs);
         if (it != m_filesystem_peers.end()) {
-          mirroring_disabled.emplace_back(fs_name);
+          mirroring_disabled.emplace_back(fs);
           m_filesystem_peers.erase(it);
         }
       } else {
-        auto [fspeersit, enabled] = m_filesystem_peers.emplace(fs_name, Peers{});
+        auto [fspeersit, enabled] = m_filesystem_peers.emplace(fs, Peers{});
         auto &peers = fspeersit->second;
 
         if (enabled) {
-          mirroring_enabled.emplace_back(fs_name);
-          fs_metadata_pools.emplace(fs_name, pool_id);
+          mirroring_enabled.emplace_back(fs);
+          fs_metadata_pools.emplace(fs, pool_id);
         }
 
         // peers added
@@ -114,11 +125,11 @@ void ClusterWatcher::handle_fsmap(const cref_t<MFSMap> &m) {
 
         // update set
         if (!added.empty()) {
-          peers_added.emplace(fs_name, added);
+          peers_added.emplace(fs, added);
           peers.insert(added.begin(), added.end());
         }
         if (!removed.empty()) {
-          peers_removed.emplace(fs_name, removed);
+          peers_removed.emplace(fs, removed);
           for (auto &p : removed) {
             peers.erase(p);
           }
@@ -129,23 +140,23 @@ void ClusterWatcher::handle_fsmap(const cref_t<MFSMap> &m) {
 
   dout(5) << ": mirroring enabled=" << mirroring_enabled << ", mirroring_disabled="
           << mirroring_disabled << dendl;
-  for (auto &fs_name : mirroring_enabled) {
-    m_listener.handle_mirroring_enabled(FilesystemSpec(fs_name, fs_metadata_pools.at(fs_name)));
+  for (auto &fs : mirroring_enabled) {
+    m_listener.handle_mirroring_enabled(FilesystemSpec(fs, fs_metadata_pools.at(fs)));
   }
-  for (auto &fs_name : mirroring_disabled) {
-    m_listener.handle_mirroring_disabled(fs_name);
+  for (auto &fs : mirroring_disabled) {
+    m_listener.handle_mirroring_disabled(fs);
   }
 
   dout(5) << ": peers added=" << peers_added << ", peers removed=" << peers_removed << dendl;
 
-  for (auto &[fs_name, peers] : peers_added) {
+  for (auto &[fs, peers] : peers_added) {
     for (auto &peer : peers) {
-      m_listener.handle_peers_added(fs_name, peer);
+      m_listener.handle_peers_added(fs, peer);
     }
   }
-  for (auto &[fs_name, peers] : peers_removed) {
+  for (auto &[fs, peers] : peers_removed) {
     for (auto &peer : peers) {
-      m_listener.handle_peers_removed(fs_name, peer);
+      m_listener.handle_peers_removed(fs, peer);
     }
   }
 

diff --git a/src/tools/cephfs_mirror/ClusterWatcher.h b/src/tools/cephfs_mirror/ClusterWatcher.h
index e3b131f9a648fed8abe474753a39b593b60e699a..a234eb8b13de3cc96c9b7833c65729c2655033f0 100644 (file)
--- a/src/tools/cephfs_mirror/ClusterWatcher.h
+++ b/src/tools/cephfs_mirror/ClusterWatcher.h
@@ -26,10 +26,10 @@ public:
     }
 
     virtual void handle_mirroring_enabled(const FilesystemSpec &spec) = 0;
-    virtual void handle_mirroring_disabled(const std::string &fs_name) = 0;
+    virtual void handle_mirroring_disabled(const Filesystem &filesystem) = 0;
 
-    virtual void handle_peers_added(const std::string &fs_name, const Peer &peer) = 0;
-    virtual void handle_peers_removed(const std::string &fs_name, const Peer &peer) = 0;
+    virtual void handle_peers_added(const Filesystem &filesystem, const Peer &peer) = 0;
+    virtual void handle_peers_removed(const Filesystem &filesystem, const Peer &peer) = 0;
   };
 
   ClusterWatcher(CephContext *cct, MonClient *monc, Listener &listener);
@@ -57,18 +57,11 @@ public:
   void shutdown();
 
 private:
-  struct StringCmp {
-    using is_transparent = void;
-    bool operator()(std::string_view a, std::string_view b) const {
-      return a < b;
-    }
-  };
-
   ceph::mutex m_lock = ceph::make_mutex("cephfs::mirror::cluster_watcher");
   MonClient *m_monc;
   Listener &m_listener;
 
-  std::map<std::string, Peers, StringCmp> m_filesystem_peers;
+  std::map<Filesystem, Peers> m_filesystem_peers;
 
   void handle_fsmap(const cref_t<MFSMap> &m);
 };