X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=ceph%2Fsrc%2Fmgr%2FDaemonState.cc;fp=ceph%2Fsrc%2Fmgr%2FDaemonState.cc;h=b13685a1561b60adf415325a618dbd90a2170968;hb=11fdf7f228cb605e22a0e495ebabd3329db96b81;hp=9ba7cf926d899bce1d9b4597be76f3bf7b8c3fb6;hpb=39cfebf25a7011204a9876d2950e4b28aba66d11;p=ceph.git

diff --git a/ceph/src/mgr/DaemonState.cc b/ceph/src/mgr/DaemonState.cc
index 9ba7cf926..b13685a15 100644
--- a/ceph/src/mgr/DaemonState.cc
+++ b/ceph/src/mgr/DaemonState.cc
@@ -14,31 +14,164 @@
 #include "DaemonState.h"
 
 #include "MgrSession.h"
+#include "include/stringify.h"
+#include "common/Formatter.h"
 
 #define dout_context g_ceph_context
 #define dout_subsys ceph_subsys_mgr
 #undef dout_prefix
 #define dout_prefix *_dout << "mgr " << __func__ << " "
 
+void DeviceState::set_metadata(map<string,string>&& m)
+{
+  metadata = std::move(m);
+  auto p = metadata.find("life_expectancy_min");
+  if (p != metadata.end()) {
+    life_expectancy.first.parse(p->second);
+  }
+  p = metadata.find("life_expectancy_max");
+  if (p != metadata.end()) {
+    life_expectancy.second.parse(p->second);
+  }
+  p = metadata.find("life_expectancy_stamp");
+  if (p != metadata.end()) {
+    life_expectancy_stamp.parse(p->second);
+  }
+}
+
+void DeviceState::set_life_expectancy(utime_t from, utime_t to, utime_t now)
+{
+  life_expectancy = make_pair(from, to);
+  life_expectancy_stamp = now;
+  if (from != utime_t()) {
+    metadata["life_expectancy_min"] = from;
+  } else {
+    metadata["life_expectancy_min"] = "";
+  }
+  if (to != utime_t()) {
+    metadata["life_expectancy_max"] = to;
+  } else {
+    metadata["life_expectancy_max"] = "";
+  }
+  if (now != utime_t()) {
+    metadata["life_expectancy_stamp"] = stringify(now);
+  } else {
+    metadata["life_expectancy_stamp"] = "";
+  }
+}
+
+void DeviceState::rm_life_expectancy()
+{
+  life_expectancy = make_pair(utime_t(), utime_t());
+  life_expectancy_stamp = utime_t();
+  metadata.erase("life_expectancy_min");
+  metadata.erase("life_expectancy_max");
+  metadata.erase("life_expectancy_stamp");
+}
+
+string DeviceState::get_life_expectancy_str(utime_t now) const
+{
+  if (life_expectancy.first == utime_t()) {
+    return string();
+  }
+  if (now >= life_expectancy.first) {
+    return "now";
+  }
+  utime_t min = life_expectancy.first - now;
+  utime_t max = life_expectancy.second - now;
+  if (life_expectancy.second == utime_t()) {
+    return string(">") + timespan_str(make_timespan(min));
+  }
+  string a = timespan_str(make_timespan(min));
+  string b = timespan_str(make_timespan(max));
+  if (a == b) {
+    return a;
+  }
+  return a + " to " + b;
+}
+
+void DeviceState::dump(Formatter *f) const
+{
+  f->dump_string("devid", devid);
+  f->open_array_section("location");
+  for (auto& i : devnames) {
+    f->open_object_section("attachment");
+    f->dump_string("host", i.first);
+    f->dump_string("dev", i.second);
+    f->close_section();
+  }
+  f->close_section();
+  f->open_array_section("daemons");
+  for (auto& i : daemons) {
+    f->dump_string("daemon", to_string(i));
+  }
+  f->close_section();
+  if (life_expectancy.first != utime_t()) {
+    f->dump_stream("life_expectancy_min") << life_expectancy.first;
+    f->dump_stream("life_expectancy_max") << life_expectancy.second;
+    f->dump_stream("life_expectancy_stamp")
+      << life_expectancy_stamp;
+  }
+}
+
+void DeviceState::print(ostream& out) const
+{
+  out << "device " << devid << "\n";
+  for (auto& i : devnames) {
+    out << "attachment " << i.first << ":" << i.second << "\n";
+  }
+  set<string> d;
+  for (auto& j : daemons) {
+    d.insert(to_string(j));
+  }
+  out << "daemons " << d << "\n";
+  if (life_expectancy.first != utime_t()) {
+    out << "life_expectancy " << life_expectancy.first << " to "
+	<< life_expectancy.second
+	<< " (as of " << life_expectancy_stamp << ")\n";
+  }
+}
+
 void DaemonStateIndex::insert(DaemonStatePtr dm)
 {
   RWLock::WLocker l(lock);
+  _insert(dm);
+}
 
+void DaemonStateIndex::_insert(DaemonStatePtr dm)
+{
   if (all.count(dm->key)) {
     _erase(dm->key);
   }
 
   by_server[dm->hostname][dm->key] = dm;
   all[dm->key] = dm;
+
+  for (auto& i : dm->devices) {
+    auto d = _get_or_create_device(i.first);
+    d->daemons.insert(dm->key);
+    d->devnames.insert(make_pair(dm->hostname, i.second));
+  }
 }
 
 void DaemonStateIndex::_erase(const DaemonKey& dmk)
 {
-  assert(lock.is_wlocked());
+  ceph_assert(lock.is_wlocked());
 
   const auto to_erase = all.find(dmk);
-  assert(to_erase != all.end());
+  ceph_assert(to_erase != all.end());
   const auto dm = to_erase->second;
+
+  for (auto& i : dm->devices) {
+    auto d = _get_or_create_device(i.first);
+    ceph_assert(d->daemons.count(dmk));
+    d->daemons.erase(dmk);
+    d->devnames.erase(make_pair(dm->hostname, i.second));
+    if (d->empty()) {
+      _erase_device(d);
+    }
+  }
+
   auto &server_collection = by_server[dm->hostname];
   server_collection.erase(dm->key);
   if (server_collection.empty()) {
@@ -95,6 +228,19 @@ DaemonStatePtr DaemonStateIndex::get(const DaemonKey &key)
   }
 }
 
+void DaemonStateIndex::rm(const DaemonKey &key)
+{
+  RWLock::WLocker l(lock);
+  _rm(key);
+}
+
+void DaemonStateIndex::_rm(const DaemonKey &key)
+{
+  if (all.count(key)) {
+    _erase(key);
+  }
+}
+
 void DaemonStateIndex::cull(const std::string& svc_name,
 			    const std::set<std::string>& names_exist)
 {
@@ -126,8 +272,8 @@ void DaemonPerfCounters::update(MMgrReport *report)
            << report->packed.length() << " bytes of data" << dendl;
 
   // Retrieve session state
-  MgrSessionRef session(static_cast<MgrSession*>(
-        report->get_connection()->get_priv()));
+  auto priv = report->get_connection()->get_priv();
+  auto session = static_cast<MgrSession*>(priv.get());
 
   // Load any newly declared types
   for (const auto &t : report->declare_types) {
@@ -142,7 +288,7 @@ void DaemonPerfCounters::update(MMgrReport *report)
   const auto now = ceph_clock_now();
 
   // Parse packed data according to declared set of types
-  bufferlist::iterator p = report->packed.begin();
+  auto p = report->packed.cbegin();
   DECODE_START(1, p);
   for (const auto &t_path : session->declared_types) {
     const auto &t = types.at(t_path);
@@ -157,10 +303,10 @@ void DaemonPerfCounters::update(MMgrReport *report)
     uint64_t avgcount = 0;
     uint64_t avgcount2 = 0;
 
-    ::decode(val, p);
+    decode(val, p);
     if (t.type & PERFCOUNTER_LONGRUNAVG) {
-      ::decode(avgcount, p);
-      ::decode(avgcount2, p);
+      decode(avgcount, p);
+      decode(avgcount2, p);
       instances_it->second.push_avg(now, val, avgcount);
     } else {
       instances_it->second.push(now, val);
@@ -169,11 +315,6 @@ void DaemonPerfCounters::update(MMgrReport *report)
   DECODE_FINISH(p);
 }
 
-uint64_t PerfCounterInstance::get_current() const
-{
-  return buffer.front().v;
-}
-
 void PerfCounterInstance::push(utime_t t, uint64_t const &v)
 {
   buffer.push_back({t, v});