Use AsyncNameResolverMan in NameResolveCommand

src/NameResolveCommand.cc

@@ -47,7 +47,7 @@
 #include "UDPTrackerClient.h"
 #include "BtRegistry.h"
 #ifdef ENABLE_ASYNC_DNS
-#include "AsyncNameResolver.h"
+#include "AsyncNameResolverMan.h"
 #endif // ENABLE_ASYNC_DNS
 
 namespace aria2 {
@@ -57,15 +57,21 @@ NameResolveCommand::NameResolveCommand
  const SharedHandle<UDPTrackerRequest>& req)
   : Command(cuid),
     e_(e),
+    asyncNameResolverMan_(new AsyncNameResolverMan()),
     req_(req)
 {
+#ifdef ENABLE_ASYNC_DNS
+  configureAsyncNameResolverMan(asyncNameResolverMan_.get(), e_->getOption());
+  // Currently we only utilize IPv4 DHT for UDP tracker
+  asyncNameResolverMan_->setIPv6(false);
+#endif // ENABLE_ASYNC_DNS
   setStatus(Command::STATUS_ONESHOT_REALTIME);
 }
 
 NameResolveCommand::~NameResolveCommand()
 {
 #ifdef ENABLE_ASYNC_DNS
-  disableNameResolverCheck(resolver_);
+  asyncNameResolverMan_->disableNameResolverCheck(e_, this);
 #endif // ENABLE_ASYNC_DNS
 }
 
@@ -79,32 +85,16 @@ bool NameResolveCommand::execute()
     onShutdown();
     return true;
   }
-#ifdef ENABLE_ASYNC_DNS
+  const std::string& hostname = req_->remoteAddr;
-  if(!resolver_) {
-    int family = AF_INET;
-    resolver_.reset(new AsyncNameResolver(family
-#ifdef HAVE_ARES_ADDR_NODE
-                                          , e_->getAsyncDNSServers()
-#endif // HAVE_ARES_ADDR_NODE
-                                          ));
-  }
-#endif // ENABLE_ASYNC_DNS
-  std::string hostname = req_->remoteAddr;
   std::vector<std::string> res;
   if(util::isNumericHost(hostname)) {
     res.push_back(hostname);
   } else {
 #ifdef ENABLE_ASYNC_DNS
     if(e_->getOption()->getAsBool(PREF_ASYNC_DNS)) {
-      try {
+      if(resolveHostname(res, hostname) == 0) {
-        if(resolveHostname(hostname, resolver_)) {
+        e_->addCommand(this);
-          res = resolver_->getResolvedAddresses();
+        return false;
-        } else {
-          e_->addCommand(this);
-          return false;
-        }
-      } catch(RecoverableException& e) {
-        A2_LOG_ERROR_EX(EX_EXCEPTION_CAUGHT, e);
       }
     } else
 #endif // ENABLE_ASYNC_DNS
@@ -147,47 +137,39 @@ void NameResolveCommand::onSuccess
 
 #ifdef ENABLE_ASYNC_DNS
 
-bool NameResolveCommand::resolveHostname
+int NameResolveCommand::resolveHostname
-(const std::string& hostname,
+(std::vector<std::string>& res, const std::string& hostname)
- const SharedHandle<AsyncNameResolver>& resolver)
 {
-  switch(resolver->getStatus()) {
+  if(!asyncNameResolverMan_->started()) {
-  case AsyncNameResolver::STATUS_READY:
+    asyncNameResolverMan_->startAsync(hostname, e_, this);
-      A2_LOG_INFO(fmt(MSG_RESOLVING_HOSTNAME,
+    return 0;
-                      getCuid(),
+  } else {
-                      hostname.c_str()));
+    switch(asyncNameResolverMan_->getStatus()) {
-    resolver->resolve(hostname);
+    case -1:
-    setNameResolverCheck(resolver);
+      A2_LOG_INFO
-    return false;
+        (fmt(MSG_NAME_RESOLUTION_FAILED, getCuid(), hostname.c_str(),
-  case AsyncNameResolver::STATUS_SUCCESS:
+             asyncNameResolverMan_->getLastError().c_str()));
-    A2_LOG_INFO(fmt(MSG_NAME_RESOLUTION_COMPLETE,
+      return -1;
-                    getCuid(),
+    case 0:
-                    resolver->getHostname().c_str(),
+      return 0;
-                    resolver->getResolvedAddresses().front().c_str()));
+    case 1:
-    return true;
+      asyncNameResolverMan_->getResolvedAddress(res);
-    break;
+      if(res.empty()) {
-  case AsyncNameResolver::STATUS_ERROR:
+        A2_LOG_INFO
-    throw DL_ABORT_EX
+          (fmt(MSG_NAME_RESOLUTION_FAILED, getCuid(), hostname.c_str(),
-      (fmt(MSG_NAME_RESOLUTION_FAILED,
+               "No address returned"));
-           getCuid(),
+        return -1;
-           hostname.c_str(),
+      } else {
-           resolver->getError().c_str()));
+        A2_LOG_INFO(fmt(MSG_NAME_RESOLUTION_COMPLETE,
-  default:
+                        getCuid(), hostname.c_str(), res.front().c_str()));
-    return false;
+        return 1;
+      }
+    }
   }
+  // Unreachable
+  return 0;
 }
 
-void NameResolveCommand::setNameResolverCheck
-(const SharedHandle<AsyncNameResolver>& resolver)
-{
-  e_->addNameResolverCheck(resolver, this);
-}
-
-void NameResolveCommand::disableNameResolverCheck
-(const SharedHandle<AsyncNameResolver>& resolver)
-{
-  e_->deleteNameResolverCheck(resolver, this);
-}
 #endif // ENABLE_ASYNC_DNS
 
 } // namespace aria2

src/NameResolveCommand.h

@@ -47,7 +47,7 @@ namespace aria2 {
 
 class DownloadEngine;
 #ifdef ENABLE_ASYNC_DNS
-class AsyncNameResolver;
+class AsyncNameResolverMan;
 #endif // ENABLE_ASYNC_DNS
 struct UDPTrackerRequest;
 
@@ -56,16 +56,12 @@ private:
   DownloadEngine* e_;
 
 #ifdef ENABLE_ASYNC_DNS
-  SharedHandle<AsyncNameResolver> resolver_;
+  SharedHandle<AsyncNameResolverMan> asyncNameResolverMan_;
 #endif // ENABLE_ASYNC_DNS
 
 #ifdef ENABLE_ASYNC_DNS
-  bool resolveHostname(const std::string& hostname,
+  int resolveHostname(std::vector<std::string>& res,
-                       const SharedHandle<AsyncNameResolver>& resolver);
+                      const std::string& hostname);
-
-  void setNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver);
-
-  void disableNameResolverCheck(const SharedHandle<AsyncNameResolver>& resolver);
 #endif // ENABLE_ASYNC_DNS
 
   SharedHandle<UDPTrackerRequest> req_;