HttpClient.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Foundation/Compiler.h"
#ifndef SC_EXPORT_LIBRARY_HTTP_CLIENT
#define SC_EXPORT_LIBRARY_HTTP_CLIENT 0
#endif
#define SC_HTTP_CLIENT_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_HTTP_CLIENT)
 
#include "../Foundation/Result.h"
#include "../Foundation/Span.h"
#include "../Foundation/StringSpan.h"
#include "Internal/HttpClientThreading.h"
 
namespace SC
{
 
struct SC_HTTP_CLIENT_EXPORT HttpClientRequest
{
    enum Method : uint8_t
    {
        HttpGET,
        HttpPOST,
        HttpPUT,
        HttpHEAD,
        HttpDELETE,
        HttpPATCH,
        HttpOPTIONS,
    };
 
    Method method = HttpGET;
 
    StringSpan url; 
 
    Span<const StringSpan> headerNames;
    Span<const StringSpan> headerValues;
 
    Span<const char> body; 
 
    uint64_t streamedBodySize = 0; 
 
    uint32_t timeoutMs      = 30000; 
    bool     allowRedirects = false;
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientResponse
{
    enum class Protocol : uint8_t
    {
        Unknown,
        Http11,
        Http2,
    };
 
    int statusCode = 0; 
 
    Span<const char> headers;
 
    size_t   headersLength      = 0;
    Protocol negotiatedProtocol = Protocol::Unknown;
 
    [[nodiscard]] bool getHeader(StringSpan name, StringSpan& value) const;
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientRequestBodyProvider
{
    virtual ~HttpClientRequestBodyProvider() {}
 
    virtual Result pullRequestBody(Span<char> dest, size_t& bytesWritten, bool& endReached) = 0;
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientOperationListener
{
    virtual ~HttpClientOperationListener() {}
 
    virtual void onResponseHead(HttpClientResponse& response) { SC_COMPILER_UNUSED(response); } // namespace SC
 
    virtual void onResponseBody(Span<const char> data) { SC_COMPILER_UNUSED(data); }
 
    virtual void onResponseComplete() {}
 
    virtual void onError(Result error) { SC_COMPILER_UNUSED(error); }
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientOperation;
 
struct SC_HTTP_CLIENT_EXPORT HttpClientOperationNotifier
{
    virtual ~HttpClientOperationNotifier() {}
 
    virtual void notifyHttpClientOperation(HttpClientOperation& operation) = 0;
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientResponseBuffer
{
    Span<char> data;
 
  private:
    friend struct HttpClientOperation;
    bool inUse = false;
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientOperationEvent
{
    enum class Type : uint8_t
    {
        ResponseHead,
        ResponseData,
        ResponseComplete,
        Error,
    };
 
    Type   type        = Type::ResponseHead;
    size_t size        = 0;
    size_t bufferIndex = 0;
    Result error       = Result(true);
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientOperationMemory
{
    Span<HttpClientResponseBuffer> responseBuffers;
    Span<HttpClientOperationEvent> eventQueue;
 
    Span<char> responseBufferMemory; 
    Span<char> responseHeaders;
    Span<char> backendScratch;
};
 
#if SC_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable : 4324)
#endif
struct SC_HTTP_CLIENT_EXPORT HttpClient
{
    HttpClient();
    ~HttpClient();
 
    HttpClient(const HttpClient&)            = delete;
    HttpClient(HttpClient&&)                 = delete;
    HttpClient& operator=(const HttpClient&) = delete;
    HttpClient& operator=(HttpClient&&)      = delete;
 
    [[nodiscard]] Result init();
    [[nodiscard]] Result close();
 
    [[nodiscard]] bool isInitialized() const { return initialized; }
 
    [[nodiscard]] static Result executeBlocking(const HttpClientRequest& request, HttpClientResponse& response,
                                                Span<char> bodyBuffer, size_t& bodyLength,
                                                const HttpClientOperationMemory& memory);
 
    friend struct HttpClientOperation;
 
  private:
    friend struct Internal;
    struct Internal;
 
    Result platformInit();
    Result platformClose();
 
    bool initialized = false;
 
#if SC_PLATFORM_APPLE
    alignas(uint64_t) char storage[128];
#elif SC_PLATFORM_WINDOWS
    alignas(uint64_t) char storage[128];
#elif SC_PLATFORM_LINUX
    alignas(uint64_t) char storage[512];
#else
    alignas(uint64_t) char storage[8];
#endif
};
 
struct SC_HTTP_CLIENT_EXPORT HttpClientOperation
{
    HttpClientOperation();
    ~HttpClientOperation();
 
    HttpClientOperation(const HttpClientOperation&)            = delete;
    HttpClientOperation(HttpClientOperation&&)                 = delete;
    HttpClientOperation& operator=(const HttpClientOperation&) = delete;
    HttpClientOperation& operator=(HttpClientOperation&&)      = delete;
 
    [[nodiscard]] Result init(HttpClient& client, const HttpClientOperationMemory& memory);
    [[nodiscard]] Result close();
    [[nodiscard]] Result cancel();
 
    [[nodiscard]] Result start(const HttpClientRequest& request, HttpClientResponse& response,
                               HttpClientOperationListener*   listener     = nullptr,
                               HttpClientRequestBodyProvider* bodyProvider = nullptr);
 
    [[nodiscard]] Result poll(uint32_t timeoutMilliseconds = 0);
 
    void setNotifier(HttpClientOperationNotifier* notifierValue) { notifier = notifierValue; }
 
    [[nodiscard]] bool isInitialized() const { return initialized; }
    [[nodiscard]] bool isRequestInFlight() const { return requestInFlight; }
 
    friend struct Internal;
    struct Internal;
 
  private:
    friend struct HttpClientAppleCallbacks;
    friend struct HttpClientLinuxCallbacks;
    friend struct HttpClientWindowsCallbacks;
 
    Result platformInit();
    Result platformClose();
    Result platformStart();
    Result platformCancel();
 
    Result enqueueEvent(const HttpClientOperationEvent& event);
    bool   dequeueEvent(HttpClientOperationEvent& event);
 
    Result allocateResponseBuffer(size_t minimumSizeInBytes, size_t& bufferIndex, Span<char>& data);
    void   releaseResponseBuffer(size_t bufferIndex);
    Result enqueueResponseDataCopy(Span<const char> data);
 
    void enqueueResponseHead();
    void enqueueResponseBuffer(size_t bufferIndex, size_t size);
    void enqueueResponseComplete();
    void enqueueError(Result error);
 
    void resetResponseState(HttpClientResponse& response);
    void resetRequestBodyState();
 
    size_t readRequestBodyChunk(Span<char> dest, Result& outError, bool& outEnd);
    bool   hasPendingEvents() const;
    Result processPendingEvents();
 
    HttpClient*                    client              = nullptr;
    HttpClientResponse*            currentResponse     = nullptr;
    HttpClientOperationListener*   currentListener     = nullptr;
    HttpClientRequestBodyProvider* currentBodyProvider = nullptr;
    HttpClientOperationNotifier*   notifier            = nullptr;
    HttpClientRequest              currentRequest;
 
    Span<HttpClientResponseBuffer> responseBuffers;
    Span<HttpClientOperationEvent> eventQueue;
 
    Span<char> responseHeaders;
    Span<char> backendScratch;
 
    mutable HttpClientLocalMutex     eventMutex;
    HttpClientLocalConditionVariable eventCV;
    HttpClientOperationEvent         dequeuedEvent;
 
    size_t   eventHead            = 0;
    size_t   eventTail            = 0;
    size_t   eventCount           = 0;
    bool     requestBodyFinished  = false;
    Result   requestBodyError     = Result(true);
    uint64_t requestBodyBytesRead = 0;
    bool     initialized          = false;
    bool     requestInFlight      = false;
 
#if SC_PLATFORM_APPLE
    alignas(uint64_t) char storage[512];
#elif SC_PLATFORM_WINDOWS
    alignas(uint64_t) char storage[256];
#elif SC_PLATFORM_LINUX
    alignas(uint64_t) char storage[512];
#else
    alignas(uint64_t) char storage[8];
#endif
};
#if SC_COMPILER_MSVC
#pragma warning(pop)
#endif
 
} // namespace SC