http_client.h

Go to the documentation of this file.

 
#ifndef OCTANE_API_CLIENT_INTERNAL_HTTP_CLIENT_H_
#define OCTANE_API_CLIENT_INTERNAL_HTTP_CLIENT_H_
 
#include <gtest/gtest_prod.h>
 
#include <map>
#include <string>
#include <vector>
 
#include "../error_response.h"
#include "../result.h"
 
namespace octane::internal {
  enum struct HttpMethod {
    Get,
    Post,
    Put,
    Delete,
  };
  enum struct HttpVersion {
    Http1_0,
    Http1_1,
    Http2,
    Http3,
  };
  struct HttpRequest {
    HttpMethod method;
    HttpVersion version;
    std::string uri;
    std::map<std::string, std::string> headerField;
    std::vector<std::uint8_t> body;
  };
  bool operator==(const HttpRequest& a, const HttpRequest& b);
  std::ostream& operator<<(std::ostream& stream, const HttpRequest& request);
 
  struct HttpResponse {
    int statusCode;
    std::string statusLine;
    HttpVersion version;
    std::map<std::string, std::string> headerField;
    std::vector<std::uint8_t> body;
  };
  bool operator==(const HttpResponse& a, const HttpResponse& b);
  std::ostream& operator<<(std::ostream& stream, const HttpResponse& response);
 
  class HttpClientBase {
  public:
    virtual ~HttpClientBase() noexcept = 0;
 
    virtual Result<_, ErrorResponse> init() noexcept = 0;
 
    virtual Result<HttpResponse, ErrorResponse>
    request(std::string_view origin, const HttpRequest& request) = 0;
  };
  class HttpClient : public HttpClientBase {
    FRIEND_TEST(HttpClientTest, WriteCallback);
    FRIEND_TEST(HttpClientTest, ReadCallback);
    FRIEND_TEST(HttpClientTest, HeaderCallback);
    FRIEND_TEST(HttpClientTest, MakeHttpResponseOk);
    FRIEND_TEST(HttpClientTest, MakeHttpResponseErr);
 
  public:
    virtual ~HttpClient() noexcept;
 
    virtual Result<_, ErrorResponse> init() noexcept override;
    virtual Result<HttpResponse, ErrorResponse> request(
      std::string_view origin,
      const HttpRequest& request) override;
 
  private:
    static size_t writeCallback(char* buffer,
                                size_t size,
                                size_t nmemb,
                                std::vector<std::uint8_t>* chunk);
 
    static size_t readCallback(
      char* buffer,
      size_t size,
      size_t nmemb,
      std::pair<const std::vector<std::uint8_t>*, size_t>* stream);
 
    static size_t headerCallback(
      char* buffer,
      size_t size,
      size_t nmemb,
      std::pair<std::string, std::map<std::string, std::string>>*
        responseHeader);
    Result<HttpResponse, ErrorResponse> makeHttpResponse(
      std::pair<std::string, std::map<std::string, std::string>>&&
        responseHeader,
      std::vector<std::uint8_t>&& chunk);
  };
} // namespace octane::internal
 
#endif // OCTANE_API_CLIENT_HTTP_CLIENT_H_