#include "librbd/WatchNotifyTypes.h"
#include "include/assert.h"
+#include "common/Formatter.h"
namespace librbd {
namespace WatchNotify {
bufferlist::iterator &m_iter;
};
+class DumpPayloadVisitor : public boost::static_visitor<void> {
+public:
+ DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}
+
+ template <typename Payload>
+ inline void operator()(const Payload &payload) const {
+ payload.dump(m_formatter);
+ }
+
+private:
+ ceph::Formatter *m_formatter;
+};
+
}
void ClientId::encode(bufferlist &bl) const {
::decode(handle, iter);
}
+void ClientId::dump(Formatter *f) const {
+ f->dump_unsigned("gid", gid);
+ f->dump_unsigned("handle", handle);
+}
+
void AsyncRequestId::encode(bufferlist &bl) const {
::encode(client_id, bl);
::encode(request_id, bl);
::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(static_cast<uint32_t>(NOTIFY_OP_ACQUIRED_LOCK), bl);
}
void AcquiredLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
}
+void AcquiredLockPayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "AcquiredLock");
+}
+
void ReleasedLockPayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_RELEASED_LOCK), bl);
}
void ReleasedLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
}
+void ReleasedLockPayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "ReleasedLock");
+}
+
void RequestLockPayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_REQUEST_LOCK), bl);
}
void RequestLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
}
+void RequestLockPayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "RequestLock");
+}
+
void HeaderUpdatePayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_HEADER_UPDATE), bl);
}
void HeaderUpdatePayload::decode(__u8 version, bufferlist::iterator &iter) {
}
+void HeaderUpdatePayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "HeaderUpdate");
+}
+
void AsyncProgressPayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_ASYNC_PROGRESS), bl);
::encode(async_request_id, bl);
::decode(total, iter);
}
+void AsyncProgressPayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "AsyncProgress");
+ f->open_object_section("async_request_id");
+ async_request_id.dump(f);
+ f->close_section();
+ f->dump_unsigned("offset", offset);
+ f->dump_unsigned("total", total);
+}
+
void AsyncCompletePayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_ASYNC_COMPLETE), bl);
::encode(async_request_id, bl);
::decode(result, iter);
}
+void AsyncCompletePayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "AsyncComplete");
+ f->open_object_section("async_request_id");
+ async_request_id.dump(f);
+ f->close_section();
+ f->dump_int("result", result);
+}
+
void FlattenPayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_FLATTEN), bl);
::encode(async_request_id, bl);
::decode(async_request_id, iter);
}
+void FlattenPayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "Flatten");
+ f->open_object_section("async_request_id");
+ async_request_id.dump(f);
+ f->close_section();
+}
+
void ResizePayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_RESIZE), bl);
::encode(size, bl);
::decode(async_request_id, iter);
}
+void ResizePayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "Resize");
+ f->dump_unsigned("size", size);
+ f->open_object_section("async_request_id");
+ async_request_id.dump(f);
+ f->close_section();
+}
+
void SnapCreatePayload::encode(bufferlist &bl) const {
::encode(static_cast<uint32_t>(NOTIFY_OP_SNAP_CREATE), bl);
::encode(snap_name, bl);
::decode(snap_name, iter);
}
+void SnapCreatePayload::dump(Formatter *f) const {
+ f->dump_string("notify_op", "SnapCreate");
+ f->dump_string("snap_name", snap_name);
+}
+
void UnknownPayload::encode(bufferlist &bl) const {
assert(false);
}
void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
}
+void UnknownPayload::dump(Formatter *f) const {
+}
+
void NotifyMessage::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
boost::apply_visitor(EncodePayloadVisitor(bl), 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()));
+ o.push_back(new NotifyMessage(ReleasedLockPayload()));
+ o.push_back(new NotifyMessage(RequestLockPayload()));
+ 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, AsyncRequestId(ClientId(0, 1), 2))));
+ o.push_back(new NotifyMessage(SnapCreatePayload("foo")));
+}
+
void ResponseMessage::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
::encode(result, bl);
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 WatchNotify
} // namespace librbd
#include "include/buffer.h"
#include "include/encoding.h"
#include <iostream>
+#include <list>
#include <string>
#include <boost/variant.hpp>
+namespace ceph {
+class Formatter;
+}
+
namespace librbd {
namespace WatchNotify {
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator& it);
+ void dump(Formatter *f) const;
inline bool operator==(const ClientId &rhs) const {
return (gid == rhs.gid && handle == rhs.handle);
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) {
struct AcquiredLockPayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct ReleasedLockPayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct RequestLockPayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct HeaderUpdatePayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct AsyncProgressPayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct AsyncCompletePayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct FlattenPayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct ResizePayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct SnapCreatePayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
struct UnknownPayload {
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::iterator &iter);
+ void dump(Formatter *f) const;
};
typedef boost::variant<AcquiredLockPayload,
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 {
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 WatchNotify