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 };
  25
  26 struct ImagePayloadBase {
  27   uint64_t request_id;
  28   std::string global_image_id;
  29   std::string peer_mirror_uuid;
  30   std::string peer_image_id;
  31
  32   ImagePayloadBase() : request_id(0) {
  33   }
  34
  35   ImagePayloadBase(uint64_t request_id, const std::string &global_image_id,
  36                    const std::string &peer_mirror_uuid,
  37                    const std::string &peer_image_id)
  38     : request_id(request_id), global_image_id(global_image_id),
  39       peer_mirror_uuid(peer_mirror_uuid), peer_image_id(peer_image_id) {
  40   }
  41
  42   void encode(bufferlist &bl) const;
  43   void decode(__u8 version, bufferlist::iterator &iter);
  44   void dump(Formatter *f) const;
  45 };
  46
  47 struct ImageAcquirePayload : public ImagePayloadBase {
  48   static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_ACQUIRE;
  49
  50   ImageAcquirePayload() : ImagePayloadBase() {
  51   }
  52
  53   ImageAcquirePayload(uint64_t request_id, const std::string &global_image_id,
  54                       const std::string &peer_mirror_uuid,
  55                       const std::string &peer_image_id)
  56     : ImagePayloadBase(request_id, global_image_id, peer_mirror_uuid,
  57                        peer_image_id) {
  58   }
  59 };
  60
  61 struct ImageReleasePayload : public ImagePayloadBase {
  62   static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_RELEASE;
  63
  64   bool schedule_delete;
  65
  66   ImageReleasePayload() : ImagePayloadBase(), schedule_delete(false) {
  67   }
  68
  69   ImageReleasePayload(uint64_t request_id, const std::string &global_image_id,
  70                       const std::string &peer_mirror_uuid,
  71                       const std::string &peer_image_id, bool schedule_delete)
  72     : ImagePayloadBase(request_id, global_image_id, peer_mirror_uuid,
  73                        peer_image_id),
  74       schedule_delete(schedule_delete) {
  75   }
  76
  77   void encode(bufferlist &bl) const;
  78   void decode(__u8 version, bufferlist::iterator &iter);
  79   void dump(Formatter *f) const;
  80 };
  81
  82 struct UnknownPayload {
  83   static const NotifyOp NOTIFY_OP = static_cast<NotifyOp>(-1);
  84
  85   UnknownPayload() {
  86   }
  87
  88   void encode(bufferlist &bl) const;
  89   void decode(__u8 version, bufferlist::iterator &iter);
  90   void dump(Formatter *f) const;
  91 };
  92
  93 typedef boost::variant<ImageAcquirePayload,
  94                        ImageReleasePayload,
  95                        UnknownPayload> Payload;
  96
  97 struct NotifyMessage {
  98   NotifyMessage(const Payload &payload = UnknownPayload()) : payload(payload) {
  99   }
 100
 101   Payload payload;
 102
 103   void encode(bufferlist& bl) const;
 104   void decode(bufferlist::iterator& it);
 105   void dump(Formatter *f) const;
 106
 107   static void generate_test_instances(std::list<NotifyMessage *> &o);
 108 };
 109
 110 WRITE_CLASS_ENCODER(NotifyMessage);
 111
 112 std::ostream &operator<<(std::ostream &out, const NotifyOp &op);
 113
 114 struct NotifyAckPayload {
 115   std::string instance_id;
 116   uint64_t request_id;
 117   int ret_val;
 118
 119   NotifyAckPayload() : request_id(0), ret_val(0) {
 120   }
 121
 122   NotifyAckPayload(const std::string &instance_id, uint64_t request_id,
 123                    int ret_val)
 124     : instance_id(instance_id), request_id(request_id), ret_val(ret_val) {
 125   }
 126
 127   void encode(bufferlist &bl) const;
 128   void decode(bufferlist::iterator& it);
 129   void dump(Formatter *f) const;
 130 };
 131
 132 WRITE_CLASS_ENCODER(NotifyAckPayload);
 133
 134 } // namespace instance_watcher
 135 } // namespace mirror
 136 } // namespace librbd
 137
 138 using rbd::mirror::instance_watcher::encode;
 139 using rbd::mirror::instance_watcher::decode;
 140
 141 #endif // RBD_MIRROR_INSTANCE_WATCHER_TYPES_H