public:
uint64_t gid;
std::string name;
+ std::set<std::string> available_modules;
- StandbyInfo(uint64_t gid_, const std::string &name_)
- : gid(gid_), name(name_)
+ StandbyInfo(uint64_t gid_, const std::string &name_,
+ std::set<std::string>& am)
+ : gid(gid_), name(name_), available_modules(am)
{}
StandbyInfo()
void encode(bufferlist& bl) const
{
- ENCODE_START(1, 1, bl);
+ ENCODE_START(2, 1, bl);
::encode(gid, bl);
::encode(name, bl);
+ ::encode(available_modules, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& p)
{
- DECODE_START(1, p);
+ DECODE_START(2, p);
::decode(gid, p);
::decode(name, p);
+ if (struct_v >= 2) {
+ ::decode(available_modules, p);
+ }
DECODE_FINISH(p);
}
};
std::map<uint64_t, StandbyInfo> standbys;
+ std::set<std::string> modules;
+ std::set<std::string> available_modules;
+
epoch_t get_epoch() const { return epoch; }
entity_addr_t get_active_addr() const { return active_addr; }
uint64_t get_active_gid() const { return active_gid; }
bool get_available() const { return available; }
const std::string &get_active_name() const { return active_name; }
+ bool all_support_module(const std::string& module) {
+ if (!available_modules.count(module)) {
+ return false;
+ }
+ for (auto& p : standbys) {
+ if (!p.second.available_modules.count(module)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ bool have_name(const string& name) const {
+ if (active_name == name) {
+ return true;
+ }
+ for (auto& p : standbys) {
+ if (p.second.name == name) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ std::set<std::string> get_all_names() const {
+ std::set<std::string> ls;
+ if (active_name.size()) {
+ ls.insert(active_name);
+ }
+ for (auto& p : standbys) {
+ ls.insert(p.second.name);
+ }
+ return ls;
+ }
+
void encode(bufferlist& bl, uint64_t features) const
{
- ENCODE_START(1, 1, bl);
+ ENCODE_START(2, 1, bl);
::encode(epoch, bl);
::encode(active_addr, bl, features);
::encode(active_gid, bl);
::encode(available, bl);
::encode(active_name, bl);
::encode(standbys, bl);
+ ::encode(modules, bl);
+ ::encode(available_modules, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& p)
{
- DECODE_START(1, p);
+ DECODE_START(2, p);
::decode(epoch, p);
::decode(active_addr, p);
::decode(active_gid, p);
::decode(available, p);
::decode(active_name, p);
::decode(standbys, p);
+ if (struct_v >= 2) {
+ ::decode(modules, p);
+ ::decode(available_modules, p);
+ }
DECODE_FINISH(p);
}
f->open_object_section("standby");
f->dump_int("gid", i.second.gid);
f->dump_string("name", i.second.name);
+ f->open_array_section("available_modules");
+ for (auto& j : i.second.available_modules) {
+ f->dump_string("module", j);
+ }
f->close_section();
+ f->close_section();
+ }
+ f->close_section();
+ f->open_array_section("modules");
+ for (auto& i : modules) {
+ f->dump_string("module", i);
+ }
+ f->close_section();
+ f->open_array_section("available_modules");
+ for (auto& j : available_modules) {
+ f->dump_string("module", j);
}
f->close_section();
}
dump(f);
} else {
if (get_active_gid() != 0) {
- *ss << "active: " << get_active_name();
+ *ss << get_active_name();
if (!available) {
// If the daemon hasn't gone active yet, indicate that.
- *ss << "(starting)";
+ *ss << "(active, starting)";
+ } else {
+ *ss << "(active)";
}
- *ss << " ";
} else {
- *ss << "no daemons active ";
+ *ss << "no daemons active";
}
if (standbys.size()) {
- *ss << "standbys: ";
+ *ss << ", standbys: ";
bool first = true;
for (const auto &i : standbys) {
if (!first) {