ceph/src/librbd/WatchNotifyTypes.h

   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