ceph/src/tools/rbd_mirror/instance_watcher/Types.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef RBD_MIRROR_INSTANCE_WATCHER_TYPES_H
   5 #define RBD_MIRROR_INSTANCE_WATCHER_TYPES_H
   6
   7 #include <string>
   8 #include <set>
   9 #include <boost/variant.hpp>
  10
  11 #include "include/buffer_fwd.h"
  12 #include "include/encoding.h"
  13 #include "include/int_types.h"
  14
  15 namespace ceph { class Formatter; }
  16
  17 namespace rbd {
  18 namespace mirror {
  19 namespace instance_watcher {
  20
  21 enum NotifyOp {
  22   NOTIFY_OP_IMAGE_ACQUIRE  = 0,
  23   NOTIFY_OP_IMAGE_RELEASE  = 1,
  24   NOTIFY_OP_SYNC_REQUEST   = 2,
  25   NOTIFY_OP_SYNC_START     = 3,
  26 };
  27
  28 struct PayloadBase {
  29   uint64_t request_id;
  30
  31   PayloadBase() : request_id(0) {
  32   }
  33
  34   PayloadBase(uint64_t request_id) : request_id(request_id) {
  35   }
  36
  37   void encode(bufferlist &bl) const;
  38   void decode(__u8 version, bufferlist::iterator &iter);
  39   void dump(Formatter *f) const;
  40 };
  41
  42 struct ImagePayloadBase : public PayloadBase {
  43   std::string global_image_id;
  44   std::string peer_mirror_uuid;
  45   std::string peer_image_id;
  46
  47   ImagePayloadBase() : PayloadBase() {
  48   }
  49
  50   ImagePayloadBase(uint64_t request_id, const std::string &global_image_id,
  51                    const std::string &peer_mirror_uuid,
  52                    const std::string &peer_image_id)
  53     : PayloadBase(request_id), global_image_id(global_image_id),
  54       peer_mirror_uuid(peer_mirror_uuid), peer_image_id(peer_image_id) {
  55   }
  56
  57   void encode(bufferlist &bl) const;
  58   void decode(__u8 version, bufferlist::iterator &iter);
  59   void dump(Formatter *f) const;
  60 };
  61
  62 struct ImageAcquirePayload : public ImagePayloadBase {
  63   static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_ACQUIRE;
  64
  65   ImageAcquirePayload() : ImagePayloadBase() {
  66   }
  67
  68   ImageAcquirePayload(uint64_t request_id, const std::string &global_image_id,
  69                       const std::string &peer_mirror_uuid,
  70                       const std::string &peer_image_id)
  71     : ImagePayloadBase(request_id, global_image_id, peer_mirror_uuid,
  72                        peer_image_id) {
  73   }
  74 };
  75
  76 struct ImageReleasePayload : public ImagePayloadBase {
  77   static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_RELEASE;
  78
  79   bool schedule_delete;
  80
  81   ImageReleasePayload() : ImagePayloadBase(), schedule_delete(false) {
  82   }
  83
  84   ImageReleasePayload(uint64_t request_id, const std::string &global_image_id,
  85                       const std::string &peer_mirror_uuid,
  86                       const std::string &peer_image_id, bool schedule_delete)
  87     : ImagePayloadBase(request_id, global_image_id, peer_mirror_uuid,
  88                        peer_image_id),
  89       schedule_delete(schedule_delete) {
  90   }
  91
  92   void encode(bufferlist &bl) const;
  93   void decode(__u8 version, bufferlist::iterator &iter);
  94   void dump(Formatter *f) const;
  95 };
  96
  97 struct SyncPayloadBase : public PayloadBase {
  98   std::string sync_id;
  99
 100   SyncPayloadBase() : PayloadBase() {
 101   }
 102
 103   SyncPayloadBase(uint64_t request_id, const std::string &sync_id)
 104     : PayloadBase(request_id), sync_id(sync_id) {
 105   }
 106
 107   void encode(bufferlist &bl) const;
 108   void decode(__u8 version, bufferlist::iterator &iter);
 109   void dump(Formatter *f) const;
 110 };
 111
 112 struct SyncRequestPayload : public SyncPayloadBase {
 113   static const NotifyOp NOTIFY_OP = NOTIFY_OP_SYNC_REQUEST;
 114
 115   SyncRequestPayload() : SyncPayloadBase() {
 116   }
 117
 118   SyncRequestPayload(uint64_t request_id, const std::string &sync_id)
 119     : SyncPayloadBase(request_id, sync_id) {
 120   }
 121 };
 122
 123 struct SyncStartPayload : public SyncPayloadBase {
 124   static const NotifyOp NOTIFY_OP = NOTIFY_OP_SYNC_START;
 125
 126   SyncStartPayload() : SyncPayloadBase() {
 127   }
 128
 129   SyncStartPayload(uint64_t request_id, const std::string &sync_id)
 130     : SyncPayloadBase(request_id, sync_id) {
 131   }
 132 };
 133
 134 struct UnknownPayload {
 135   static const NotifyOp NOTIFY_OP = static_cast<NotifyOp>(-1);
 136
 137   UnknownPayload() {
 138   }
 139
 140   void encode(bufferlist &bl) const;
 141   void decode(__u8 version, bufferlist::iterator &iter);
 142   void dump(Formatter *f) const;
 143 };
 144
 145 typedef boost::variant<ImageAcquirePayload,
 146                        ImageReleasePayload,
 147                        SyncRequestPayload,
 148                        SyncStartPayload,
 149                        UnknownPayload> Payload;
 150
 151 struct NotifyMessage {
 152   NotifyMessage(const Payload &payload = UnknownPayload()) : payload(payload) {
 153   }
 154
 155   Payload payload;
 156
 157   void encode(bufferlist& bl) const;
 158   void decode(bufferlist::iterator& it);
 159   void dump(Formatter *f) const;
 160
 161   static void generate_test_instances(std::list<NotifyMessage *> &o);
 162 };
 163
 164 WRITE_CLASS_ENCODER(NotifyMessage);
 165
 166 std::ostream &operator<<(std::ostream &out, const NotifyOp &op);
 167
 168 struct NotifyAckPayload {
 169   std::string instance_id;
 170   uint64_t request_id;
 171   int ret_val;
 172
 173   NotifyAckPayload() : request_id(0), ret_val(0) {
 174   }
 175
 176   NotifyAckPayload(const std::string &instance_id, uint64_t request_id,
 177                    int ret_val)
 178     : instance_id(instance_id), request_id(request_id), ret_val(ret_val) {
 179   }
 180
 181   void encode(bufferlist &bl) const;
 182   void decode(bufferlist::iterator& it);
 183   void dump(Formatter *f) const;
 184 };
 185
 186 WRITE_CLASS_ENCODER(NotifyAckPayload);
 187
 188 } // namespace instance_watcher
 189 } // namespace mirror
 190 } // namespace librbd
 191
 192 using rbd::mirror::instance_watcher::encode;
 193 using rbd::mirror::instance_watcher::decode;
 194
 195 #endif // RBD_MIRROR_INSTANCE_WATCHER_TYPES_H