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<entity_type_t, 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   // The perf counters received in MMgrReport messages
 106   DaemonPerfCounters perf_counters;
 107
 108   DaemonState(PerfCounterTypes &types_)
 109     : perf_counters(types_)
 110   {
 111   }
 112 };
 113
 114 typedef std::shared_ptr<DaemonState> DaemonStatePtr;
 115 typedef std::map<DaemonKey, DaemonStatePtr> DaemonStateCollection;
 116
 117
 118
 119
 120 /**
 121  * Fuse the collection of per-daemon metadata from Ceph into
 122  * a view that can be queried by service type, ID or also
 123  * by server (aka fqdn).
 124  */
 125 class DaemonStateIndex
 126 {
 127   private:
 128   std::map<std::string, DaemonStateCollection> by_server;
 129   DaemonStateCollection all;
 130
 131   std::set<DaemonKey> updating;
 132
 133   mutable Mutex lock;
 134
 135   public:
 136
 137   DaemonStateIndex() : lock("DaemonState") {}
 138
 139   // FIXME: shouldn't really be public, maybe construct DaemonState
 140   // objects internally to avoid this.
 141   PerfCounterTypes types;
 142
 143   void insert(DaemonStatePtr dm);
 144   void _erase(const DaemonKey& dmk);
 145
 146   bool exists(const DaemonKey &key) const;
 147   DaemonStatePtr get(const DaemonKey &key);
 148   DaemonStateCollection get_by_server(const std::string &hostname) const;
 149   DaemonStateCollection get_by_type(uint8_t type) const;
 150
 151   const DaemonStateCollection &get_all() const {return all;}
 152   const std::map<std::string, DaemonStateCollection> &get_all_servers() const
 153   {
 154     return by_server;
 155   }
 156
 157   void notify_updating(const DaemonKey &k) { updating.insert(k); }
 158   void clear_updating(const DaemonKey &k) { updating.erase(k); }
 159   bool is_updating(const DaemonKey &k) { return updating.count(k) > 0; }
 160
 161   /**
 162    * Remove state for all daemons of this type whose names are
 163    * not present in `names_exist`.  Use this function when you have
 164    * a cluster map and want to ensure that anything absent in the map
 165    * is also absent in this class.
 166    */
 167   void cull(entity_type_t daemon_type, const std::set<std::string>& names_exist);
 168 };
 169
 170 #endif
 171