[ceph.git] / ceph / src / librbd / WatchNotifyTypes.h

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef LIBRBD_WATCH_NOTIFY_TYPES_H
#define LIBRBD_WATCH_NOTIFY_TYPES_H

#include "cls/rbd/cls_rbd_types.h"
#include "include/int_types.h"
#include "include/buffer_fwd.h"
#include "include/encoding.h"
#include "librbd/watcher/Types.h"
#include <iosfwd>
#include <list>
#include <string>
#include <boost/variant.hpp>

namespace ceph {
class Formatter;
}

namespace librbd {
namespace watch_notify {

using librbd::watcher::ClientId;

WRITE_CLASS_ENCODER(ClientId);

struct AsyncRequestId {
  ClientId client_id;
  uint64_t request_id;

  AsyncRequestId() : request_id() {}
  AsyncRequestId(const ClientId &client_id_, uint64_t request_id_)
    : client_id(client_id_), request_id(request_id_) {}

  void encode(bufferlist& bl) const;
  void decode(bufferlist::iterator& it);
  void dump(Formatter *f) const;

  inline bool operator<(const AsyncRequestId &rhs) const {
    if (client_id != rhs.client_id) {
      return client_id < rhs.client_id;
    } else {
      return request_id < rhs.request_id;
    }
  }
  inline bool operator!=(const AsyncRequestId &rhs) const {
    return (client_id != rhs.client_id || request_id != rhs.request_id);
  }
};

enum NotifyOp {
  NOTIFY_OP_ACQUIRED_LOCK      = 0,
  NOTIFY_OP_RELEASED_LOCK      = 1,
  NOTIFY_OP_REQUEST_LOCK       = 2,
  NOTIFY_OP_HEADER_UPDATE      = 3,
  NOTIFY_OP_ASYNC_PROGRESS     = 4,
  NOTIFY_OP_ASYNC_COMPLETE     = 5,
  NOTIFY_OP_FLATTEN            = 6,
  NOTIFY_OP_RESIZE             = 7,
  NOTIFY_OP_SNAP_CREATE        = 8,
  NOTIFY_OP_SNAP_REMOVE        = 9,
  NOTIFY_OP_REBUILD_OBJECT_MAP = 10,
  NOTIFY_OP_SNAP_RENAME        = 11,
  NOTIFY_OP_SNAP_PROTECT       = 12,
  NOTIFY_OP_SNAP_UNPROTECT     = 13,
  NOTIFY_OP_RENAME             = 14,
  NOTIFY_OP_UPDATE_FEATURES    = 15,
};

struct AcquiredLockPayload {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_ACQUIRED_LOCK;
  static const bool CHECK_FOR_REFRESH = false;

  ClientId client_id;

  AcquiredLockPayload() {}
  AcquiredLockPayload(const ClientId &client_id_) : client_id(client_id_) {}

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct ReleasedLockPayload {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_RELEASED_LOCK;
  static const bool CHECK_FOR_REFRESH = false;

  ClientId client_id;

  ReleasedLockPayload() {}
  ReleasedLockPayload(const ClientId &client_id_) : client_id(client_id_) {}

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct RequestLockPayload {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_REQUEST_LOCK;
  static const bool CHECK_FOR_REFRESH = false;

  ClientId client_id;
  bool force = false;

  RequestLockPayload() {}
  RequestLockPayload(const ClientId &client_id_, bool force_)
    : client_id(client_id_), force(force_) {
  }

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct HeaderUpdatePayload {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_HEADER_UPDATE;
  static const bool CHECK_FOR_REFRESH = false;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct AsyncRequestPayloadBase {
public:
  AsyncRequestId async_request_id;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;

protected:
  AsyncRequestPayloadBase() {}
  AsyncRequestPayloadBase(const AsyncRequestId &id) : async_request_id(id) {}
};

struct AsyncProgressPayload : public AsyncRequestPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_ASYNC_PROGRESS;
  static const bool CHECK_FOR_REFRESH = false;

  AsyncProgressPayload() : offset(0), total(0) {}
  AsyncProgressPayload(const AsyncRequestId &id, uint64_t offset_, uint64_t total_)
    : AsyncRequestPayloadBase(id), offset(offset_), total(total_) {}

  uint64_t offset;
  uint64_t total;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct AsyncCompletePayload : public AsyncRequestPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_ASYNC_COMPLETE;
  static const bool CHECK_FOR_REFRESH = false;

  AsyncCompletePayload() : result(0) {}
  AsyncCompletePayload(const AsyncRequestId &id, int r)
    : AsyncRequestPayloadBase(id), result(r) {}

  int result;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct FlattenPayload : public AsyncRequestPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_FLATTEN;
  static const bool CHECK_FOR_REFRESH = true;

  FlattenPayload() {}
  FlattenPayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}
};

struct ResizePayload : public AsyncRequestPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_RESIZE;
  static const bool CHECK_FOR_REFRESH = true;

  ResizePayload() : size(0), allow_shrink(true) {}
  ResizePayload(uint64_t size_, bool allow_shrink_, const AsyncRequestId &id)
    : AsyncRequestPayloadBase(id), size(size_), allow_shrink(allow_shrink_) {}

  uint64_t size;
  bool allow_shrink;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct SnapPayloadBase {
public:
  static const bool CHECK_FOR_REFRESH = true;

  cls::rbd::SnapshotNamespace snap_namespace;
  std::string snap_name;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;

protected:
  SnapPayloadBase() {}
  SnapPayloadBase(const cls::rbd::SnapshotNamespace& _snap_namespace,
		  const std::string &name)
    : snap_namespace(_snap_namespace), snap_name(name) {}
};

struct SnapCreatePayload : public SnapPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_CREATE;

  SnapCreatePayload() {}
  SnapCreatePayload(const cls::rbd::SnapshotNamespace &_snap_namespace,
		    const std::string &name)
    : SnapPayloadBase(_snap_namespace, name) {}

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct SnapRenamePayload : public SnapPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_RENAME;

  SnapRenamePayload() {}
  SnapRenamePayload(const uint64_t &src_snap_id,
		    const std::string &dst_name)
    : SnapPayloadBase(cls::rbd::UserSnapshotNamespace(), dst_name), snap_id(src_snap_id) {}

  uint64_t snap_id;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct SnapRemovePayload : public SnapPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_REMOVE;

  SnapRemovePayload() {}
  SnapRemovePayload(const cls::rbd::SnapshotNamespace& snap_namespace,
		    const std::string &name)
    : SnapPayloadBase(snap_namespace, name) {}
};

struct SnapProtectPayload : public SnapPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_PROTECT;

  SnapProtectPayload() {}
  SnapProtectPayload(const cls::rbd::SnapshotNamespace& snap_namespace,
		     const std::string &name)
    : SnapPayloadBase(snap_namespace, name) {}
};

struct SnapUnprotectPayload : public SnapPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_UNPROTECT;

  SnapUnprotectPayload() {}
  SnapUnprotectPayload(const cls::rbd::SnapshotNamespace& snap_namespace,
		       const std::string &name)
    : SnapPayloadBase(snap_namespace, name) {}
};

struct RebuildObjectMapPayload : public AsyncRequestPayloadBase {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_REBUILD_OBJECT_MAP;
  static const bool CHECK_FOR_REFRESH = true;

  RebuildObjectMapPayload() {}
  RebuildObjectMapPayload(const AsyncRequestId &id)
    : AsyncRequestPayloadBase(id) {}
};

struct RenamePayload {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_RENAME;
  static const bool CHECK_FOR_REFRESH = true;

  RenamePayload() {}
  RenamePayload(const std::string _image_name) : image_name(_image_name) {}

  std::string image_name;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct UpdateFeaturesPayload {
  static const NotifyOp NOTIFY_OP = NOTIFY_OP_UPDATE_FEATURES;
  static const bool CHECK_FOR_REFRESH = true;

  UpdateFeaturesPayload() : features(0), enabled(false) {}
  UpdateFeaturesPayload(uint64_t features_, bool enabled_)
    : features(features_), enabled(enabled_) {}

  uint64_t features;
  bool enabled;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

struct UnknownPayload {
  static const NotifyOp NOTIFY_OP = static_cast<NotifyOp>(-1);
  static const bool CHECK_FOR_REFRESH = false;

  void encode(bufferlist &bl) const;
  void decode(__u8 version, bufferlist::iterator &iter);
  void dump(Formatter *f) const;
};

typedef boost::variant<AcquiredLockPayload,
                       ReleasedLockPayload,
                       RequestLockPayload,
                       HeaderUpdatePayload,
                       AsyncProgressPayload,
                       AsyncCompletePayload,
                       FlattenPayload,
                       ResizePayload,
                       SnapCreatePayload,
                       SnapRemovePayload,
                       SnapRenamePayload,
                       SnapProtectPayload,
                       SnapUnprotectPayload,
                       RebuildObjectMapPayload,
                       RenamePayload,
                       UpdateFeaturesPayload,
                       UnknownPayload> Payload;

struct NotifyMessage {
  NotifyMessage() : payload(UnknownPayload()) {}
  NotifyMessage(const Payload &payload_) : payload(payload_) {}

  Payload payload;

  bool check_for_refresh() const;

  void encode(bufferlist& bl) const;
  void decode(bufferlist::iterator& it);
  void dump(Formatter *f) const;

  static void generate_test_instances(std::list<NotifyMessage *> &o);
};

struct ResponseMessage {
  ResponseMessage() : result(0) {}
  ResponseMessage(int result_) : result(result_) {}

  int result;

  void encode(bufferlist& bl) const;
  void decode(bufferlist::iterator& it);
  void dump(Formatter *f) const;

  static void generate_test_instances(std::list<ResponseMessage *> &o);
};

} // namespace watch_notify
} // namespace librbd

std::ostream &operator<<(std::ostream &out,
                         const librbd::watch_notify::NotifyOp &op);
std::ostream &operator<<(std::ostream &out,
                         const librbd::watch_notify::AsyncRequestId &request);

WRITE_CLASS_ENCODER(librbd::watch_notify::AsyncRequestId);
WRITE_CLASS_ENCODER(librbd::watch_notify::NotifyMessage);
WRITE_CLASS_ENCODER(librbd::watch_notify::ResponseMessage);

#endif // LIBRBD_WATCH_NOTIFY_TYPES_H
Commit	Line	Data
7c673cae FG	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
	5
	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"
	11	#include <iosfwd>
	12	#include <list>
	13	#include <string>
	14	#include <boost/variant.hpp>
	15
	16	namespace ceph {
	17	class Formatter;
	18	}
	19
	20	namespace librbd {
	21	namespace watch_notify {
	22
	23	using librbd::watcher::ClientId;
	24
	25	WRITE_CLASS_ENCODER(ClientId);
	26
	27	struct AsyncRequestId {
	28	ClientId client_id;
	29	uint64_t request_id;
	30
	31	AsyncRequestId() : request_id() {}
	32	AsyncRequestId(const ClientId &client_id_, uint64_t request_id_)
	33	: client_id(client_id_), request_id(request_id_) {}
	34
	35	void encode(bufferlist& bl) const;
	36	void decode(bufferlist::iterator& it);
	37	void dump(Formatter *f) const;
	38
	39	inline bool operator<(const AsyncRequestId &rhs) const {
	40	if (client_id != rhs.client_id) {
	41	return client_id < rhs.client_id;
	42	} else {
	43	return request_id < rhs.request_id;
	44	}
	45	}
	46	inline bool operator!=(const AsyncRequestId &rhs) const {
	47	return (client_id != rhs.client_id \|\| request_id != rhs.request_id);
	48	}
	49	};
	50
	51	enum NotifyOp {
	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,
	59	NOTIFY_OP_RESIZE = 7,
	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,
68	};
69
70	struct AcquiredLockPayload {
71	static const NotifyOp NOTIFY_OP = NOTIFY_OP_ACQUIRED_LOCK;
72	static const bool CHECK_FOR_REFRESH = false;
73
74	ClientId client_id;
75
76	AcquiredLockPayload() {}
77	AcquiredLockPayload(const ClientId &client_id_) : client_id(client_id_) {}
78
79	void encode(bufferlist &bl) const;
80	void decode(__u8 version, bufferlist::iterator &iter);
81	void dump(Formatter *f) const;
82	};
83
84	struct ReleasedLockPayload {
85	static const NotifyOp NOTIFY_OP = NOTIFY_OP_RELEASED_LOCK;
86	static const bool CHECK_FOR_REFRESH = false;
87
88	ClientId client_id;
89
90	ReleasedLockPayload() {}
91	ReleasedLockPayload(const ClientId &client_id_) : client_id(client_id_) {}
92
93	void encode(bufferlist &bl) const;
94	void decode(__u8 version, bufferlist::iterator &iter);
95	void dump(Formatter *f) const;
96	};
97
98	struct RequestLockPayload {
99	static const NotifyOp NOTIFY_OP = NOTIFY_OP_REQUEST_LOCK;
100	static const bool CHECK_FOR_REFRESH = false;
101
102	ClientId client_id;
103	bool force = false;
104
105	RequestLockPayload() {}
106	RequestLockPayload(const ClientId &client_id_, bool force_)
107	: client_id(client_id_), force(force_) {
108	}
109
110	void encode(bufferlist &bl) const;
111	void decode(__u8 version, bufferlist::iterator &iter);
112	void dump(Formatter *f) const;
113	};
114
115	struct HeaderUpdatePayload {
116	static const NotifyOp NOTIFY_OP = NOTIFY_OP_HEADER_UPDATE;
117	static const bool CHECK_FOR_REFRESH = false;
118
119	void encode(bufferlist &bl) const;
120	void decode(__u8 version, bufferlist::iterator &iter);
121	void dump(Formatter *f) const;
122	};
123
124	struct AsyncRequestPayloadBase {
125	public:
126	AsyncRequestId async_request_id;
127
128	void encode(bufferlist &bl) const;
129	void decode(__u8 version, bufferlist::iterator &iter);
130	void dump(Formatter *f) const;
131
132	protected:
133	AsyncRequestPayloadBase() {}
134	AsyncRequestPayloadBase(const AsyncRequestId &id) : async_request_id(id) {}
135	};
136
137	struct AsyncProgressPayload : public AsyncRequestPayloadBase {
138	static const NotifyOp NOTIFY_OP = NOTIFY_OP_ASYNC_PROGRESS;
139	static const bool CHECK_FOR_REFRESH = false;
140
141	AsyncProgressPayload() : offset(0), total(0) {}
142	AsyncProgressPayload(const AsyncRequestId &id, uint64_t offset_, uint64_t total_)
143	: AsyncRequestPayloadBase(id), offset(offset_), total(total_) {}
144
145	uint64_t offset;
146	uint64_t total;
147
148	void encode(bufferlist &bl) const;
149	void decode(__u8 version, bufferlist::iterator &iter);
150	void dump(Formatter *f) const;
151	};
152
153	struct AsyncCompletePayload : public AsyncRequestPayloadBase {
154	static const NotifyOp NOTIFY_OP = NOTIFY_OP_ASYNC_COMPLETE;
155	static const bool CHECK_FOR_REFRESH = false;
156
157	AsyncCompletePayload() : result(0) {}
158	AsyncCompletePayload(const AsyncRequestId &id, int r)
159	: AsyncRequestPayloadBase(id), result(r) {}
160
161	int result;
162
163	void encode(bufferlist &bl) const;
164	void decode(__u8 version, bufferlist::iterator &iter);
165	void dump(Formatter *f) const;
166	};
167
168	struct FlattenPayload : public AsyncRequestPayloadBase {
169	static const NotifyOp NOTIFY_OP = NOTIFY_OP_FLATTEN;
170	static const bool CHECK_FOR_REFRESH = true;
171
172	FlattenPayload() {}
173	FlattenPayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {}
174	};
175
176	struct ResizePayload : public AsyncRequestPayloadBase {
177	static const NotifyOp NOTIFY_OP = NOTIFY_OP_RESIZE;
178	static const bool CHECK_FOR_REFRESH = true;
179
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_) {}
183
184	uint64_t size;
185	bool allow_shrink;
186
187	void encode(bufferlist &bl) const;
188	void decode(__u8 version, bufferlist::iterator &iter);
189	void dump(Formatter *f) const;
190	};
191
192	struct SnapPayloadBase {
193	public:
194	static const bool CHECK_FOR_REFRESH = true;
195
196	cls::rbd::SnapshotNamespace snap_namespace;
197	std::string snap_name;
198
199	void encode(bufferlist &bl) const;
200	void decode(__u8 version, bufferlist::iterator &iter);
201	void dump(Formatter *f) const;
202
203	protected:
204	SnapPayloadBase() {}
205	SnapPayloadBase(const cls::rbd::SnapshotNamespace& _snap_namespace,
206	const std::string &name)
207	: snap_namespace(_snap_namespace), snap_name(name) {}
208	};
209
210	struct SnapCreatePayload : public SnapPayloadBase {
211	static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_CREATE;
212
213	SnapCreatePayload() {}
214	SnapCreatePayload(const cls::rbd::SnapshotNamespace &_snap_namespace,
215	const std::string &name)
216	: SnapPayloadBase(_snap_namespace, name) {}
217
218	void encode(bufferlist &bl) const;
219	void decode(__u8 version, bufferlist::iterator &iter);
220	void dump(Formatter *f) const;
221	};
222
223	struct SnapRenamePayload : public SnapPayloadBase {
224	static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_RENAME;
225
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) {}
230
231	uint64_t snap_id;
232
233	void encode(bufferlist &bl) const;
234	void decode(__u8 version, bufferlist::iterator &iter);
235	void dump(Formatter *f) const;
236	};
237
238	struct SnapRemovePayload : public SnapPayloadBase {
239	static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_REMOVE;
240
241	SnapRemovePayload() {}
242	SnapRemovePayload(const cls::rbd::SnapshotNamespace& snap_namespace,
243	const std::string &name)
244	: SnapPayloadBase(snap_namespace, name) {}
245	};
246
247	struct SnapProtectPayload : public SnapPayloadBase {
248	static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_PROTECT;
249
250	SnapProtectPayload() {}
251	SnapProtectPayload(const cls::rbd::SnapshotNamespace& snap_namespace,
252	const std::string &name)
253	: SnapPayloadBase(snap_namespace, name) {}
254	};
255
256	struct SnapUnprotectPayload : public SnapPayloadBase {
257	static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_UNPROTECT;
258
259	SnapUnprotectPayload() {}
260	SnapUnprotectPayload(const cls::rbd::SnapshotNamespace& snap_namespace,
261	const std::string &name)
262	: SnapPayloadBase(snap_namespace, name) {}
263	};
264
265	struct RebuildObjectMapPayload : public AsyncRequestPayloadBase {
266	static const NotifyOp NOTIFY_OP = NOTIFY_OP_REBUILD_OBJECT_MAP;
267	static const bool CHECK_FOR_REFRESH = true;
268
269	RebuildObjectMapPayload() {}
270	RebuildObjectMapPayload(const AsyncRequestId &id)
271	: AsyncRequestPayloadBase(id) {}
272	};
273
274	struct RenamePayload {
275	static const NotifyOp NOTIFY_OP = NOTIFY_OP_RENAME;
276	static const bool CHECK_FOR_REFRESH = true;
277
278	RenamePayload() {}
279	RenamePayload(const std::string _image_name) : image_name(_image_name) {}
280
281	std::string image_name;
282
283	void encode(bufferlist &bl) const;
284	void decode(__u8 version, bufferlist::iterator &iter);
285	void dump(Formatter *f) const;
286	};
287
288	struct UpdateFeaturesPayload {
289	static const NotifyOp NOTIFY_OP = NOTIFY_OP_UPDATE_FEATURES;
290	static const bool CHECK_FOR_REFRESH = true;
291
292	UpdateFeaturesPayload() : features(0), enabled(false) {}
293	UpdateFeaturesPayload(uint64_t features_, bool enabled_)
294	: features(features_), enabled(enabled_) {}
295
296	uint64_t features;
297	bool enabled;
298
299	void encode(bufferlist &bl) const;
300	void decode(__u8 version, bufferlist::iterator &iter);
301	void dump(Formatter *f) const;
302	};
303
304	struct UnknownPayload {
305	static const NotifyOp NOTIFY_OP = static_cast<NotifyOp>(-1);
306	static const bool CHECK_FOR_REFRESH = false;
307
308	void encode(bufferlist &bl) const;
309	void decode(__u8 version, bufferlist::iterator &iter);
310	void dump(Formatter *f) const;
311	};
312
313	typedef boost::variant<AcquiredLockPayload,
314	ReleasedLockPayload,
315	RequestLockPayload,
316	HeaderUpdatePayload,
317	AsyncProgressPayload,
318	AsyncCompletePayload,
319	FlattenPayload,
320	ResizePayload,
321	SnapCreatePayload,
322	SnapRemovePayload,
323	SnapRenamePayload,
324	SnapProtectPayload,
325	SnapUnprotectPayload,
326	RebuildObjectMapPayload,
327	RenamePayload,
328	UpdateFeaturesPayload,
329	UnknownPayload> Payload;
330
331	struct NotifyMessage {
332	NotifyMessage() : payload(UnknownPayload()) {}
333	NotifyMessage(const Payload &payload_) : payload(payload_) {}
334
335	Payload payload;
336
337	bool check_for_refresh() const;
338
339	void encode(bufferlist& bl) const;
340	void decode(bufferlist::iterator& it);
341	void dump(Formatter *f) const;
342
343	static void generate_test_instances(std::list<NotifyMessage *> &o);
344	};
345
346	struct ResponseMessage {
347	ResponseMessage() : result(0) {}
348	ResponseMessage(int result_) : result(result_) {}
349
350	int result;
351
352	void encode(bufferlist& bl) const;
353	void decode(bufferlist::iterator& it);
354	void dump(Formatter *f) const;
355
356	static void generate_test_instances(std::list<ResponseMessage *> &o);
357	};
358
359	} // namespace watch_notify
360	} // namespace librbd
361
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);
366
367	WRITE_CLASS_ENCODER(librbd::watch_notify::AsyncRequestId);
368	WRITE_CLASS_ENCODER(librbd::watch_notify::NotifyMessage);
369	WRITE_CLASS_ENCODER(librbd::watch_notify::ResponseMessage);
370
371	#endif // LIBRBD_WATCH_NOTIFY_TYPES_H