ceph/src/mgr/ServiceMap.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 "mgr/ServiceMap.h"
   5
   6 #include "common/Formatter.h"
   7
   8 using ceph::bufferlist;
   9 using ceph::Formatter;
  10
  11 // Daemon
  12
  13 void ServiceMap::Daemon::encode(bufferlist& bl, uint64_t features) const
  14 {
  15   ENCODE_START(2, 1, bl);
  16   encode(gid, bl);
  17   encode(addr, bl, features);
  18   encode(start_epoch, bl);
  19   encode(start_stamp, bl);
  20   encode(metadata, bl);
  21   encode(task_status, bl);
  22   ENCODE_FINISH(bl);
  23 }
  24
  25 void ServiceMap::Daemon::decode(bufferlist::const_iterator& p)
  26 {
  27   DECODE_START(2, p);
  28   decode(gid, p);
  29   decode(addr, p);
  30   decode(start_epoch, p);
  31   decode(start_stamp, p);
  32   decode(metadata, p);
  33   if (struct_v >= 2) {
  34     decode(task_status, p);
  35   }
  36   DECODE_FINISH(p);
  37 }
  38
  39 void ServiceMap::Daemon::dump(Formatter *f) const
  40 {
  41   f->dump_unsigned("start_epoch", start_epoch);
  42   f->dump_stream("start_stamp") << start_stamp;
  43   f->dump_unsigned("gid", gid);
  44   f->dump_string("addr", addr.get_legacy_str());
  45   f->open_object_section("metadata");
  46   for (auto& p : metadata) {
  47     f->dump_string(p.first.c_str(), p.second);
  48   }
  49   f->close_section();
  50   f->open_object_section("task_status");
  51   for (auto& p : task_status) {
  52     f->dump_string(p.first.c_str(), p.second);
  53   }
  54   f->close_section();
  55 }
  56
  57 void ServiceMap::Daemon::generate_test_instances(std::list<Daemon*>& ls)
  58 {
  59   ls.push_back(new Daemon);
  60   ls.push_back(new Daemon);
  61   ls.back()->gid = 222;
  62   ls.back()->metadata["this"] = "that";
  63   ls.back()->task_status["task1"] = "running";
  64 }
  65
  66 // Service
  67
  68 void ServiceMap::Service::encode(bufferlist& bl, uint64_t features) const
  69 {
  70   ENCODE_START(1, 1, bl);
  71   encode(daemons, bl, features);
  72   encode(summary, bl);
  73   ENCODE_FINISH(bl);
  74 }
  75
  76 void ServiceMap::Service::decode(bufferlist::const_iterator& p)
  77 {
  78   DECODE_START(1, p);
  79   decode(daemons, p);
  80   decode(summary, p);
  81   DECODE_FINISH(p);
  82 }
  83
  84 void ServiceMap::Service::dump(Formatter *f) const
  85 {
  86   f->open_object_section("daemons");
  87   f->dump_string("summary", summary);
  88   for (auto& p : daemons) {
  89     f->dump_object(p.first.c_str(), p.second);
  90   }
  91   f->close_section();
  92 }
  93
  94 void ServiceMap::Service::generate_test_instances(std::list<Service*>& ls)
  95 {
  96   ls.push_back(new Service);
  97   ls.push_back(new Service);
  98   ls.back()->daemons["one"].gid = 1;
  99   ls.back()->daemons["two"].gid = 2;
 100 }
 101
 102 // ServiceMap
 103
 104 void ServiceMap::encode(bufferlist& bl, uint64_t features) const
 105 {
 106   ENCODE_START(1, 1, bl);
 107   encode(epoch, bl);
 108   encode(modified, bl);
 109   encode(services, bl, features);
 110   ENCODE_FINISH(bl);
 111 }
 112
 113 void ServiceMap::decode(bufferlist::const_iterator& p)
 114 {
 115   DECODE_START(1, p);
 116   decode(epoch, p);
 117   decode(modified, p);
 118   decode(services, p);
 119   DECODE_FINISH(p);
 120 }
 121
 122 void ServiceMap::dump(Formatter *f) const
 123 {
 124   f->dump_unsigned("epoch", epoch);
 125   f->dump_stream("modified") << modified;
 126   f->open_object_section("services");
 127   for (auto& p : services) {
 128     f->dump_object(p.first.c_str(), p.second);
 129   }
 130   f->close_section();
 131 }
 132
 133 void ServiceMap::generate_test_instances(std::list<ServiceMap*>& ls)
 134 {
 135   ls.push_back(new ServiceMap);
 136   ls.push_back(new ServiceMap);
 137   ls.back()->epoch = 123;
 138   ls.back()->services["rgw"].daemons["one"].gid = 123;
 139   ls.back()->services["rgw"].daemons["two"].gid = 344;
 140   ls.back()->services["iscsi"].daemons["foo"].gid = 3222;
 141 }