Add shortcuts for GET, POST, etc. to HttpClientSession.

webcc/globals.h

@@ -39,14 +39,22 @@ const std::size_t kGzipThreshold = 1400;
 // HTTP headers.
 namespace http {
 
+namespace methods {
+
 // HTTP methods (verbs) in string.
 // Don't use enum to avoid converting back and forth.
-const char* const kHead   = "HEAD";
-const char* const kGet    = "GET";
-const char* const kPost   = "POST";
-const char* const kPatch  = "PATCH";
-const char* const kPut    = "PUT";
-const char* const kDelete = "DELETE";
+
+const char* const kGet      = "GET";
+const char* const kHead     = "HEAD";
+const char* const kPost     = "POST";
+const char* const kPut      = "PUT";
+const char* const kDelete   = "DELETE";
+const char* const kConnect  = "CONNECT";
+const char* const kOptions  = "OPTIONS";
+const char* const kTrace    = "TRACE";
+const char* const kPatch    = "PATCH";
+
+}  // namespace methods
 
 // HTTP response status.
 // This is not a full list.
@@ -69,6 +77,7 @@ namespace headers {
 
 // NOTE: Field names are case-insensitive.
 //   See https://stackoverflow.com/a/5259004 for more details.
+
 const char* const kHost = "Host";
 const char* const kDate = "Date";
 const char* const kContentType = "Content-Type";

webcc/http_client.cc

@@ -9,9 +9,9 @@ using boost::asio::ip::tcp;
 
 namespace webcc {
 
-HttpClient::HttpClient(bool ssl_verify)
+HttpClient::HttpClient()
     : timer_(io_context_),
-      ssl_verify_(ssl_verify),
+      ssl_verify_(true),
       timeout_(kMaxReadSeconds),
       closed_(false),
       timer_canceled_(false),

webcc/http_client.h

@@ -27,7 +27,7 @@ typedef std::shared_ptr<HttpClient> HttpClientPtr;
 // Please don't use the same client object in multiple threads.
 class HttpClient {
 public:
-  explicit HttpClient(bool ssl_verify = true);
+  HttpClient();
 
   virtual ~HttpClient() = default;
 
@@ -94,8 +94,7 @@ private:
   // Verify the certificate of the peer or not (for HTTPS).
   bool ssl_verify_;
 
-  // Maximum seconds to wait before the client cancels the operation.
-  // Only for reading response from server.
+  // Timeout (seconds) for receiving response.
   int timeout_;
 
   // Connection closed.

webcc/http_client_session.cc

@@ -5,25 +5,6 @@
 
 namespace webcc {
 
-namespace {
-
-// -----------------------------------------------------------------------------
-// Helper functions.
-
-//bool GetSslVerify(const boost::optional<bool>& session_ssl_verify,
-//                  const boost::optional<bool>& request_ssl_verify) {
-//  if (request_ssl_verify) {
-//    return request_ssl_verify.value();
-//  } else if (session_ssl_verify) {
-//    return session_ssl_verify.value();
-//  }
-//  return true;
-//}
-
-}  // namespace
-
-// -----------------------------------------------------------------------------
-
 HttpClientSession::HttpClientSession() {
   InitHeaders();
 }
@@ -47,6 +28,83 @@ HttpResponsePtr HttpClientSession::Request(HttpRequestPtr request) {
   return Send(request);
 }
 
+static void SetHeaders(const std::vector<std::string>& headers,
+                       HttpRequestBuilder* builder) {
+  assert(headers.size() % 2 == 0);
+
+  for (std::size_t i = 1; i < headers.size(); i += 2) {
+    builder->header(headers[i - 1], headers[i]);
+  }
+}
+
+HttpResponsePtr HttpClientSession::Get(const std::string& url,
+                                       const std::vector<std::string>& parameters,
+                                       const std::vector<std::string>& headers) {
+  HttpRequestBuilder builder{http::methods::kGet};
+  builder.url(url);
+
+  assert(parameters.size() % 2 == 0);
+  for (std::size_t i = 1; i < parameters.size(); i += 2) {
+    builder.parameter(parameters[i - 1], parameters[i]);
+  }
+
+  SetHeaders(headers, &builder);
+
+  return Request(builder());
+}
+
+HttpResponsePtr HttpClientSession::Post(const std::string& url,
+                                        std::string&& data, bool json,
+                                        const std::vector<std::string>& headers) {
+  HttpRequestBuilder builder{http::methods::kPost};
+  builder.url(url);
+
+  SetHeaders(headers, &builder);
+
+  builder.data(std::move(data));
+  builder.json(json);
+
+  return Request(builder());
+}
+
+HttpResponsePtr HttpClientSession::Put(const std::string& url,
+                                       std::string&& data, bool json,
+                                       const std::vector<std::string>& headers) {
+  HttpRequestBuilder builder{http::methods::kPut};
+  builder.url(url);
+
+  SetHeaders(headers, &builder);
+
+  builder.data(std::move(data));
+  builder.json(json);
+
+  return Request(builder());
+}
+
+HttpResponsePtr HttpClientSession::Delete(const std::string& url,
+                                          const std::vector<std::string>& headers) {
+  HttpRequestBuilder builder{http::methods::kDelete};
+  builder.url(url);
+
+  SetHeaders(headers, &builder);
+
+  return Request(builder());
+}
+
+HttpResponsePtr HttpClientSession::Patch(const std::string& url,
+                                         std::string&& data, bool json,
+                                         const std::vector<std::string>& headers) {
+  HttpRequestBuilder builder{http::methods::kPatch};
+  builder.url(url);
+
+  SetHeaders(headers, &builder);
+
+  builder.data(std::move(data));
+  builder.json(json);
+
+  return Request(builder());
+}
+
 void HttpClientSession::InitHeaders() {
   using namespace http::headers;
 
@@ -92,14 +150,14 @@ HttpResponsePtr HttpClientSession::Send(HttpRequestPtr request) {
 
   HttpClientPtr client = pool_.Get(key);
   if (!client) {
-    client.reset(new HttpClient{ssl_verify_});
+    client.reset(new HttpClient{});
     reuse = false;
   } else {
-    client->set_ssl_verify(ssl_verify_);
-    reuse = true;
     LOG_VERB("Reuse an existing connection.");
+    reuse = true;
   }
 
+  client->set_ssl_verify(ssl_verify_);
   client->set_timeout(timeout_);
 
   bool ok = client->Request(request, !reuse);

webcc/http_client_session.h

@@ -41,12 +41,35 @@ public:
     }
   }
 
-  void AddHeader(const std::string& key, const std::string& value) {
+  void SetHeader(const std::string& key, const std::string& value) {
     headers_.Set(key, value);
   }
 
+  // Send a request.
+  // Please use HttpRequestBuilder to build the request.
   HttpResponsePtr Request(HttpRequestPtr request);
 
+  // Shortcut for GET request.
+  HttpResponsePtr Get(const std::string& url,
+                      const std::vector<std::string>& parameters = {},
+                      const std::vector<std::string>& headers = {});
+
+  // Shortcut for POST request.
+  HttpResponsePtr Post(const std::string& url, std::string&& data, bool json,
+                       const std::vector<std::string>& headers = {});
+
+  // Shortcut for PUT request.
+  HttpResponsePtr Put(const std::string& url, std::string&& data, bool json,
+                      const std::vector<std::string>& headers = {});
+
+  // Shortcut for DELETE request.
+  HttpResponsePtr Delete(const std::string& url,
+                         const std::vector<std::string>& headers = {});
+
+  // Shortcut for PATCH request.
+  HttpResponsePtr Patch(const std::string& url, std::string&& data, bool json,
+                        const std::vector<std::string>& headers = {});
+
 private:
   void InitHeaders();
 

webcc/http_request.h

@@ -11,7 +11,6 @@
 namespace webcc {
 
 class HttpRequest;
-
 typedef std::shared_ptr<HttpRequest> HttpRequestPtr;
 
 class HttpRequest : public HttpMessage {
@@ -37,6 +36,14 @@ public:
     url_.AddParameter(key, value);
   }
 
+  void set_buffer_size(std::size_t buffer_size) {
+    buffer_size_ = buffer_size;
+  }
+
+  void set_ssl_verify(bool ssl_verify) {
+    ssl_verify_ = ssl_verify;
+  }
+
   const std::string& method() const {
     return method_;
   }
@@ -61,8 +68,8 @@ public:
     return buffer_size_;
   }
 
-  void set_buffer_size(std::size_t buffer_size) {
-    buffer_size_ = buffer_size;
+  bool ssl_verify() const {
+    return ssl_verify_;
   }
 
   // Prepare payload.
@@ -73,6 +80,11 @@ private:
   std::string method_;
   Url url_;
 
+  // Verify the certificate of the peer or not (for HTTPS).
+  bool ssl_verify_ = true;
+
+  // The size of the buffer for reading response.
+  // 0 means default value will be used.
   std::size_t buffer_size_ = 0;
 };
 

webcc/http_request_builder.h

@@ -4,26 +4,25 @@
 #include <string>
 #include <vector>
 
-#include "boost/optional.hpp"
-
 #include "webcc/http_request.h"
 
 namespace webcc {
 
-// TODO: Add timeout()
-
-// HTTP request builder.
 class HttpRequestBuilder {
 public:
-  HttpRequestBuilder() = default;
+  explicit HttpRequestBuilder(const std::string& method = "")
+      : method_(method) {
+  }
 
   // Build the request.
   HttpRequestPtr operator()();
 
-  HttpRequestBuilder& Get() { return method(http::kGet); }
-  HttpRequestBuilder& Post() { return method(http::kPost); }
-  HttpRequestBuilder& Put() { return method(http::kPut); }
-  HttpRequestBuilder& Delete() { return method(http::kDelete); }
+  HttpRequestBuilder& Get() { return method(http::methods::kGet); }
+  HttpRequestBuilder& Head() { return method(http::methods::kHead); }
+  HttpRequestBuilder& Post() { return method(http::methods::kPost); }
+  HttpRequestBuilder& Put() { return method(http::methods::kPut); }
+  HttpRequestBuilder& Delete() { return method(http::methods::kDelete); }
+  HttpRequestBuilder& Patch() { return method(http::methods::kPatch); }
 
   HttpRequestBuilder& method(const std::string& method) {
     method_ = method;
@@ -69,11 +68,6 @@ public:
     return *this;
   }
 
-  HttpRequestBuilder& ssl_verify(bool ssl_verify = true) {
-    ssl_verify_.emplace(ssl_verify);
-    return *this;
-  }
-
   HttpRequestBuilder& buffer(std::size_t buffer) {
     buffer_ = buffer;
     return *this;
@@ -107,9 +101,6 @@ private:
   // Additional request headers.
   std::vector<std::string> headers_;
 
-  // Verify the certificate of the peer or not.
-  boost::optional<bool> ssl_verify_;
-
   // Size of the buffer to read response.
   // Leave it to 0 for using default value.
   std::size_t buffer_ = 0;

webcc/rest_service.cc

@@ -8,9 +8,9 @@ namespace webcc {
 
 void RestListService::Handle(const RestRequest& request,
                              RestResponse* response) {
-  if (request.method == http::kGet) {
+  if (request.method == http::methods::kGet) {
     Get(UrlQuery(request.url_query_str), response);
-  } else if (request.method == http::kPost) {
+  } else if (request.method == http::methods::kPost) {
     Post(request.content, response);
   } else {
     LOG_ERRO("RestListService doesn't support '%s' method.",
@@ -22,13 +22,13 @@ void RestListService::Handle(const RestRequest& request,
 
 void RestDetailService::Handle(const RestRequest& request,
                                RestResponse* response) {
-  if (request.method == http::kGet) {
+  if (request.method == http::methods::kGet) {
     Get(request.url_matches, UrlQuery(request.url_query_str), response);
-  } else if (request.method == http::kPut) {
+  } else if (request.method == http::methods::kPut) {
     Put(request.url_matches, request.content, response);
-  } else if (request.method == http::kPatch) {
+  } else if (request.method == http::methods::kPatch) {
     Patch(request.url_matches, request.content, response);
-  } else if (request.method == http::kDelete) {
+  } else if (request.method == http::methods::kDelete) {
     Delete(request.url_matches, response);
   } else {
     LOG_ERRO("RestDetailService doesn't support '%s' method.",

webcc/soap_client.cc

@@ -13,7 +13,6 @@ namespace webcc {
 SoapClient::SoapClient(const std::string& url, SoapVersion soap_version)
     : url_(url),
       soap_version_(soap_version),
-      http_client_(true),
       format_raw_(true),
       error_(kNoError) {
 }
@@ -48,7 +47,7 @@ bool SoapClient::Request(const std::string& operation,
   std::string http_content;
   soap_request.ToXml(format_raw_, indent_str_, &http_content);
 
-  auto http_request = std::make_shared<HttpRequest>(http::kPost, url_);
+  auto http_request = std::make_shared<HttpRequest>(http::methods::kPost, url_);
 
   http_request->SetContent(std::move(http_content), true);