Modify the Resolver class (#48)

Author: an-tao

trantor/net/inner/AresResolver.cc

@@ -51,7 +51,7 @@ AresResolver::AresResolver(EventLoop* loop, size_t timeout)
     : _loop(loop), _ctx(NULL), _timerActive(false), _timeout(timeout)
 {
     assert(_loop);
-    static char lookups[] = "b";
+    // static char lookups[] = "b";
     struct ares_options options;
     int optmask = ARES_OPT_FLAGS;
     options.flags = ARES_FLAG_NOCHECKRESP;
@@ -62,8 +62,8 @@ AresResolver::AresResolver(EventLoop* loop, size_t timeout)
     options.sock_state_cb_data = this;
     optmask |= ARES_OPT_TIMEOUT;
     options.timeout = 2;
-    optmask |= ARES_OPT_LOOKUPS;
-    options.lookups = lookups;
+    // optmask |= ARES_OPT_LOOKUPS;
+    // options.lookups = lookups;
 
     int status = ares_init_options(&_ctx, &options, optmask);
     if (status != ARES_SUCCESS)
@@ -84,23 +84,33 @@ void AresResolver::resolveInLoop(const std::string& hostname,
                                  const Callback& cb)
 {
     _loop->assertInLoopThread();
-    auto iter = _dnsCache.find(hostname);
-    if (iter != _dnsCache.end())
+    bool cached = false;
+    InetAddress inet;
     {
-        auto& cachedAddr = iter->second;
-        if (_timeout == 0 ||
-            cachedAddr.second.after(_timeout) > trantor::Date::date())
+        std::lock_guard<std::mutex> lock(globalMutex());
+        auto iter = globalCache().find(hostname);
+        if (iter != globalCache().end())
         {
-            struct sockaddr_in addr;
-            memset(&addr, 0, sizeof addr);
-            addr.sin_family = AF_INET;
-            addr.sin_port = 0;
-            addr.sin_addr = cachedAddr.first;
-            InetAddress inet(addr);
-            cb(inet);
-            return;
+            auto& cachedAddr = iter->second;
+            if (_timeout == 0 ||
+                cachedAddr.second.after(_timeout) > trantor::Date::date())
+            {
+                struct sockaddr_in addr;
+                memset(&addr, 0, sizeof addr);
+                addr.sin_family = AF_INET;
+                addr.sin_port = 0;
+                addr.sin_addr = cachedAddr.first;
+                inet = InetAddress(addr);
+                cached = true;
+            }
         }
     }
+    if (cached)
+    {
+        cb(inet);
+        return;
+    }
+
     QueryData* queryData = new QueryData(this, cb, hostname);
     ares_gethostbyname(_ctx,
                        hostname.c_str(),
@@ -157,8 +167,11 @@ void AresResolver::onQueryResult(int status,
         addr.sin_addr = *reinterpret_cast<in_addr*>(result->h_addr);
     }
     InetAddress inet(addr);
-    _dnsCache[hostname].first = addr.sin_addr;
-    _dnsCache[hostname].second = trantor::Date::date();
+    {
+        std::lock_guard<std::mutex> lock(globalMutex());
+        globalCache()[hostname].first = addr.sin_addr;
+        globalCache()[hostname].second = trantor::Date::date();
+    }
     callback(inet);
 }
 

trantor/net/inner/AresResolver.h

@@ -62,8 +62,21 @@ class AresResolver : public Resolver,
     bool _timerActive;
     typedef std::map<int, std::unique_ptr<trantor::Channel>> ChannelList;
     ChannelList _channels;
-    std::unordered_map<std::string, std::pair<struct in_addr, trantor::Date>>
-        _dnsCache;
+    static std::unordered_map<std::string,
+                              std::pair<struct in_addr, trantor::Date>>&
+    globalCache()
+    {
+        static std::unordered_map<std::string,
+                                  std::pair<struct in_addr, trantor::Date>>
+            _dnsCache;
+        return _dnsCache;
+    }
+    static std::mutex& globalMutex()
+    {
+        static std::mutex _mutex;
+        return _mutex;
+    }
+
     const size_t _timeout = 60;
 
     void onRead(int sockfd);

trantor/net/inner/NormalResolver.cc

@@ -17,9 +17,9 @@ void NormalResolver::resolve(const std::string &hostname,
                              const Callback &callback)
 {
     {
-        std::lock_guard<std::mutex> guard(_dnsMutex);
-        auto iter = _dnsCache.find(hostname);
-        if (iter != _dnsCache.end())
+        std::lock_guard<std::mutex> guard(globalMutex());
+        auto iter = globalCache().find(hostname);
+        if (iter != globalCache().end())
         {
             auto &cachedAddr = iter->second;
             if (_timeout == 0 ||
@@ -92,9 +92,9 @@ void NormalResolver::resolve(const std::string &hostname,
                 InetAddress inet(addr);
                 callback(inet);
                 {
-                    std::lock_guard<std::mutex> guard(thisPtr->_dnsMutex);
-                    thisPtr->_dnsCache[hostname].first = addr.sin_addr;
-                    thisPtr->_dnsCache[hostname].second = trantor::Date::date();
+                    std::lock_guard<std::mutex> guard(thisPtr->globalMutex());
+                    thisPtr->globalCache()[hostname].first = addr.sin_addr;
+                    thisPtr->globalCache()[hostname].second = trantor::Date::date();
                 }
                 return;
             }

trantor/net/inner/NormalResolver.h

@@ -30,9 +30,20 @@ class NormalResolver : public Resolver,
     }
 
   private:
-    std::mutex _dnsMutex;
-    std::unordered_map<std::string, std::pair<struct in_addr, trantor::Date>>
-        _dnsCache;
+    static std::unordered_map<std::string,
+                              std::pair<struct in_addr, trantor::Date>>&
+    globalCache()
+    {
+        static std::unordered_map<std::string,
+                                  std::pair<struct in_addr, trantor::Date>>
+            _dnsCache;
+        return _dnsCache;
+    }
+    static std::mutex& globalMutex()
+    {
+        static std::mutex _mutex;
+        return _mutex;
+    }
     trantor::SerialTaskQueue _taskQueue;
     const size_t _timeout = 60;
     std::vector<char> _resolveBuffer;

trantor/tests/DnsTest.cc

@@ -31,6 +31,14 @@ void dns(const std::shared_ptr<trantor::Resolver> &resolver)
                           std::cout << "bad address:" << addr.toIp() << " "
                                     << interval / 1000 << "ms" << std::endl;
                       });
+    resolver->resolve("localhost",
+                      [now](const trantor::InetAddress &addr) {
+                          auto interval =
+                              trantor::Date::now().microSecondsSinceEpoch() -
+                              now.microSecondsSinceEpoch();
+                          std::cout << "localhost:" << addr.toIp() << " "
+                                    << interval / 1000 << "ms" << std::endl;
+                      });
 }
 int main()
 {
@@ -39,4 +47,4 @@ int main()
     dns(resolver);
     loop.runAfter(1.0, [resolver]() { dns(resolver); });
     loop.loop();
-}
+}