]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 MGR_MAP_H_ | |
15 | #define MGR_MAP_H_ | |
16 | ||
17 | #include <sstream> | |
18 | ||
19 | #include "msg/msg_types.h" | |
20 | #include "common/Formatter.h" | |
21 | #include "include/encoding.h" | |
22 | ||
23 | class StandbyInfo | |
24 | { | |
25 | public: | |
26 | uint64_t gid; | |
27 | std::string name; | |
28 | ||
29 | StandbyInfo(uint64_t gid_, const std::string &name_) | |
30 | : gid(gid_), name(name_) | |
31 | {} | |
32 | ||
33 | StandbyInfo() | |
34 | : gid(0) | |
35 | {} | |
36 | ||
37 | void encode(bufferlist& bl) const | |
38 | { | |
39 | ENCODE_START(1, 1, bl); | |
40 | ::encode(gid, bl); | |
41 | ::encode(name, bl); | |
42 | ENCODE_FINISH(bl); | |
43 | } | |
44 | ||
45 | void decode(bufferlist::iterator& p) | |
46 | { | |
47 | DECODE_START(1, p); | |
48 | ::decode(gid, p); | |
49 | ::decode(name, p); | |
50 | DECODE_FINISH(p); | |
51 | } | |
52 | }; | |
53 | WRITE_CLASS_ENCODER(StandbyInfo) | |
54 | ||
55 | class MgrMap | |
56 | { | |
57 | public: | |
58 | epoch_t epoch = 0; | |
59 | ||
60 | /// global_id of the ceph-mgr instance selected as a leader | |
61 | uint64_t active_gid = 0; | |
62 | /// server address reported by the leader once it is active | |
63 | entity_addr_t active_addr; | |
64 | /// whether the nominated leader is active (i.e. has initialized its server) | |
65 | bool available = false; | |
66 | /// the name (foo in mgr.<foo>) of the active daemon | |
67 | std::string active_name; | |
68 | ||
69 | std::map<uint64_t, StandbyInfo> standbys; | |
70 | ||
71 | epoch_t get_epoch() const { return epoch; } | |
72 | entity_addr_t get_active_addr() const { return active_addr; } | |
73 | uint64_t get_active_gid() const { return active_gid; } | |
74 | bool get_available() const { return available; } | |
75 | const std::string &get_active_name() const { return active_name; } | |
76 | ||
77 | void encode(bufferlist& bl, uint64_t features) const | |
78 | { | |
79 | ENCODE_START(1, 1, bl); | |
80 | ::encode(epoch, bl); | |
81 | ::encode(active_addr, bl, features); | |
82 | ::encode(active_gid, bl); | |
83 | ::encode(available, bl); | |
84 | ::encode(active_name, bl); | |
85 | ::encode(standbys, bl); | |
86 | ENCODE_FINISH(bl); | |
87 | } | |
88 | ||
89 | void decode(bufferlist::iterator& p) | |
90 | { | |
91 | DECODE_START(1, p); | |
92 | ::decode(epoch, p); | |
93 | ::decode(active_addr, p); | |
94 | ::decode(active_gid, p); | |
95 | ::decode(available, p); | |
96 | ::decode(active_name, p); | |
97 | ::decode(standbys, p); | |
98 | DECODE_FINISH(p); | |
99 | } | |
100 | ||
101 | void dump(Formatter *f) const { | |
102 | f->dump_int("epoch", epoch); | |
103 | f->dump_int("active_gid", get_active_gid()); | |
104 | f->dump_string("active_name", get_active_name()); | |
105 | f->dump_stream("active_addr") << active_addr; | |
106 | f->dump_bool("available", available); | |
107 | f->open_array_section("standbys"); | |
108 | for (const auto &i : standbys) { | |
109 | f->open_object_section("standby"); | |
110 | f->dump_int("gid", i.second.gid); | |
111 | f->dump_string("name", i.second.name); | |
112 | f->close_section(); | |
113 | } | |
114 | f->close_section(); | |
115 | } | |
116 | ||
117 | static void generate_test_instances(list<MgrMap*> &l) { | |
118 | l.push_back(new MgrMap); | |
119 | } | |
120 | ||
121 | void print_summary(Formatter *f, std::ostream *ss) const | |
122 | { | |
123 | // One or the other, not both | |
124 | assert((ss != nullptr) != (f != nullptr)); | |
125 | if (f) { | |
126 | dump(f); | |
127 | } else { | |
128 | if (get_active_gid() != 0) { | |
31f18b77 | 129 | *ss << get_active_name(); |
7c673cae FG |
130 | if (!available) { |
131 | // If the daemon hasn't gone active yet, indicate that. | |
31f18b77 FG |
132 | *ss << "(active, starting)"; |
133 | } else { | |
134 | *ss << "(active)"; | |
7c673cae | 135 | } |
7c673cae | 136 | } else { |
31f18b77 | 137 | *ss << "no daemons active"; |
7c673cae FG |
138 | } |
139 | if (standbys.size()) { | |
31f18b77 | 140 | *ss << ", standbys: "; |
7c673cae FG |
141 | bool first = true; |
142 | for (const auto &i : standbys) { | |
143 | if (!first) { | |
144 | *ss << ", "; | |
145 | } | |
146 | *ss << i.second.name; | |
147 | first = false; | |
148 | } | |
149 | } | |
150 | } | |
151 | } | |
152 | ||
153 | friend ostream& operator<<(ostream& out, const MgrMap& m) { | |
154 | ostringstream ss; | |
155 | m.print_summary(nullptr, &ss); | |
156 | return out << ss.str(); | |
157 | } | |
158 | }; | |
159 | ||
160 | WRITE_CLASS_ENCODER_FEATURES(MgrMap) | |
161 | ||
162 | #endif | |
163 |