Body generator for PUT/POST APIs

This commit does the following things:

- Add overloads to the HTTP Client implementation that takes a generator
  callback to generate chunks of the POST or PUT requests.
- Fixes cpp-netlib#245 which happens when a resolution error occurs, which leaks
  futures and potentially threads associated with futures.
- Formats the files touched using clang-format in Google's style.

Unfortunately the API cannot be tested without starting a POST/PUT
capable server. A future commit should add an end-to-end test that uses
the HTTP server implementation and the HTTP client implementation to
verify end-to-end correctness.

Author: deanberris

boost/network/protocol/http/client/async_impl.hpp

@@ -15,82 +15,78 @@
 #include <boost/make_shared.hpp>
 #include <boost/bind.hpp>
 
-namespace boost { namespace network { namespace http {
+namespace boost {
+namespace network {
+namespace http {
 
-  template <class Tag, unsigned version_major, unsigned version_minor>
-  struct basic_client_impl;
+template <class Tag, unsigned version_major, unsigned version_minor>
+struct basic_client_impl;
 
-  namespace impl {
-    template <class Tag, unsigned version_major, unsigned version_minor>
-    struct async_client :
-      connection_policy<Tag,version_major,version_minor>::type
-    {
-      typedef
-        typename connection_policy<Tag,version_major,version_minor>::type
-        connection_base;
-      typedef
-        typename resolver<Tag>::type
-        resolver_type;
-      typedef
-        typename string<Tag>::type
-        string_type;
+namespace impl {
+template <class Tag, unsigned version_major, unsigned version_minor>
+struct async_client
+    : connection_policy<Tag, version_major, version_minor>::type {
+  typedef typename connection_policy<Tag, version_major, version_minor>::type
+      connection_base;
+  typedef typename resolver<Tag>::type resolver_type;
+  typedef typename string<Tag>::type string_type;
 
-      typedef
-        function<void(boost::iterator_range<char const *> const &, system::error_code const &)>
-        body_callback_function_type;
+  typedef function<void(boost::iterator_range<char const*> const&,
+                        system::error_code const&)> body_callback_function_type;
 
-      async_client(bool cache_resolved, bool follow_redirect, boost::shared_ptr<boost::asio::io_service> service, optional<string_type> const & certificate_filename, optional<string_type> const & verify_path)
-        : connection_base(cache_resolved, follow_redirect),
-        service_ptr(service.get() ? service : boost::make_shared<boost::asio::io_service>()),
+  typedef function<bool(string_type&)> body_generator_function_type;
+
+  async_client(bool cache_resolved,
+               bool follow_redirect,
+               boost::shared_ptr<boost::asio::io_service> service,
+               optional<string_type> const& certificate_filename,
+               optional<string_type> const& verify_path)
+      : connection_base(cache_resolved, follow_redirect),
+        service_ptr(service.get()
+                        ? service
+                        : boost::make_shared<boost::asio::io_service>()),
         service_(*service_ptr),
         resolver_(service_),
         sentinel_(new boost::asio::io_service::work(service_)),
         certificate_filename_(certificate_filename),
-        verify_path_(verify_path)
-      {
-        connection_base::resolver_strand_.reset(new
-          boost::asio::io_service::strand(service_));
-        lifetime_thread_.reset(new boost::thread(
-          boost::bind(
-            &boost::asio::io_service::run,
-            &service_
-            )));
-      }
-
-      ~async_client() throw ()
-      {
-        sentinel_.reset();
-        if (lifetime_thread_.get()) {
-          lifetime_thread_->join();
-          lifetime_thread_.reset();
-        }
-      }
-
-      basic_response<Tag> const request_skeleton(
-        basic_request<Tag> const & request_,
-        string_type const & method,
-        bool get_body,
-        body_callback_function_type callback
-        )
-      {
-        typename connection_base::connection_ptr connection_;
-        connection_ = connection_base::get_connection(resolver_, request_, certificate_filename_, verify_path_);
-        return connection_->send_request(method, request_, get_body, callback);
-      }
-
-      boost::shared_ptr<boost::asio::io_service> service_ptr;
-      boost::asio::io_service & service_;
-      resolver_type resolver_;
-      boost::shared_ptr<boost::asio::io_service::work> sentinel_;
-      boost::shared_ptr<boost::thread> lifetime_thread_;
-      optional<string_type> certificate_filename_, verify_path_;
-    };
-  } // namespace impl
+        verify_path_(verify_path) {
+    connection_base::resolver_strand_.reset(
+        new boost::asio::io_service::strand(service_));
+    lifetime_thread_.reset(new boost::thread(
+        boost::bind(&boost::asio::io_service::run, &service_)));
+  }
 
-} // namespace http
+  ~async_client() throw() {
+    sentinel_.reset();
+    if (lifetime_thread_.get()) {
+      lifetime_thread_->join();
+      lifetime_thread_.reset();
+    }
+  }
 
-} // namespace network
+  basic_response<Tag> const request_skeleton(
+      basic_request<Tag> const& request_,
+      string_type const& method,
+      bool get_body,
+      body_callback_function_type callback,
+      body_generator_function_type generator) {
+    typename connection_base::connection_ptr connection_;
+    connection_ = connection_base::get_connection(
+        resolver_, request_, certificate_filename_, verify_path_);
+    return connection_->send_request(
+        method, request_, get_body, callback, generator);
+  }
 
-} // namespace boost
+  boost::shared_ptr<boost::asio::io_service> service_ptr;
+  boost::asio::io_service& service_;
+  resolver_type resolver_;
+  boost::shared_ptr<boost::asio::io_service::work> sentinel_;
+  boost::shared_ptr<boost::thread> lifetime_thread_;
+  optional<string_type> certificate_filename_, verify_path_;
+};
+}  // namespace impl
+}  // namespace http
+}  // namespace network
+}  // namespace boost
 
-#endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_ASYNC_IMPL_HPP_20100623
+#endif  // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_ASYNC_IMPL_HPP_20100623

boost/network/protocol/http/client/connection/async_base.hpp

@@ -1,7 +1,8 @@
 #ifndef BOOST_NETWORK_PROTOCOL_HTTP_IMPL_ASYNC_CONNECTION_BASE_20100529
 #define BOOST_NETWORK_PROTOCOL_HTTP_IMPL_ASYNC_CONNECTION_BASE_20100529
 
-// Copyright 2010 (C) Dean Michael Berris
+// Copryight 2013 Google, Inc.
+// Copyright 2010 Dean Michael Berris <[email protected]>
 // Copyright 2010 (C) Sinefunc, Inc.
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
@@ -26,6 +27,7 @@ namespace boost { namespace network { namespace http { namespace impl {
     typedef iterator_range<char const *> char_const_range;
     typedef function<void(char_const_range const &, system::error_code const &)>
         body_callback_function_type;
+    typedef function<bool(string_type&)> body_generator_function_type;
     typedef shared_ptr<this_type> connection_ptr;
 
     // This is the factory function which constructs the appropriate async
@@ -61,7 +63,8 @@ namespace boost { namespace network { namespace http { namespace impl {
         request const & request,
         string_type const & method,
         bool get_body,
-        body_callback_function_type callback) = 0;
+        body_callback_function_type callback,
+        body_generator_function_type generator) = 0;
 
     virtual ~async_connection_base() {}