1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
3 #ifndef LIBRBD_WATCH_NOTIFY_TYPES_H
4 #define LIBRBD_WATCH_NOTIFY_TYPES_H
6 #include "cls/rbd/cls_rbd_types.h"
7 #include "include/int_types.h"
8 #include "include/buffer_fwd.h"
9 #include "include/encoding.h"
10 #include "librbd/watcher/Types.h"
14 #include <boost/variant.hpp>
21 namespace watch_notify {
23 using librbd::watcher::ClientId;
25 WRITE_CLASS_ENCODER(ClientId);
27 struct AsyncRequestId {
31 AsyncRequestId() : request_id() {}
32 AsyncRequestId(const ClientId &client_id_, uint64_t request_id_)
33 : client_id(client_id_), request_id(request_id_) {}
35 void encode(bufferlist& bl) const;
36 void decode(bufferlist::iterator& it);
37 void dump(Formatter *f) const;
39 inline bool operator<(const AsyncRequestId &rhs) const {
40 if (client_id != rhs.client_id) {
41 return client_id < rhs.client_id;
43 return request_id < rhs.request_id;
46 inline bool operator!=(const AsyncRequestId &rhs) const {
47 return (client_id != rhs.client_id || request_id != rhs.request_id);
52 NOTIFY_OP_ACQUIRED_LOCK = 0,
53 NOTIFY_OP_RELEASED_LOCK = 1,
54 NOTIFY_OP_REQUEST_LOCK = 2,
55 NOTIFY_OP_HEADER_UPDATE = 3,
56 NOTIFY_OP_ASYNC_PROGRESS = 4,
57 NOTIFY_OP_ASYNC_COMPLETE = 5,
58 NOTIFY_OP_FLATTEN = 6,
60 NOTIFY_OP_SNAP_CREATE = 8,
61 NOTIFY_OP_SNAP_REMOVE = 9,
62 NOTIFY_OP_REBUILD_OBJECT_MAP = 10,
63 NOTIFY_OP_SNAP_RENAME = 11,
64 NOTIFY_OP_SNAP_PROTECT = 12,
65 NOTIFY_OP_SNAP_UNPROTECT = 13,
66 NOTIFY_OP_RENAME = 14,
67 NOTIFY_OP_UPDATE_FEATURES = 15,
70 struct AcquiredLockPayload {
71 static const NotifyOp NOTIFY_OP = NOTIFY_OP_ACQUIRED_LOCK;
72 static const bool CHECK_FOR_REFRESH = false;
76 AcquiredLockPayload() {}
77 AcquiredLockPayload(const ClientId &client_id_) : client_id(client_id_) {}
79 void encode(bufferlist &bl) const;
80 void decode(__u8 version, bufferlist::iterator &iter);
81 void dump(Formatter *f) const;
84 struct ReleasedLockPayload {
85 static const NotifyOp NOTIFY_OP = NOTIFY_OP_RELEASED_LOCK;
86 static const bool CHECK_FOR_REFRESH = false;
90 ReleasedLockPayload() {}
91 ReleasedLockPayload(const ClientId &client_id_) : client_id(client_id_) {}
93 void encode(bufferlist &bl) const;
94 void decode(__u8 version, bufferlist::iterator &iter);
95 void dump(Formatter *f) const;
98 struct RequestLockPayload {
99 static const NotifyOp NOTIFY_OP = NOTIFY_OP_REQUEST_LOCK;
100 static const bool CHECK_FOR_REFRESH = false;
105 RequestLockPayload() {}
106 RequestLockPayload(const ClientId &client_id_, bool force_)
107 : client_id(client_id_), force(force_) {
110 void encode(bufferlist &bl) const;
111 void decode(__u8 version, bufferlist::iterator &iter);
112 void dump(Formatter *f) const;
115 struct HeaderUpdatePayload {
116 static const NotifyOp NOTIFY_OP = NOTIFY_OP_HEADER_UPDATE;
117 static const bool CHECK_FOR_REFRESH = false;
119 void encode(bufferlist &bl) const;
120 void decode(__u8 version, bufferlist::iterator &iter);
121 void dump(Formatter *f) const;
124 struct AsyncRequestPayloadBase {
126 AsyncRequestId async_request_id;
128 void encode(bufferlist &bl) const;
129 void decode(__u8 version, bufferlist::iterator &iter);
130 void dump(Formatter *f) const;
133 AsyncRequestPayloadBase() {}
134 AsyncRequestPayloadBase(const AsyncRequestId &id) : async_request_id(id) {}
137 struct AsyncProgressPayload : public AsyncRequestPayloadBase {
138 static const NotifyOp NOTIFY_OP = NOTIFY_OP_ASYNC_PROGRESS;
139 static const bool CHECK_FOR_REFRESH = false;
141 AsyncProgressPayload() : offset(0), total(0) {}
142 AsyncProgressPayload(const AsyncRequestId &id, uint64_t offset_, uint64_t total_)
143 : AsyncRequestPayloadBase(id), offset(offset_), total(total_) {}
148 void encode(bufferlist &bl) const;
149 void decode(__u8 version, bufferlist::iterator &iter);
150 void dump(Formatter *f) const;
153 struct AsyncCompletePayload : public AsyncRequestPayloadBase {
154 static const NotifyOp NOTIFY_OP = NOTIFY_OP_ASYNC_COMPLETE;
155 static const bool CHECK_FOR_REFRESH = false;
157 AsyncCompletePayload() : result(0) {}
158 AsyncCompletePayload(const AsyncRequestId &id, int r)
159 : AsyncRequestPayloadBase(id), result(r) {}
163 void encode(bufferlist &bl) const;
164 void decode(__u8 version, bufferlist::iterator &iter);
165 void dump(Formatter *f) const;
168 struct FlattenPayload : public AsyncRequestPayloadBase {
169 static const NotifyOp NOTIFY_OP = NOTIFY_OP_FLATTEN;
170 static const bool CHECK_FOR_REFRESH = true;
173 FlattenPayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}
176 struct ResizePayload : public AsyncRequestPayloadBase {
177 static const NotifyOp NOTIFY_OP = NOTIFY_OP_RESIZE;
178 static const bool CHECK_FOR_REFRESH = true;
180 ResizePayload() : size(0), allow_shrink(true) {}
181 ResizePayload(uint64_t size_, bool allow_shrink_, const AsyncRequestId &id)
182 : AsyncRequestPayloadBase(id), size(size_), allow_shrink(allow_shrink_) {}
187 void encode(bufferlist &bl) const;
188 void decode(__u8 version, bufferlist::iterator &iter);
189 void dump(Formatter *f) const;
192 struct SnapPayloadBase {
194 static const bool CHECK_FOR_REFRESH = true;
196 cls::rbd::SnapshotNamespace snap_namespace;
197 std::string snap_name;
199 void encode(bufferlist &bl) const;
200 void decode(__u8 version, bufferlist::iterator &iter);
201 void dump(Formatter *f) const;
205 SnapPayloadBase(const cls::rbd::SnapshotNamespace& _snap_namespace,
206 const std::string &name)
207 : snap_namespace(_snap_namespace), snap_name(name) {}
210 struct SnapCreatePayload : public SnapPayloadBase {
211 static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_CREATE;
213 SnapCreatePayload() {}
214 SnapCreatePayload(const cls::rbd::SnapshotNamespace &_snap_namespace,
215 const std::string &name)
216 : SnapPayloadBase(_snap_namespace, name) {}
218 void encode(bufferlist &bl) const;
219 void decode(__u8 version, bufferlist::iterator &iter);
220 void dump(Formatter *f) const;
223 struct SnapRenamePayload : public SnapPayloadBase {
224 static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_RENAME;
226 SnapRenamePayload() {}
227 SnapRenamePayload(const uint64_t &src_snap_id,
228 const std::string &dst_name)
229 : SnapPayloadBase(cls::rbd::UserSnapshotNamespace(), dst_name), snap_id(src_snap_id) {}
233 void encode(bufferlist &bl) const;
234 void decode(__u8 version, bufferlist::iterator &iter);
235 void dump(Formatter *f) const;
238 struct SnapRemovePayload : public SnapPayloadBase {
239 static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_REMOVE;
241 SnapRemovePayload() {}
242 SnapRemovePayload(const cls::rbd::SnapshotNamespace& snap_namespace,
243 const std::string &name)
244 : SnapPayloadBase(snap_namespace, name) {}
247 struct SnapProtectPayload : public SnapPayloadBase {
248 static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_PROTECT;
250 SnapProtectPayload() {}
251 SnapProtectPayload(const cls::rbd::SnapshotNamespace& snap_namespace,
252 const std::string &name)
253 : SnapPayloadBase(snap_namespace, name) {}
256 struct SnapUnprotectPayload : public SnapPayloadBase {
257 static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_UNPROTECT;
259 SnapUnprotectPayload() {}
260 SnapUnprotectPayload(const cls::rbd::SnapshotNamespace& snap_namespace,
261 const std::string &name)
262 : SnapPayloadBase(snap_namespace, name) {}
265 struct RebuildObjectMapPayload : public AsyncRequestPayloadBase {
266 static const NotifyOp NOTIFY_OP = NOTIFY_OP_REBUILD_OBJECT_MAP;
267 static const bool CHECK_FOR_REFRESH = true;
269 RebuildObjectMapPayload() {}
270 RebuildObjectMapPayload(const AsyncRequestId &id)
271 : AsyncRequestPayloadBase(id) {}
274 struct RenamePayload {
275 static const NotifyOp NOTIFY_OP = NOTIFY_OP_RENAME;
276 static const bool CHECK_FOR_REFRESH = true;
279 RenamePayload(const std::string _image_name) : image_name(_image_name) {}
281 std::string image_name;
283 void encode(bufferlist &bl) const;
284 void decode(__u8 version, bufferlist::iterator &iter);
285 void dump(Formatter *f) const;
288 struct UpdateFeaturesPayload {
289 static const NotifyOp NOTIFY_OP = NOTIFY_OP_UPDATE_FEATURES;
290 static const bool CHECK_FOR_REFRESH = true;
292 UpdateFeaturesPayload() : features(0), enabled(false) {}
293 UpdateFeaturesPayload(uint64_t features_, bool enabled_)
294 : features(features_), enabled(enabled_) {}
299 void encode(bufferlist &bl) const;
300 void decode(__u8 version, bufferlist::iterator &iter);
301 void dump(Formatter *f) const;
304 struct UnknownPayload {
305 static const NotifyOp NOTIFY_OP = static_cast<NotifyOp>(-1);
306 static const bool CHECK_FOR_REFRESH = false;
308 void encode(bufferlist &bl) const;
309 void decode(__u8 version, bufferlist::iterator &iter);
310 void dump(Formatter *f) const;
313 typedef boost::variant<AcquiredLockPayload,
317 AsyncProgressPayload,
318 AsyncCompletePayload,
325 SnapUnprotectPayload,
326 RebuildObjectMapPayload,
328 UpdateFeaturesPayload,
329 UnknownPayload> Payload;
331 struct NotifyMessage {
332 NotifyMessage() : payload(UnknownPayload()) {}
333 NotifyMessage(const Payload &payload_) : payload(payload_) {}
337 bool check_for_refresh() const;
339 void encode(bufferlist& bl) const;
340 void decode(bufferlist::iterator& it);
341 void dump(Formatter *f) const;
343 static void generate_test_instances(std::list<NotifyMessage *> &o);
346 struct ResponseMessage {
347 ResponseMessage() : result(0) {}
348 ResponseMessage(int result_) : result(result_) {}
352 void encode(bufferlist& bl) const;
353 void decode(bufferlist::iterator& it);
354 void dump(Formatter *f) const;
356 static void generate_test_instances(std::list<ResponseMessage *> &o);
359 } // namespace watch_notify
360 } // namespace librbd
362 std::ostream &operator<<(std::ostream &out,
363 const librbd::watch_notify::NotifyOp &op);
364 std::ostream &operator<<(std::ostream &out,
365 const librbd::watch_notify::AsyncRequestId &request);
367 WRITE_CLASS_ENCODER(librbd::watch_notify::AsyncRequestId);
368 WRITE_CLASS_ENCODER(librbd::watch_notify::NotifyMessage);
369 WRITE_CLASS_ENCODER(librbd::watch_notify::ResponseMessage);
371 #endif // LIBRBD_WATCH_NOTIFY_TYPES_H