Updated client errors and added code to allow the processing of a response body.

Author: glynos

http/src/http/v2/client/client.cpp

@@ -44,6 +44,10 @@ namespace network {
                                    std::size_t bytes_read,
                                    std::shared_ptr<response> res);
 
+        void read_response_body(const boost::system::error_code &ec,
+                                std::size_t bytes_read,
+                                std::shared_ptr<response> res);
+
 	std::future<response> do_request(method method_, request request_, request_options options);
 
 	client_options options_;
@@ -83,7 +87,7 @@ namespace network {
         if (ec) {
           if (endpoint_iterator == tcp::resolver::iterator()) {
             response_promise_.set_exception(std::make_exception_ptr(
-                                              connection_error(client_error::host_not_found)));
+                                              client_exception(client_error::host_not_found)));
             return;
           }
 
@@ -142,19 +146,19 @@ namespace network {
         }
 
         std::istream is(&response_);
-        std::string version;
+        string_type version;
         is >> version;
         unsigned int status;
         is >> status;
-        std::string message;
+        string_type message;
         std::getline(is, message);
 
         res->set_version(version);
         res->set_status(network::http::v2::status::code(status));
         res->set_status_message(boost::trim_copy(message));
 
         connection_->async_read_until(response_,
-                                      "\r\n",
+                                      "\r\n\r\n",
                                       strand_.wrap(
                                         [=] (const boost::system::error_code &ec,
                                              std::size_t bytes_read) {
@@ -173,23 +177,65 @@ namespace network {
 
         // fill headers
         std::istream is(&response_);
-        std::string header;
-        while ((header != "\r") && std::getline(is, header)) {
+        string_type header;
+        while (std::getline(is, header) && (header != "\r")) {
           std::vector<string_type> kvp;
           boost::split(kvp, header, boost::is_any_of(":"));
           res->add_header(kvp[0], boost::trim_copy(kvp[1]));
         }
 
-        connection_->async_read_until(response_,
-                                      "\r\n\r\n",
-                                      strand_.wrap(
-                                        [=] (const boost::system::error_code &ec,
-                                             std::size_t bytes_read) {
-                                          // um...
-                                          response_promise_.set_value(*res);
-                                        }));
+        connection_->async_read(response_,
+                                strand_.wrap(
+                                  [=] (const boost::system::error_code &ec,
+                                       std::size_t bytes_read) {
+                                    read_response_body(ec, bytes_read, res);
+                                  }));
+      }
+
+      namespace {
+        std::istream &getline_with_newline(std::istream &is, std::string &line) {
+          line.clear();
+
+          std::istream::sentry se(is, true);
+          std::streambuf *sb = is.rdbuf();
+
+          while (true) {
+            int c = sb->sbumpc();
+            switch (c) {
+            case EOF:
+              if (line.empty()) {
+                is.setstate(std::ios::eofbit);
+              }
+              return is;
+            default:
+              line += static_cast<char>(c);
+            }
+          }
+        }
+      } // namespace
+
+      void client::impl::read_response_body(const boost::system::error_code &ec,
+                                            std::size_t bytes_read,
+                                            std::shared_ptr<response> res) {
+        if (bytes_read == 0) {
+          response_promise_.set_value(*res);
+          return;
         }
 
+        std::istream is(&response_);
+        string_type line;
+        while (!getline_with_newline(is, line).eof()) {
+          res->append_body(line);
+        }
+
+        connection_->async_read(response_,
+                                strand_.wrap(
+                                  [=] (const boost::system::error_code &ec,
+                                       std::size_t bytes_read) {
+                                    read_response_body(ec, bytes_read, res);
+                                  }));
+      }
+
       std::future<response> client::impl::do_request(method met,
 						     request req,
 						     request_options options) {
@@ -199,7 +245,8 @@ namespace network {
         std::ostream request_stream(&request_);
         request_stream << req;
         if (!request_stream) {
-          // set error
+          response_promise_.set_exception(std::make_exception_ptr(
+                                            client_exception(client_error::invalid_request)));
         }
 
         // HTTP 1.1

http/src/http/v2/client/client_errors.cpp

@@ -37,8 +37,12 @@ namespace network {
 	switch (client_error(ev)) {
 	case client_error::invalid_url:
 	  return "Requires HTTP or HTTPS URL.";
-	case client_error::resolver_error:
-	  return "Unable to resolve host";
+	case client_error::invalid_request:
+	  return "Invalid HTTP request.";
+        case client_error::host_not_found:
+	  return "Unable to resolve host.";
+        case client_error::invalid_response:
+	  return "Invalid HTTP response.";
 	default:
 	  break;
 	}
@@ -63,21 +67,12 @@ namespace network {
 
       }
 
-      resolver_error::resolver_error()
-	: std::system_error(make_error_code(client_error::resolver_error)) {
-
-      }
-
-      resolver_error::~resolver_error() {
-
-      }
-
-      connection_error::connection_error(client_error error)
+      client_exception::client_exception(client_error error)
 	: std::system_error(make_error_code(error)) {
 
       }
 
-      connection_error::~connection_error() {
+      client_exception::~client_exception() {
 
       }
 

http/src/network/http/v2/client/client_errors.hpp

@@ -20,15 +20,15 @@ namespace network {
     namespace v2 {
       /**
        * \ingroup http_client
-       * \enum client_error network/http/v2/client/client_errors.hpp
+       * \enum client_error network/http/v2/client/client_errors.hpp network/http/v2/client.hpp
        * \brief An enumeration of all types of client error.
        */
       enum class client_error {
         // url
         invalid_url,
 
-        // resolution
-        resolver_error,
+        // request
+        invalid_request,
 
         // connection
         host_not_found,
@@ -49,7 +49,7 @@ namespace network {
 
       /**
        * \ingroup http_client
-       * \class invalid_url network/http/v2/client/client_errors.hpp
+       * \class invalid_url network/http/v2/client/client_errors.hpp network/http/v2/client.hpp
        * \brief An exception thrown if the URL provides is invalid.
        */
       class invalid_url : public std::system_error {
@@ -70,67 +70,25 @@ namespace network {
 
       /**
        * \ingroup http_client
-       * \class resolver_error network/http/v2/client/client_errors.hpp
-       * \brief An exception thrown when there is a resolver error.
+       * \class client_exception network/http/v2/client/client_errors.hpp network/http/v2/client.hpp
+       * \brief An exception thrown when there is a client error.
        */
-      class resolver_error : std::system_error {
+      class client_exception : public std::system_error {
 
       public:
 
         /**
          * \brief Constructor.
          */
-        explicit resolver_error();
+        explicit client_exception(client_error error);
 
         /**
          * \brief Destructor.
          */
-        virtual ~resolver_error() noexcept;
+        virtual ~client_exception() noexcept;
 
       };
 
-      /**
-       * \ingroup http_client
-       * \class connection_error network/http/v2/client/client_errors.hpp
-       * \brief An exception thrown when there is a connection error.
-       */
-      class connection_error : public std::system_error {
-
-      public:
-
-        /**
-         * \brief Constructor.
-         * \param The client_error code.
-         */
-        explicit connection_error(client_error error);
-
-        /**
-         * \brief Destructor.
-         */
-        virtual ~connection_error() noexcept;
-
-      };
-
-      /**
-       * \ingroup http_client
-       * \class response_error network/http/v2/client/client_errors.hpp
-       */
-      class response_error : public std::system_error {
-
-      public:
-
-        /**
-         * \brief Constructor.
-         * \param The client_error code.
-         */
-        explicit response_error(client_error error);
-
-        /**
-         * \brief Destructor.
-         */
-        virtual ~response_error() noexcept;
-
-      };
     } // namespace v2
   } // namespace http
 } // namespace network

http/src/network/http/v2/client/connection/async_connection.hpp

@@ -77,6 +77,8 @@ namespace network {
                                       const std::string &delim,
                                       read_callback callback) = 0;
 
+        virtual void async_read(boost::asio::streambuf &command_streambuf,
+                                read_callback callback) = 0;
 
         /**
          * \brief Cancels an operation on a connection.

http/src/network/http/v2/client/connection/normal_connection.hpp

@@ -7,6 +7,7 @@
 #define NETWORK_HTTP_V2_CLIENT_CONNECTION_NORMAL_CONNECTION_INC
 
 #include <boost/asio/write.hpp>
+#include <boost/asio/read.hpp>
 #include <boost/asio/read_until.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/io_service.hpp>
@@ -50,6 +51,12 @@ namespace network {
           boost::asio::async_read_until(*socket_, command_streambuf, delim, callback);
         }
 
+        virtual void async_read(boost::asio::streambuf &command_streambuf,
+                                read_callback callback) {
+          boost::asio::async_read(*socket_, command_streambuf,
+                                  boost::asio::transfer_at_least(1), callback);
+        }
+
         virtual void cancel() {
           socket_->cancel();
         }

http/src/network/http/v2/client/response.hpp

@@ -67,7 +67,8 @@ namespace network {
 	  : version_(other.version_)
 	  , status_(other.status_)
 	  , status_message_(other.status_message_)
-	  , headers_(other.headers_) {
+	  , headers_(other.headers_)
+          , body_(other.body_) {
 
 	}
 
@@ -79,7 +80,8 @@ namespace network {
           : version_(std::move(other.version_))
           , status_(std::move(other.status_))
           , status_message_(std::move(other.status_message_))
-	  , headers_(std::move(other.headers_)) {
+          , headers_(std::move(other.headers_))
+          , body_(std::move(other.body_)) {
 
 	}
 
@@ -102,13 +104,14 @@ namespace network {
 	  swap(status_, other.status_);
 	  swap(status_message_, other.status_message_);
 	  swap(headers_, other.headers_);
+          swap(body_, other.body_);
 	}
 
         /**
          * \brief Sets the HTTP version.
          * \param version The HTTP version (1.0 or 1.1).
          */
-        void set_version(const string_type &version) {
+        void set_version(string_type version) {
           version_ = version;
         }
 
@@ -140,7 +143,7 @@ namespace network {
          * \brief Sets the HTTP response status message.
          * \param status The HTTP response status message.
          */
-        void set_status_message(const string_type &status_message) {
+        void set_status_message(string_type status_message) {
           status_message_ = status_message;
         }
 
@@ -163,19 +166,26 @@ namespace network {
 	  return boost::make_iterator_range(std::begin(headers_), std::end(headers_));
 	}
 
-	std::future<string_type> read_body(std::size_t length) const;
+        void append_body(const char *body, std::size_t length) {
+          body_.reserve(body_.size() + length);
+          body_.append(body);
+        }
+
+        void append_body(string_type body) {
+          body_.append(body);
+        }
 
-	// add_header
-	// set_body
-	// append_body
-	// get_body
+        string_type body() const {
+          return body_;
+        }
 
       private:
 
         string_type version_;
         network::http::v2::status::code status_;
 	string_type status_message_;
 	headers_type headers_;
+        string_type body_;
 
       };