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/Mutex.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   // FIXME: this state is really local to DaemonServer, it's part
  78   // of the protocol rather than being part of what other classes
  79   // mgiht want to read.  Maybe have a separate session object
  80   // inside DaemonServer instead of stashing session-ish state here?
  81   std::set<std::string> declared_types;
  82
  83   void update(MMgrReport *report);
  84
  85   void clear()
  86   {
  87     instances.clear();
  88     declared_types.clear();
  89   }
  90 };
  91
  92 // The state that we store about one daemon
  93 class DaemonState
  94 {
  95   public:
  96   DaemonKey key;
  97
  98   // The hostname where daemon was last seen running (extracted
  99   // from the metadata)
 100   std::string hostname;
 101
 102   // The metadata (hostname, version, etc) sent from the daemon
 103   std::map<std::string, std::string> metadata;
 104
 105   // Ephemeral state
 106   bool service_daemon = false;
 107   utime_t service_status_stamp;
 108   std::map<std::string, std::string> service_status;
 109   utime_t last_service_beacon;
 110
 111   // The perf counters received in MMgrReport messages
 112   DaemonPerfCounters perf_counters;
 113
 114   DaemonState(PerfCounterTypes &types_)
 115     : perf_counters(types_)
 116   {
 117   }
 118 };
 119
 120 typedef std::shared_ptr<DaemonState> DaemonStatePtr;
 121 typedef std::map<DaemonKey, DaemonStatePtr> DaemonStateCollection;
 122
 123
 124
 125
 126 /**
 127  * Fuse the collection of per-daemon metadata from Ceph into
 128  * a view that can be queried by service type, ID or also
 129  * by server (aka fqdn).
 130  */
 131 class DaemonStateIndex
 132 {
 133   private:
 134   std::map<std::string, DaemonStateCollection> by_server;
 135   DaemonStateCollection all;
 136
 137   std::set<DaemonKey> updating;
 138
 139   mutable Mutex lock;
 140
 141   public:
 142
 143   DaemonStateIndex() : lock("DaemonState") {}
 144
 145   // FIXME: shouldn't really be public, maybe construct DaemonState
 146   // objects internally to avoid this.
 147   PerfCounterTypes types;
 148
 149   void insert(DaemonStatePtr dm);
 150   void _erase(const DaemonKey& dmk);
 151
 152   bool exists(const DaemonKey &key) const;
 153   DaemonStatePtr get(const DaemonKey &key);
 154   DaemonStateCollection get_by_server(const std::string &hostname) const;
 155   DaemonStateCollection get_by_service(const std::string &svc_name) const;
 156
 157   const DaemonStateCollection &get_all() const {return all;}
 158   const std::map<std::string, DaemonStateCollection> &get_all_servers() const
 159   {
 160     return by_server;
 161   }
 162
 163   void notify_updating(const DaemonKey &k) { updating.insert(k); }
 164   void clear_updating(const DaemonKey &k) { updating.erase(k); }
 165   bool is_updating(const DaemonKey &k) { return updating.count(k) > 0; }
 166
 167   /**
 168    * Remove state for all daemons of this type whose names are
 169    * not present in `names_exist`.  Use this function when you have
 170    * a cluster map and want to ensure that anything absent in the map
 171    * is also absent in this class.
 172    */
 173   void cull(const std::string& svc_name,
 174             const std::set<std::string>& names_exist);
 175 };
 176
 177 #endif
 178