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

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "Types.h"
   5 #include "include/assert.h"
   6 #include "include/stringify.h"
   7 #include "common/Formatter.h"
   8
   9 namespace rbd {
  10 namespace mirror {
  11 namespace instance_watcher {
  12
  13 namespace {
  14
  15 class EncodePayloadVisitor : public boost::static_visitor<void> {
  16 public:
  17   explicit EncodePayloadVisitor(bufferlist &bl) : m_bl(bl) {}
  18
  19   template <typename Payload>
  20   inline void operator()(const Payload &payload) const {
  21     ::encode(static_cast<uint32_t>(Payload::NOTIFY_OP), m_bl);
  22     payload.encode(m_bl);
  23   }
  24
  25 private:
  26   bufferlist &m_bl;
  27 };
  28
  29 class DecodePayloadVisitor : public boost::static_visitor<void> {
  30 public:
  31   DecodePayloadVisitor(__u8 version, bufferlist::iterator &iter)
  32     : m_version(version), m_iter(iter) {}
  33
  34   template <typename Payload>
  35   inline void operator()(Payload &payload) const {
  36     payload.decode(m_version, m_iter);
  37   }
  38
  39 private:
  40   __u8 m_version;
  41   bufferlist::iterator &m_iter;
  42 };
  43
  44 class DumpPayloadVisitor : public boost::static_visitor<void> {
  45 public:
  46   explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}
  47
  48   template <typename Payload>
  49   inline void operator()(const Payload &payload) const {
  50     NotifyOp notify_op = Payload::NOTIFY_OP;
  51     m_formatter->dump_string("notify_op", stringify(notify_op));
  52     payload.dump(m_formatter);
  53   }
  54
  55 private:
  56   ceph::Formatter *m_formatter;
  57 };
  58
  59 } // anonymous namespace
  60
  61 void PayloadBase::encode(bufferlist &bl) const {
  62   ::encode(request_id, bl);
  63 }
  64
  65 void PayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
  66   ::decode(request_id, iter);
  67 }
  68
  69 void PayloadBase::dump(Formatter *f) const {
  70   f->dump_unsigned("request_id", request_id);
  71 }
  72
  73 void ImagePayloadBase::encode(bufferlist &bl) const {
  74   PayloadBase::encode(bl);
  75   ::encode(global_image_id, bl);
  76 }
  77
  78 void ImagePayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
  79   PayloadBase::decode(version, iter);
  80   ::decode(global_image_id, iter);
  81 }
  82
  83 void ImagePayloadBase::dump(Formatter *f) const {
  84   PayloadBase::dump(f);
  85   f->dump_string("global_image_id", global_image_id);
  86 }
  87
  88 void PeerImageRemovedPayload::encode(bufferlist &bl) const {
  89   PayloadBase::encode(bl);
  90   ::encode(global_image_id, bl);
  91   ::encode(peer_mirror_uuid, bl);
  92 }
  93
  94 void PeerImageRemovedPayload::decode(__u8 version, bufferlist::iterator &iter) {
  95   PayloadBase::decode(version, iter);
  96   ::decode(global_image_id, iter);
  97   ::decode(peer_mirror_uuid, iter);
  98 }
  99
 100 void PeerImageRemovedPayload::dump(Formatter *f) const {
 101   PayloadBase::dump(f);
 102   f->dump_string("global_image_id", global_image_id);
 103   f->dump_string("peer_mirror_uuid", peer_mirror_uuid);
 104 }
 105
 106 void SyncPayloadBase::encode(bufferlist &bl) const {
 107   PayloadBase::encode(bl);
 108   ::encode(sync_id, bl);
 109 }
 110
 111 void SyncPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
 112   PayloadBase::decode(version, iter);
 113   ::decode(sync_id, iter);
 114 }
 115
 116 void SyncPayloadBase::dump(Formatter *f) const {
 117   PayloadBase::dump(f);
 118   f->dump_string("sync_id", sync_id);
 119 }
 120
 121 void UnknownPayload::encode(bufferlist &bl) const {
 122   assert(false);
 123 }
 124
 125 void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
 126 }
 127
 128 void UnknownPayload::dump(Formatter *f) const {
 129 }
 130
 131 void NotifyMessage::encode(bufferlist& bl) const {
 132   ENCODE_START(2, 2, bl);
 133   boost::apply_visitor(EncodePayloadVisitor(bl), payload);
 134   ENCODE_FINISH(bl);
 135 }
 136
 137 void NotifyMessage::decode(bufferlist::iterator& iter) {
 138   DECODE_START(2, iter);
 139
 140   uint32_t notify_op;
 141   ::decode(notify_op, iter);
 142
 143   // select the correct payload variant based upon the encoded op
 144   switch (notify_op) {
 145   case NOTIFY_OP_IMAGE_ACQUIRE:
 146     payload = ImageAcquirePayload();
 147     break;
 148   case NOTIFY_OP_IMAGE_RELEASE:
 149     payload = ImageReleasePayload();
 150     break;
 151   case NOTIFY_OP_PEER_IMAGE_REMOVED:
 152     payload = PeerImageRemovedPayload();
 153     break;
 154   case NOTIFY_OP_SYNC_REQUEST:
 155     payload = SyncRequestPayload();
 156     break;
 157   case NOTIFY_OP_SYNC_START:
 158     payload = SyncStartPayload();
 159     break;
 160   default:
 161     payload = UnknownPayload();
 162     break;
 163   }
 164
 165   apply_visitor(DecodePayloadVisitor(struct_v, iter), payload);
 166   DECODE_FINISH(iter);
 167 }
 168
 169 void NotifyMessage::dump(Formatter *f) const {
 170   apply_visitor(DumpPayloadVisitor(f), payload);
 171 }
 172
 173 void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
 174   o.push_back(new NotifyMessage(ImageAcquirePayload()));
 175   o.push_back(new NotifyMessage(ImageAcquirePayload(1, "gid")));
 176
 177   o.push_back(new NotifyMessage(ImageReleasePayload()));
 178   o.push_back(new NotifyMessage(ImageReleasePayload(1, "gid")));
 179
 180   o.push_back(new NotifyMessage(PeerImageRemovedPayload()));
 181   o.push_back(new NotifyMessage(PeerImageRemovedPayload(1, "gid", "uuid")));
 182
 183   o.push_back(new NotifyMessage(SyncRequestPayload()));
 184   o.push_back(new NotifyMessage(SyncRequestPayload(1, "sync_id")));
 185
 186   o.push_back(new NotifyMessage(SyncStartPayload()));
 187   o.push_back(new NotifyMessage(SyncStartPayload(1, "sync_id")));
 188 }
 189
 190 std::ostream &operator<<(std::ostream &out, const NotifyOp &op) {
 191   switch (op) {
 192   case NOTIFY_OP_IMAGE_ACQUIRE:
 193     out << "ImageAcquire";
 194     break;
 195   case NOTIFY_OP_IMAGE_RELEASE:
 196     out << "ImageRelease";
 197     break;
 198   case NOTIFY_OP_PEER_IMAGE_REMOVED:
 199     out << "PeerImageRemoved";
 200     break;
 201   case NOTIFY_OP_SYNC_REQUEST:
 202     out << "SyncRequest";
 203     break;
 204   case NOTIFY_OP_SYNC_START:
 205     out << "SyncStart";
 206     break;
 207   default:
 208     out << "Unknown (" << static_cast<uint32_t>(op) << ")";
 209     break;
 210   }
 211   return out;
 212 }
 213
 214 void NotifyAckPayload::encode(bufferlist &bl) const {
 215   ::encode(instance_id, bl);
 216   ::encode(request_id, bl);
 217   ::encode(ret_val, bl);
 218 }
 219
 220 void NotifyAckPayload::decode(bufferlist::iterator &iter) {
 221   ::decode(instance_id, iter);
 222   ::decode(request_id, iter);
 223   ::decode(ret_val, iter);
 224 }
 225
 226 void NotifyAckPayload::dump(Formatter *f) const {
 227   f->dump_string("instance_id", instance_id);
 228   f->dump_unsigned("request_id", request_id);
 229   f->dump_int("request_id", ret_val);
 230 }
 231
 232 } // namespace instance_watcher
 233 } // namespace mirror
 234 } // namespace rbd