ceph/src/tools/cephfs_mirror/FSMirror.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef CEPHFS_MIRROR_FS_MIRROR_H
   5 #define CEPHFS_MIRROR_FS_MIRROR_H
   6
   7 #include "common/Formatter.h"
   8 #include "common/Thread.h"
   9 #include "mds/FSMap.h"
  10 #include "Types.h"
  11 #include "InstanceWatcher.h"
  12 #include "MirrorWatcher.h"
  13
  14 class ContextWQ;
  15
  16 namespace cephfs {
  17 namespace mirror {
  18
  19 class MirrorAdminSocketHook;
  20 class PeerReplayer;
  21 class ServiceDaemon;
  22
  23 // handle mirroring for a filesystem to a set of peers
  24
  25 class FSMirror {
  26 public:
  27   FSMirror(CephContext *cct, const Filesystem &filesystem, uint64_t pool_id,
  28            ServiceDaemon *service_daemon, std::vector<const char*> args,
  29            ContextWQ *work_queue);
  30   ~FSMirror();
  31
  32   void init(Context *on_finish);
  33   void shutdown(Context *on_finish);
  34
  35   void add_peer(const Peer &peer);
  36   void remove_peer(const Peer &peer);
  37
  38   bool is_stopping() {
  39     std::scoped_lock locker(m_lock);
  40     return m_stopping;
  41   }
  42
  43   bool is_init_failed() {
  44     std::scoped_lock locker(m_lock);
  45     return m_init_failed;
  46   }
  47
  48   bool is_failed() {
  49     std::scoped_lock locker(m_lock);
  50     return m_init_failed ||
  51            m_instance_watcher->is_failed() ||
  52            m_mirror_watcher->is_failed();
  53   }
  54
  55   bool is_blocklisted() {
  56     std::scoped_lock locker(m_lock);
  57     return is_blocklisted(locker);
  58   }
  59
  60   Peers get_peers() {
  61     std::scoped_lock locker(m_lock);
  62     return m_all_peers;
  63   }
  64
  65   std::string get_instance_addr() {
  66     std::scoped_lock locker(m_lock);
  67     return m_addrs;
  68   }
  69
  70   // admin socket helpers
  71   void mirror_status(Formatter *f);
  72
  73 private:
  74   bool is_blocklisted(const std::scoped_lock<ceph::mutex> &locker) const {
  75     bool blocklisted = false;
  76     if (m_instance_watcher) {
  77       blocklisted = m_instance_watcher->is_blocklisted();
  78     }
  79     if (m_mirror_watcher) {
  80       blocklisted |= m_mirror_watcher->is_blocklisted();
  81     }
  82
  83     return blocklisted;
  84   }
  85
  86   struct SnapListener : public InstanceWatcher::Listener {
  87     FSMirror *fs_mirror;
  88
  89     SnapListener(FSMirror *fs_mirror)
  90       : fs_mirror(fs_mirror) {
  91     }
  92
  93     void acquire_directory(string_view dir_path) override {
  94       fs_mirror->handle_acquire_directory(dir_path);
  95     }
  96
  97     void release_directory(string_view dir_path) override {
  98       fs_mirror->handle_release_directory(dir_path);
  99     }
 100   };
 101
 102   CephContext *m_cct;
 103   Filesystem m_filesystem;
 104   uint64_t m_pool_id;
 105   ServiceDaemon *m_service_daemon;
 106   std::vector<const char *> m_args;
 107   ContextWQ *m_work_queue;
 108
 109   ceph::mutex m_lock = ceph::make_mutex("cephfs::mirror::fs_mirror");
 110   SnapListener m_snap_listener;
 111   std::set<std::string, std::less<>> m_directories;
 112   Peers m_all_peers;
 113   std::map<Peer, std::unique_ptr<PeerReplayer>> m_peer_replayers;
 114
 115   RadosRef m_cluster;
 116   std::string m_addrs;
 117   librados::IoCtx m_ioctx;
 118   InstanceWatcher *m_instance_watcher = nullptr;
 119   MirrorWatcher *m_mirror_watcher = nullptr;
 120
 121   int m_retval = 0;
 122   bool m_stopping = false;
 123   bool m_init_failed = false;
 124   Context *m_on_init_finish = nullptr;
 125   Context *m_on_shutdown_finish = nullptr;
 126
 127   MirrorAdminSocketHook *m_asok_hook = nullptr;
 128
 129   MountRef m_mount;
 130
 131   int init_replayer(PeerReplayer *peer_replayer);
 132   void shutdown_replayer(PeerReplayer *peer_replayer);
 133   void cleanup();
 134
 135   void init_instance_watcher(Context *on_finish);
 136   void handle_init_instance_watcher(int r);
 137
 138   void init_mirror_watcher();
 139   void handle_init_mirror_watcher(int r);
 140
 141   void shutdown_peer_replayers();
 142
 143   void shutdown_mirror_watcher();
 144   void handle_shutdown_mirror_watcher(int r);
 145
 146   void shutdown_instance_watcher();
 147   void handle_shutdown_instance_watcher(int r);
 148
 149   void handle_acquire_directory(string_view dir_path);
 150   void handle_release_directory(string_view dir_path);
 151 };
 152
 153 } // namespace mirror
 154 } // namespace cephfs
 155
 156 #endif // CEPHFS_MIRROR_FS_MIRROR_H