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   ::encode(peer_mirror_uuid, bl);
  77   ::encode(peer_image_id, bl);
  78 }
  79
  80 void ImagePayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
  81   PayloadBase::decode(version, iter);
  82   ::decode(global_image_id, iter);
  83   ::decode(peer_mirror_uuid, iter);
  84   ::decode(peer_image_id, iter);
  85 }
  86
  87 void ImagePayloadBase::dump(Formatter *f) const {
  88   PayloadBase::dump(f);
  89   f->dump_string("global_image_id", global_image_id);
  90   f->dump_string("peer_mirror_uuid", peer_mirror_uuid);
  91   f->dump_string("peer_image_id", peer_image_id);
  92 }
  93
  94 void ImageReleasePayload::encode(bufferlist &bl) const {
  95   ImagePayloadBase::encode(bl);
  96   ::encode(schedule_delete, bl);
  97 }
  98
  99 void ImageReleasePayload::decode(__u8 version, bufferlist::iterator &iter) {
 100   ImagePayloadBase::decode(version, iter);
 101   ::decode(schedule_delete, iter);
 102 }
 103
 104 void ImageReleasePayload::dump(Formatter *f) const {
 105   ImagePayloadBase::dump(f);
 106   f->dump_bool("schedule_delete", schedule_delete);
 107 }
 108
 109 void SyncPayloadBase::encode(bufferlist &bl) const {
 110   PayloadBase::encode(bl);
 111   ::encode(sync_id, bl);
 112 }
 113
 114 void SyncPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
 115   PayloadBase::decode(version, iter);
 116   ::decode(sync_id, iter);
 117 }
 118
 119 void SyncPayloadBase::dump(Formatter *f) const {
 120   PayloadBase::dump(f);
 121   f->dump_string("sync_id", sync_id);
 122 }
 123
 124 void UnknownPayload::encode(bufferlist &bl) const {
 125   assert(false);
 126 }
 127
 128 void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
 129 }
 130
 131 void UnknownPayload::dump(Formatter *f) const {
 132 }
 133
 134 void NotifyMessage::encode(bufferlist& bl) const {
 135   ENCODE_START(1, 1, bl);
 136   boost::apply_visitor(EncodePayloadVisitor(bl), payload);
 137   ENCODE_FINISH(bl);
 138 }
 139
 140 void NotifyMessage::decode(bufferlist::iterator& iter) {
 141   DECODE_START(1, iter);
 142
 143   uint32_t notify_op;
 144   ::decode(notify_op, iter);
 145
 146   // select the correct payload variant based upon the encoded op
 147   switch (notify_op) {
 148   case NOTIFY_OP_IMAGE_ACQUIRE:
 149     payload = ImageAcquirePayload();
 150     break;
 151   case NOTIFY_OP_IMAGE_RELEASE:
 152     payload = ImageReleasePayload();
 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", "uuid", "id")));
 176
 177   o.push_back(new NotifyMessage(ImageReleasePayload()));
 178   o.push_back(new NotifyMessage(ImageReleasePayload(1, "gid", "uuid", "id",
 179                                                     true)));
 180
 181   o.push_back(new NotifyMessage(SyncRequestPayload()));
 182   o.push_back(new NotifyMessage(SyncRequestPayload(1, "sync_id")));
 183
 184   o.push_back(new NotifyMessage(SyncStartPayload()));
 185   o.push_back(new NotifyMessage(SyncStartPayload(1, "sync_id")));
 186 }
 187
 188 std::ostream &operator<<(std::ostream &out, const NotifyOp &op) {
 189   switch (op) {
 190   case NOTIFY_OP_IMAGE_ACQUIRE:
 191     out << "ImageAcquire";
 192     break;
 193   case NOTIFY_OP_IMAGE_RELEASE:
 194     out << "ImageRelease";
 195     break;
 196   case NOTIFY_OP_SYNC_REQUEST:
 197     out << "SyncRequest";
 198     break;
 199   case NOTIFY_OP_SYNC_START:
 200     out << "SyncStart";
 201     break;
 202   default:
 203     out << "Unknown (" << static_cast<uint32_t>(op) << ")";
 204     break;
 205   }
 206   return out;
 207 }
 208
 209 void NotifyAckPayload::encode(bufferlist &bl) const {
 210   ::encode(instance_id, bl);
 211   ::encode(request_id, bl);
 212   ::encode(ret_val, bl);
 213 }
 214
 215 void NotifyAckPayload::decode(bufferlist::iterator &iter) {
 216   ::decode(instance_id, iter);
 217   ::decode(request_id, iter);
 218   ::decode(ret_val, iter);
 219 }
 220
 221 void NotifyAckPayload::dump(Formatter *f) const {
 222   f->dump_string("instance_id", instance_id);
 223   f->dump_unsigned("request_id", request_id);
 224   f->dump_int("request_id", ret_val);
 225 }
 226
 227 } // namespace instance_watcher
 228 } // namespace mirror
 229 } // namespace rbd