Add enum for HttpMethod for which we use to route to different execute methods. Implement head request

Author: ggcr

src/s3cpp/httpclient.cpp

@@ -5,9 +5,19 @@
 #include <stdexcept>
 #include <string>
 
-HttpResponse HttpRequest::execute() { return client_.execute(*this); }
+// Route to its HttpMethod
+HttpResponse HttpRequest::execute() { 
+	switch (this->http_method_) {
+		case HttpMethod::Get:
+			return client_.execute_get(*this); 
+		case HttpMethod::Head:
+			return client_.execute_head(*this); 
+		default:
+			throw std::runtime_error(std::format("No matching enum Http Method"));
+	}
+}
 
-HttpResponse HttpClient::execute(HttpRequest &request) {
+HttpResponse HttpClient::execute_get(HttpRequest &request) {
   if (!curl_handle) {
     throw std::runtime_error(
         // this can happen both when cURL handle is not initialized or when it
@@ -53,6 +63,50 @@ HttpResponse HttpClient::execute(HttpRequest &request) {
   return HttpResponse(static_cast<int>(response_code), std::move(buffer));
 }
 
+HttpResponse HttpClient::execute_head(HttpRequest &request) {
+  if (!curl_handle) {
+    throw std::runtime_error(
+        // this can happen both when cURL handle is not initialized or when it
+        // is invalidated in the HTTPClient copy constructor
+        "cURL handle is invalid");
+  }
+  std::string error_buf;
+
+  // TODO(cristian): from libcurl docs, they state that each curl handle has
+  // "sticky" params, this is why we are resetting at each get request
+  // However, I think we should only do this when moving a new handle the only
+  // thing that will change is the URL from now
+  //
+  // curl_easy_reset(curl_handle);
+
+  curl_easy_setopt(curl_handle, CURLOPT_URL, request.getURL().c_str());
+  curl_easy_setopt(curl_handle, CURLOPT_NOBODY, 1L);
+  curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, request.getTimeout());
+
+	// merge client and request headers
+	// https://stackoverflow.com/questions/34321719
+	auto headers = request.getHeaders();
+	headers.insert(this->getHeaders().begin(), this->getHeaders().end());
+	struct curl_slist *list = NULL;
+	for (const auto &[k, v] : headers) {
+		list = curl_slist_append(list, std::format("{}: {}", k, v).c_str());
+	}
+	curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, list);
+
+	CURLcode code = curl_easy_perform(curl_handle);
+	curl_slist_free_all(list);
+  if (code != CURLE_OK) {
+    throw std::runtime_error(
+        std::format("libcurl error for request: {}", curl_easy_strerror(code)));
+  }
+
+  // HTTP code
+  long response_code = 0;
+  curl_easy_getinfo(curl_handle, CURLINFO_HTTP_CODE, &response_code);
+
+  return HttpResponse(static_cast<int>(response_code));
+}
+
 size_t HttpClient::write_callback(char *ptr, size_t size, size_t nmemb,
                                   void *userdata) {
   std::string *buffer = static_cast<std::string *>(userdata);

src/s3cpp/httpclient.h

@@ -12,8 +12,16 @@
 // Forward declaration
 class HttpClient;
 
+enum class HttpMethod {
+	Get,
+	Post,
+	Put,
+	Head
+};
+
 class HttpResponse {
 public:
+  HttpResponse(int c) : code_(c) {};
   HttpResponse(int c, std::string b) : code_(c), body_(std::move(b)) {};
 
   int status() const { return code_; }
@@ -36,8 +44,8 @@ class HttpResponse {
 // HttpRequest will handle all the headers and request params
 class HttpRequest {
 public:
-  HttpRequest(HttpClient &client, std::string URL)
-      : client_(client), URL_(std::move(URL)), timeout_(0) {};
+  HttpRequest(HttpClient &client, std::string URL, const HttpMethod &http_method)
+      : client_(client), URL_(std::move(URL)), http_method_(std::move(http_method)), timeout_(0) {};
 
   HttpRequest &timeout(const long long &seconds) {
     timeout_ = std::chrono::seconds(seconds);
@@ -63,6 +71,7 @@ class HttpRequest {
   std::string URL_;
   std::unordered_map<std::string, std::string> headers_;
   std::chrono::seconds timeout_;
+	HttpMethod http_method_;
 };
 
 // HttpClient should only focus on handling the cURL handle
@@ -108,7 +117,10 @@ class HttpClient {
 
   // HTTP GET
   [[nodiscard]] HttpRequest get(const std::string &URL) {
-    return HttpRequest{*this, URL};
+    return HttpRequest{*this, URL, HttpMethod::Get};
+  };
+  [[nodiscard]] HttpRequest head(const std::string &URL) {
+    return HttpRequest{*this, URL, HttpMethod::Head};
   };
 
 private:
@@ -119,7 +131,8 @@ class HttpClient {
 
   // main logic to perform the request
   // this is invoked by HttpRequest
-  HttpResponse execute(HttpRequest &request);
+  HttpResponse execute_get(HttpRequest &request);
+  HttpResponse execute_head(HttpRequest &request);
 
   const std::unordered_map<std::string, std::string> &getHeaders() const { return headers_; }
 };

test/httpclient_test.cpp

@@ -153,3 +153,10 @@ TEST(HTTP, HTTPRemoveHeader) {
     FAIL() << std::format("Request failed: {}", e.what());
   }
 }
+
+TEST(HTTP, HTTPHead) {
+  HttpClient client{};
+  HttpResponse resp = client.head("https://postman-echo.com/get?foo0=bar1&foo2=bar2").execute();
+	EXPECT_TRUE(resp.body().empty());
+}
+