ceph/src/crimson/mgr/client.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 "client.h"
   5
   6 #include "crimson/common/log.h"
   7 #include "crimson/net/Connection.h"
   8 #include "crimson/net/Messenger.h"
   9 #include "messages/MMgrConfigure.h"
  10 #include "messages/MMgrMap.h"
  11 #include "messages/MMgrOpen.h"
  12
  13 namespace {
  14   seastar::logger& logger()
  15   {
  16     return crimson::get_logger(ceph_subsys_mgrc);
  17   }
  18 }
  19
  20 using crimson::common::local_conf;
  21
  22 namespace crimson::mgr
  23 {
  24
  25 Client::Client(crimson::net::Messenger& msgr,
  26                  WithStats& with_stats)
  27   : msgr{msgr},
  28     with_stats{with_stats},
  29     tick_timer{[this] {tick();}}
  30 {}
  31
  32 seastar::future<> Client::start()
  33 {
  34   return seastar::now();
  35 }
  36
  37 seastar::future<> Client::stop()
  38 {
  39   return gate.close().then([this] {
  40     if (conn) {
  41       return conn->close();
  42     } else {
  43       return seastar::now();
  44     }
  45   });
  46 }
  47
  48 seastar::future<> Client::ms_dispatch(crimson::net::Connection* conn,
  49                                       MessageRef m)
  50 {
  51   switch(m->get_type()) {
  52   case MSG_MGR_MAP:
  53     return handle_mgr_map(conn, boost::static_pointer_cast<MMgrMap>(m));
  54   case MSG_MGR_CONFIGURE:
  55     return handle_mgr_conf(conn, boost::static_pointer_cast<MMgrConfigure>(m));
  56   default:
  57     return seastar::now();
  58   }
  59 }
  60
  61 seastar::future<> Client::ms_handle_reset(crimson::net::ConnectionRef c)
  62 {
  63   if (conn == c) {
  64     conn = nullptr;
  65     tick_timer.cancel();
  66   }
  67   return seastar::now();
  68 }
  69
  70 seastar::future<> Client::reconnect()
  71 {
  72   if (conn) {
  73     // crimson::net::Protocol::close() is able to close() in background
  74     (void)conn->close();
  75   }
  76   if (!mgrmap.get_available()) {
  77     logger().warn("No active mgr available yet");
  78     return seastar::now();
  79   }
  80   auto peer = mgrmap.get_active_addrs().front();
  81   conn = msgr.connect(peer, CEPH_ENTITY_TYPE_MGR);
  82   // ask for the mgrconfigure message
  83   auto m = ceph::make_message<MMgrOpen>();
  84   m->daemon_name = local_conf()->name.get_id();
  85   return conn->send(std::move(m));
  86 }
  87
  88 seastar::future<> Client::handle_mgr_map(crimson::net::Connection*,
  89                                          Ref<MMgrMap> m)
  90 {
  91   mgrmap = m->get_map();
  92   if (!conn) {
  93     return reconnect();
  94   } else if (conn->get_peer_addr() !=
  95              mgrmap.get_active_addrs().legacy_addr()) {
  96     return reconnect();
  97   } else {
  98     return seastar::now();
  99   }
 100 }
 101
 102 seastar::future<> Client::handle_mgr_conf(crimson::net::Connection* conn,
 103                                           Ref<MMgrConfigure> m)
 104 {
 105   logger().info("{} {}", __func__, *m);
 106
 107   auto tick_period = std::chrono::seconds{m->stats_period};
 108   if (tick_period.count()) {
 109     if (tick_timer.armed()) {
 110       tick_timer.rearm(tick_timer.get_timeout(), tick_period);
 111     } else {
 112       tick_timer.arm_periodic(tick_period);
 113     }
 114   } else {
 115     tick_timer.cancel();
 116   }
 117   return seastar::now();
 118 }
 119
 120 void Client::tick()
 121 {
 122   (void) seastar::with_gate(gate, [this] {
 123     if (conn) {
 124       auto pg_stats = with_stats.get_stats();
 125       return conn->send(std::move(pg_stats));
 126     } else {
 127       return reconnect();
 128     }
 129   });
 130 }
 131
 132 }