https_client.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_HTTP_HTTPS_CLIENT_H
#define CPPSERVER_HTTP_HTTPS_CLIENT_H
 
#include "http_request.h"
#include "http_response.h"
 
#include "server/asio/ssl_client.h"
#include "server/asio/timer.h"
 
#include <future>
 
namespace CppServer {
namespace HTTP {
 
 
class HTTPSClient : public Asio::SSLClient
{
public:
    using SSLClient::SSLClient;
 
    HTTPSClient(const HTTPSClient&) = delete;
    HTTPSClient(HTTPSClient&&) = delete;
    virtual ~HTTPSClient() = default;
 
    HTTPSClient& operator=(const HTTPSClient&) = delete;
    HTTPSClient& operator=(HTTPSClient&&) = delete;
 
    HTTPRequest& request() noexcept { return _request; }
    const HTTPRequest& request() const noexcept { return _request; }
 
 
    size_t SendRequest() { return SendRequest(_request); }
 
    size_t SendRequest(const HTTPRequest& request) { return Send(request.cache()); }
 
 
    size_t SendRequestBody(std::string_view body) { return Send(body); }
 
    size_t SendRequestBody(const void* buffer, size_t size) { return Send(buffer, size); }
 
 
    size_t SendRequest(const CppCommon::Timespan& timeout) { return SendRequest(_request, timeout); }
 
    size_t SendRequest(const HTTPRequest& request, const CppCommon::Timespan& timeout) { return Send(request.cache(), timeout); }
 
 
    size_t SendRequestBody(std::string_view body, const CppCommon::Timespan& timeout) { return Send(body, timeout); }
 
    size_t SendRequestBody(const void* buffer, size_t size, const CppCommon::Timespan& timeout) { return Send(buffer, size, timeout); }
 
 
    bool SendRequestAsync() { return SendRequestAsync(_request); }
 
    bool SendRequestAsync(const HTTPRequest& request) { return SendAsync(request.cache()); }
 
 
    bool SendRequestBodyAsync(std::string_view body) { return SendAsync(body); }
 
    bool SendRequestBodyAsync(const void* buffer, size_t size) { return SendAsync(buffer, size); }
 
protected:
    void onReceived(const void* buffer, size_t size) override;
    void onDisconnected() override;
 
 
    virtual void onReceivedResponseHeader(const HTTPResponse& response) {}
 
 
    virtual void onReceivedResponse(const HTTPResponse& response) {}
 
 
    virtual void onReceivedResponseError(const HTTPResponse& response, const std::string& error) {}
 
protected:
    HTTPRequest _request;
    HTTPResponse _response;
};
 
 
class HTTPSClientEx : public HTTPSClient
{
public:
    using HTTPSClient::HTTPSClient;
 
    std::shared_ptr<Asio::TCPResolver>& resolver() noexcept { return _resolver; }
    const std::shared_ptr<Asio::TCPResolver>& resolver() const noexcept { return _resolver; }
    std::shared_ptr<Asio::Timer>& timeout() noexcept { return _timeout; }
    const std::shared_ptr<Asio::Timer>& timeout() const noexcept { return _timeout; }
 
 
    std::future<HTTPResponse> SendRequest(const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1)) { return SendRequest(_request, timeout); }
 
    std::future<HTTPResponse> SendRequest(const HTTPRequest& request, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1));
 
 
    std::future<HTTPResponse> SendHeadRequest(std::string_view url, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1))
    { return SendRequest(_request.MakeHeadRequest(url), timeout); }
 
    std::future<HTTPResponse> SendGetRequest(std::string_view url, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1))
    { return SendRequest(_request.MakeGetRequest(url), timeout); }
 
    std::future<HTTPResponse> SendPostRequest(std::string_view url, std::string_view content, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1))
    { return SendRequest(_request.MakePostRequest(url, content), timeout); }
 
    std::future<HTTPResponse> SendPutRequest(std::string_view url, std::string_view content, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1))
    { return SendRequest(_request.MakePutRequest(url, content), timeout); }
 
    std::future<HTTPResponse> SendDeleteRequest(std::string_view url, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1))
    { return SendRequest(_request.MakeDeleteRequest(url), timeout); }
 
    std::future<HTTPResponse> SendOptionsRequest(std::string_view url, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1))
    { return SendRequest(_request.MakeOptionsRequest(url), timeout); }
 
    std::future<HTTPResponse> SendTraceRequest(std::string_view url, const CppCommon::Timespan& timeout = CppCommon::Timespan::minutes(1))
    { return SendRequest(_request.MakeTraceRequest(url), timeout); }
 
protected:
    void onHandshaked() override;
    void onDisconnected() override;
    void onReceivedResponse(const HTTPResponse& response) override;
    void onReceivedResponseError(const HTTPResponse& response, const std::string& error) override;
 
private:
    std::shared_ptr<Asio::TCPResolver> _resolver;
    std::shared_ptr<Asio::Timer> _timeout;
    std::promise<HTTPResponse> _promise;
 
    void SetPromiseValue(const HTTPResponse& response);
    void SetPromiseError(const std::string& error);
};
 
} // namespace HTTP
} // namespace CppServer
 
#endif // CPPSERVER_HTTP_HTTPS_CLIENT_H