Introducing client_options and request_options.

deanberris · deanberris · commit 9d492c3b8652 · 2012-03-04T20:40:41.000+11:00
This commit makes changes to the API that moves the options setting to a
different type to keep the client API relatively stable even across
version releases supporting newer options. The intention is to keep the
ABI stable as well as we add more supported features in the form of
options in two levels: the client, and the request.

The client_options type is meant to define options that affect the
behavior of the constructed client and the connections it creates
internally. The request_options on the other hand define per-request
options pertaining to the HTTP implementation.

This paves the way for supporting more optional modes and extensions
that can and will be easily testable and turned on/off in a programmatic
manner.
diff --git a/boost/network/protocol/http/client/base.hpp b/boost/network/protocol/http/client/base.hpp
@@ -10,27 +10,29 @@
 #include <boost/function.hpp>
 #include <boost/range/iterator_range.hpp>
 #include <boost/asio/io_service.hpp>
-#include <boost/network/protocol/http/client/connection_manager.hpp>
 #include <boost/network/protocol/http/response.hpp>
 #include <boost/network/protocol/http/request.hpp>
 
 namespace boost { namespace network { namespace http {
 
 struct client_base_pimpl;
 
+class request_options;
+
+class client_options;
+
 struct client_base {
   typedef
     function<void(boost::iterator_range<char const *> const &, system::error_code const &)>
     body_callback_function_type;
 
-  client_base(shared_ptr<connection_manager> connection_manager_);
-  client_base(asio::io_service & service,
-              shared_ptr<connection_manager> connection_manager_);
+  explicit client_base(client_options const &options);
   ~client_base();
   response const request_skeleton(request const & request_,
                                   std::string const & method,
                                   bool get_body,
-                                  body_callback_function_type callback);
+                                  body_callback_function_type callback,
+                                  request_options const &options);
   void clear_resolved_cache();
  private:
   client_base_pimpl * pimpl;
diff --git a/boost/network/protocol/http/client/base.ipp b/boost/network/protocol/http/client/base.ipp
@@ -8,6 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/network/protocol/http/client/base.hpp>
+#include <boost/network/protocol/http/client/options.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/strand.hpp>
 #include <boost/thread/thread.hpp>
@@ -21,67 +22,52 @@ struct client_base_pimpl {
   typedef
     function<void(boost::iterator_range<char const *> const &, system::error_code const &)>
     body_callback_function_type;
-  client_base_pimpl(shared_ptr<connection_manager> connection_manager_);
-  client_base_pimpl(asio::io_service & service, shared_ptr<connection_manager> connection_manager_);
+  client_base_pimpl(client_options const &options);
   response const request_skeleton(request const & request_,
                                   std::string const & method,
                                   bool get_body,
-                                  body_callback_function_type callback);
+                                  body_callback_function_type callback,
+                                  request_options const &options);
   ~client_base_pimpl();
  private:
+  client_options options_;
   boost::asio::io_service * service_ptr;
-  boost::asio::io_service & service_;
   boost::shared_ptr<boost::asio::io_service::work> sentinel_;
   boost::shared_ptr<boost::thread> lifetime_thread_;
   shared_ptr<connection_manager> connection_manager_;
 };
 
-client_base::client_base(shared_ptr<connection_manager> connection_manager_)
-: pimpl(new (std::nothrow) client_base_pimpl(connection_manager_))
-{}
-
-client_base::client_base(asio::io_service & service,
-                         shared_ptr<connection_manager> connection_manager_)
-: pimpl(new (std::nothrow) client_base_pimpl(service, connection_manager_))
+client_base::client_base(client_options const &options)
+: pimpl(new (std::nothrow) client_base_pimpl(options))
 {}
 
 response const client_base::request_skeleton(request const & request_,
                                              std::string const & method,
                                              bool get_body,
-                                             body_callback_function_type callback) {
-  return pimpl->request_skeleton(request_, method, get_body, callback);
+                                             body_callback_function_type callback,
+                                             request_options const &options) {
+  return pimpl->request_skeleton(request_, method, get_body, callback, options);
 }
 
 client_base::~client_base() {
   delete pimpl;
 }
 
-client_base_pimpl::client_base_pimpl(shared_ptr<connection_manager> connection_manager)
-  : service_ptr(new (std::nothrow) boost::asio::io_service),
-  service_(*service_ptr),
-  sentinel_(new (std::nothrow) boost::asio::io_service::work(service_)),
-  connection_manager_(connection_manager)
+client_base_pimpl::client_base_pimpl(client_options const &options)
+  : options_(options),
+  service_ptr(options.io_service()),
+  sentinel_(new (std::nothrow) boost::asio::io_service::work(*service_ptr)),
+  connection_manager_(options.connection_manager())
 {
   lifetime_thread_.reset(new (std::nothrow) boost::thread(
     boost::bind(
       &boost::asio::io_service::run,
-      &service_
+      service_ptr
       )));
   if (!lifetime_thread_.get())
     BOOST_THROW_EXCEPTION(std::runtime_error("Cannot allocate client lifetime thread; not enough memory."));
 }
 
-client_base_pimpl::client_base_pimpl(boost::asio::io_service & service,
-             shared_ptr<connection_manager> connection_manager)
-  : service_ptr(0),
-  service_(service),
-  sentinel_(new (std::nothrow) boost::asio::io_service::work(service_)),
-  connection_manager_(connection_manager)
-{
-  if (!sentinel_.get())
-    BOOST_THROW_EXCEPTION(std::runtime_error("Cannot allocate sentinel; not enough memory."));
-}
-
 client_base_pimpl::~client_base_pimpl()
 {
   sentinel_.reset();
@@ -97,12 +83,13 @@ response const client_base_pimpl::request_skeleton(
   request const & request_,
   std::string const & method,
   bool get_body,
-  body_callback_function_type callback
+  body_callback_function_type callback,
+  request_options const &options
   )
 {
   shared_ptr<client_connection> connection_;
-  connection_ = connection_manager_->get_connection(service_, request_);
-  return connection_->send_request(method, request_, get_body, callback);
+  connection_ = connection_manager_->get_connection(*service_ptr, request_, options_);
+  return connection_->send_request(method, request_, get_body, callback, options);
 }
 
 } // namespace http
diff --git a/boost/network/protocol/http/client/client_connection.hpp b/boost/network/protocol/http/client/client_connection.hpp
@@ -15,14 +15,17 @@
 
 namespace boost { namespace network { namespace http {
 
+class request_options;
+
 struct client_connection {
   typedef function<void(iterator_range<char const *> const &,
                         system::error_code const &)>
       callback_type;
   virtual response send_request(std::string const & method,
                                 request const & request,
                                 bool get_body,
-                                callback_type callback) = 0;
+                                callback_type callback,
+                                request_options const &options) = 0;
   virtual client_connection * clone() const = 0;
   virtual void reset() = 0;
   virtual ~client_connection() = 0;
diff --git a/boost/network/protocol/http/client/connection/async_normal.hpp b/boost/network/protocol/http/client/connection/async_normal.hpp
@@ -31,7 +31,8 @@ struct http_async_connection : client_connection
   virtual response send_request(std::string const & method,
                                 request const & request,
                                 bool get_body,
-                                callback_type callback);  // override
+                                callback_type callback,
+                                request_options const &options);  // override
   virtual void reset();  // override
   virtual ~http_async_connection();
  private:
diff --git a/boost/network/protocol/http/client/connection/async_normal.ipp b/boost/network/protocol/http/client/connection/async_normal.ipp
@@ -43,7 +43,8 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
   response start(request const & request,
                  std::string const & method,
                  bool get_body,
-                 body_callback_function_type callback) {
+                 body_callback_function_type callback,
+                 request_options const &options) {
     response response_;
     this->init_response(response_);
     // Use HTTP/1.1 -- at some point we might want to implement a different
@@ -757,8 +758,9 @@ http_async_connection * http_async_connection::clone() const {
 response http_async_connection::send_request(std::string const & method,
                                              request const & request,
                                              bool get_body,
-                                             callback_type callback) {
-  return pimpl->start(request, method, get_body, callback);
+                                             callback_type callback,
+                                             request_options const &options) {
+  return pimpl->start(request, method, get_body, callback, options);
 }
 
 void http_async_connection::reset() {
diff --git a/boost/network/protocol/http/client/connection/connection_delegate_factory.hpp b/boost/network/protocol/http/client/connection/connection_delegate_factory.hpp
@@ -12,18 +12,18 @@
 
 namespace boost { namespace network { namespace http {
 
+class client_options;
+
 struct connection_delegate_factory {
   typedef shared_ptr<connection_delegate> connection_delegate_ptr;
 
   connection_delegate_factory();
 
   // This is the factory method that actually returns the delegate instance.
-  // TODO Support passing in proxy settings when crafting connections.
   virtual connection_delegate_ptr create_connection_delegate(
       asio::io_service & service,
       bool https,
-      optional<std::string> certificate_filename,
-      optional<std::string> verify_path);
+      client_options const &options);
 
   virtual ~connection_delegate_factory();
 
diff --git a/boost/network/protocol/http/client/connection/connection_delegate_factory.ipp b/boost/network/protocol/http/client/connection/connection_delegate_factory.ipp
@@ -13,6 +13,7 @@
 #endif /* BOOST_NETWORK_ENABLE_HTTPS */
 
 #include <boost/network/protocol/http/client/connection/connection_delegate_factory.hpp>
+#include <boost/network/protocol/http/client/options.hpp>
 
 namespace boost { namespace network { namespace http {
 
@@ -22,14 +23,12 @@ connection_delegate_factory::connection_delegate_ptr
 connection_delegate_factory::create_connection_delegate(
     asio::io_service & service,
     bool https,
-    optional<std::string> certificate_filename,
-    optional<std::string> verify_path) {
+    client_options const &options) {
   connection_delegate_ptr delegate;
   if (https) {
 #ifdef BOOST_NETWORK_ENABLE_HTTPS
     delegate.reset(new ssl_delegate(service,
-                                    certificate_filename,
-                                    verify_path));
+                                    options));
 #else
     BOOST_THROW_EXCEPTION(std::runtime_error("HTTPS not supported."));
 #endif /* BOOST_NETWORK_ENABLE_HTTPS */
diff --git a/boost/network/protocol/http/client/connection/connection_factory.hpp b/boost/network/protocol/http/client/connection/connection_factory.hpp
@@ -13,13 +13,14 @@
 
 namespace boost { namespace network { namespace http {
 
+class client_options;
+
+struct client_connection;
+
 struct connection_factory {
-  virtual shared_ptr<client_connection> create_connection(asio::io_service & service,
+  virtual shared_ptr<client_connection> create_connection(asio::io_service &service,
                                                           request_base const & request,
-                                                          bool cache_resolved,
-                                                          bool follow_redirects,
-                                                          optional<std::string> openssl_certificate,
-                                                          optional<std::string> openssl_verify_path) = 0;
+                                                          client_options const &options) = 0;
   virtual ~connection_factory() = 0; // pure virtual, interface only.
 };
   
diff --git a/boost/network/protocol/http/client/connection/simple_connection_factory.hpp b/boost/network/protocol/http/client/connection/simple_connection_factory.hpp
@@ -23,10 +23,7 @@ struct simple_connection_factory : connection_factory {
                             shared_ptr<resolver_delegate_factory> res_delegate_factory);
   virtual shared_ptr<client_connection> create_connection(asio::io_service & service,
                                                           request_base const & request,
-                                                          bool cache_resolved,
-                                                          bool follow_redirects,
-                                                          optional<std::string> openssl_certificate,
-                                                          optional<std::string> openssl_verify_path); // override
+                                                          client_options const & options); // override
   virtual ~simple_connection_factory();
  private:
   scoped_ptr<simple_connection_factory_pimpl> pimpl;
diff --git a/boost/network/protocol/http/client/connection/simple_connection_factory.ipp b/boost/network/protocol/http/client/connection/simple_connection_factory.ipp
@@ -11,6 +11,7 @@
 #include <boost/network/protocol/http/client/connection/resolver_delegate_factory.hpp>
 #include <boost/network/protocol/http/client/connection/connection_delegate_factory.hpp>
 #include <boost/network/protocol/http/client/connection/async_normal.hpp>
+#include <boost/network/protocol/http/client/options.hpp>
 
 namespace boost { namespace network { namespace http {
 
@@ -24,19 +25,15 @@ struct simple_connection_factory_pimpl {
   shared_ptr<client_connection> create_connection(
       asio::io_service & service,
       request_base const & request,
-      bool cache_resolved,
-      bool follow_redirects,
-      optional<std::string> openssl_certificate,
-      optional<std::string> openssl_verify_path) {
+      client_options const & options) {
     ::boost::network::uri::uri uri_(destination(request));
     bool https = to_lower_copy(scheme(uri_)) == "https";
     shared_ptr<client_connection> conn_;
     conn_.reset(new (std::nothrow) http_async_connection(
-      res_delegate_factory_->create_resolver_delegate(service, cache_resolved),
-      conn_delegate_factory_->create_connection_delegate(
-        service, https, openssl_certificate, openssl_verify_path),
+      res_delegate_factory_->create_resolver_delegate(service, options.cache_resolved()),
+      conn_delegate_factory_->create_connection_delegate(service, https, options),
       service,
-      follow_redirects));
+      options.follow_redirects()));
     return conn_;
   }
 
@@ -62,12 +59,8 @@ simple_connection_factory::simple_connection_factory(shared_ptr<connection_deleg
 shared_ptr<client_connection>
 simple_connection_factory::create_connection(asio::io_service & service,
                                              request_base const & request,
-                                             bool cache_resolved,
-                                             bool follow_redirects,
-                                             optional<std::string> openssl_certificate,
-                                             optional<std::string> openssl_verify_path) {
-  return pimpl->create_connection(service, request, cache_resolved, follow_redirects,
-                                  openssl_certificate, openssl_verify_path);
+                                             client_options const &options) {
+  return pimpl->create_connection(service, request, options);
 }
 
 simple_connection_factory::~simple_connection_factory() {
diff --git a/boost/network/protocol/http/client/connection/ssl_delegate.hpp b/boost/network/protocol/http/client/connection/ssl_delegate.hpp
@@ -10,15 +10,15 @@
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/ssl.hpp>
 #include <boost/network/protocol/http/client/connection/connection_delegate.hpp>
+#include <boost/network/protocol/http/client/options.hpp>
 #include <boost/optional.hpp>
 #include <boost/enable_shared_from_this.hpp>
 
 namespace boost { namespace network { namespace http {
 
 struct ssl_delegate : connection_delegate, enable_shared_from_this<ssl_delegate> {
   ssl_delegate(asio::io_service & service,
-                      optional<std::string> certificate_filename,
-                      optional<std::string> verify_path);
+               client_options const &options);
 
   virtual void connect(asio::ip::tcp::endpoint & endpoint,
                        function<void(system::error_code const &)> handler);
@@ -30,7 +30,7 @@ struct ssl_delegate : connection_delegate, enable_shared_from_this<ssl_delegate>
 
  private:
   asio::io_service & service_;
-  optional<std::string> certificate_filename_, verify_path_;
+  client_options options_;
   scoped_ptr<asio::ssl::context> context_;
   scoped_ptr<asio::ssl::stream<asio::ip::tcp::socket> > socket_;
 
diff --git a/boost/network/protocol/http/client/connection/ssl_delegate.ipp b/boost/network/protocol/http/client/connection/ssl_delegate.ipp
@@ -7,29 +7,38 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/network/protocol/http/client/options.hpp>
 #include <boost/network/protocol/http/client/connection/ssl_delegate.hpp>
 #include <boost/bind.hpp>
 
 boost::network::http::ssl_delegate::ssl_delegate(asio::io_service & service,
-                                         optional<std::string> certificate_filename,
-                                         optional<std::string> verify_path) :
+                                                 client_options const &options) :
   service_(service),
-  certificate_filename_(certificate_filename),
-  verify_path_(verify_path) {}
+  options_(options) {}
 
 void boost::network::http::ssl_delegate::connect(
     asio::ip::tcp::endpoint & endpoint,
     function<void(system::error_code const &)> handler) {
   context_.reset(new asio::ssl::context(
       service_,
       asio::ssl::context::sslv23_client));
-  if (certificate_filename_ || verify_path_) {
-    context_->set_verify_mode(asio::ssl::context::verify_peer);
-    if (certificate_filename_) context_->load_verify_file(*certificate_filename_);
-    if (verify_path_) context_->add_verify_path(*verify_path_);
-  } else {
-    context_->set_verify_mode(asio::ssl::context::verify_none);
+  std::list<std::string> const & certificate_paths = 
+      options_.openssl_certificate_paths();
+  std::list<std::string> const & verifier_paths =
+      options_.openssl_verify_paths();
+  bool verify_peer = false;
+  for (std::list<std::string>::const_iterator it = certificate_paths.begin();
+       it != certificate_paths.end(); ++it) {
+    context_->load_verify_file(*it);
+    verify_peer = true;
+  }
+  for (std::list<std::string>::const_iterator it = verifier_paths.begin();
+       it != verifier_paths.begin(); ++it) {
+    context_->add_verify_path(*it);
+    verify_peer = true;
   }
+  if (verify_peer) context_->set_verify_mode(asio::ssl::context::verify_peer);
+  else context_->set_verify_mode(asio::ssl::context::verify_none);
   socket_.reset(new asio::ssl::stream<asio::ip::tcp::socket>(service_, *context_));
   socket_->lowest_layer().async_connect(
       endpoint,
diff --git a/boost/network/protocol/http/client/connection_manager.hpp b/boost/network/protocol/http/client/connection_manager.hpp
diff --git a/boost/network/protocol/http/client/facade.ipp b/boost/network/protocol/http/client/facade.ipp
diff --git a/boost/network/protocol/http/client/options.hpp b/boost/network/protocol/http/client/options.hpp
diff --git a/boost/network/protocol/http/client/simple_connection_manager.hpp b/boost/network/protocol/http/client/simple_connection_manager.hpp
diff --git a/boost/network/protocol/http/client/simple_connection_manager.ipp b/boost/network/protocol/http/client/simple_connection_manager.ipp
