Continued refactoring, improved read_headers and simple_wget examples.

glynos · glynos · commit 3e33f13f8784 · 2013-12-14T21:00:42.000+01:00
diff --git a/contrib/http_examples/read_headers.cpp b/contrib/http_examples/read_headers.cpp
@@ -20,7 +20,9 @@ main(int argc, char *argv[]) {
   try {
     http::client client;
     http::client::request request{network::uri{std::string{argv[1]}}};
+    request.version("1.0");
     request.append_header("Connection", "close");
+    request.append_header("User-Agent", "cpp-netlib read_headers example");
     auto future_response = client.head(request);
     auto response = future_response.get();
 
@@ -37,6 +39,5 @@ main(int argc, char *argv[]) {
     return 1;
   }
 
-
   return 0;
 }
diff --git a/contrib/http_examples/simple_wget.cpp b/contrib/http_examples/simple_wget.cpp
@@ -38,7 +38,9 @@ int main(int argc, char* argv[]) {
   try {
     http::client client;
     http::client::request request{network::uri{std::string{argv[1]}}};
+    request.version("1.0");
     request.append_header("Connection", "close");
+    request.append_header("User-Agent", "cpp-netlib simple_wget example");
     auto future_response = client.get(request);
     auto response = future_response.get();
 
@@ -54,4 +56,3 @@ int main(int argc, char* argv[]) {
 
   return 0;
 }
-//]
diff --git a/http/src/http/v2/client/client.cpp b/http/src/http/v2/client/client.cpp
@@ -52,6 +52,8 @@ namespace network {
 
 	~impl() noexcept;
 
+	std::future<response> do_request(std::shared_ptr<request_helper> helper);
+
         void connect(const boost::system::error_code &ec,
                      tcp::resolver::iterator endpoint_iterator,
                      std::shared_ptr<request_helper> helper);
@@ -78,8 +80,6 @@ namespace network {
                                 std::shared_ptr<request_helper> helper,
                                 std::shared_ptr<response> res);
 
-	std::future<response> do_request(method method_, std::shared_ptr<request_helper> helper);
-
 	client_options options_;
 	boost::asio::io_service io_service_;
 	std::unique_ptr<boost::asio::io_service::work> sentinel_;
@@ -103,6 +103,44 @@ namespace network {
 	lifetime_thread_.join();
       }
 
+      std::future<client::response> client::impl::do_request(std::shared_ptr<request_helper> helper) {
+        std::future<client::response> res = helper->response_promise_.get_future();
+
+        // TODO see linearize.hpp
+        // TODO write User-Agent: cpp-netlib/NETLIB_VERSION (if no user-agent is supplied)
+
+        // HTTP 1.1
+        auto it = std::find_if(std::begin(helper->request_.headers()),
+                               std::end(helper->request_.headers()),
+                               [] (const std::pair<uri::string_type, uri::string_type> &header) {
+                                 return (boost::iequals(header.first, "host"));
+                               });
+        if (it == std::end(helper->request_.headers())) {
+          // set error
+          helper->response_promise_.set_value(response());
+          return res;
+        }
+
+        uri_builder builder;
+        builder
+          .authority(it->second)
+          ;
+
+        auto auth = builder.uri();
+        auto host = auth.host()?
+          uri::string_type(std::begin(*auth.host()), std::end(*auth.host())) : uri::string_type();
+        auto port = auth.port<std::uint16_t>()? *auth.port<std::uint16_t>() : 80;
+
+	resolver_->async_resolve(host, port,
+                                 strand_.wrap(
+                                   [=](const boost::system::error_code &ec,
+                                       tcp::resolver::iterator endpoint_iterator) {
+                                     connect(ec, endpoint_iterator, helper);
+                                   }));
+
+	return res;
+      }
+
       void client::impl::connect(const boost::system::error_code &ec,
                                  tcp::resolver::iterator endpoint_iterator,
                                  std::shared_ptr<request_helper> helper) {
@@ -122,6 +160,15 @@ namespace network {
         helper->connection_->async_connect(endpoint,
                                      strand_.wrap(
                                      [=] (const boost::system::error_code &ec) {
+                                       if (ec && endpoint_iterator != tcp::resolver::iterator()) {
+                                         // copy iterator because it is const after the lambda
+                                         // capture
+                                         auto it = endpoint_iterator;
+                                         boost::system::error_code ignore;
+                                         connect(ignore, ++it, helper);
+                                         return;
+                                       }
+
                                        write_request(ec, helper);
                                      }));
       }
@@ -134,6 +181,15 @@ namespace network {
           return;
         }
 
+        std::ostream request_stream(&helper->request_buffer_);
+        request_stream << helper->request_;
+        if (!request_stream) {
+          helper->response_promise_.set_exception(
+            std::make_exception_ptr(client_exception(client_error::invalid_request)));
+        }
+
+        // TODO write payload to request_buffer_
+
         helper->connection_->async_write(helper->request_buffer_,
                                  strand_.wrap(
                                    [=] (const boost::system::error_code &ec,
@@ -265,52 +321,6 @@ namespace network {
                                   }));
       }
 
-      std::future<client::response> client::impl::do_request(method met,
-                                                             std::shared_ptr<request_helper> helper) {
-        std::future<client::response> res = helper->response_promise_.get_future();
-
-	helper->request_.method(met);
-        std::ostream request_stream(&helper->request_buffer_);
-        request_stream << helper->request_;
-        if (!request_stream) {
-          helper->response_promise_.set_exception(
-            std::make_exception_ptr(client_exception(client_error::invalid_request)));
-        }
-
-        // TODO write payload to request_buffer_
-
-        // HTTP 1.1
-        auto it = std::find_if(std::begin(helper->request_.headers()),
-                               std::end(helper->request_.headers()),
-                               [] (const std::pair<uri::string_type, uri::string_type> &header) {
-                                 return (boost::iequals(header.first, "host"));
-                               });
-        if (it == std::end(helper->request_.headers())) {
-          // set error
-          helper->response_promise_.set_value(response());
-          return res;
-        }
-
-        uri_builder builder;
-        builder
-          .authority(it->second)
-          ;
-
-        auto auth = builder.uri();
-        auto host = auth.host()?
-          uri::string_type(std::begin(*auth.host()), std::end(*auth.host())) : uri::string_type();
-        auto port = auth.port<std::uint16_t>()? *auth.port<std::uint16_t>() : 80;
-
-	resolver_->async_resolve(host, port,
-                                 strand_.wrap(
-                                   [=](const boost::system::error_code &ec,
-                                       tcp::resolver::iterator endpoint_iterator) {
-                                     connect(ec, endpoint_iterator, helper);
-                                   }));
-
-	return res;
-      }
-
       client::client(client_options options)
 	: pimpl_(new impl(options)) {
 
@@ -321,33 +331,33 @@ namespace network {
       }
 
       std::future<client::response> client::get(request req, request_options options) {
-	return pimpl_->do_request(method::get,
-                                  std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+	req.method(method::get);
+	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
       }
 
       std::future<client::response> client::post(request req, request_options options) {
-	return pimpl_->do_request(method::post,
-                                  std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+	req.method(method::post);
+	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
       }
 
       std::future<client::response> client::put(request req, request_options options) {
-	return pimpl_->do_request(method::put,
-                                  std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+	req.method(method::put);
+	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
       }
 
       std::future<client::response> client::delete_(request req, request_options options) {
-	return pimpl_->do_request(method::delete_,
-                                  std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+	req.method(method::delete_);
+	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
       }
 
       std::future<client::response> client::head(request req, request_options options) {
-	return pimpl_->do_request(method::head,
-                                  std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+	req.method(method::head);
+	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
       }
 
       std::future<client::response> client::options(request req, request_options options) {
-	return pimpl_->do_request(method::options,
-                                  std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+	req.method(method::options);
+	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
       }
     } // namespace v2
   } // namespace http
diff --git a/http/src/network/http/client.hpp b/http/src/network/http/client.hpp
@@ -15,6 +15,9 @@
 namespace network {
   namespace http {
     using v2::client;
+    using v2::client_options;
+    using v2::method;
+    namespace status = v2::status;
     using v2::client_error;
     using v2::invalid_url;
     using v2::client_exception;
diff --git a/http/src/network/http/v2/client/request.hpp b/http/src/network/http/v2/client/request.hpp
@@ -249,6 +249,7 @@ namespace network {
 
               is_https_ = boost::equal(*scheme, boost::as_literal("https"));
               path_.assign(std::begin(*url.path()), std::end(*url.path()));
+              // TODO append query and fragment to path_
 
               std::ostringstream oss;
               std::copy(std::begin(*url.host()), std::end(*url.host()),
diff --git a/http/src/network/http/v2/client/response.hpp b/http/src/network/http/v2/client/response.hpp
@@ -161,12 +161,19 @@ namespace network {
             return status_message_;
           }
 
+          /**
+           * \brief Adds a header to the HTTP response.
+           * \param name The header name.
+           * \param value The header value.
+           */
           void add_header(const string_type &name, const string_type &value) {
             headers_.push_back(std::make_pair(name, value));
           }
 
           /**
-           * \brief
+           * \brief Returns the full range of headers.
+           * \returns An iterator range covering the HTTP response
+           *          headers.
            */
           boost::iterator_range<const_headers_iterator> headers() const {
             return boost::make_iterator_range(std::begin(headers_), std::end(headers_));
diff --git a/http/src/network/version.hpp b/http/src/network/version.hpp
@@ -1,5 +1,5 @@
 // Copyright Dean Michael Berris 2009.
-// Copyright Glyn Matthews 2010.
+// Copyright Glyn Matthews 2010, 2013.
 // Copyright 2012 Google, Inc.
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,9 @@ main(int argc, char *argv[]) {`
`20`	`20`	`try {`
`21`	`21`	`http::client client;`
`22`	`22`	`http::client::request request{network::uri{std::string{argv[1]}}};`
	`23`	`+ request.version("1.0");`
`23`	`24`	`request.append_header("Connection", "close");`
	`25`	`+ request.append_header("User-Agent", "cpp-netlib read_headers example");`
`24`	`26`	`auto future_response = client.head(request);`
`25`	`27`	`auto response = future_response.get();`
`26`	`28`
`@@ -37,6 +39,5 @@ main(int argc, char *argv[]) {`
`37`	`39`	`return 1;`
`38`	`40`	`}`
`39`	`41`
`40`		`-`
`41`	`42`	`return 0;`
`42`	`43`	`}`