]>
Commit | Line | Data |
---|---|---|
9f95a23c TL |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | ||
4 | #ifndef CEPH_RBD_MIRROR_NAMESPACE_REPLAYER_H | |
5 | #define CEPH_RBD_MIRROR_NAMESPACE_REPLAYER_H | |
6 | ||
7 | #include "common/AsyncOpTracker.h" | |
9f95a23c TL |
8 | #include "common/ceph_mutex.h" |
9 | #include "include/rados/librados.hpp" | |
10 | ||
11 | #include "tools/rbd_mirror/ImageDeleter.h" | |
12 | #include "tools/rbd_mirror/ImageMap.h" | |
13 | #include "tools/rbd_mirror/InstanceReplayer.h" | |
14 | #include "tools/rbd_mirror/InstanceWatcher.h" | |
15 | #include "tools/rbd_mirror/MirrorStatusUpdater.h" | |
16 | #include "tools/rbd_mirror/PoolWatcher.h" | |
17 | #include "tools/rbd_mirror/Types.h" | |
18 | #include "tools/rbd_mirror/image_map/Types.h" | |
19 | #include "tools/rbd_mirror/pool_watcher/Types.h" | |
20 | ||
21 | #include <memory> | |
22 | #include <string> | |
23 | #include <vector> | |
24 | ||
25 | class AdminSocketHook; | |
26 | ||
27 | namespace journal { struct CacheManagerHandler; } | |
28 | ||
29 | namespace librbd { class ImageCtx; } | |
30 | ||
31 | namespace rbd { | |
32 | namespace mirror { | |
33 | ||
34 | struct PoolMetaCache; | |
35 | template <typename> class ServiceDaemon; | |
36 | template <typename> class Throttler; | |
37 | template <typename> struct Threads; | |
38 | ||
39 | /** | |
40 | * Controls mirroring for a single remote cluster. | |
41 | */ | |
42 | template <typename ImageCtxT = librbd::ImageCtx> | |
43 | class NamespaceReplayer { | |
44 | public: | |
45 | static NamespaceReplayer *create( | |
46 | const std::string &name, | |
47 | librados::IoCtx &local_ioctx, | |
48 | librados::IoCtx &remote_ioctx, | |
49 | const std::string &local_mirror_uuid, | |
50 | const std::string &local_mirror_peer_uuid, | |
51 | const RemotePoolMeta& remote_pool_meta, | |
52 | Threads<ImageCtxT> *threads, | |
53 | Throttler<ImageCtxT> *image_sync_throttler, | |
54 | Throttler<ImageCtxT> *image_deletion_throttler, | |
55 | ServiceDaemon<ImageCtxT> *service_daemon, | |
56 | journal::CacheManagerHandler *cache_manager_handler, | |
57 | PoolMetaCache* pool_meta_cache) { | |
58 | return new NamespaceReplayer(name, local_ioctx, remote_ioctx, | |
59 | local_mirror_uuid, local_mirror_peer_uuid, | |
60 | remote_pool_meta, threads, | |
61 | image_sync_throttler, image_deletion_throttler, | |
62 | service_daemon, cache_manager_handler, | |
63 | pool_meta_cache); | |
64 | } | |
65 | ||
66 | NamespaceReplayer(const std::string &name, | |
67 | librados::IoCtx &local_ioctx, | |
68 | librados::IoCtx &remote_ioctx, | |
69 | const std::string &local_mirror_uuid, | |
70 | const std::string& local_mirror_peer_uuid, | |
71 | const RemotePoolMeta& remote_pool_meta, | |
72 | Threads<ImageCtxT> *threads, | |
73 | Throttler<ImageCtxT> *image_sync_throttler, | |
74 | Throttler<ImageCtxT> *image_deletion_throttler, | |
75 | ServiceDaemon<ImageCtxT> *service_daemon, | |
76 | journal::CacheManagerHandler *cache_manager_handler, | |
77 | PoolMetaCache* pool_meta_cache); | |
78 | NamespaceReplayer(const NamespaceReplayer&) = delete; | |
79 | NamespaceReplayer& operator=(const NamespaceReplayer&) = delete; | |
80 | ||
f67539c2 | 81 | bool is_blocklisted() const; |
9f95a23c TL |
82 | |
83 | void init(Context *on_finish); | |
84 | void shut_down(Context *on_finish); | |
85 | ||
86 | void handle_acquire_leader(Context *on_finish); | |
87 | void handle_release_leader(Context *on_finish); | |
88 | void handle_update_leader(const std::string &leader_instance_id); | |
89 | void handle_instances_added(const std::vector<std::string> &instance_ids); | |
90 | void handle_instances_removed(const std::vector<std::string> &instance_ids); | |
91 | ||
92 | void print_status(Formatter *f); | |
93 | void start(); | |
94 | void stop(); | |
95 | void restart(); | |
96 | void flush(); | |
97 | ||
98 | private: | |
99 | /** | |
100 | * @verbatim | |
101 | * | |
102 | * <uninitialized> <------------------------------------\ | |
103 | * | (init) ^ (error) | | |
104 | * v * | | |
105 | * INIT_LOCAL_STATUS_UPDATER * * * * * * * * > SHUT_DOWN_LOCAL_STATUS_UPDATER | |
106 | * | * (error) ^ | |
107 | * v * | | |
108 | * INIT_REMOTE_STATUS_UPDATER * * * * * * * > SHUT_DOWN_REMOTE_STATUS_UPDATER | |
109 | * | * (error) ^ | |
110 | * v * | | |
111 | * INIT_INSTANCE_REPLAYER * * * * * * * * * > SHUT_DOWN_INSTANCE_REPLAYER | |
112 | * | * ^ | |
113 | * v * | | |
114 | * INIT_INSTANCE_WATCHER * * * * * * * * * * SHUT_DOWN_INSTANCE_WATCHER | |
115 | * | (error) ^ | |
116 | * | | | |
117 | * v STOP_INSTANCE_REPLAYER | |
118 | * | ^ | |
119 | * | (shut down) | | |
120 | * | /----------------------------------------------/ | |
121 | * v | | |
122 | * <follower> <---------------------------\ | |
123 | * . | | |
124 | * . | | |
125 | * v (leader acquired) | | |
126 | * INIT_IMAGE_MAP | | |
127 | * | | | |
128 | * v | | |
129 | * INIT_LOCAL_POOL_WATCHER SHUT_DOWN_IMAGE_MAP | |
130 | * | ^ | |
131 | * v | | |
132 | * INIT_REMOTE_POOL_WATCHER SHUT_DOWN_POOL_WATCHERS | |
133 | * | ^ | |
134 | * v | | |
135 | * INIT_IMAGE_DELETER SHUT_DOWN_IMAGE_DELETER | |
136 | * | ^ | |
137 | * v . | |
138 | * <leader> <-----------\ . | |
139 | * . | . | |
140 | * . (image update) | . | |
141 | * . . > NOTIFY_INSTANCE_WATCHER . | |
142 | * . . | |
143 | * . (leader lost / shut down) . | |
144 | * . . . . . . . . . . . . . . . . . . . | |
145 | * | |
146 | * @endverbatim | |
147 | */ | |
148 | ||
149 | struct PoolWatcherListener : public pool_watcher::Listener { | |
150 | NamespaceReplayer *namespace_replayer; | |
151 | bool local; | |
152 | ||
153 | PoolWatcherListener(NamespaceReplayer *namespace_replayer, bool local) | |
154 | : namespace_replayer(namespace_replayer), local(local) { | |
155 | } | |
156 | ||
157 | void handle_update(const std::string &mirror_uuid, | |
158 | ImageIds &&added_image_ids, | |
159 | ImageIds &&removed_image_ids) override { | |
160 | namespace_replayer->handle_update((local ? "" : mirror_uuid), | |
161 | std::move(added_image_ids), | |
162 | std::move(removed_image_ids)); | |
163 | } | |
164 | }; | |
165 | ||
166 | struct ImageMapListener : public image_map::Listener { | |
167 | NamespaceReplayer *namespace_replayer; | |
168 | ||
169 | ImageMapListener(NamespaceReplayer *namespace_replayer) | |
170 | : namespace_replayer(namespace_replayer) { | |
171 | } | |
172 | ||
173 | void acquire_image(const std::string &global_image_id, | |
174 | const std::string &instance_id, | |
175 | Context* on_finish) override { | |
176 | namespace_replayer->handle_acquire_image(global_image_id, instance_id, | |
177 | on_finish); | |
178 | } | |
179 | ||
180 | void release_image(const std::string &global_image_id, | |
181 | const std::string &instance_id, | |
182 | Context* on_finish) override { | |
183 | namespace_replayer->handle_release_image(global_image_id, instance_id, | |
184 | on_finish); | |
185 | } | |
186 | ||
187 | void remove_image(const std::string &mirror_uuid, | |
188 | const std::string &global_image_id, | |
189 | const std::string &instance_id, | |
190 | Context* on_finish) override { | |
191 | namespace_replayer->handle_remove_image(mirror_uuid, global_image_id, | |
192 | instance_id, on_finish); | |
193 | } | |
194 | }; | |
195 | ||
196 | void handle_update(const std::string &mirror_uuid, | |
197 | ImageIds &&added_image_ids, | |
198 | ImageIds &&removed_image_ids); | |
199 | ||
200 | int init_rados(const std::string &cluster_name, | |
201 | const std::string &client_name, | |
202 | const std::string &mon_host, | |
203 | const std::string &key, | |
204 | const std::string &description, RadosRef *rados_ref, | |
205 | bool strip_cluster_overrides); | |
206 | ||
207 | void init_local_status_updater(); | |
208 | void handle_init_local_status_updater(int r); | |
209 | ||
210 | void init_remote_status_updater(); | |
211 | void handle_init_remote_status_updater(int r); | |
212 | ||
213 | void init_instance_replayer(); | |
214 | void handle_init_instance_replayer(int r); | |
215 | ||
216 | void init_instance_watcher(); | |
217 | void handle_init_instance_watcher(int r); | |
218 | ||
219 | void stop_instance_replayer(); | |
220 | void handle_stop_instance_replayer(int r); | |
221 | ||
222 | void shut_down_instance_watcher(); | |
223 | void handle_shut_down_instance_watcher(int r); | |
224 | ||
225 | void shut_down_instance_replayer(); | |
226 | void handle_shut_down_instance_replayer(int r); | |
227 | ||
228 | void shut_down_remote_status_updater(); | |
229 | void handle_shut_down_remote_status_updater(int r); | |
230 | ||
231 | void shut_down_local_status_updater(); | |
232 | void handle_shut_down_local_status_updater(int r); | |
233 | ||
234 | void init_image_map(Context *on_finish); | |
235 | void handle_init_image_map(int r, ImageMap<ImageCtxT> *image_map, | |
236 | Context *on_finish); | |
237 | ||
238 | void init_local_pool_watcher(Context *on_finish); | |
239 | void handle_init_local_pool_watcher(int r, Context *on_finish); | |
240 | ||
241 | void init_remote_pool_watcher(Context *on_finish); | |
242 | void handle_init_remote_pool_watcher(int r, Context *on_finish); | |
243 | ||
244 | void init_image_deleter(Context* on_finish); | |
245 | void handle_init_image_deleter(int r, Context* on_finish); | |
246 | ||
247 | void shut_down_image_deleter(Context* on_finish); | |
248 | void handle_shut_down_image_deleter(int r, Context* on_finish); | |
249 | ||
250 | void shut_down_pool_watchers(Context *on_finish); | |
251 | void handle_shut_down_pool_watchers(int r, Context *on_finish); | |
252 | ||
253 | void shut_down_image_map(Context *on_finish); | |
254 | void handle_shut_down_image_map(int r, Context *on_finish); | |
255 | ||
256 | void handle_acquire_image(const std::string &global_image_id, | |
257 | const std::string &instance_id, | |
258 | Context* on_finish); | |
259 | void handle_release_image(const std::string &global_image_id, | |
260 | const std::string &instance_id, | |
261 | Context* on_finish); | |
262 | void handle_remove_image(const std::string &mirror_uuid, | |
263 | const std::string &global_image_id, | |
264 | const std::string &instance_id, | |
265 | Context* on_finish); | |
266 | ||
267 | std::string m_namespace_name; | |
268 | librados::IoCtx m_local_io_ctx; | |
269 | librados::IoCtx m_remote_io_ctx; | |
270 | std::string m_local_mirror_uuid; | |
271 | std::string m_local_mirror_peer_uuid; | |
272 | RemotePoolMeta m_remote_pool_meta; | |
273 | Threads<ImageCtxT> *m_threads; | |
274 | Throttler<ImageCtxT> *m_image_sync_throttler; | |
275 | Throttler<ImageCtxT> *m_image_deletion_throttler; | |
276 | ServiceDaemon<ImageCtxT> *m_service_daemon; | |
277 | journal::CacheManagerHandler *m_cache_manager_handler; | |
278 | PoolMetaCache* m_pool_meta_cache; | |
279 | ||
280 | mutable ceph::mutex m_lock; | |
281 | ||
282 | int m_ret_val = 0; | |
283 | Context *m_on_finish = nullptr; | |
284 | ||
285 | std::unique_ptr<MirrorStatusUpdater<ImageCtxT>> m_local_status_updater; | |
286 | std::unique_ptr<MirrorStatusUpdater<ImageCtxT>> m_remote_status_updater; | |
287 | ||
288 | PoolWatcherListener m_local_pool_watcher_listener; | |
289 | std::unique_ptr<PoolWatcher<ImageCtxT>> m_local_pool_watcher; | |
290 | ||
291 | PoolWatcherListener m_remote_pool_watcher_listener; | |
292 | std::unique_ptr<PoolWatcher<ImageCtxT>> m_remote_pool_watcher; | |
293 | ||
294 | std::unique_ptr<InstanceReplayer<ImageCtxT>> m_instance_replayer; | |
295 | std::unique_ptr<ImageDeleter<ImageCtxT>> m_image_deleter; | |
296 | ||
297 | ImageMapListener m_image_map_listener; | |
298 | std::unique_ptr<ImageMap<ImageCtxT>> m_image_map; | |
299 | ||
300 | std::unique_ptr<InstanceWatcher<ImageCtxT>> m_instance_watcher; | |
301 | }; | |
302 | ||
303 | } // namespace mirror | |
304 | } // namespace rbd | |
305 | ||
306 | extern template class rbd::mirror::NamespaceReplayer<librbd::ImageCtx>; | |
307 | ||
308 | #endif // CEPH_RBD_MIRROR_NAMESPACE_REPLAYER_H |