HttpAsyncClient.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "HttpConnection.h"
#include "HttpExport.h"
#include "HttpURLParser.h"
 
namespace SC
{
 
template <int ReadQueue, int WriteQueue, int HeaderBytes, int StreamBytes>
struct SC_HTTP_EXPORT HttpAsyncClientConnection
    : public HttpStaticConnection<ReadQueue, WriteQueue, HeaderBytes, StreamBytes, 8, HttpConnectionBase>
{
    static constexpr int ExtraBuffers = 8;
 
    HttpAsyncClientConnection()
    {
        this->readableSocketStream.setAutoDestroy(false);
        this->writableSocketStream.setAutoDestroy(false);
    }
};
 
struct SC_HTTP_EXPORT HttpAsyncClient
{
    Result init(HttpConnectionBase& storage);
 
    Result close();
 
    Result start(AsyncEventLoop& loop, HttpParser::Method method, StringSpan url, bool keepAlive = false);
 
    Result get(AsyncEventLoop& loop, StringSpan url, bool keepAlive = false);
 
    Result put(AsyncEventLoop& loop, StringSpan url, Span<const char> body, bool keepAlive = false);
    Result put(AsyncEventLoop& loop, StringSpan url, StringSpan body, bool keepAlive = false)
    {
        return put(loop, url, body.toCharSpan(), keepAlive);
    }
 
    Result post(AsyncEventLoop& loop, StringSpan url, Span<const char> body, bool keepAlive = false);
    Result post(AsyncEventLoop& loop, StringSpan url, StringSpan body, bool keepAlive = false)
    {
        return post(loop, url, body.toCharSpan(), keepAlive);
    }
 
    Result postMultipart(AsyncEventLoop& loop, StringSpan url, HttpMultipartWriter& writer, bool keepAlive = false);
 
    [[nodiscard]] HttpAsyncClientResponse&       getResponse() { return response; }
    [[nodiscard]] const HttpAsyncClientResponse& getResponse() const { return response; }
 
    Function<void(HttpAsyncClientRequest&)> onPrepareRequest;
 
    Function<void(HttpAsyncClientResponse&)> onResponse;
 
    Function<void(Result)> onError;
 
  private:
    struct RequestPreset
    {
        enum class BodyMode : uint8_t
        {
            None,
            Span,
            Stream,
            Multipart,
        };
 
        HttpParser::Method method = HttpParser::Method::HttpGET;
 
        StringSpan url;
 
        bool keepAlive = false;
        bool autoSend  = false;
 
        Span<const char> bodySpan;
 
        BodyMode bodyMode      = BodyMode::None;
        uint64_t contentLength = 0;
 
        AsyncReadableStream* bodyStream      = nullptr;
        HttpMultipartWriter* multipartWriter = nullptr;
    };
 
    enum class State : uint8_t
    {
        Idle,
        Connecting,
        Sending,
        WaitingResponse,
        StreamingResponse,
    };
 
    Result startRequest(AsyncEventLoop& loop, const RequestPreset& preset);
    Result prepareRequest(const RequestPreset& preset);
    Result startPreparedRequest(const RequestPreset& preset);
    Result ensureConnected();
    Result beginSocketConnection();
    Result beginResponseRead();
    Result beginRequestSend();
    Result onResponseBodyStreamRead();
    Result validateActiveRequest() const;
 
    void finalizeResponse(bool finishBodyStream);
    void closeConnection();
    void finishResponse();
    void fail(Result error);
 
    void onConnected(AsyncSocketConnect::Result& result);
    void onReadableError(Result result);
    void onWritableError(Result result);
    void onPipelineError(Result result);
    void onReadableEnd();
    void onHeadersBufferWritten(AsyncBufferView::ID bufferID);
    void onResponseData(AsyncBufferView::ID bufferID);
    void onResponseBodyData(AsyncBufferView::ID bufferID);
 
    [[nodiscard]] bool canReuseConnectionFor(StringSpan host, uint16_t port) const;
    [[nodiscard]] bool responseMustNotHaveBody() const;
    [[nodiscard]] bool responseHasKnownLength() const;
 
    HttpConnectionBase* connection = nullptr;
 
    AsyncEventLoop*         eventLoop      = nullptr;
    HttpAsyncClientRequest* currentRequest = nullptr;
    HttpAsyncClientRequest  request;
    HttpAsyncClientResponse response;
    AsyncSocketConnect      connectAsync;
    RequestPreset           currentPreset;
 
    State state = State::Idle;
 
    StringSpan currentHost;
    char       currentHostStorage[256] = {0};
    uint16_t   currentPort             = 0;
 
    HttpURLParser currentURL;
    uint32_t      requestCount = 0;
 
    bool hasOpenConnection = false;
    bool responseDelivered = false;
    bool responseFinalized = false;
};
 
} // namespace SC