make DnsResolver better

src/manager/DnsCache.cc

@@ -23,42 +23,31 @@
 
 #define GET_CURRENT_SECOND	std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now().time_since_epoch()).count()
 
-#define CONFIDENT_INC		10
-#define	TTL_INC				10
+#define	TTL_INC				5
 
-const DnsCache::DnsHandle *DnsCache::get_inner(const HostPort& host_port, int type)
+const DnsCache::DnsHandle *DnsCache::get_inner(const HostPort& host_port,
+											   int type)
 {
-	int64_t cur_time = GET_CURRENT_SECOND;
+	int64_t cur = GET_CURRENT_SECOND;
 	std::lock_guard<std::mutex> lock(mutex_);
 	const DnsHandle *handle = cache_pool_.get(host_port);
 
-	if (handle)
+	if (handle && ((type == GET_TYPE_TTL && cur > handle->value.expire_time) ||
+		(type == GET_TYPE_CONFIDENT && cur > handle->value.confident_time)))
 	{
-		switch (type)
+		if (!handle->value.delayed())
 		{
-		case GET_TYPE_TTL:
-			if (cur_time > handle->value.expire_time)
-			{
-				const_cast<DnsHandle *>(handle)->value.expire_time += TTL_INC;
-				cache_pool_.release(handle);
-				return NULL;
-			}
-
-			break;
-
-		case GET_TYPE_CONFIDENT:
-			if (cur_time > handle->value.confident_time)
-			{
-				const_cast<DnsHandle *>(handle)->value.confident_time += CONFIDENT_INC;
-				cache_pool_.release(handle);
-				return NULL;
-			}
-
-			break;
-
-		default:
-			break;
+			DnsHandle *h = const_cast<DnsHandle *>(handle);
+			if (type == GET_TYPE_TTL)
+				h->value.expire_time += TTL_INC;
+			else
+				h->value.confident_time += TTL_INC;
+
+			h->value.addrinfo->ai_flags |= 2;
 		}
+
+		cache_pool_.release(handle);
+		return NULL;
 	}
 
 	return handle;

src/manager/DnsCache.h

@@ -35,6 +35,11 @@ struct DnsCacheValue
 	struct addrinfo *addrinfo;
 	int64_t confident_time;
 	int64_t expire_time;
+
+	bool delayed() const
+	{
+		return addrinfo->ai_flags & 2;
+	}
 };
 
 // RAII: NO. Release handle by user
@@ -143,7 +148,7 @@ class DnsCache
 		{
 			struct addrinfo *ai = value.addrinfo;
 
-			if (ai && (ai->ai_flags & AI_PASSIVE))
+			if (ai && (ai->ai_flags & 1))
 				freeaddrinfo(ai);
 			else
 				protocol::DnsUtil::freeaddrinfo(ai);

src/nameservice/WFDnsResolver.cc

@@ -321,12 +321,11 @@ static int __readaddrinfo(const char *path,
 	return ret;
 }
 
-// Add AI_PASSIVE to point that this addrinfo is alloced by getaddrinfo
-static void __add_passive_flags(struct addrinfo *ai)
+static void __set_thread_dns_flag(struct addrinfo *ai)
 {
 	while (ai)
 	{
-		ai->ai_flags |= AI_PASSIVE;
+		ai->ai_flags = 1;
 		ai = ai->ai_next;
 	}
 }
@@ -346,6 +345,32 @@ static ThreadDnsTask *__create_thread_dns_task(const std::string& host,
 	return task;
 }
 
+static std::string __get_cache_host(const std::string& hostname,
+									int family)
+{
+	char c;
+
+	if (family == AF_UNSPEC)
+		c = '*';
+	else if (family == AF_INET)
+		c = '4';
+	else if (family == AF_INET6)
+		c = '6';
+	else
+		c = '?';
+
+	return hostname + c;
+}
+
+static std::string __get_guard_name(const std::string& cache_host,
+									unsigned short port)
+{
+	std::string guard_name("INTERNAL-dns:");
+	guard_name.append(cache_host).append(":");
+	guard_name.append(std::to_string(port));
+	return guard_name;
+}
+
 void WFResolverTask::dispatch()
 {
 	const ParsedURI& uri = ns_params_.uri;
@@ -355,11 +380,22 @@ void WFResolverTask::dispatch()
 	DnsCache *dns_cache = WFGlobal::get_dns_cache();
 	const DnsCache::DnsHandle *addr_handle;
 	std::string hostname = host_;
+	int family = ep_params_.address_family;
+	std::string cache_host = __get_cache_host(hostname, family);
 
 	if (ns_params_.retry_times == 0)
-		addr_handle = dns_cache->get_ttl(hostname, port_);
+		addr_handle = dns_cache->get_ttl(cache_host, port_);
 	else
-		addr_handle = dns_cache->get_confident(hostname, port_);
+		addr_handle = dns_cache->get_confident(cache_host, port_);
+
+	if (in_guard_ && (addr_handle == NULL || addr_handle->value.delayed()))
+	{
+		if (addr_handle)
+			dns_cache->release(addr_handle);
+
+		this->request_dns();
+		return;
+	}
 
 	if (addr_handle)
 	{
@@ -411,7 +447,7 @@ void WFResolverTask::dispatch()
 			DnsOutput dns_out;
 
 			DnsRoutine::run(&dns_in, &dns_out);
-			__add_passive_flags((struct addrinfo *)dns_out.get_addrinfo());
+			__set_thread_dns_flag((struct addrinfo *)dns_out.get_addrinfo());
 			dns_callback_internal(&dns_out, (unsigned int)-1, (unsigned int)-1);
 			this->subtask_done();
 			return;
@@ -434,13 +470,25 @@ void WFResolverTask::dispatch()
 		{
 			DnsOutput out;
 			DnsRoutine::create(&out, ret, ai);
-			__add_passive_flags((struct addrinfo *)out.get_addrinfo());
+			__set_thread_dns_flag((struct addrinfo *)out.get_addrinfo());
 			dns_callback_internal(&out, dns_ttl_default_, dns_ttl_min_);
 			this->subtask_done();
 			return;
 		}
 	}
 
+	std::string guard_name = __get_guard_name(cache_host, port_);
+	WFConditional *guard = WFTaskFactory::create_guard(guard_name, this);
+
+	in_guard_ = true;
+	has_next_ = true;
+
+	series_of(this)->push_front(guard);
+	this->subtask_done();
+}
+
+void WFResolverTask::request_dns()
+{
 	WFDnsClient *client = WFGlobal::get_dns_client();
 	if (client)
 	{
@@ -456,7 +504,7 @@ void WFResolverTask::dispatch()
 			auto&& cb = std::bind(&WFResolverTask::dns_single_callback,
 								  this,
 								  std::placeholders::_1);
-			WFDnsTask *dns_task = client->create_dns_task(hostname, std::move(cb));
+			WFDnsTask *dns_task = client->create_dns_task(host_, std::move(cb));
 
 			if (family == AF_INET6)
 				dns_task->get_req()->set_question_type(DNS_TYPE_AAAA);
@@ -476,10 +524,10 @@ void WFResolverTask::dispatch()
 			dctx[0].port = port_;
 			dctx[1].port = port_;
 
-			task_v4 = client->create_dns_task(hostname, dns_partial_callback);
+			task_v4 = client->create_dns_task(host_, dns_partial_callback);
 			task_v4->user_data = dctx;
 
-			task_v6 = client->create_dns_task(hostname, dns_partial_callback);
+			task_v6 = client->create_dns_task(host_, dns_partial_callback);
 			task_v6->get_req()->set_question_type(DNS_TYPE_AAAA);
 			task_v6->user_data = dctx + 1;
 
@@ -504,7 +552,7 @@ void WFResolverTask::dispatch()
 		auto&& cb = std::bind(&WFResolverTask::thread_dns_callback,
 							  this,
 							  std::placeholders::_1);
-		dns_task = __create_thread_dns_task(hostname, port_,
+		dns_task = __create_thread_dns_task(host_, port_,
 											ep_params_.address_family,
 											std::move(cb));
 		series_of(this)->push_front(dns_task);
@@ -519,12 +567,7 @@ SubTask *WFResolverTask::done()
 	SeriesWork *series = series_of(this);
 
 	if (!has_next_)
-	{
-		if (this->callback)
-			this->callback(this);
-
-		delete this;
-	}
+		task_callback();
 	else
 		has_next_ = false;
 
@@ -558,8 +601,10 @@ void WFResolverTask::dns_callback_internal(void *thrd_dns_output,
 		struct addrinfo *addrinfo = dns_out->move_addrinfo();
 		const DnsCache::DnsHandle *addr_handle;
 		std::string hostname = host_;
+		int family = ep_params_.address_family;
+		std::string cache_host = __get_cache_host(hostname, family);
 
-		addr_handle = dns_cache->put(hostname, port_, addrinfo,
+		addr_handle = dns_cache->put(cache_host, port_, addrinfo,
 									 (unsigned int)ttl_default,
 									 (unsigned int)ttl_min);
 		if (route_manager->get(ns_params_.type, addrinfo, ns_params_.info,
@@ -596,10 +641,7 @@ void WFResolverTask::dns_single_callback(void *net_dns_task)
 		this->error = dns_task->get_error();
 	}
 
-	if (this->callback)
-		this->callback(this);
-
-	delete this;
+	task_callback();
 }
 
 void WFResolverTask::dns_partial_callback(void *net_dns_task)
@@ -659,10 +701,7 @@ void WFResolverTask::dns_parallel_callback(const void *parallel)
 
 	delete[] c4;
 
-	if (this->callback)
-		this->callback(this);
-
-	delete this;
+	task_callback();
 }
 
 void WFResolverTask::thread_dns_callback(void *thrd_dns_task)
@@ -672,7 +711,7 @@ void WFResolverTask::thread_dns_callback(void *thrd_dns_task)
 	if (dns_task->get_state() == WFT_STATE_SUCCESS)
 	{
 		DnsOutput *out = dns_task->get_output();
-		__add_passive_flags((struct addrinfo *)out->get_addrinfo());
+		__set_thread_dns_flag((struct addrinfo *)out->get_addrinfo());
 		dns_callback_internal(out, dns_ttl_default_, dns_ttl_min_);
 	}
 	else
@@ -681,6 +720,19 @@ void WFResolverTask::thread_dns_callback(void *thrd_dns_task)
 		this->error = dns_task->get_error();
 	}
 
+	task_callback();
+}
+
+void WFResolverTask::task_callback()
+{
+	if (in_guard_)
+	{
+		int family = ep_params_.address_family;
+		std::string cache_host = __get_cache_host(host_, family);
+		std::string guard_name = __get_guard_name(cache_host, port_);
+		WFTaskFactory::release_guard_safe(guard_name);
+	}
+
 	if (this->callback)
 		this->callback(this);
 

src/nameservice/WFDnsResolver.h

@@ -38,6 +38,7 @@ class WFResolverTask : public WFRouterTask
 		dns_ttl_default_ = dns_ttl_default;
 		dns_ttl_min_ = dns_ttl_min;
 		has_next_ = false;
+		in_guard_ = false;
 	}
 
 	WFResolverTask(const struct WFNSParams *ns_params,
@@ -46,6 +47,7 @@ class WFResolverTask : public WFRouterTask
 		ns_params_(*ns_params)
 	{
 		has_next_ = false;
+		in_guard_ = false;
 	}
 
 protected:
@@ -62,6 +64,9 @@ class WFResolverTask : public WFRouterTask
 							   unsigned int ttl_default,
 							   unsigned int ttl_min);
 
+	void request_dns();
+	void task_callback();
+
 protected:
 	struct WFNSParams ns_params_;
 	unsigned int dns_ttl_default_;
@@ -72,6 +77,7 @@ class WFResolverTask : public WFRouterTask
 	const char *host_;
 	unsigned short port_;
 	bool has_next_;
+	bool in_guard_;
 };
 
 class WFDnsResolver : public WFNSPolicy