Resolver now uses asynchronous futures.

glynos · glynos · commit 3442d7637a7e · 2013-09-08T11:12:51.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -144,7 +144,7 @@ endif()
 find_package(Doxygen)
 if (DOXYGEN_FOUND)
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
-  add_custom_target(doc ALL
+  add_custom_target(doc
     ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     COMMENT "Generating API documentation with Doxygen" VERBATIM)
diff --git a/http/src/http/v2/client/client.cpp b/http/src/http/v2/client/client.cpp
@@ -46,17 +46,7 @@ namespace network {
 	request_.set_method(method_);
 
 	std::future<response> response;
-	resolver_.resolve(request_.host(), request_.port(),
-	    [&response] (const boost::system::error_code &ec,
-			 boost::iterator_range<async_resolver_delegate::resolver_iterator> resolvers) {
-			    if (ec) {
-			      return;
-			    }
-
-			    // make TCP connection
-			  });
-
-
+	auto endpoints = resolver_.resolve(request_.host(), request_.port());
 	return response;
       }
 
diff --git a/http/src/network/http/v2/client/connection/async_resolver_delegate.hpp b/http/src/network/http/v2/client/connection/async_resolver_delegate.hpp
@@ -52,28 +52,35 @@ namespace network {
 	/**
 	 * \brief Resolves a host asynchronously.
 	 */
-	virtual void resolve(const std::string &host, std::uint16_t port, on_resolved_fn on_resolved) {
+	virtual std::future<resolver_iterator_range>
+	resolve(const std::string &host, std::uint16_t port) {
 	  if (cache_resolved_) {
 	    endpoint_cache::iterator it = endpoint_cache_.find(boost::to_lower_copy(host));
 	    if (it != endpoint_cache_.end()) {
 	      boost::system::error_code ignored;
-	      on_resolved(ignored, it->second);
-	      return;
+	      promise_.set_value(it->second);
+	      return promise_.get_future();
 	    }
 	  }
 
 	  resolver::query query(host, std::to_string(port));
 	  resolver_.async_resolve(query,
               resolver_strand_->wrap(
-	          [=](const boost::system::error_code &ec,
-		      resolver_iterator endpoint_iterator) {
-
-		    auto resolvers = std::make_pair(endpoint_iterator, resolver_iterator());
-		    if (!ec && cache_resolved_) {
-		      endpoint_cache_.insert(std::make_pair(host, resolvers));
+		  [&host, this](const boost::system::error_code &ec,
+				resolver_iterator endpoint_iterator) {
+		    if (ec) {
+		      promise_.set_value(std::make_pair(resolver_iterator(), resolver_iterator()));
+		    }
+		    else {
+		      auto resolvers = std::make_pair(endpoint_iterator, resolver_iterator());
+		      if (cache_resolved_) {
+			endpoint_cache_.insert(std::make_pair(host, resolvers));
+		      }
+		      promise_.set_value(resolvers);
 		    }
-		    on_resolved(ec, resolvers);
 		  }));
+
+	  return promise_.get_future();
 	}
 
 	/**
@@ -87,6 +94,7 @@ namespace network {
 
 	typedef boost::asio::io_service::strand strand;
 	typedef std::unordered_map<std::string, resolver_iterator_range> endpoint_cache;
+	std::promise<resolver_iterator_range> promise_;
 
 	resolver resolver_;
 	std::unique_ptr<strand> resolver_strand_;
diff --git a/http/src/network/http/v2/client/connection/resolver_delegate.hpp b/http/src/network/http/v2/client/connection/resolver_delegate.hpp
@@ -9,6 +9,8 @@
 #include <cstdint>
 #include <string>
 #include <functional>
+#include <utility>
+#include <future>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/range/iterator_range.hpp>
 
@@ -27,6 +29,7 @@ namespace network {
       public:
 
 	typedef boost::asio::ip::tcp::resolver resolver;
+	typedef boost::asio::ip::tcp::endpoint endpoint;
 	typedef resolver::iterator resolver_iterator;
 	typedef boost::iterator_range<resolver_iterator> resolver_iterator_range;
 	typedef std::function<void (const boost::system::error_code &,
@@ -36,7 +39,8 @@ namespace network {
 
 	virtual ~resolver_delegate() noexcept { }
 
-	virtual void resolve(const std::string &host, std::uint16_t port, on_resolved_fn on_resolved) = 0;
+	virtual std::future<resolver_iterator_range>
+	resolve(const std::string &host, std::uint16_t port) = 0;
 
 	virtual void clear_resolved_cache() = 0;
 
diff --git a/http/test/v2/features/client/async_resolver_test.cpp b/http/test/v2/features/client/async_resolver_test.cpp
@@ -22,15 +22,12 @@ Describe(async_resolver) {
     // An HTTP server must be running on 127.0.0.1:80
     // maybe execute a script
 
-    resolver_->resolve("127.0.0.1", 80,
-		       [] (const boost::system::error_code &ec,
-			   const http::async_resolver_delegate::resolver_iterator_range &endpoints) {
-			 for (auto endpoint : endpoints) {
-			   Assert::That(endpoint.endpoint().address().to_string(), Equals("127.0.0.1"));
-			   Assert::That(endpoint.endpoint().port(), Equals(80));
-			 }
-		       });
+    auto endpoints = resolver_->resolve("127.0.0.1", 80);
     io_service_->run_one();
+    for (auto endpoint : endpoints.get()) {
+      Assert::That(endpoint.endpoint().address().to_string(), Equals("127.0.0.1"));
+      Assert::That(endpoint.endpoint().port(), Equals(80));
+    }
   }
 
   std::unique_ptr<boost::asio::io_service> io_service_;
diff --git a/http/test/v2/features/client/normal_connection_test.cpp b/http/test/v2/features/client/normal_connection_test.cpp
@@ -3,6 +3,7 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#include <memory>
 #include <igloo/igloo_alt.h>
 #include <boost/asio.hpp>
 #include "network/http/v2/client/connection/normal_connection_delegate.hpp"
@@ -11,6 +12,25 @@ using namespace igloo;
 using boost::asio::ip::tcp;
 namespace http = network::http::v2;
 
+Describe(normal_http_connection) {
+
+  //void SetUp() {
+  //  io_service_.reset(new boost::asio::io_service);
+  //  connection_.reset(new normal_http_connection(io_service));
+  //
+  //  // resolve endpoints
+  //}
+
+  It(connects_to_localhost) {
+    //auto ec = connection_.connect(endpoint_, "127.0.0.1");
+    // ec
+  }
+
+  std::unique_ptr<boost::asio::io_service> io_service_;
+  std::unique_ptr<http::connection_delegate> connection_;
+
+};
+
 int
 main(int argc, char *argv[]) {
   return TestRunner::RunAllTests(argc, const_cast<const char **>(argv));
