Incremental changes to slowly support persistent connections in HTTP/1.1 Async mode.

deanberris · deanberris · commit 8651d163bf73 · 2011-09-09T14:28:48.000+10:00
diff --git a/boost/network/protocol/http/policies/async_connection.hpp b/boost/network/protocol/http/policies/async_connection.hpp
@@ -16,6 +16,7 @@
 #include <boost/network/protocol/http/traits/resolver_policy.hpp>
 #include <boost/network/protocol/http/client/connection/async_base.hpp>
 #include <boost/network/protocol/http/client/connection_manager.hpp>
+#include <boost/enable_shared_from_this.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
@@ -39,9 +40,9 @@ struct simple_async_connection_manager : connection_manager {
   shared_ptr<resolver_delegate> shared_resolver_delegate;
 };
 
-struct http_1_1_async_connection_manager_pimpl;
+struct http_1_1_async_connection;
 
-struct http_1_1_async_connection_manager : connection_manager {
+struct http_1_1_async_connection_manager : connection_manager, enable_shared_from_this<http_1_1_async_connection_manager> {
   http_1_1_async_connection_manager(bool cache_resolved,
                                     bool follow_redirects,
                                     optional<std::string> openssl_certificate,
@@ -51,6 +52,15 @@ struct http_1_1_async_connection_manager : connection_manager {
       request_base const & request);  // override
   virtual void reset();  // override
   virtual ~http_1_1_async_connection_manager();  // override
+
+ protected:
+  friend struct http_1_1_async_connection;
+  void add_ready_connection(shared_ptr<client_connection> connection_ptr);
+  shared_ptr<client_connection> get_ready_connection(std::string const & host);
+  bool cache_resolved, follow_redirects_;
+  mutex shared_resolver_mutex;
+  shared_ptr<resolver_delegate> shared_resolver_delegate;
+  unordered_map<std::string, shared_ptr<client_connection> > ready_connections;
 };
 
 template <class Tag, unsigned version_major, unsigned version_minor>
diff --git a/boost/network/protocol/http/policies/async_connection.ipp b/boost/network/protocol/http/policies/async_connection.ipp
@@ -10,8 +10,7 @@
 namespace boost { namespace network { namespace http {
 
 struct simple_async_client_connection : client_connection {
-  simple_async_client_connection(asio::io_service & service,
-                                 bool follow_redirects,
+  simple_async_client_connection(bool follow_redirects,
                                  shared_ptr<resolver_delegate> resolver_delegate,
                                  shared_ptr<connection_delegate> connection_delegate);
   virtual shared_ptr<response_base> send_request(std::string const & method,
@@ -21,20 +20,17 @@ struct simple_async_client_connection : client_connection {
   virtual void reset();  // override
   virtual ~client_connection();  // override
  protected:
-  asio::io_service & service_;
   bool follow_redirects_;
   shared_ptr<resolver_delegate> resolver_delegate_;
   shared_ptr<connection_delegate> connection_delegate_;
   shared_ptr<connection> connection_;
 };
 
 simple_async_client_connection::simple_async_client_connection(
-    asio::io_service & service,
     bool follow_redirects,
     shared_ptr<resolver_delegate> resolver_delegate,
     shared_ptr<connection_delegate> connection_delegate)
-: service_(service),
-  follow_redirects_(follow_redirects),
+: follow_redirects_(follow_redirects),
   resolver_delegate_(resolver_delegate),
   connection_delegate_(connection_delegate),
 {}
@@ -45,9 +41,12 @@ shared_ptr<response_base> send_request(std::string const & method,
                                        callback_type callback) {
   shared_ptr<response_base> response;
   shared_ptr<connection> connection_;
-  connection_.reset(new impl::async_connection(resolver_delegate_,
-                                               follow_redirects_,
-                                               connection_delegate_))
+  connection_.reset(new(std::nothrow) impl::async_connection(
+      resolver_delegate_,
+      follow_redirects_,
+      connection_delegate_))
+  if (!connection_.get())
+    BOOST_THROW_EXCEPTION(std::runtime_error("Insufficient memory."));
   response = connection_->start(request, method, get_body, callback);
   return response
 }
@@ -86,16 +85,15 @@ boost::network::http::simple_async_connection_manager::get_connection(
   } else {
     resolver_delegate.reset(new(std::nothrow) async_resolver(service));
     if (!resolver_delegate_.get())
-      BOOST_THROW_EXCEPTION(std::runtime_error("Insuffucuent memory."));
+      BOOST_THROW_EXCEPTION(std::runtime_error("Insuffucient memory."));
   }
   shared_ptr<connection_delegate> connection_delegate;
   bool https = (scheme(request) == "https");
   connection_delegate =
       connection_delegate_factory::new_connection_delegate(
           service, openssl_certificate_, openssl_verify_path_);
   connection.reset(
-      new(std::nothrow) simple_async_client_connection(service,
-                                                       follow_redirects_,
+      new(std::nothrow) simple_async_client_connection(follow_redirects_,
                                                        resolver_delegate,
                                                        connection_delegate));
   if (!connection.get())
@@ -110,4 +108,16 @@ void boost::network::http::simple_async_connection_manager::reset() {
   }
 }
 
+namespace boost { namespace network { namespace http {
+
+struct http_1_1_async_connection : client_connection {
+  http_1_1_async_connection(bool follow_redirects,
+                            shared_ptr<resolver_delegate> resolver_delegate,
+                            shared_ptr<connection_delegate> connection_delegate)
+}
+
+} /* http */
+} /* network */
+} /* boost */
+
 #endif /* BOOST_NETWORK_PROTOCOL_HTTP_POLICIES_ASYNC_CONNECTION_IPP_20110930 */
