mon: Update MonMap to work without using namespace

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/mon/MonMap.cc b/src/mon/MonMap.cc
index 215821d743a9f4c7e32045ca30f46154c71e78dd..7f1a3f88c03bafd0b5578668d6f63b9129bb28bd 100644 (file)
--- a/src/mon/MonMap.cc
+++ b/src/mon/MonMap.cc
@@ -25,9 +25,17 @@
 #include "common/dout.h"
 #include "common/Clock.h"
 
+using std::list;
+using std::map;
+using std::ostream;
+using std::set;
+using std::string;
+using std::vector;
+
+using ceph::DNSResolver;
 using ceph::Formatter;
 
-void mon_info_t::encode(bufferlist& bl, uint64_t features) const
+void mon_info_t::encode(ceph::buffer::list& bl, uint64_t features) const
 {
   uint8_t v = 4;
   if (!HAVE_FEATURE(features, SERVER_NAUTILUS)) {
@@ -45,7 +53,7 @@ void mon_info_t::encode(bufferlist& bl, uint64_t features) const
   ENCODE_FINISH(bl);
 }
 
-void mon_info_t::decode(bufferlist::const_iterator& p)
+void mon_info_t::decode(ceph::buffer::list::const_iterator& p)
 {
   DECODE_START(4, p);
   decode(name, p);
@@ -97,29 +105,25 @@ void MonMap::calc_legacy_ranks()
   // added complexity makes up for the additional memory usage of a 'set'.
   set<mon_info_t, rank_cmp> tmp;
 
-  for (map<string,mon_info_t>::iterator p = mon_info.begin();
-      p != mon_info.end();
-      ++p) {
+  for (auto p = mon_info.begin(); p != mon_info.end(); ++p) {
     mon_info_t &m = p->second;
     tmp.insert(m);
   }
 
   // map the set to the actual ranks etc
   unsigned i = 0;
-  for (set<mon_info_t>::iterator p = tmp.begin();
-      p != tmp.end();
-      ++p, ++i) {
+  for (auto p = tmp.begin(); p != tmp.end(); ++p, ++i) {
     ranks[i] = p->name;
   }
 }
 
-void MonMap::encode(bufferlist& blist, uint64_t con_features) const
+void MonMap::encode(ceph::buffer::list& blist, uint64_t con_features) const
 {
   if ((con_features & CEPH_FEATURE_MONNAMES) == 0) {
     using ceph::encode;
     __u16 v = 1;
     encode(v, blist);
-    encode_raw(fsid, blist);
+    ceph::encode_raw(fsid, blist);
     encode(epoch, blist);
     vector<entity_inst_t> mon_inst(ranks.size());
     for (unsigned n = 0; n < ranks.size(); n++) {
@@ -151,7 +155,7 @@ void MonMap::encode(bufferlist& blist, uint64_t con_features) const
     using ceph::encode;
     __u16 v = 2;
     encode(v, blist);
-    encode_raw(fsid, blist);
+    ceph::encode_raw(fsid, blist);
     encode(epoch, blist);
     encode(legacy_mon_addr, blist, con_features);
     encode(last_changed, blist);
@@ -161,7 +165,7 @@ void MonMap::encode(bufferlist& blist, uint64_t con_features) const
 
   if (!HAVE_FEATURE(con_features, SERVER_NAUTILUS)) {
     ENCODE_START(5, 3, blist);
-    encode_raw(fsid, blist);
+    ceph::encode_raw(fsid, blist);
     encode(epoch, blist);
     encode(legacy_mon_addr, blist, con_features);
     encode(last_changed, blist);
@@ -174,7 +178,7 @@ void MonMap::encode(bufferlist& blist, uint64_t con_features) const
   }
 
   ENCODE_START(7, 6, blist);
-  encode_raw(fsid, blist);
+  ceph::encode_raw(fsid, blist);
   encode(epoch, blist);
   encode(last_changed, blist);
   encode(created, blist);
@@ -186,11 +190,11 @@ void MonMap::encode(bufferlist& blist, uint64_t con_features) const
   ENCODE_FINISH(blist);
 }
 
-void MonMap::decode(bufferlist::const_iterator& p)
+void MonMap::decode(ceph::buffer::list::const_iterator& p)
 {
   map<string,entity_addr_t> mon_addr;
   DECODE_START_LEGACY_COMPAT_LEN_16(7, 3, 3, p);
-  decode_raw(fsid, p);
+  ceph::decode_raw(fsid, p);
   decode(epoch, p);
   if (struct_v == 1) {
     vector<entity_inst_t> mon_inst;
@@ -273,7 +277,7 @@ void MonMap::generate_test_instances(list<MonMap*>& o)
 int MonMap::write(const char *fn) 
 {
   // encode
-  bufferlist bl;
+  ceph::buffer::list bl;
   encode(bl, CEPH_FEATURES_ALL);
   
   return bl.write_file(fn);
@@ -282,7 +286,7 @@ int MonMap::write(const char *fn)
 int MonMap::read(const char *fn) 
 {
   // read
-  bufferlist bl;
+  ceph::buffer::list bl;
   std::string error;
   int r = bl.read_file(fn, &error);
   if (r < 0)
@@ -300,9 +304,7 @@ void MonMap::print_summary(ostream& out) const
   // mon_info_t instead. As such, print the map in a way
   // that keeps the expected format.
   bool has_printed = false;
-  for (map<string,mon_info_t>::const_iterator p = mon_info.begin();
-       p != mon_info.end();
-       ++p) {
+  for (auto p = mon_info.begin(); p != mon_info.end(); ++p) {
     if (has_printed)
       out << ",";
     out << p->first << "=" << p->second.public_addrs;
@@ -320,9 +322,7 @@ void MonMap::print(ostream& out) const
   out << "min_mon_release " << (int)min_mon_release
       << " (" << ceph_release_name(min_mon_release) << ")\n";
   unsigned i = 0;
-  for (vector<string>::const_iterator p = ranks.begin();
-       p != ranks.end();
-       ++p) {
+  for (auto p = ranks.begin(); p != ranks.end(); ++p) {
     out << i++ << ": " << get_addrs(*p) << " mon." << *p << "\n";
   }
 }
@@ -341,9 +341,7 @@ void MonMap::dump(Formatter *f) const
   f->close_section();
   f->open_array_section("mons");
   int i = 0;
-  for (vector<string>::const_iterator p = ranks.begin();
-       p != ranks.end();
-       ++p, ++i) {
+  for (auto p = ranks.begin(); p != ranks.end(); ++p, ++i) {
     f->open_object_section("mon");
     f->dump_int("rank", i);
     f->dump_string("name", *p);
@@ -649,8 +647,8 @@ future<> MonMap::read_monmap(const std::string& monmap)
     return f.size().then([this, f = std::move(f)](size_t s) {
       return do_with(make_file_input_stream(f), [this, s](input_stream<char>& in) {
         return in.read_exactly(s).then([this](temporary_buffer<char> buf) {
-          bufferlist bl;
-          bl.append(buffer::create(std::move(buf)));
+          ceph::buffer::list bl;
+          bl.append(ceph::buffer::create(std::move(buf)));
           decode(bl);
         });
       });
@@ -762,7 +760,7 @@ int MonMap::init_with_monmap(const std::string& monmap, std::ostream& errout)
   int r;
   try {
     r = read(monmap.c_str());
-  } catch (buffer::error&) {
+  } catch (ceph::buffer::error&) {
     r = -EINVAL;
   }
   if (r >= 0)

diff --git a/src/mon/MonMap.h b/src/mon/MonMap.h
index 65f933151b605f1a6e540034da48e34ab8f0445d..fed84fb2e6b3910044d500fbef7d8568d66588cc 100644 (file)
--- a/src/mon/MonMap.h
+++ b/src/mon/MonMap.h
@@ -44,7 +44,7 @@ struct mon_info_t {
    *
    * i.e., 'foo' in 'mon.foo'
    */
-  string name;
+  std::string name;
   /**
    * monitor's public address(es)
    *
@@ -59,29 +59,29 @@ struct mon_info_t {
   uint16_t weight{0};
 
   // <REMOVE ME>
-  mon_info_t(const string& n, const entity_addr_t& p_addr, uint16_t p)
+  mon_info_t(const std::string& n, const entity_addr_t& p_addr, uint16_t p)
     : name(n), public_addrs(p_addr), priority(p)
   {}
   // </REMOVE ME>
 
-  mon_info_t(const string& n, const entity_addrvec_t& p_addrs,
+  mon_info_t(const std::string& n, const entity_addrvec_t& p_addrs,
              uint16_t p, uint16_t w)
     : name(n), public_addrs(p_addrs), priority(p), weight(w)
   {}
-  mon_info_t(const string &n, const entity_addrvec_t& p_addrs)
+  mon_info_t(const std::string &n, const entity_addrvec_t& p_addrs)
     : name(n), public_addrs(p_addrs)
   { }
 
   mon_info_t() { }
 
 
-  void encode(bufferlist& bl, uint64_t features) const;
-  void decode(bufferlist::const_iterator& p);
-  void print(ostream& out) const;
+  void encode(ceph::buffer::list& bl, uint64_t features) const;
+  void decode(ceph::buffer::list::const_iterator& p);
+  void print(std::ostream& out) const;
 };
 WRITE_CLASS_ENCODER_FEATURES(mon_info_t)
 
-inline ostream& operator<<(ostream& out, const mon_info_t& mon) {
+inline std::ostream& operator<<(std::ostream& out, const mon_info_t& mon) {
   mon.print(out);
   return out;
 }
@@ -93,10 +93,10 @@ class MonMap {
   utime_t last_changed;
   utime_t created;
 
-  map<string, mon_info_t> mon_info;
-  map<entity_addr_t, string> addr_mons;
+  std::map<std::string, mon_info_t> mon_info;
+  std::map<entity_addr_t, std::string> addr_mons;
 
-  vector<string> ranks;
+  std::vector<std::string> ranks;
 
   /**
    * Persistent Features are all those features that once set on a
@@ -136,7 +136,7 @@ class MonMap {
   // upgrade gate
   uint8_t min_mon_release = 0;
 
-  void _add_ambiguous_addr(const string& name,
+  void _add_ambiguous_addr(const std::string& name,
                            entity_addr_t addr,
                            int priority,
                            int weight,
@@ -172,7 +172,7 @@ public:
    *
    * @param ls list to populate with the monitors' addresses
    */
-  void list_addrs(list<entity_addr_t>& ls) const {
+  void list_addrs(std::list<entity_addr_t>& ls) const {
     for (auto& i : mon_info) {
       for (auto& j : i.second.public_addrs.v) {
        ls.push_back(j);
@@ -207,7 +207,7 @@ public:
    * @param name Monitor name (i.e., 'foo' in 'mon.foo')
    * @param addr Monitor's public address
    */
-  void add(const string &name, const entity_addrvec_t &addrv,
+  void add(const std::string &name, const entity_addrvec_t &addrv,
           uint16_t priority=0, uint16_t weight=0) {
     add(mon_info_t(name, addrv, priority, weight));
   }
@@ -217,7 +217,7 @@ public:
    *
    * @param name Monitor name (i.e., 'foo' in 'mon.foo')
    */
-  void remove(const string &name) {
+  void remove(const std::string &name) {
     ceph_assert(mon_info.count(name));
     mon_info.erase(name);
     ceph_assert(mon_info.count(name) == 0);
@@ -237,7 +237,7 @@ public:
    * @param oldname monitor's current name (i.e., 'foo' in 'mon.foo')
    * @param newname monitor's new name (i.e., 'bar' in 'mon.bar')
    */
-  void rename(string oldname, string newname) {
+  void rename(std::string oldname, std::string newname) {
     ceph_assert(contains(oldname));
     ceph_assert(!contains(newname));
     mon_info[newname] = mon_info[oldname];
@@ -253,7 +253,7 @@ public:
     calc_addr_mons();
   }
 
-  int set_rank(const string& name, int rank) {
+  int set_rank(const std::string& name, int rank) {
     int oldrank = get_rank(name);
     if (oldrank < 0) {
       return -ENOENT;
@@ -268,7 +268,7 @@ public:
     return 0;
   }
 
-  bool contains(const string& name) const {
+  bool contains(const std::string& name) const {
     return mon_info.count(name);
   }
 
@@ -281,7 +281,7 @@ public:
    * @returns true if monmap contains a monitor with address @p;
    *          false otherwise.
    */
-  bool contains(const entity_addr_t &a, string *name=nullptr) const {
+  bool contains(const entity_addr_t &a, std::string *name=nullptr) const {
     for (auto& i : mon_info) {
       for (auto& j : i.second.public_addrs.v) {
        if (j == a) {
@@ -294,7 +294,7 @@ public:
     }
     return false;
   }
-  bool contains(const entity_addrvec_t &av, string *name=nullptr) const {
+  bool contains(const entity_addrvec_t &av, std::string *name=nullptr) const {
     for (auto& i : mon_info) {
       for (auto& j : i.second.public_addrs.v) {
        for (auto& k : av.v) {
@@ -310,27 +310,27 @@ public:
     return false;
   }
 
-  string get_name(unsigned n) const {
+  std::string get_name(unsigned n) const {
     ceph_assert(n < ranks.size());
     return ranks[n];
   }
-  string get_name(const entity_addr_t& a) const {
-    map<entity_addr_t,string>::const_iterator p = addr_mons.find(a);
+  std::string get_name(const entity_addr_t& a) const {
+    std::map<entity_addr_t, std::string>::const_iterator p = addr_mons.find(a);
     if (p == addr_mons.end())
-      return string();
+      return std::string();
     else
       return p->second;
   }
-  string get_name(const entity_addrvec_t& av) const {
+  std::string get_name(const entity_addrvec_t& av) const {
     for (auto& i : av.v) {
-      map<entity_addr_t,string>::const_iterator p = addr_mons.find(i);
+      std::map<entity_addr_t, std::string>::const_iterator p = addr_mons.find(i);
       if (p != addr_mons.end())
        return p->second;
     }
-    return string();
+    return std::string();
   }
 
-  int get_rank(const string& n) const {
+  int get_rank(const std::string& n) const {
     if (auto found = std::find(ranks.begin(), ranks.end(), n);
        found != ranks.end()) {
       return std::distance(ranks.begin(), found);
@@ -339,62 +339,62 @@ public:
     }
   }
   int get_rank(const entity_addr_t& a) const {
-    string n = get_name(a);
+    std::string n = get_name(a);
     if (!n.empty()) {
       return get_rank(n);
     }
     return -1;
   }
   int get_rank(const entity_addrvec_t& av) const {
-    string n = get_name(av);
+    std::string n = get_name(av);
     if (!n.empty()) {
       return get_rank(n);
     }
     return -1;
   }
-  bool get_addr_name(const entity_addr_t& a, string& name) {
+  bool get_addr_name(const entity_addr_t& a, std::string& name) {
     if (addr_mons.count(a) == 0)
       return false;
     name = addr_mons[a];
     return true;
   }
 
-  const entity_addrvec_t& get_addrs(const string& n) const {
+  const entity_addrvec_t& get_addrs(const std::string& n) const {
     ceph_assert(mon_info.count(n));
-    map<string,mon_info_t>::const_iterator p = mon_info.find(n);
+    std::map<std::string,mon_info_t>::const_iterator p = mon_info.find(n);
     return p->second.public_addrs;
   }
   const entity_addrvec_t& get_addrs(unsigned m) const {
     ceph_assert(m < ranks.size());
     return get_addrs(ranks[m]);
   }
-  void set_addrvec(const string& n, const entity_addrvec_t& a) {
+  void set_addrvec(const std::string& n, const entity_addrvec_t& a) {
     ceph_assert(mon_info.count(n));
     mon_info[n].public_addrs = a;
     calc_addr_mons();
   }
-  uint16_t get_priority(const string& n) const {
+  uint16_t get_priority(const std::string& n) const {
     auto it = mon_info.find(n);
     ceph_assert(it != mon_info.end());
     return it->second.priority;
   }
-  uint16_t get_weight(const string& n) const {
+  uint16_t get_weight(const std::string& n) const {
     auto it = mon_info.find(n);
     ceph_assert(it != mon_info.end());
     return it->second.weight;
   }
-  void set_weight(const string& n, uint16_t v) {
+  void set_weight(const std::string& n, uint16_t v) {
     auto it = mon_info.find(n);
     ceph_assert(it != mon_info.end());
     it->second.weight = v;
   }
 
-  void encode(bufferlist& blist, uint64_t con_features) const;
-  void decode(bufferlist& blist) {
+  void encode(ceph::buffer::list& blist, uint64_t con_features) const;
+  void decode(ceph::buffer::list& blist) {
     auto p = std::cbegin(blist);
     decode(p);
   }
-  void decode(bufferlist::const_iterator& p);
+  void decode(ceph::buffer::list::const_iterator& p);
 
   void generate_fsid() {
     fsid.generate_random();
@@ -415,12 +415,12 @@ public:
    *   3 config [mon.*] sections, and 'mon addr' fields in those sections
    *
    * @param cct context (and associated config)
-   * @param errout ostream to send error messages too
+   * @param errout std::ostream to send error messages too
    */
 #ifdef WITH_SEASTAR
   seastar::future<> build_initial(const ceph::common::ConfigProxy& conf, bool for_mkfs);
 #else
-  int build_initial(CephContext *cct, bool for_mkfs, ostream& errout);
+  int build_initial(CephContext *cct, bool for_mkfs, std::ostream& errout);
 #endif
   /**
    * filter monmap given a set of initial members.
@@ -436,16 +436,16 @@ public:
    * @param removed optional pointer to set to insert removed mon addrs to
    */
   void set_initial_members(CephContext *cct,
-                          list<std::string>& initial_members,
-                          string my_name,
+                          std::list<std::string>& initial_members,
+                          std::string my_name,
                           const entity_addrvec_t& my_addrs,
-                          set<entity_addrvec_t> *removed);
+                          std::set<entity_addrvec_t> *removed);
 
-  void print(ostream& out) const;
-  void print_summary(ostream& out) const;
+  void print(std::ostream& out) const;
+  void print_summary(std::ostream& out) const;
   void dump(ceph::Formatter *f) const;
 
-  static void generate_test_instances(list<MonMap*>& o);
+  static void generate_test_instances(std::list<MonMap*>& o);
 protected:
   /**
    * build a monmap from a list of ips
@@ -488,7 +488,7 @@ protected:
 };
 WRITE_CLASS_ENCODER_FEATURES(MonMap)
 
-inline ostream& operator<<(ostream &out, const MonMap &m) {
+inline std::ostream& operator<<(std::ostream &out, const MonMap &m) {
   m.print_summary(out);
   return out;
 }