ceph/src/mgr/DaemonState.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2016 John Spray <john.spray@redhat.com>
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  */
  13
  14 #ifndef DAEMON_STATE_H_
  15 #define DAEMON_STATE_H_
  16
  17 #include <map>
  18 #include <string>
  19 #include <memory>
  20 #include <set>
  21 #include <boost/circular_buffer.hpp>
  22
  23 #include "common/RWLock.h"
  24
  25 #include "msg/msg_types.h"
  26
  27 // For PerfCounterType
  28 #include "messages/MMgrReport.h"
  29
  30
  31 // Unique reference to a daemon within a cluster
  32 typedef std::pair<std::string, std::string> DaemonKey;
  33
  34 // An instance of a performance counter type, within
  35 // a particular daemon.
  36 class PerfCounterInstance
  37 {
  38   class DataPoint
  39   {
  40     public:
  41     utime_t t;
  42     uint64_t v;
  43     DataPoint(utime_t t_, uint64_t v_)
  44       : t(t_), v(v_)
  45     {}
  46   };
  47
  48   boost::circular_buffer<DataPoint> buffer;
  49   uint64_t get_current() const;
  50
  51   public:
  52   const boost::circular_buffer<DataPoint> & get_data() const
  53   {
  54     return buffer;
  55   }
  56   void push(utime_t t, uint64_t const &v);
  57   PerfCounterInstance()
  58     : buffer(20) {}
  59 };
  60
  61
  62 typedef std::map<std::string, PerfCounterType> PerfCounterTypes;
  63
  64 // Performance counters for one daemon
  65 class DaemonPerfCounters
  66 {
  67   public:
  68   // The record of perf stat types, shared between daemons
  69   PerfCounterTypes &types;
  70
  71   DaemonPerfCounters(PerfCounterTypes &types_)
  72     : types(types_)
  73   {}
  74
  75   std::map<std::string, PerfCounterInstance> instances;
  76
  77   void update(MMgrReport *report);
  78
  79   void clear()
  80   {
  81     instances.clear();
  82   }
  83 };
  84
  85 // The state that we store about one daemon
  86 class DaemonState
  87 {
  88   public:
  89   Mutex lock = {"DaemonState::lock"};
  90
  91   DaemonKey key;
  92
  93   // The hostname where daemon was last seen running (extracted
  94   // from the metadata)
  95   std::string hostname;
  96
  97   // The metadata (hostname, version, etc) sent from the daemon
  98   std::map<std::string, std::string> metadata;
  99
 100   // TODO: this can be generalized to other daemons
 101   std::vector<OSDHealthMetric> osd_health_metrics;
 102
 103   // Ephemeral state
 104   bool service_daemon = false;
 105   utime_t service_status_stamp;
 106   std::map<std::string, std::string> service_status;
 107   utime_t last_service_beacon;
 108
 109   // The perf counters received in MMgrReport messages
 110   DaemonPerfCounters perf_counters;
 111
 112   DaemonState(PerfCounterTypes &types_)
 113     : perf_counters(types_)
 114   {
 115   }
 116 };
 117
 118 typedef std::shared_ptr<DaemonState> DaemonStatePtr;
 119 typedef std::map<DaemonKey, DaemonStatePtr> DaemonStateCollection;
 120
 121
 122
 123
 124 /**
 125  * Fuse the collection of per-daemon metadata from Ceph into
 126  * a view that can be queried by service type, ID or also
 127  * by server (aka fqdn).
 128  */
 129 class DaemonStateIndex
 130 {
 131   private:
 132   mutable RWLock lock = {"DaemonStateIndex", true, true, true};
 133
 134   std::map<std::string, DaemonStateCollection> by_server;
 135   DaemonStateCollection all;
 136   std::set<DaemonKey> updating;
 137
 138   void _erase(const DaemonKey& dmk);
 139
 140   public:
 141   DaemonStateIndex() {}
 142
 143   // FIXME: shouldn't really be public, maybe construct DaemonState
 144   // objects internally to avoid this.
 145   PerfCounterTypes types;
 146
 147   void insert(DaemonStatePtr dm);
 148   bool exists(const DaemonKey &key) const;
 149   DaemonStatePtr get(const DaemonKey &key);
 150
 151   // Note that these return by value rather than reference to avoid
 152   // callers needing to stay in lock while using result.  Callers must
 153   // still take the individual DaemonState::lock on each entry though.
 154   DaemonStateCollection get_by_server(const std::string &hostname) const;
 155   DaemonStateCollection get_by_service(const std::string &svc_name) const;
 156   DaemonStateCollection get_all() const {return all;}
 157
 158   template<typename Callback, typename...Args>
 159   auto with_daemons_by_server(Callback&& cb, Args&&... args) const ->
 160     decltype(cb(by_server, std::forward<Args>(args)...)) {
 161     RWLock::RLocker l(lock);
 162
 163     return std::forward<Callback>(cb)(by_server, std::forward<Args>(args)...);
 164   }
 165
 166   void notify_updating(const DaemonKey &k) {
 167     RWLock::WLocker l(lock);
 168     updating.insert(k);
 169   }
 170   void clear_updating(const DaemonKey &k) {
 171     RWLock::WLocker l(lock);
 172     updating.erase(k);
 173   }
 174   bool is_updating(const DaemonKey &k) {
 175     RWLock::RLocker l(lock);
 176     return updating.count(k) > 0;
 177   }
 178
 179   /**
 180    * Remove state for all daemons of this type whose names are
 181    * not present in `names_exist`.  Use this function when you have
 182    * a cluster map and want to ensure that anything absent in the map
 183    * is also absent in this class.
 184    */
 185   void cull(const std::string& svc_name,
 186             const std::set<std::string>& names_exist);
 187 };
 188
 189 #endif
 190