1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 * Ceph - scalable distributed file system
6 * Copyright (C) 2016 John Spray <john.spray@redhat.com>
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.
19 #include "msg/msg_types.h"
20 #include "common/Formatter.h"
21 #include "include/encoding.h"
28 std::set
<std::string
> available_modules
;
30 StandbyInfo(uint64_t gid_
, const std::string
&name_
,
31 std::set
<std::string
>& am
)
32 : gid(gid_
), name(name_
), available_modules(am
)
39 void encode(bufferlist
& bl
) const
41 ENCODE_START(2, 1, bl
);
44 ::encode(available_modules
, bl
);
48 void decode(bufferlist::iterator
& p
)
54 ::decode(available_modules
, p
);
59 WRITE_CLASS_ENCODER(StandbyInfo
)
66 /// global_id of the ceph-mgr instance selected as a leader
67 uint64_t active_gid
= 0;
68 /// server address reported by the leader once it is active
69 entity_addr_t active_addr
;
70 /// whether the nominated leader is active (i.e. has initialized its server)
71 bool available
= false;
72 /// the name (foo in mgr.<foo>) of the active daemon
73 std::string active_name
;
75 std::map
<uint64_t, StandbyInfo
> standbys
;
77 std::set
<std::string
> modules
;
78 std::set
<std::string
> available_modules
;
80 epoch_t
get_epoch() const { return epoch
; }
81 entity_addr_t
get_active_addr() const { return active_addr
; }
82 uint64_t get_active_gid() const { return active_gid
; }
83 bool get_available() const { return available
; }
84 const std::string
&get_active_name() const { return active_name
; }
86 bool all_support_module(const std::string
& module
) {
87 if (!available_modules
.count(module
)) {
90 for (auto& p
: standbys
) {
91 if (!p
.second
.available_modules
.count(module
)) {
98 void encode(bufferlist
& bl
, uint64_t features
) const
100 ENCODE_START(2, 1, bl
);
102 ::encode(active_addr
, bl
, features
);
103 ::encode(active_gid
, bl
);
104 ::encode(available
, bl
);
105 ::encode(active_name
, bl
);
106 ::encode(standbys
, bl
);
107 ::encode(modules
, bl
);
108 ::encode(available_modules
, bl
);
112 void decode(bufferlist::iterator
& p
)
116 ::decode(active_addr
, p
);
117 ::decode(active_gid
, p
);
118 ::decode(available
, p
);
119 ::decode(active_name
, p
);
120 ::decode(standbys
, p
);
122 ::decode(modules
, p
);
123 ::decode(available_modules
, p
);
128 void dump(Formatter
*f
) const {
129 f
->dump_int("epoch", epoch
);
130 f
->dump_int("active_gid", get_active_gid());
131 f
->dump_string("active_name", get_active_name());
132 f
->dump_stream("active_addr") << active_addr
;
133 f
->dump_bool("available", available
);
134 f
->open_array_section("standbys");
135 for (const auto &i
: standbys
) {
136 f
->open_object_section("standby");
137 f
->dump_int("gid", i
.second
.gid
);
138 f
->dump_string("name", i
.second
.name
);
139 f
->open_array_section("available_modules");
140 for (auto& j
: i
.second
.available_modules
) {
141 f
->dump_string("module", j
);
147 f
->open_array_section("modules");
148 for (auto& i
: modules
) {
149 f
->dump_string("module", i
);
152 f
->open_array_section("available_modules");
153 for (auto& j
: available_modules
) {
154 f
->dump_string("module", j
);
159 static void generate_test_instances(list
<MgrMap
*> &l
) {
160 l
.push_back(new MgrMap
);
163 void print_summary(Formatter
*f
, std::ostream
*ss
) const
165 // One or the other, not both
166 assert((ss
!= nullptr) != (f
!= nullptr));
170 if (get_active_gid() != 0) {
171 *ss
<< get_active_name();
173 // If the daemon hasn't gone active yet, indicate that.
174 *ss
<< "(active, starting)";
179 *ss
<< "no daemons active";
181 if (standbys
.size()) {
182 *ss
<< ", standbys: ";
184 for (const auto &i
: standbys
) {
188 *ss
<< i
.second
.name
;
195 friend ostream
& operator<<(ostream
& out
, const MgrMap
& m
) {
197 m
.print_summary(nullptr, &ss
);
198 return out
<< ss
.str();
202 WRITE_CLASS_ENCODER_FEATURES(MgrMap
)