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

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

#include "cls/rbd/cls_rbd_types.h"
#include "common/Formatter.h"
#include "include/assert.h"
#include "include/stringify.h"
#include "librbd/WatchNotifyTypes.h"
#include "librbd/watcher/Utils.h"

namespace librbd {
namespace watch_notify {

namespace {

class CheckForRefreshVisitor  : public boost::static_visitor<bool> {
public:
  template <typename Payload>
  inline bool operator()(const Payload &payload) const {
    return Payload::CHECK_FOR_REFRESH;
  }
};

class DumpPayloadVisitor : public boost::static_visitor<void> {
public:
  explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}

  template <typename Payload>
  inline void operator()(const Payload &payload) const {
    NotifyOp notify_op = Payload::NOTIFY_OP;
    m_formatter->dump_string("notify_op", stringify(notify_op));
    payload.dump(m_formatter);
  }

private:
  ceph::Formatter *m_formatter;
};

} // anonymous namespace

void AsyncRequestId::encode(bufferlist &bl) const {
  ::encode(client_id, bl);
  ::encode(request_id, bl);
}

void AsyncRequestId::decode(bufferlist::iterator &iter) {
  ::decode(client_id, iter);
  ::decode(request_id, iter);
}

void AsyncRequestId::dump(Formatter *f) const {
  f->open_object_section("client_id");
  client_id.dump(f);
  f->close_section();
  f->dump_unsigned("request_id", request_id);
}

void AcquiredLockPayload::encode(bufferlist &bl) const {
  ::encode(client_id, bl);
}

void AcquiredLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
  if (version >= 2) {
    ::decode(client_id, iter);
  }
}

void AcquiredLockPayload::dump(Formatter *f) const {
  f->open_object_section("client_id");
  client_id.dump(f);
  f->close_section();
}

void ReleasedLockPayload::encode(bufferlist &bl) const {
  ::encode(client_id, bl);
}

void ReleasedLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
  if (version >= 2) {
    ::decode(client_id, iter);
  }
}

void ReleasedLockPayload::dump(Formatter *f) const {
  f->open_object_section("client_id");
  client_id.dump(f);
  f->close_section();
}

void RequestLockPayload::encode(bufferlist &bl) const {
  ::encode(client_id, bl);
  ::encode(force, bl);
}

void RequestLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
  if (version >= 2) {
    ::decode(client_id, iter);
  }
  if (version >= 3) {
    ::decode(force, iter);
  }
}

void RequestLockPayload::dump(Formatter *f) const {
  f->open_object_section("client_id");
  client_id.dump(f);
  f->close_section();
  f->dump_bool("force", force);
}

void HeaderUpdatePayload::encode(bufferlist &bl) const {
}

void HeaderUpdatePayload::decode(__u8 version, bufferlist::iterator &iter) {
}

void HeaderUpdatePayload::dump(Formatter *f) const {
}

void AsyncRequestPayloadBase::encode(bufferlist &bl) const {
  ::encode(async_request_id, bl);
}

void AsyncRequestPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
  ::decode(async_request_id, iter);
}

void AsyncRequestPayloadBase::dump(Formatter *f) const {
  f->open_object_section("async_request_id");
  async_request_id.dump(f);
  f->close_section();
}

void AsyncProgressPayload::encode(bufferlist &bl) const {
  AsyncRequestPayloadBase::encode(bl);
  ::encode(offset, bl);
  ::encode(total, bl);
}

void AsyncProgressPayload::decode(__u8 version, bufferlist::iterator &iter) {
  AsyncRequestPayloadBase::decode(version, iter);
  ::decode(offset, iter);
  ::decode(total, iter);
}

void AsyncProgressPayload::dump(Formatter *f) const {
  AsyncRequestPayloadBase::dump(f);
  f->dump_unsigned("offset", offset);
  f->dump_unsigned("total", total);
}

void AsyncCompletePayload::encode(bufferlist &bl) const {
  AsyncRequestPayloadBase::encode(bl);
  ::encode(result, bl);
}

void AsyncCompletePayload::decode(__u8 version, bufferlist::iterator &iter) {
  AsyncRequestPayloadBase::decode(version, iter);
  ::decode(result, iter);
}

void AsyncCompletePayload::dump(Formatter *f) const {
  AsyncRequestPayloadBase::dump(f);
  f->dump_int("result", result);
}

void ResizePayload::encode(bufferlist &bl) const {
  ::encode(size, bl);
  AsyncRequestPayloadBase::encode(bl);
  ::encode(allow_shrink, bl);
}

void ResizePayload::decode(__u8 version, bufferlist::iterator &iter) {
  ::decode(size, iter);
  AsyncRequestPayloadBase::decode(version, iter);

  if (version >= 4) {
    ::decode(allow_shrink, iter);
  }
}

void ResizePayload::dump(Formatter *f) const {
  f->dump_unsigned("size", size);
  f->dump_bool("allow_shrink", allow_shrink);
  AsyncRequestPayloadBase::dump(f);
}

void SnapPayloadBase::encode(bufferlist &bl) const {
  ::encode(snap_name, bl);
  ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl);
}

void SnapPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
  ::decode(snap_name, iter);
  if (version >= 6) {
    cls::rbd::SnapshotNamespaceOnDisk sn;
    ::decode(sn, iter);
    snap_namespace = sn.snapshot_namespace;
  }
}

void SnapPayloadBase::dump(Formatter *f) const {
  f->dump_string("snap_name", snap_name);
  cls::rbd::SnapshotNamespaceOnDisk sn(snap_namespace);
  sn.dump(f);
}

void SnapCreatePayload::encode(bufferlist &bl) const {
  SnapPayloadBase::encode(bl);
}

void SnapCreatePayload::decode(__u8 version, bufferlist::iterator &iter) {
  SnapPayloadBase::decode(version, iter);
  if (version == 5) {
    cls::rbd::SnapshotNamespaceOnDisk sn;
    ::decode(sn, iter);
    snap_namespace = sn.snapshot_namespace;
  }
}

void SnapCreatePayload::dump(Formatter *f) const {
  SnapPayloadBase::dump(f);
}

void SnapRenamePayload::encode(bufferlist &bl) const {
  ::encode(snap_id, bl);
  SnapPayloadBase::encode(bl);
}

void SnapRenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
  ::decode(snap_id, iter);
  SnapPayloadBase::decode(version, iter);
}

void SnapRenamePayload::dump(Formatter *f) const {
  f->dump_unsigned("src_snap_id", snap_id);
  SnapPayloadBase::dump(f);
}

void RenamePayload::encode(bufferlist &bl) const {
  ::encode(image_name, bl);
}

void RenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
  ::decode(image_name, iter);
}

void RenamePayload::dump(Formatter *f) const {
  f->dump_string("image_name", image_name);
}

void UpdateFeaturesPayload::encode(bufferlist &bl) const {
  ::encode(features, bl);
  ::encode(enabled, bl);
}

void UpdateFeaturesPayload::decode(__u8 version, bufferlist::iterator &iter) {
  ::decode(features, iter);
  ::decode(enabled, iter);
}

void UpdateFeaturesPayload::dump(Formatter *f) const {
  f->dump_unsigned("features", features);
  f->dump_bool("enabled", enabled);
}

void UnknownPayload::encode(bufferlist &bl) const {
  assert(false);
}

void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
}

void UnknownPayload::dump(Formatter *f) const {
}

bool NotifyMessage::check_for_refresh() const {
  return boost::apply_visitor(CheckForRefreshVisitor(), payload);
}

void NotifyMessage::encode(bufferlist& bl) const {
  ENCODE_START(6, 1, bl);
  boost::apply_visitor(watcher::util::EncodePayloadVisitor(bl), payload);
  ENCODE_FINISH(bl);
}

void NotifyMessage::decode(bufferlist::iterator& iter) {
  DECODE_START(1, iter);

  uint32_t notify_op;
  ::decode(notify_op, iter);

  // select the correct payload variant based upon the encoded op
  switch (notify_op) {
  case NOTIFY_OP_ACQUIRED_LOCK:
    payload = AcquiredLockPayload();
    break;
  case NOTIFY_OP_RELEASED_LOCK:
    payload = ReleasedLockPayload();
    break;
  case NOTIFY_OP_REQUEST_LOCK:
    payload = RequestLockPayload();
    break;
  case NOTIFY_OP_HEADER_UPDATE:
    payload = HeaderUpdatePayload();
    break;
  case NOTIFY_OP_ASYNC_PROGRESS:
    payload = AsyncProgressPayload();
    break;
  case NOTIFY_OP_ASYNC_COMPLETE:
    payload = AsyncCompletePayload();
    break;
  case NOTIFY_OP_FLATTEN:
    payload = FlattenPayload();
    break;
  case NOTIFY_OP_RESIZE:
    payload = ResizePayload();
    break;
  case NOTIFY_OP_SNAP_CREATE:
    payload = SnapCreatePayload();
    break;
  case NOTIFY_OP_SNAP_REMOVE:
    payload = SnapRemovePayload();
    break;
  case NOTIFY_OP_SNAP_RENAME:
    payload = SnapRenamePayload();
    break;
  case NOTIFY_OP_SNAP_PROTECT:
    payload = SnapProtectPayload();
    break;
  case NOTIFY_OP_SNAP_UNPROTECT:
    payload = SnapUnprotectPayload();
    break;
  case NOTIFY_OP_REBUILD_OBJECT_MAP:
    payload = RebuildObjectMapPayload();
    break;
  case NOTIFY_OP_RENAME:
    payload = RenamePayload();
    break;
  case NOTIFY_OP_UPDATE_FEATURES:
    payload = UpdateFeaturesPayload();
    break;
  default:
    payload = UnknownPayload();
    break;
  }

  apply_visitor(watcher::util::DecodePayloadVisitor(struct_v, iter), payload);
  DECODE_FINISH(iter);
}

void NotifyMessage::dump(Formatter *f) const {
  apply_visitor(DumpPayloadVisitor(f), payload);
}

void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
  o.push_back(new NotifyMessage(AcquiredLockPayload(ClientId(1, 2))));
  o.push_back(new NotifyMessage(ReleasedLockPayload(ClientId(1, 2))));
  o.push_back(new NotifyMessage(RequestLockPayload(ClientId(1, 2), true)));
  o.push_back(new NotifyMessage(HeaderUpdatePayload()));
  o.push_back(new NotifyMessage(AsyncProgressPayload(AsyncRequestId(ClientId(0, 1), 2), 3, 4)));
  o.push_back(new NotifyMessage(AsyncCompletePayload(AsyncRequestId(ClientId(0, 1), 2), 3)));
  o.push_back(new NotifyMessage(FlattenPayload(AsyncRequestId(ClientId(0, 1), 2))));
  o.push_back(new NotifyMessage(ResizePayload(123, true, AsyncRequestId(ClientId(0, 1), 2))));
  o.push_back(new NotifyMessage(SnapCreatePayload(cls::rbd::UserSnapshotNamespace(),
						  "foo")));
  o.push_back(new NotifyMessage(SnapRemovePayload(cls::rbd::UserSnapshotNamespace(), "foo")));
  o.push_back(new NotifyMessage(SnapProtectPayload(cls::rbd::UserSnapshotNamespace(), "foo")));
  o.push_back(new NotifyMessage(SnapUnprotectPayload(cls::rbd::UserSnapshotNamespace(), "foo")));
  o.push_back(new NotifyMessage(RebuildObjectMapPayload(AsyncRequestId(ClientId(0, 1), 2))));
  o.push_back(new NotifyMessage(RenamePayload("foo")));
  o.push_back(new NotifyMessage(UpdateFeaturesPayload(1, true)));
}

void ResponseMessage::encode(bufferlist& bl) const {
  ENCODE_START(1, 1, bl);
  ::encode(result, bl);
  ENCODE_FINISH(bl);
}

void ResponseMessage::decode(bufferlist::iterator& iter) {
  DECODE_START(1, iter);
  ::decode(result, iter);
  DECODE_FINISH(iter);
}

void ResponseMessage::dump(Formatter *f) const {
  f->dump_int("result", result);
}

void ResponseMessage::generate_test_instances(std::list<ResponseMessage *> &o) {
  o.push_back(new ResponseMessage(1));
}

} // namespace watch_notify
} // namespace librbd

std::ostream &operator<<(std::ostream &out,
                         const librbd::watch_notify::NotifyOp &op) {
  using namespace librbd::watch_notify;

  switch (op) {
  case NOTIFY_OP_ACQUIRED_LOCK:
    out << "AcquiredLock";
    break;
  case NOTIFY_OP_RELEASED_LOCK:
    out << "ReleasedLock";
    break;
  case NOTIFY_OP_REQUEST_LOCK:
    out << "RequestLock";
    break;
  case NOTIFY_OP_HEADER_UPDATE:
    out << "HeaderUpdate";
    break;
  case NOTIFY_OP_ASYNC_PROGRESS:
    out << "AsyncProgress";
    break;
  case NOTIFY_OP_ASYNC_COMPLETE:
    out << "AsyncComplete";
    break;
  case NOTIFY_OP_FLATTEN:
    out << "Flatten";
    break;
  case NOTIFY_OP_RESIZE:
    out << "Resize";
    break;
  case NOTIFY_OP_SNAP_CREATE:
    out << "SnapCreate";
    break;
  case NOTIFY_OP_SNAP_REMOVE:
    out << "SnapRemove";
    break;
  case NOTIFY_OP_SNAP_RENAME:
    out << "SnapRename";
    break;
  case NOTIFY_OP_SNAP_PROTECT:
    out << "SnapProtect";
    break;
  case NOTIFY_OP_SNAP_UNPROTECT:
    out << "SnapUnprotect";
    break;
  case NOTIFY_OP_REBUILD_OBJECT_MAP:
    out << "RebuildObjectMap";
    break;
  case NOTIFY_OP_RENAME:
    out << "Rename";
    break;
  case NOTIFY_OP_UPDATE_FEATURES:
    out << "UpdateFeatures";
    break;
  default:
    out << "Unknown (" << static_cast<uint32_t>(op) << ")";
    break;
  }
  return out;
}

std::ostream &operator<<(std::ostream &out,
                         const librbd::watch_notify::AsyncRequestId &request) {
  out << "[" << request.client_id.gid << "," << request.client_id.handle << ","
      << request.request_id << "]";
  return out;
}
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
	4	#include "cls/rbd/cls_rbd_types.h"
	5	#include "common/Formatter.h"
	6	#include "include/assert.h"
	7	#include "include/stringify.h"
	8	#include "librbd/WatchNotifyTypes.h"
	9	#include "librbd/watcher/Utils.h"
	10
	11	namespace librbd {
	12	namespace watch_notify {
	13
	14	namespace {
	15
	16	class CheckForRefreshVisitor : public boost::static_visitor<bool> {
	17	public:
	18	template <typename Payload>
	19	inline bool operator()(const Payload &payload) const {
	20	return Payload::CHECK_FOR_REFRESH;
	21	}
	22	};
	23
	24	class DumpPayloadVisitor : public boost::static_visitor<void> {
	25	public:
	26	explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}
	27
	28	template <typename Payload>
	29	inline void operator()(const Payload &payload) const {
	30	NotifyOp notify_op = Payload::NOTIFY_OP;
	31	m_formatter->dump_string("notify_op", stringify(notify_op));
	32	payload.dump(m_formatter);
	33	}
	34
	35	private:
	36	ceph::Formatter *m_formatter;
	37	};
	38
	39	} // anonymous namespace
	40
	41	void AsyncRequestId::encode(bufferlist &bl) const {
	42	::encode(client_id, bl);
	43	::encode(request_id, bl);
	44	}
	45
	46	void AsyncRequestId::decode(bufferlist::iterator &iter) {
	47	::decode(client_id, iter);
	48	::decode(request_id, iter);
	49	}
	50
	51	void AsyncRequestId::dump(Formatter *f) const {
	52	f->open_object_section("client_id");
	53	client_id.dump(f);
	54	f->close_section();
	55	f->dump_unsigned("request_id", request_id);
	56	}
	57
	58	void AcquiredLockPayload::encode(bufferlist &bl) const {
	59	::encode(client_id, bl);
	60	}
	61
	62	void AcquiredLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
	63	if (version >= 2) {
	64	::decode(client_id, iter);
65	}
66	}
67
68	void AcquiredLockPayload::dump(Formatter *f) const {
69	f->open_object_section("client_id");
70	client_id.dump(f);
71	f->close_section();
72	}
73
74	void ReleasedLockPayload::encode(bufferlist &bl) const {
75	::encode(client_id, bl);
76	}
77
78	void ReleasedLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
79	if (version >= 2) {
80	::decode(client_id, iter);
81	}
82	}
83
84	void ReleasedLockPayload::dump(Formatter *f) const {
85	f->open_object_section("client_id");
86	client_id.dump(f);
87	f->close_section();
88	}
89
90	void RequestLockPayload::encode(bufferlist &bl) const {
91	::encode(client_id, bl);
92	::encode(force, bl);
93	}
94
95	void RequestLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
96	if (version >= 2) {
97	::decode(client_id, iter);
98	}
99	if (version >= 3) {
100	::decode(force, iter);
101	}
102	}
103
104	void RequestLockPayload::dump(Formatter *f) const {
105	f->open_object_section("client_id");
106	client_id.dump(f);
107	f->close_section();
108	f->dump_bool("force", force);
109	}
110
111	void HeaderUpdatePayload::encode(bufferlist &bl) const {
112	}
113
114	void HeaderUpdatePayload::decode(__u8 version, bufferlist::iterator &iter) {
115	}
116
117	void HeaderUpdatePayload::dump(Formatter *f) const {
118	}
119
120	void AsyncRequestPayloadBase::encode(bufferlist &bl) const {
121	::encode(async_request_id, bl);
122	}
123
124	void AsyncRequestPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
125	::decode(async_request_id, iter);
126	}
127
128	void AsyncRequestPayloadBase::dump(Formatter *f) const {
129	f->open_object_section("async_request_id");
130	async_request_id.dump(f);
131	f->close_section();
132	}
133
134	void AsyncProgressPayload::encode(bufferlist &bl) const {
135	AsyncRequestPayloadBase::encode(bl);
136	::encode(offset, bl);
137	::encode(total, bl);
138	}
139
140	void AsyncProgressPayload::decode(__u8 version, bufferlist::iterator &iter) {
141	AsyncRequestPayloadBase::decode(version, iter);
142	::decode(offset, iter);
143	::decode(total, iter);
144	}
145
146	void AsyncProgressPayload::dump(Formatter *f) const {
147	AsyncRequestPayloadBase::dump(f);
148	f->dump_unsigned("offset", offset);
149	f->dump_unsigned("total", total);
150	}
151
152	void AsyncCompletePayload::encode(bufferlist &bl) const {
153	AsyncRequestPayloadBase::encode(bl);
154	::encode(result, bl);
155	}
156
157	void AsyncCompletePayload::decode(__u8 version, bufferlist::iterator &iter) {
158	AsyncRequestPayloadBase::decode(version, iter);
159	::decode(result, iter);
160	}
161
162	void AsyncCompletePayload::dump(Formatter *f) const {
163	AsyncRequestPayloadBase::dump(f);
164	f->dump_int("result", result);
165	}
166
167	void ResizePayload::encode(bufferlist &bl) const {
168	::encode(size, bl);
169	AsyncRequestPayloadBase::encode(bl);
170	::encode(allow_shrink, bl);
171	}
172
173	void ResizePayload::decode(__u8 version, bufferlist::iterator &iter) {
174	::decode(size, iter);
175	AsyncRequestPayloadBase::decode(version, iter);
176
177	if (version >= 4) {
178	::decode(allow_shrink, iter);
179	}
180	}
181
182	void ResizePayload::dump(Formatter *f) const {
183	f->dump_unsigned("size", size);
184	f->dump_bool("allow_shrink", allow_shrink);
185	AsyncRequestPayloadBase::dump(f);
186	}
187
188	void SnapPayloadBase::encode(bufferlist &bl) const {
189	::encode(snap_name, bl);
190	::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl);
191	}
192
193	void SnapPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
194	::decode(snap_name, iter);
195	if (version >= 6) {
196	cls::rbd::SnapshotNamespaceOnDisk sn;
197	::decode(sn, iter);
198	snap_namespace = sn.snapshot_namespace;
199	}
200	}
201
202	void SnapPayloadBase::dump(Formatter *f) const {
203	f->dump_string("snap_name", snap_name);
204	cls::rbd::SnapshotNamespaceOnDisk sn(snap_namespace);
205	sn.dump(f);
206	}
207
208	void SnapCreatePayload::encode(bufferlist &bl) const {
209	SnapPayloadBase::encode(bl);
210	}
211
212	void SnapCreatePayload::decode(__u8 version, bufferlist::iterator &iter) {
213	SnapPayloadBase::decode(version, iter);
214	if (version == 5) {
215	cls::rbd::SnapshotNamespaceOnDisk sn;
216	::decode(sn, iter);
217	snap_namespace = sn.snapshot_namespace;
218	}
219	}
220
221	void SnapCreatePayload::dump(Formatter *f) const {
222	SnapPayloadBase::dump(f);
223	}
224
225	void SnapRenamePayload::encode(bufferlist &bl) const {
226	::encode(snap_id, bl);
227	SnapPayloadBase::encode(bl);
228	}
229
230	void SnapRenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
231	::decode(snap_id, iter);
232	SnapPayloadBase::decode(version, iter);
233	}
234
235	void SnapRenamePayload::dump(Formatter *f) const {
236	f->dump_unsigned("src_snap_id", snap_id);
237	SnapPayloadBase::dump(f);
238	}
239
240	void RenamePayload::encode(bufferlist &bl) const {
241	::encode(image_name, bl);
242	}
243
244	void RenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
245	::decode(image_name, iter);
246	}
247
248	void RenamePayload::dump(Formatter *f) const {
249	f->dump_string("image_name", image_name);
250	}
251
252	void UpdateFeaturesPayload::encode(bufferlist &bl) const {
253	::encode(features, bl);
254	::encode(enabled, bl);
255	}
256
257	void UpdateFeaturesPayload::decode(__u8 version, bufferlist::iterator &iter) {
258	::decode(features, iter);
259	::decode(enabled, iter);
260	}
261
262	void UpdateFeaturesPayload::dump(Formatter *f) const {
263	f->dump_unsigned("features", features);
264	f->dump_bool("enabled", enabled);
265	}
266
267	void UnknownPayload::encode(bufferlist &bl) const {
268	assert(false);
269	}
270
271	void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
272	}
273
274	void UnknownPayload::dump(Formatter *f) const {
275	}
276
277	bool NotifyMessage::check_for_refresh() const {
278	return boost::apply_visitor(CheckForRefreshVisitor(), payload);
279	}
280
281	void NotifyMessage::encode(bufferlist& bl) const {
282	ENCODE_START(6, 1, bl);
283	boost::apply_visitor(watcher::util::EncodePayloadVisitor(bl), payload);
284	ENCODE_FINISH(bl);
285	}
286
287	void NotifyMessage::decode(bufferlist::iterator& iter) {
288	DECODE_START(1, iter);
289
290	uint32_t notify_op;
291	::decode(notify_op, iter);
292
293	// select the correct payload variant based upon the encoded op
294	switch (notify_op) {
295	case NOTIFY_OP_ACQUIRED_LOCK:
296	payload = AcquiredLockPayload();
297	break;
298	case NOTIFY_OP_RELEASED_LOCK:
299	payload = ReleasedLockPayload();
300	break;
301	case NOTIFY_OP_REQUEST_LOCK:
302	payload = RequestLockPayload();
303	break;
304	case NOTIFY_OP_HEADER_UPDATE:
305	payload = HeaderUpdatePayload();
306	break;
307	case NOTIFY_OP_ASYNC_PROGRESS:
308	payload = AsyncProgressPayload();
309	break;
310	case NOTIFY_OP_ASYNC_COMPLETE:
311	payload = AsyncCompletePayload();
312	break;
313	case NOTIFY_OP_FLATTEN:
314	payload = FlattenPayload();
315	break;
316	case NOTIFY_OP_RESIZE:
317	payload = ResizePayload();
318	break;
319	case NOTIFY_OP_SNAP_CREATE:
320	payload = SnapCreatePayload();
321	break;
322	case NOTIFY_OP_SNAP_REMOVE:
323	payload = SnapRemovePayload();
324	break;
325	case NOTIFY_OP_SNAP_RENAME:
326	payload = SnapRenamePayload();
327	break;
328	case NOTIFY_OP_SNAP_PROTECT:
329	payload = SnapProtectPayload();
330	break;
331	case NOTIFY_OP_SNAP_UNPROTECT:
332	payload = SnapUnprotectPayload();
333	break;
334	case NOTIFY_OP_REBUILD_OBJECT_MAP:
335	payload = RebuildObjectMapPayload();
336	break;
337	case NOTIFY_OP_RENAME:
338	payload = RenamePayload();
339	break;
340	case NOTIFY_OP_UPDATE_FEATURES:
341	payload = UpdateFeaturesPayload();
342	break;
343	default:
344	payload = UnknownPayload();
345	break;
346	}
347
348	apply_visitor(watcher::util::DecodePayloadVisitor(struct_v, iter), payload);
349	DECODE_FINISH(iter);
350	}
351
352	void NotifyMessage::dump(Formatter *f) const {
353	apply_visitor(DumpPayloadVisitor(f), payload);
354	}
355
356	void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
357	o.push_back(new NotifyMessage(AcquiredLockPayload(ClientId(1, 2))));
358	o.push_back(new NotifyMessage(ReleasedLockPayload(ClientId(1, 2))));
359	o.push_back(new NotifyMessage(RequestLockPayload(ClientId(1, 2), true)));
360	o.push_back(new NotifyMessage(HeaderUpdatePayload()));
361	o.push_back(new NotifyMessage(AsyncProgressPayload(AsyncRequestId(ClientId(0, 1), 2), 3, 4)));
362	o.push_back(new NotifyMessage(AsyncCompletePayload(AsyncRequestId(ClientId(0, 1), 2), 3)));
363	o.push_back(new NotifyMessage(FlattenPayload(AsyncRequestId(ClientId(0, 1), 2))));
364	o.push_back(new NotifyMessage(ResizePayload(123, true, AsyncRequestId(ClientId(0, 1), 2))));
365	o.push_back(new NotifyMessage(SnapCreatePayload(cls::rbd::UserSnapshotNamespace(),
366	"foo")));
367	o.push_back(new NotifyMessage(SnapRemovePayload(cls::rbd::UserSnapshotNamespace(), "foo")));
368	o.push_back(new NotifyMessage(SnapProtectPayload(cls::rbd::UserSnapshotNamespace(), "foo")));
369	o.push_back(new NotifyMessage(SnapUnprotectPayload(cls::rbd::UserSnapshotNamespace(), "foo")));
370	o.push_back(new NotifyMessage(RebuildObjectMapPayload(AsyncRequestId(ClientId(0, 1), 2))));
371	o.push_back(new NotifyMessage(RenamePayload("foo")));
372	o.push_back(new NotifyMessage(UpdateFeaturesPayload(1, true)));
373	}
374
375	void ResponseMessage::encode(bufferlist& bl) const {
376	ENCODE_START(1, 1, bl);
377	::encode(result, bl);
378	ENCODE_FINISH(bl);
379	}
380
381	void ResponseMessage::decode(bufferlist::iterator& iter) {
382	DECODE_START(1, iter);
383	::decode(result, iter);
384	DECODE_FINISH(iter);
385	}
386
387	void ResponseMessage::dump(Formatter *f) const {
388	f->dump_int("result", result);
389	}
390
391	void ResponseMessage::generate_test_instances(std::list<ResponseMessage *> &o) {
392	o.push_back(new ResponseMessage(1));
393	}
394
395	} // namespace watch_notify
396	} // namespace librbd
397
398	std::ostream &operator<<(std::ostream &out,
399	const librbd::watch_notify::NotifyOp &op) {
400	using namespace librbd::watch_notify;
401
402	switch (op) {
403	case NOTIFY_OP_ACQUIRED_LOCK:
404	out << "AcquiredLock";
405	break;
406	case NOTIFY_OP_RELEASED_LOCK:
407	out << "ReleasedLock";
408	break;
409	case NOTIFY_OP_REQUEST_LOCK:
410	out << "RequestLock";
411	break;
412	case NOTIFY_OP_HEADER_UPDATE:
413	out << "HeaderUpdate";
414	break;
415	case NOTIFY_OP_ASYNC_PROGRESS:
416	out << "AsyncProgress";
417	break;
418	case NOTIFY_OP_ASYNC_COMPLETE:
419	out << "AsyncComplete";
420	break;
421	case NOTIFY_OP_FLATTEN:
422	out << "Flatten";
423	break;
424	case NOTIFY_OP_RESIZE:
425	out << "Resize";
426	break;
427	case NOTIFY_OP_SNAP_CREATE:
428	out << "SnapCreate";
429	break;
430	case NOTIFY_OP_SNAP_REMOVE:
431	out << "SnapRemove";
432	break;
433	case NOTIFY_OP_SNAP_RENAME:
434	out << "SnapRename";
435	break;
436	case NOTIFY_OP_SNAP_PROTECT:
437	out << "SnapProtect";
438	break;
439	case NOTIFY_OP_SNAP_UNPROTECT:
440	out << "SnapUnprotect";
441	break;
442	case NOTIFY_OP_REBUILD_OBJECT_MAP:
443	out << "RebuildObjectMap";
444	break;
445	case NOTIFY_OP_RENAME:
446	out << "Rename";
447	break;
448	case NOTIFY_OP_UPDATE_FEATURES:
449	out << "UpdateFeatures";
450	break;
451	default:
452	out << "Unknown (" << static_cast<uint32_t>(op) << ")";
453	break;
454	}
455	return out;
456	}
457
458	std::ostream &operator<<(std::ostream &out,
459	const librbd::watch_notify::AsyncRequestId &request) {
460	out << "[" << request.client_id.gid << "," << request.client_id.handle << ","
461	<< request.request_id << "]";
462	return out;
463	}