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