diff options
Diffstat (limited to 'src/librbd/WatchNotifyTypes.h')
-rw-r--r-- | src/librbd/WatchNotifyTypes.h | 532 |
1 files changed, 532 insertions, 0 deletions
diff --git a/src/librbd/WatchNotifyTypes.h b/src/librbd/WatchNotifyTypes.h new file mode 100644 index 000000000..4fad31ffa --- /dev/null +++ b/src/librbd/WatchNotifyTypes.h @@ -0,0 +1,532 @@ +// -*- 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 <memory> +#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::const_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); + } + inline operator bool() const { + return (*this != AsyncRequestId()); + } +}; + +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, + NOTIFY_OP_MIGRATE = 16, + NOTIFY_OP_SPARSIFY = 17, + NOTIFY_OP_QUIESCE = 18, + NOTIFY_OP_UNQUIESCE = 19, + NOTIFY_OP_METADATA_UPDATE = 20, +}; + +struct Payload { + virtual ~Payload() {} + + virtual NotifyOp get_notify_op() const = 0; + virtual bool check_for_refresh() const = 0; + + virtual void encode(bufferlist &bl) const = 0; + virtual void decode(__u8 version, bufferlist::const_iterator &iter) = 0; + virtual void dump(Formatter *f) const = 0; +}; + +struct AcquiredLockPayload : public Payload { + ClientId client_id; + + AcquiredLockPayload() {} + AcquiredLockPayload(const ClientId &client_id) : client_id(client_id) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_ACQUIRED_LOCK; + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct ReleasedLockPayload : public Payload { + ClientId client_id; + + ReleasedLockPayload() {} + ReleasedLockPayload(const ClientId &client_id) : client_id(client_id) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_RELEASED_LOCK; + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct RequestLockPayload : public Payload { + ClientId client_id; + bool force = false; + + RequestLockPayload() {} + RequestLockPayload(const ClientId &client_id, bool force) + : client_id(client_id), force(force) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_REQUEST_LOCK; + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct HeaderUpdatePayload : public Payload { + NotifyOp get_notify_op() const override { + return NOTIFY_OP_HEADER_UPDATE; + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct AsyncRequestPayloadBase : public Payload { +public: + AsyncRequestId async_request_id; + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; + +protected: + AsyncRequestPayloadBase() {} + AsyncRequestPayloadBase(const AsyncRequestId &id) : async_request_id(id) {} +}; + +struct AsyncProgressPayload : public AsyncRequestPayloadBase { + uint64_t offset = 0; + uint64_t total = 0; + + AsyncProgressPayload() {} + AsyncProgressPayload(const AsyncRequestId &id, uint64_t offset, uint64_t total) + : AsyncRequestPayloadBase(id), offset(offset), total(total) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_ASYNC_PROGRESS; + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct AsyncCompletePayload : public AsyncRequestPayloadBase { + int result = 0; + + AsyncCompletePayload() {} + AsyncCompletePayload(const AsyncRequestId &id, int r) + : AsyncRequestPayloadBase(id), result(r) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_ASYNC_COMPLETE; + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct FlattenPayload : public AsyncRequestPayloadBase { + FlattenPayload() {} + FlattenPayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_FLATTEN; + } + bool check_for_refresh() const override { + return true; + } +}; + +struct ResizePayload : public AsyncRequestPayloadBase { + uint64_t size = 0; + bool allow_shrink = true; + + ResizePayload() {} + ResizePayload(const AsyncRequestId &id, uint64_t size, bool allow_shrink) + : AsyncRequestPayloadBase(id), size(size), allow_shrink(allow_shrink) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_RESIZE; + } + bool check_for_refresh() const override { + return true; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct SnapPayloadBase : public AsyncRequestPayloadBase { +public: + cls::rbd::SnapshotNamespace snap_namespace; + std::string snap_name; + + bool check_for_refresh() const override { + return true; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; + +protected: + SnapPayloadBase() {} + SnapPayloadBase(const AsyncRequestId &id, + const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &name) + : AsyncRequestPayloadBase(id), snap_namespace(snap_namespace), + snap_name(name) { + } +}; + +struct SnapCreatePayload : public SnapPayloadBase { + uint64_t flags = 0; + + SnapCreatePayload() {} + SnapCreatePayload(const AsyncRequestId &id, + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &name, uint64_t flags) + : SnapPayloadBase(id, snap_namespace, name), flags(flags) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_SNAP_CREATE; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct SnapRenamePayload : public SnapPayloadBase { + uint64_t snap_id = 0; + + SnapRenamePayload() {} + SnapRenamePayload(const AsyncRequestId &id, + const uint64_t &src_snap_id, + const std::string &dst_name) + : SnapPayloadBase(id, cls::rbd::UserSnapshotNamespace(), dst_name), + snap_id(src_snap_id) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_SNAP_RENAME; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct SnapRemovePayload : public SnapPayloadBase { + SnapRemovePayload() {} + SnapRemovePayload(const AsyncRequestId &id, + const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &name) + : SnapPayloadBase(id, snap_namespace, name) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_SNAP_REMOVE; + } +}; + +struct SnapProtectPayload : public SnapPayloadBase { + SnapProtectPayload() {} + SnapProtectPayload(const AsyncRequestId &id, + const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &name) + : SnapPayloadBase(id, snap_namespace, name) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_SNAP_PROTECT; + } +}; + +struct SnapUnprotectPayload : public SnapPayloadBase { + SnapUnprotectPayload() {} + SnapUnprotectPayload(const AsyncRequestId &id, + const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &name) + : SnapPayloadBase(id, snap_namespace, name) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_SNAP_UNPROTECT; + } +}; + +struct RebuildObjectMapPayload : public AsyncRequestPayloadBase { + RebuildObjectMapPayload() {} + RebuildObjectMapPayload(const AsyncRequestId &id) + : AsyncRequestPayloadBase(id) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_REBUILD_OBJECT_MAP; + } + bool check_for_refresh() const override { + return true; + } +}; + +struct RenamePayload : public AsyncRequestPayloadBase { + std::string image_name; + + RenamePayload() {} + RenamePayload(const AsyncRequestId &id, const std::string _image_name) + : AsyncRequestPayloadBase(id), image_name(_image_name) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_RENAME; + } + bool check_for_refresh() const override { + return true; + } + + void encode(bufferlist &bl) const; + void decode(__u8 version, bufferlist::const_iterator &iter); + void dump(Formatter *f) const; +}; + +struct UpdateFeaturesPayload : public AsyncRequestPayloadBase { + uint64_t features = 0; + bool enabled = false; + + UpdateFeaturesPayload() {} + UpdateFeaturesPayload(const AsyncRequestId &id, uint64_t features, + bool enabled) + : AsyncRequestPayloadBase(id), features(features), enabled(enabled) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_UPDATE_FEATURES; + } + bool check_for_refresh() const override { + return true; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct MigratePayload : public AsyncRequestPayloadBase { + MigratePayload() {} + MigratePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_MIGRATE; + } + bool check_for_refresh() const override { + return true; + } +}; + +struct SparsifyPayload : public AsyncRequestPayloadBase { + uint64_t sparse_size = 0; + + SparsifyPayload() {} + SparsifyPayload(const AsyncRequestId &id, uint64_t sparse_size) + : AsyncRequestPayloadBase(id), sparse_size(sparse_size) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_SPARSIFY; + } + bool check_for_refresh() const override { + return true; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct QuiescePayload : public AsyncRequestPayloadBase { + QuiescePayload() {} + QuiescePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_QUIESCE; + } + bool check_for_refresh() const override { + return false; + } +}; + +struct UnquiescePayload : public AsyncRequestPayloadBase { + UnquiescePayload() {} + UnquiescePayload(const AsyncRequestId &id) : AsyncRequestPayloadBase(id) {} + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_UNQUIESCE; + } + bool check_for_refresh() const override { + return false; + } +}; + +struct MetadataUpdatePayload : public AsyncRequestPayloadBase { + std::string key; + std::optional<std::string> value; + MetadataUpdatePayload() {} + MetadataUpdatePayload(const AsyncRequestId &id, std::string key, + std::optional<std::string> value) + : AsyncRequestPayloadBase(id), key(key), value(value) { + } + + NotifyOp get_notify_op() const override { + return NOTIFY_OP_METADATA_UPDATE; + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const; + void decode(__u8 version, bufferlist::const_iterator &iter); + void dump(Formatter *f) const; +}; + +struct UnknownPayload : public Payload { + NotifyOp get_notify_op() const override { + return static_cast<NotifyOp>(-1); + } + bool check_for_refresh() const override { + return false; + } + + void encode(bufferlist &bl) const override; + void decode(__u8 version, bufferlist::const_iterator &iter) override; + void dump(Formatter *f) const override; +}; + +struct NotifyMessage { + NotifyMessage() : payload(new UnknownPayload()) {} + NotifyMessage(Payload *payload) : payload(payload) {} + + std::unique_ptr<Payload> payload; + + bool check_for_refresh() const; + + void encode(bufferlist& bl) const; + void decode(bufferlist::const_iterator& it); + void dump(Formatter *f) const; + NotifyOp get_notify_op() 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::const_iterator& it); + void dump(Formatter *f) const; + + static void generate_test_instances(std::list<ResponseMessage *> &o); +}; + +std::ostream &operator<<(std::ostream &out, + const NotifyOp &op); +std::ostream &operator<<(std::ostream &out, + const AsyncRequestId &request); + +WRITE_CLASS_ENCODER(AsyncRequestId); +WRITE_CLASS_ENCODER(NotifyMessage); +WRITE_CLASS_ENCODER(ResponseMessage); + +} // namespace watch_notify +} // namespace librbd + + +#endif // LIBRBD_WATCH_NOTIFY_TYPES_H |