#include "messages/MGenericMessage.h"
#include "messages/MMonCommand.h"
#include "messages/MMonCommandAck.h"
+#include "messages/MMonHealth.h"
#include "messages/MMonMetadata.h"
#include "messages/MMonSync.h"
#include "messages/MMonScrub.h"
#include "messages/MAuthReply.h"
#include "messages/MTimeCheck.h"
-#include "messages/MMonHealth.h"
#include "messages/MPing.h"
#include "common/strtol.h"
#include "LogMonitor.h"
#include "AuthMonitor.h"
#include "MgrMonitor.h"
+#include "MgrStatMonitor.h"
#include "mon/QuorumService.h"
+#include "mon/OldHealthMonitor.h"
#include "mon/HealthMonitor.h"
#include "mon/ConfigKeyService.h"
#include "common/config.h"
};
-long parse_pos_long(const char *s, ostream *pss)
-{
- if (*s == '-' || *s == '+') {
- if (pss)
- *pss << "expected numerical value, got: " << s;
- return -EINVAL;
- }
-
- string err;
- long r = strict_strtol(s, 10, &err);
- if ((r == 0) && !err.empty()) {
- if (pss)
- *pss << err;
- return -1;
- }
- if (r < 0) {
- if (pss)
- *pss << "unable to parse positive integer '" << s << "'";
- return -1;
- }
- return r;
-}
-
void C_MonContext::finish(int r) {
if (mon->is_shutdown())
return;
leader_supported_mon_commands_size(0),
mgr_messenger(mgr_m),
mgr_client(cct_, mgr_m),
+ pgservice(nullptr),
store(s),
state(STATE_PROBING),
paxos_service[PAXOS_LOG] = new LogMonitor(this, paxos, "logm");
paxos_service[PAXOS_AUTH] = new AuthMonitor(this, paxos, "auth");
paxos_service[PAXOS_MGR] = new MgrMonitor(this, paxos, "mgr");
+ paxos_service[PAXOS_MGRSTAT] = new MgrStatMonitor(this, paxos, "mgrstat");
+ paxos_service[PAXOS_HEALTH] = new HealthMonitor(this, paxos, "health");
- health_monitor = new HealthMonitor(this);
+ health_monitor = new OldHealthMonitor(this);
config_key_service = new ConfigKeyService(this, paxos);
mon_caps = new MonCap();
int cmdsize;
get_locally_supported_monitor_commands(&cmds, &cmdsize);
set_leader_supported_commands(cmds, cmdsize);
-}
-PaxosService *Monitor::get_paxos_service_by_name(const string& name)
-{
- if (name == "mdsmap")
- return paxos_service[PAXOS_MDSMAP];
- if (name == "monmap")
- return paxos_service[PAXOS_MONMAP];
- if (name == "osdmap")
- return paxos_service[PAXOS_OSDMAP];
- if (name == "pgmap")
- return paxos_service[PAXOS_PGMAP];
- if (name == "logm")
- return paxos_service[PAXOS_LOG];
- if (name == "auth")
- return paxos_service[PAXOS_AUTH];
- if (name == "mgr")
- return paxos_service[PAXOS_MGR];
-
- assert(0 == "given name does not match known paxos service");
- return NULL;
+ // note: OSDMonitor may update this based on the luminous flag.
+ pgservice = mgrstatmon()->get_pg_stat_service();
}
Monitor::~Monitor()
bool read_only = (command == "mon_status" ||
command == "mon metadata" ||
command == "quorum_status" ||
- command == "ops");
+ command == "ops" ||
+ command == "sessions");
(read_only ? audit_clog->debug() : audit_clog->info())
<< "from='admin socket' entity='admin socket' "
if (f) {
f->flush(ss);
}
+ } else if (command == "sessions") {
+
+ if (f) {
+ f->open_array_section("sessions");
+ for (auto p : session_map.sessions) {
+ f->dump_stream("session") << *p;
+ }
+ f->close_section();
+ f->flush(ss);
+ }
+
} else {
assert(0 == "bad AdminSocket command binding");
}
admin_hook,
"show the ops currently in flight");
assert(r == 0);
+ r = admin_socket->register_command("sessions",
+ "sessions",
+ admin_hook,
+ "list existing sessions");
+ assert(r == 0);
lock.Lock();
for (int i = 0; i < PAXOS_NUM; ++i) {
paxos_service[i]->post_refresh();
}
+ load_metadata();
}
void Monitor::register_cluster_logger()
admin_socket->unregister_command("quorum enter");
admin_socket->unregister_command("quorum exit");
admin_socket->unregister_command("ops");
+ admin_socket->unregister_command("sessions");
delete admin_hook;
admin_hook = NULL;
}
}
quorum.clear();
outside_quorum.clear();
+ quorum_feature_map.clear();
scrub_reset();
while (sp.last_committed < paxos->get_version() && left > 0) {
bufferlist bl;
sp.last_committed++;
- store->get(paxos->get_name(), sp.last_committed, bl);
- // TODO: what if store->get returns error or empty bl?
+
+ int err = store->get(paxos->get_name(), sp.last_committed, bl);
+ assert(err == 0);
+
tx->put(paxos->get_name(), sp.last_committed, bl);
left -= bl.length();
dout(20) << __func__ << " including paxos state " << sp.last_committed
set<int> q;
q.insert(rank);
- const MonCommand *my_cmds;
- int cmdsize;
+ map<int,Metadata> metadata;
+ collect_metadata(&metadata[0]);
+
+ const MonCommand *my_cmds = nullptr;
+ int cmdsize = 0;
get_locally_supported_monitor_commands(&my_cmds, &cmdsize);
win_election(elector.get_epoch(), q,
CEPH_FEATURES_ALL,
ceph::features::mon::get_supported(),
+ metadata,
my_cmds, cmdsize);
}
void Monitor::win_election(epoch_t epoch, set<int>& active, uint64_t features,
const mon_feature_t& mon_features,
+ const map<int,Metadata>& metadata,
const MonCommand *cmdset, int cmdsize)
{
dout(10) << __func__ << " epoch " << epoch << " quorum " << active
quorum = active;
quorum_con_features = features;
quorum_mon_features = mon_features;
+ pending_metadata = metadata;
outside_quorum.clear();
clog->info() << "mon." << name << "@" << rank
logger->inc(l_mon_election_win);
+ // inject new metadata in first transaction.
+ {
+ // include previous metadata for missing mons (that aren't part of
+ // the current quorum).
+ map<int,Metadata> m = metadata;
+ for (unsigned rank = 0; rank < monmap->size(); ++rank) {
+ if (m.count(rank) == 0 &&
+ mon_metadata.count(rank)) {
+ m[rank] = mon_metadata[rank];
+ }
+ }
+
+ // FIXME: This is a bit sloppy because we aren't guaranteed to submit
+ // a new transaction immediately after the election finishes. We should
+ // do that anyway for other reasons, though.
+ MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
+ bufferlist bl;
+ ::encode(m, bl);
+ t->put(MONITOR_STORE_PREFIX, "last_metadata", bl);
+ }
+
finish_election();
if (monmap->size() > 1 &&
monmap->get_epoch() > 0) {
do_health_to_clog_interval();
scrub_event_start();
}
-
- Metadata my_meta;
- collect_sys_info(&my_meta, g_ceph_context);
- my_meta["addr"] = stringify(messenger->get_myaddr());
- update_mon_metadata(rank, std::move(my_meta));
}
void Monitor::lose_election(epoch_t epoch, set<int> &q, int l,
finish_election();
- if (quorum_con_features & CEPH_FEATURE_MON_METADATA) {
+ if ((quorum_con_features & CEPH_FEATURE_MON_METADATA) &&
+ !HAVE_FEATURE(quorum_con_features, SERVER_LUMINOUS)) {
+ // for pre-luminous mons only
Metadata sys_info;
- collect_sys_info(&sys_info, g_ceph_context);
+ collect_metadata(&sys_info);
messenger->send_message(new MMonMetadata(sys_info),
monmap->get_inst(get_leader()));
}
}
+void Monitor::collect_metadata(Metadata *m)
+{
+ collect_sys_info(m, g_ceph_context);
+ (*m)["addr"] = stringify(messenger->get_myaddr());
+}
+
void Monitor::finish_election()
{
apply_quorum_to_compatset_features();
dout(10) << __func__ << " required_features " << required_features << dendl;
}
+void Monitor::get_combined_feature_map(FeatureMap *fm)
+{
+ *fm += session_map.feature_map;
+ for (auto id : quorum) {
+ if (id != rank) {
+ *fm += quorum_feature_map[id];
+ }
+ }
+}
+
void Monitor::sync_force(Formatter *f, ostream& ss)
{
bool free_formatter = false;
monmap->dump(f);
f->close_section();
+ f->dump_object("feature_map", session_map.feature_map);
f->close_section(); // mon_status
if (free_formatter) {
dout(10) << __func__ << (force ? " (force)" : "") << dendl;
- list<string> status;
- health_status_t overall = get_health(status, NULL, NULL);
+ if (osdmon()->osdmap.require_osd_release >= CEPH_RELEASE_LUMINOUS) {
+ string summary;
+ health_status_t level = get_health_status(false, nullptr, &summary);
+ if (!force &&
+ summary == health_status_cache.summary &&
+ level == health_status_cache.overall)
+ return;
+ if (level == HEALTH_OK)
+ clog->info() << "overall " << summary;
+ else if (level == HEALTH_WARN)
+ clog->warn() << "overall " << summary;
+ else if (level == HEALTH_ERR)
+ clog->error() << "overall " << summary;
+ else
+ ceph_abort();
+ health_status_cache.summary = summary;
+ health_status_cache.overall = level;
+ } else {
+ // for jewel only
+ list<string> status;
+ health_status_t overall = get_health(status, NULL, NULL);
+ dout(25) << __func__
+ << (force ? " (force)" : "")
+ << dendl;
+
+ string summary = joinify(status.begin(), status.end(), string("; "));
- dout(25) << __func__
- << (force ? " (force)" : "")
- << dendl;
+ if (!force &&
+ overall == health_status_cache.overall &&
+ !health_status_cache.summary.empty() &&
+ health_status_cache.summary == summary) {
+ // we got a dup!
+ return;
+ }
+
+ clog->info() << summary;
+
+ health_status_cache.overall = overall;
+ health_status_cache.summary = summary;
+ }
+}
+
+health_status_t Monitor::get_health_status(
+ bool want_detail,
+ Formatter *f,
+ std::string *plain,
+ const char *sep1,
+ const char *sep2)
+{
+ health_status_t r = HEALTH_OK;
+ bool compat = g_conf->mon_health_preluminous_compat;
+ if (f) {
+ f->open_object_section("health");
+ f->open_object_section("checks");
+ }
+
+ string summary;
+ string *psummary = f ? nullptr : &summary;
+ for (auto& svc : paxos_service) {
+ r = std::min(r, svc->get_health_checks().dump_summary(
+ f, psummary, sep2, want_detail));
+ }
+
+ if (f) {
+ f->close_section();
+ f->dump_stream("status") << r;
+ } else {
+ // one-liner: HEALTH_FOO[ thing1[; thing2 ...]]
+ *plain = stringify(r);
+ if (summary.size()) {
+ *plain += sep1;
+ *plain += summary;
+ }
+ *plain += "\n";
+ }
- string summary = joinify(status.begin(), status.end(), string("; "));
+ if (f && compat) {
+ f->open_array_section("summary");
+ for (auto& svc : paxos_service) {
+ svc->get_health_checks().dump_summary_compat(f);
+ }
+ f->close_section();
+ f->dump_stream("overall_status") << r;
+ }
+
+ if (want_detail) {
+ if (f && compat) {
+ f->open_array_section("detail");
+ }
+
+ for (auto& svc : paxos_service) {
+ svc->get_health_checks().dump_detail(f, plain, compat);
+ }
+
+ if (f && compat) {
+ f->close_section();
+ }
+ }
+ if (f) {
+ f->close_section();
+ }
+ return r;
+}
- if (!force &&
- overall == health_status_cache.overall &&
- !health_status_cache.summary.empty() &&
- health_status_cache.summary == summary) {
- // we got a dup!
+void Monitor::log_health(
+ const health_check_map_t& updated,
+ const health_check_map_t& previous,
+ MonitorDBStore::TransactionRef t)
+{
+ if (!g_conf->mon_health_to_clog) {
return;
}
+ // FIXME: log atomically as part of @t instead of using clog.
+ dout(10) << __func__ << " updated " << updated.checks.size()
+ << " previous " << previous.checks.size()
+ << dendl;
+ for (auto& p : updated.checks) {
+ auto q = previous.checks.find(p.first);
+ if (q == previous.checks.end()) {
+ // new
+ ostringstream ss;
+ ss << "Health check failed: " << p.second.summary << " ("
+ << p.first << ")";
+ if (p.second.severity == HEALTH_WARN)
+ clog->warn() << ss.str();
+ else
+ clog->error() << ss.str();
+ } else {
+ if (p.second.summary != q->second.summary ||
+ p.second.severity != q->second.severity) {
+ // summary or severity changed (ignore detail changes at this level)
+ ostringstream ss;
+ ss << "Health check update: " << p.second.summary << " (" << p.first << ")";
+ if (p.second.severity == HEALTH_WARN)
+ clog->warn() << ss.str();
+ else
+ clog->error() << ss.str();
+ }
+ }
+ }
+ for (auto& p : previous.checks) {
+ if (!updated.checks.count(p.first)) {
+ // cleared
+ ostringstream ss;
+ if (p.first == "DEGRADED_OBJECTS") {
+ clog->info() << "All degraded objects recovered";
+ } else if (p.first == "OSD_FLAGS") {
+ clog->info() << "OSD flags cleared";
+ } else {
+ clog->info() << "Health check cleared: " << p.first << " (was: "
+ << p.second.summary << ")";
+ }
+ }
+ }
- clog->info() << summary;
+ if (previous.checks.size() && updated.checks.size() == 0) {
+ // We might be going into a fully healthy state, check
+ // other subsystems
+ bool any_checks = false;
+ for (auto& svc : paxos_service) {
+ if (&(svc->get_health_checks()) == &(previous)) {
+ // Ignore the ones we're clearing right now
+ continue;
+ }
- health_status_cache.overall = overall;
- health_status_cache.summary = summary;
+ if (svc->get_health_checks().checks.size() > 0) {
+ any_checks = true;
+ break;
+ }
+ }
+ if (!any_checks) {
+ clog->info() << "Cluster is now healthy";
+ }
+ }
}
health_status_t Monitor::get_health(list<string>& status,
s->get_health(summary, detailbl ? &detail : NULL, cct);
}
- health_monitor->get_health(f, summary, (detailbl ? &detail : NULL));
-
- if (f) {
- f->open_object_section("timechecks");
- f->dump_unsigned("epoch", get_epoch());
- f->dump_int("round", timecheck_round);
- f->dump_stream("round_status")
- << ((timecheck_round%2) ? "on-going" : "finished");
- }
+ health_monitor->get_health(summary, (detailbl ? &detail : NULL));
health_status_t overall = HEALTH_OK;
if (!timecheck_skews.empty()) {
list<string> warns;
- if (f)
- f->open_array_section("mons");
for (map<entity_inst_t,double>::iterator i = timecheck_skews.begin();
i != timecheck_skews.end(); ++i) {
entity_inst_t inst = i->first;
double skew = i->second;
double latency = timecheck_latencies[inst];
string name = monmap->get_name(inst.addr);
-
ostringstream tcss;
health_status_t tcstatus = timecheck_status(tcss, skew, latency);
if (tcstatus != HEALTH_OK) {
if (overall > tcstatus)
overall = tcstatus;
warns.push_back(name);
-
ostringstream tmp_ss;
tmp_ss << "mon." << name
<< " addr " << inst.addr << " " << tcss.str()
<< " (latency " << latency << "s)";
detail.push_back(make_pair(tcstatus, tmp_ss.str()));
}
-
- if (f) {
- f->open_object_section("mon");
- f->dump_string("name", name.c_str());
- f->dump_float("skew", skew);
- f->dump_float("latency", latency);
- f->dump_stream("health") << tcstatus;
- if (tcstatus != HEALTH_OK)
- f->dump_stream("details") << tcss.str();
- f->close_section();
- }
}
if (!warns.empty()) {
ostringstream ss;
status.push_back(ss.str());
summary.push_back(make_pair(HEALTH_WARN, "Monitor clock skew detected "));
}
- if (f)
- f->close_section();
}
- if (f)
- f->close_section();
if (f)
f->open_array_section("summary");
if (f)
f->open_object_section("status");
- // reply with the status for all the components
- list<string> health;
- get_health(health, NULL, f);
-
if (f) {
f->dump_stream("fsid") << monmap->get_fsid();
+ get_health_status(false, f, nullptr);
f->dump_unsigned("election_epoch", get_epoch());
{
f->open_array_section("quorum");
monmap->dump(f);
f->close_section();
f->open_object_section("osdmap");
- osdmon()->osdmap.print_summary(f, cout);
+ osdmon()->osdmap.print_summary(f, cout, string(12, ' '));
f->close_section();
f->open_object_section("pgmap");
- pgmon()->pg_map.print_summary(f, NULL);
+ pgservice->print_summary(f, NULL);
f->close_section();
f->open_object_section("fsmap");
mdsmon()->get_fsmap().print_summary(f, NULL);
f->close_section();
-
f->open_object_section("mgrmap");
mgrmon()->get_map().print_summary(f, nullptr);
f->close_section();
+
+ f->dump_object("servicemap", mgrstatmon()->get_service_map());
f->close_section();
} else {
- ss << " cluster " << monmap->get_fsid() << "\n";
- ss << " health " << joinify(health.begin(), health.end(),
- string("\n ")) << "\n";
- ss << " monmap " << *monmap << "\n";
- ss << " election epoch " << get_epoch()
- << ", quorum " << get_quorum() << " " << get_quorum_names() << "\n";
- if (mdsmon()->get_fsmap().filesystem_count() > 0) {
- ss << " fsmap " << mdsmon()->get_fsmap() << "\n";
+ ss << " cluster:\n";
+ ss << " id: " << monmap->get_fsid() << "\n";
+
+ string health;
+ if (osdmon()->osdmap.require_osd_release >= CEPH_RELEASE_LUMINOUS) {
+ get_health_status(false, nullptr, &health,
+ "\n ", "\n ");
+ } else {
+ list<string> ls;
+ get_health(ls, NULL, f);
+ health = joinify(ls.begin(), ls.end(),
+ string("\n "));
}
- if (mgrmon()->in_use()) {
- ss << " mgr ";
- mgrmon()->get_map().print_summary(nullptr, &ss);
+ ss << " health: " << health << "\n";
+
+ ss << "\n \n services:\n";
+ {
+ size_t maxlen = 3;
+ auto& service_map = mgrstatmon()->get_service_map();
+ for (auto& p : service_map.services) {
+ maxlen = std::max(maxlen, p.first.size());
+ }
+ string spacing(maxlen - 3, ' ');
+ const auto quorum_names = get_quorum_names();
+ const auto mon_count = monmap->mon_info.size();
+ ss << " mon: " << spacing << mon_count << " daemons, quorum "
+ << quorum_names;
+ if (quorum_names.size() != mon_count) {
+ std::list<std::string> out_of_q;
+ for (size_t i = 0; i < monmap->ranks.size(); ++i) {
+ if (quorum.count(i) == 0) {
+ out_of_q.push_back(monmap->ranks[i]);
+ }
+ }
+ ss << ", out of quorum: " << joinify(out_of_q.begin(),
+ out_of_q.end(), std::string(", "));
+ }
+ ss << "\n";
+ if (mgrmon()->in_use()) {
+ ss << " mgr: " << spacing;
+ mgrmon()->get_map().print_summary(nullptr, &ss);
+ ss << "\n";
+ }
+ if (mdsmon()->get_fsmap().filesystem_count() > 0) {
+ ss << " mds: " << spacing << mdsmon()->get_fsmap() << "\n";
+ }
+ ss << " osd: " << spacing;
+ osdmon()->osdmap.print_summary(NULL, ss, string(maxlen + 6, ' '));
ss << "\n";
+ for (auto& p : service_map.services) {
+ ss << " " << p.first << ": " << string(maxlen - p.first.size(), ' ')
+ << p.second.get_summary() << "\n";
+ }
}
- osdmon()->osdmap.print_summary(NULL, ss);
- pgmon()->pg_map.print_summary(NULL, &ss);
+ ss << "\n \n data:\n";
+ pgservice->print_summary(NULL, &ss);
+ ss << "\n ";
}
}
Formatter *f = Formatter::create("json");
// hide mgr commands until luminous upgrade is complete
bool hide_mgr_flag =
- !osdmon()->osdmap.test_flag(CEPH_OSDMAP_REQUIRE_LUMINOUS);
+ osdmon()->osdmap.require_osd_release < CEPH_RELEASE_LUMINOUS;
format_command_descriptions(leader_supported_mon_commands,
leader_supported_mon_commands_size, f, &rdata,
hide_mgr_flag);
<< "cmd=" << m->cmd << ": dispatch";
if (mon_cmd->is_mgr() &&
- osdmon()->osdmap.test_flag(CEPH_OSDMAP_REQUIRE_LUMINOUS)) {
+ osdmon()->osdmap.require_osd_release >= CEPH_RELEASE_LUMINOUS) {
const auto& hdr = m->get_header();
uint64_t size = hdr.front_len + hdr.middle_len + hdr.data_len;
uint64_t max =
mdsmon()->dispatch(op);
return;
}
- if (module == "osd" || prefix == "pg map") {
+ if ((module == "osd" || prefix == "pg map") &&
+ prefix != "osd last-stat-seq") {
osdmon()->dispatch(op);
return;
}
prefix != "mon compact" &&
prefix != "mon scrub" &&
prefix != "mon sync force" &&
- prefix != "mon metadata") {
+ prefix != "mon metadata" &&
+ prefix != "mon versions" &&
+ prefix != "mon count-metadata") {
monmon()->dispatch(op);
return;
}
end -= start;
dout(1) << "finished manual compaction in " << end << " seconds" << dendl;
ostringstream oss;
- oss << "compacted leveldb in " << end;
+ oss << "compacted " << g_conf->get_val<std::string>("mon_keyvaluedb") << " in " << end << " seconds";
rs = oss.str();
r = 0;
}
rs = "must supply options to be parsed in a single string";
r = -EINVAL;
}
+ } else if (prefix == "time-sync-status") {
+ if (!f)
+ f.reset(Formatter::create("json-pretty"));
+ f->open_object_section("time_sync");
+ if (!timecheck_skews.empty()) {
+ f->open_object_section("time_skew_status");
+ for (auto& i : timecheck_skews) {
+ entity_inst_t inst = i.first;
+ double skew = i.second;
+ double latency = timecheck_latencies[inst];
+ string name = monmap->get_name(inst.addr);
+ ostringstream tcss;
+ health_status_t tcstatus = timecheck_status(tcss, skew, latency);
+ f->open_object_section(name.c_str());
+ f->dump_float("skew", skew);
+ f->dump_float("latency", latency);
+ f->dump_stream("health") << tcstatus;
+ if (tcstatus != HEALTH_OK) {
+ f->dump_stream("details") << tcss.str();
+ }
+ f->close_section();
+ }
+ f->close_section();
+ }
+ f->open_object_section("timechecks");
+ f->dump_unsigned("epoch", get_epoch());
+ f->dump_int("round", timecheck_round);
+ f->dump_stream("round_status") << ((timecheck_round%2) ?
+ "on-going" : "finished");
+ f->close_section();
+ f->close_section();
+ f->flush(rdata);
+ r = 0;
+ rs = "";
} else if (prefix == "status" ||
prefix == "health" ||
prefix == "df") {
}
rdata.append(ds);
} else if (prefix == "health") {
- list<string> health_str;
- get_health(health_str, detail == "detail" ? &rdata : NULL, f.get());
- if (f) {
- f->flush(ds);
- ds << '\n';
+ if (osdmon()->osdmap.require_osd_release >= CEPH_RELEASE_LUMINOUS) {
+ string plain;
+ get_health_status(detail == "detail", f.get(), f ? nullptr : &plain);
+ if (f) {
+ f->flush(rdata);
+ } else {
+ rdata.append(plain);
+ }
} else {
- assert(!health_str.empty());
- ds << health_str.front();
- health_str.pop_front();
- if (!health_str.empty()) {
- ds << ' ';
- ds << joinify(health_str.begin(), health_str.end(), string("; "));
+ list<string> health_str;
+ get_health(health_str, detail == "detail" ? &rdata : NULL, f.get());
+ if (f) {
+ f->flush(ds);
+ ds << '\n';
+ } else {
+ assert(!health_str.empty());
+ ds << health_str.front();
+ health_str.pop_front();
+ if (!health_str.empty()) {
+ ds << ' ';
+ ds << joinify(health_str.begin(), health_str.end(), string("; "));
+ }
}
+ bufferlist comb;
+ comb.append(ds);
+ if (detail == "detail")
+ comb.append(rdata);
+ rdata = comb;
}
- bufferlist comb;
- comb.append(ds);
- if (detail == "detail")
- comb.append(rdata);
- rdata = comb;
} else if (prefix == "df") {
bool verbose = (detail == "detail");
if (f)
f->open_object_section("stats");
- pgmon()->pg_map.dump_fs_stats(&ds, f.get(), verbose);
+ pgservice->dump_fs_stats(&ds, f.get(), verbose);
if (!f)
ds << '\n';
- pgmon()->pg_map.dump_pool_stats(osdmon()->osdmap, &ds, f.get(), verbose);
+ pgservice->dump_pool_stats(osdmon()->osdmap, &ds, f.get(), verbose);
if (f) {
f->close_section();
monmon()->dump_info(f.get());
osdmon()->dump_info(f.get());
mdsmon()->dump_info(f.get());
- pgmon()->dump_info(f.get());
authmon()->dump_info(f.get());
+ pgservice->dump_info(f.get());
paxos->dump_info(f.get());
ss2 << "report " << rdata.crc32c(CEPH_MON_PORT);
rs = ss2.str();
r = 0;
+ } else if (prefix == "osd last-stat-seq") {
+ int64_t osd;
+ cmd_getval(g_ceph_context, cmdmap, "id", osd);
+ uint64_t seq = mgrstatmon()->get_last_osd_stat_seq(osd);
+ if (f) {
+ f->dump_unsigned("seq", seq);
+ f->flush(ds);
+ } else {
+ ds << seq;
+ rdata.append(ds);
+ }
+ rs = "";
+ r = 0;
} else if (prefix == "node ls") {
string node_type("all");
cmd_getval(g_ceph_context, cmdmap, "type", node_type);
rdata.append(ds);
rs = "";
r = 0;
+ } else if (prefix == "features") {
+ if (!is_leader() && !is_peon()) {
+ dout(10) << " waiting for quorum" << dendl;
+ waitfor_quorum.push_back(new C_RetryMessage(this, op));
+ return;
+ }
+ if (!is_leader()) {
+ forward_request_leader(op);
+ return;
+ }
+ if (!f)
+ f.reset(Formatter::create("json-pretty"));
+ FeatureMap fm;
+ get_combined_feature_map(&fm);
+ f->dump_object("features", fm);
+ f->flush(rdata);
+ rs = "";
+ r = 0;
} else if (prefix == "mon metadata") {
if (!f)
f.reset(Formatter::create("json-pretty"));
f->flush(ds);
rdata.append(ds);
rs = "";
+ } else if (prefix == "mon versions") {
+ if (!f)
+ f.reset(Formatter::create("json-pretty"));
+ count_metadata("ceph_version", f.get());
+ f->flush(ds);
+ rdata.append(ds);
+ rs = "";
+ r = 0;
+ } else if (prefix == "mon count-metadata") {
+ if (!f)
+ f.reset(Formatter::create("json-pretty"));
+ string field;
+ cmd_getval(g_ceph_context, cmdmap, "property", field);
+ count_metadata(field, f.get());
+ f->flush(ds);
+ rdata.append(ds);
+ rs = "";
+ r = 0;
} else if (prefix == "quorum_status") {
// make sure our map is readable and up to date
if (!is_leader() && !is_peon()) {
void Monitor::remove_session(MonSession *s)
{
- dout(10) << "remove_session " << s << " " << s->inst << dendl;
+ dout(10) << "remove_session " << s << " " << s->inst
+ << " features 0x" << std::hex << s->con_features << std::dec << dendl;
assert(s->con);
assert(!s->closed);
for (set<uint64_t>::iterator p = s->routed_request_tids.begin();
if (s && s->closed) {
return;
}
+
+ if (src_is_mon && s) {
+ ConnectionRef con = m->get_connection();
+ if (con->get_messenger() && con->get_features() != s->con_features) {
+ // only update features if this is a non-anonymous connection
+ dout(10) << __func__ << " feature change for " << m->get_source_inst()
+ << " (was " << s->con_features
+ << ", now " << con->get_features() << ")" << dendl;
+ // connection features changed - recreate session.
+ if (s->con && s->con != con) {
+ dout(10) << __func__ << " connection for " << m->get_source_inst()
+ << " changed from session; mark down and replace" << dendl;
+ s->con->mark_down();
+ }
+ if (s->item.is_on_list()) {
+ // forwarded messages' sessions are not in the sessions map and
+ // exist only while the op is being handled.
+ remove_session(s);
+ }
+ s->put();
+ s = nullptr;
+ }
+ }
+
if (!s) {
// if the sender is not a monitor, make sure their first message for a
// session is an MAuth. If it is not, assume it's a stray message,
}
assert(s);
con->set_priv(s->get());
- dout(10) << __func__ << " new session " << s << " " << *s << dendl;
+ dout(10) << __func__ << " new session " << s << " " << *s
+ << " features 0x" << std::hex
+ << s->con_features << std::dec << dendl;
op->set_session(s);
logger->set(l_mon_num_sessions, session_map.get_size());
paxos_service[PAXOS_MGR]->dispatch(op);
break;
- // pg
+ // MgrStat
+ case MSG_MON_MGR_REPORT:
case CEPH_MSG_STATFS:
- case MSG_PGSTATS:
case MSG_GETPOOLSTATS:
+ paxos_service[PAXOS_MGRSTAT]->dispatch(op);
+ break;
+
+ // pg
+ case MSG_PGSTATS:
paxos_service[PAXOS_PGMAP]->dispatch(op);
break;
health_monitor->dispatch(op);
break;
+ case MSG_MON_HEALTH_CHECKS:
+ op->set_type_service();
+ paxos_service[PAXOS_HEALTH]->dispatch(op);
+ break;
+
default:
dealt_with = false;
break;
logmon()->check_sub(s->sub_map[p->first]);
} else if (p->first == "mgrmap" || p->first == "mgrdigest") {
mgrmon()->check_sub(s->sub_map[p->first]);
+ } else if (p->first == "servicemap") {
+ mgrstatmon()->check_sub(s->sub_map[p->first]);
}
}
void Monitor::update_mon_metadata(int from, Metadata&& m)
{
- pending_metadata.insert(make_pair(from, std::move(m)));
-
- bufferlist bl;
- int err = store->get(MONITOR_STORE_PREFIX, "last_metadata", bl);
- map<int, Metadata> last_metadata;
- if (!err) {
- bufferlist::iterator iter = bl.begin();
- ::decode(last_metadata, iter);
- pending_metadata.insert(last_metadata.begin(), last_metadata.end());
- }
+ // NOTE: this is now for legacy (kraken or jewel) mons only.
+ pending_metadata[from] = std::move(m);
MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
- bl.clear();
+ bufferlist bl;
::encode(pending_metadata, bl);
t->put(MONITOR_STORE_PREFIX, "last_metadata", bl);
paxos->trigger_propose();
}
-int Monitor::load_metadata(map<int, Metadata>& metadata)
+int Monitor::load_metadata()
{
bufferlist bl;
int r = store->get(MONITOR_STORE_PREFIX, "last_metadata", bl);
if (r)
return r;
bufferlist::iterator it = bl.begin();
- ::decode(metadata, it);
+ ::decode(mon_metadata, it);
+
+ pending_metadata = mon_metadata;
return 0;
}
int Monitor::get_mon_metadata(int mon, Formatter *f, ostream& err)
{
assert(f);
- map<int, Metadata> last_metadata;
- if (int r = load_metadata(last_metadata)) {
- err << "Unable to load metadata: " << cpp_strerror(r);
- return r;
- }
- if (!last_metadata.count(mon)) {
+ if (!mon_metadata.count(mon)) {
err << "mon." << mon << " not found";
return -EINVAL;
}
- const Metadata& m = last_metadata[mon];
+ const Metadata& m = mon_metadata[mon];
for (Metadata::const_iterator p = m.begin(); p != m.end(); ++p) {
f->dump_string(p->first.c_str(), p->second);
}
return 0;
}
-int Monitor::print_nodes(Formatter *f, ostream& err)
+void Monitor::count_metadata(const string& field, Formatter *f)
{
- map<int, Metadata> metadata;
- if (int r = load_metadata(metadata)) {
- err << "Unable to load metadata.\n";
- return r;
+ map<string,int> by_val;
+ for (auto& p : mon_metadata) {
+ auto q = p.second.find(field);
+ if (q == p.second.end()) {
+ by_val["unknown"]++;
+ } else {
+ by_val[q->second]++;
+ }
}
+ f->open_object_section(field.c_str());
+ for (auto& p : by_val) {
+ f->dump_int(p.first.c_str(), p.second);
+ }
+ f->close_section();
+}
+int Monitor::print_nodes(Formatter *f, ostream& err)
+{
map<string, list<int> > mons; // hostname => mon
- for (map<int, Metadata>::iterator it = metadata.begin();
- it != metadata.end(); ++it) {
+ for (map<int, Metadata>::iterator it = mon_metadata.begin();
+ it != mon_metadata.end(); ++it) {
const Metadata& m = it->second;
Metadata::const_iterator hostname = m.find("hostname");
if (hostname == m.end()) {
}
bufferlist bl;
- //TODO: what when store->get returns error or empty bl?
- store->get(k.first, k.second, bl);
+ int err = store->get(k.first, k.second, bl);
+ assert(err == 0);
+
uint32_t key_crc = bl.crc32c(0);
dout(30) << __func__ << " " << k << " bl " << bl.length() << " bytes"
<< " crc " << key_crc << dendl;
r->prefix_keys[k.first]++;
- if (r->prefix_crc.count(k.first) == 0)
+ if (r->prefix_crc.count(k.first) == 0) {
r->prefix_crc[k.first] = 0;
+ }
r->prefix_crc[k.first] = bl.crc32c(r->prefix_crc[k.first]);
if (cct->_conf->mon_scrub_inject_crc_mismatch > 0.0 &&
projects / ceph.git / blobdiff