ceph/src/librbd/mirroring_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 "common/Formatter.h"
   5 #include "include/ceph_assert.h"
   6 #include "include/stringify.h"
   7 #include "librbd/mirroring_watcher/Types.h"
   8 #include "librbd/watcher/Utils.h"
   9
  10 namespace librbd {
  11 namespace mirroring_watcher {
  12
  13 namespace {
  14
  15 class DumpPayloadVisitor : public boost::static_visitor<void> {
  16 public:
  17   explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}
  18
  19   template <typename Payload>
  20   inline void operator()(const Payload &payload) const {
  21     NotifyOp notify_op = Payload::NOTIFY_OP;
  22     m_formatter->dump_string("notify_op", stringify(notify_op));
  23     payload.dump(m_formatter);
  24   }
  25
  26 private:
  27   ceph::Formatter *m_formatter;
  28 };
  29
  30 } // anonymous namespace
  31
  32 void ModeUpdatedPayload::encode(bufferlist &bl) const {
  33   using ceph::encode;
  34   encode(static_cast<uint32_t>(mirror_mode), bl);
  35 }
  36
  37 void ModeUpdatedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
  38   using ceph::decode;
  39   uint32_t mirror_mode_decode;
  40   decode(mirror_mode_decode, iter);
  41   mirror_mode = static_cast<cls::rbd::MirrorMode>(mirror_mode_decode);
  42 }
  43
  44 void ModeUpdatedPayload::dump(Formatter *f) const {
  45   f->dump_stream("mirror_mode") << mirror_mode;
  46 }
  47
  48 void ImageUpdatedPayload::encode(bufferlist &bl) const {
  49   using ceph::encode;
  50   encode(static_cast<uint32_t>(mirror_image_state), bl);
  51   encode(image_id, bl);
  52   encode(global_image_id, bl);
  53 }
  54
  55 void ImageUpdatedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
  56   using ceph::decode;
  57   uint32_t mirror_image_state_decode;
  58   decode(mirror_image_state_decode, iter);
  59   mirror_image_state = static_cast<cls::rbd::MirrorImageState>(
  60     mirror_image_state_decode);
  61   decode(image_id, iter);
  62   decode(global_image_id, iter);
  63 }
  64
  65 void ImageUpdatedPayload::dump(Formatter *f) const {
  66   f->dump_stream("mirror_image_state") << mirror_image_state;
  67   f->dump_string("image_id", image_id);
  68   f->dump_string("global_image_id", global_image_id);
  69 }
  70
  71 void UnknownPayload::encode(bufferlist &bl) const {
  72   ceph_abort();
  73 }
  74
  75 void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
  76 }
  77
  78 void UnknownPayload::dump(Formatter *f) const {
  79 }
  80
  81 void NotifyMessage::encode(bufferlist& bl) const {
  82   ENCODE_START(1, 1, bl);
  83   boost::apply_visitor(watcher::util::EncodePayloadVisitor(bl), payload);
  84   ENCODE_FINISH(bl);
  85 }
  86
  87 void NotifyMessage::decode(bufferlist::const_iterator& iter) {
  88   DECODE_START(1, iter);
  89
  90   uint32_t notify_op;
  91   decode(notify_op, iter);
  92
  93   // select the correct payload variant based upon the encoded op
  94   switch (notify_op) {
  95   case NOTIFY_OP_MODE_UPDATED:
  96     payload = ModeUpdatedPayload();
  97     break;
  98   case NOTIFY_OP_IMAGE_UPDATED:
  99     payload = ImageUpdatedPayload();
 100     break;
 101   default:
 102     payload = UnknownPayload();
 103     break;
 104   }
 105
 106   apply_visitor(watcher::util::DecodePayloadVisitor(struct_v, iter), payload);
 107   DECODE_FINISH(iter);
 108 }
 109
 110 void NotifyMessage::dump(Formatter *f) const {
 111   apply_visitor(DumpPayloadVisitor(f), payload);
 112 }
 113
 114 void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
 115   o.push_back(new NotifyMessage(ModeUpdatedPayload(cls::rbd::MIRROR_MODE_DISABLED)));
 116   o.push_back(new NotifyMessage(ImageUpdatedPayload(cls::rbd::MIRROR_IMAGE_STATE_DISABLING,
 117                                                     "image id", "global image id")));
 118 }
 119
 120 std::ostream &operator<<(std::ostream &out, const NotifyOp &op) {
 121   switch (op) {
 122   case NOTIFY_OP_MODE_UPDATED:
 123     out << "ModeUpdated";
 124     break;
 125   case NOTIFY_OP_IMAGE_UPDATED:
 126     out << "ImageUpdated";
 127     break;
 128   default:
 129     out << "Unknown (" << static_cast<uint32_t>(op) << ")";
 130     break;
 131   }
 132   return out;
 133 }
 134
 135 } // namespace mirroring_watcher
 136 } // namespace librbd