refactor: make class 'dns_resolver' as a singleton (apache#1902)

src/runtime/rpc/dns_resolver.h

@@ -26,6 +26,7 @@
 #include "runtime/rpc/rpc_host_port.h"
 #include "utils/errors.h"
 #include "utils/metrics.h"
+#include "utils/singleton.h"
 #include "utils/synchronize.h"
 
 namespace dsn {
@@ -37,15 +38,18 @@ namespace dsn {
 // effect.
 // TODO(yingchun): Now the cache is unlimited, the cache size may be huge. Implement an expiration
 // mechanism to limit the cache size and make it possible to update the resolve result.
-class dns_resolver
+class dns_resolver : public utils::singleton<dns_resolver>
 {
 public:
-    explicit dns_resolver();
-
     // Resolve this host_port to an unique rpc_address.
     rpc_address resolve_address(const host_port &hp);
 
 private:
+    dns_resolver();
+    ~dns_resolver() = default;
+
+    friend class utils::singleton<dns_resolver>;
+
     bool get_cached_addresses(const host_port &hp, std::vector<rpc_address> &addresses);
 
     error_s resolve_addresses(const host_port &hp, std::vector<rpc_address> &addresses);

src/runtime/rpc/group_address.h

@@ -55,7 +55,7 @@ class rpc_group_address : public ref_counter
     void set_leader(rpc_address addr);
     bool remove(rpc_address addr) WARN_UNUSED_RESULT;
     bool contains(rpc_address addr) const WARN_UNUSED_RESULT;
-    int count();
+    int count() const;
 
     const std::vector<rpc_address> &members() const { return _members; }
     rpc_address random_member() const
@@ -194,7 +194,7 @@ inline bool rpc_group_address::contains(rpc_address addr) const
     return _members.end() != std::find(_members.begin(), _members.end(), addr);
 }
 
-inline int rpc_group_address::count()
+inline int rpc_group_address::count() const
 {
     alr_t l(_lock);
     return _members.size();

src/runtime/test/host_port_test.cpp

@@ -230,10 +230,9 @@ TEST(host_port_test, transfer_rpc_address)
 
 TEST(host_port_test, dns_resolver)
 {
-    dns_resolver resolver;
     {
         host_port hp("localhost", 8080);
-        auto addr = resolver.resolve_address(hp);
+        const auto &addr = dns_resolver::instance().resolve_address(hp);
         ASSERT_TRUE(rpc_address("127.0.0.1", 8080) == addr ||
                     rpc_address("127.0.1.1", 8080) == addr);
     }
@@ -248,8 +247,8 @@ TEST(host_port_test, dns_resolver)
         host_port hp2("localhost", 8081);
         g_hp->set_leader(hp2);
 
-        auto addr_grp = resolver.resolve_address(hp_grp);
-        auto g_addr = addr_grp.group_address();
+        const auto &addr_grp = dns_resolver::instance().resolve_address(hp_grp);
+        const auto *const g_addr = addr_grp.group_address();
 
         ASSERT_EQ(g_addr->is_update_leader_automatically(), g_hp->is_update_leader_automatically());
         ASSERT_STREQ(g_addr->name(), g_hp->name());