HttpAsyncServer.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "HttpConnection.h"
#include "HttpExport.h"
 
namespace SC
{
namespace TypeTraits
{
template <typename Base, typename Derived>
struct IsBaseOf
{
    static constexpr bool value = __is_base_of(Base, Derived);
};
 
} // namespace TypeTraits
 
template <int ReadQueue, int WriteQueue, int HeaderBytes, int StreamBytes>
struct SC_HTTP_EXPORT HttpAsyncConnection
    : public HttpStaticConnection<ReadQueue, WriteQueue, HeaderBytes, StreamBytes, 8, HttpConnection>
{
};
 
struct SC_HTTP_EXPORT HttpAsyncServerTransportSetup
{
    HttpConnection* connection = nullptr;
    AsyncEventLoop* eventLoop  = nullptr;
 
    Function<void(Result)> complete;
    Function<void(Result)> fail;
};
 
struct SC_HTTP_EXPORT HttpAsyncServer
{
    template <typename T,
              typename = typename TypeTraits::EnableIf<TypeTraits::IsBaseOf<HttpConnection, T>::value>::type>
    Result init(Span<T> clients)
    {
        return initInternal({clients.data(), clients.sizeInElements(), sizeof(T)});
    }
 
    template <typename T,
              typename = typename TypeTraits::EnableIf<TypeTraits::IsBaseOf<HttpConnection, T>::value>::type>
    Result resize(Span<T> clients)
    {
        return resizeInternal({clients.data(), clients.sizeInElements(), sizeof(T)});
    }
 
    Result close();
 
    Result start(AsyncEventLoop& loop, StringSpan address, uint16_t port);
 
    Result startExternal(AsyncEventLoop& loop);
 
    Result acceptExternalConnection(HttpConnection& connection, AsyncReadableStream& readable,
                                    AsyncWritableStream& writable);
 
    Result stop();
 
    void setMaxHeaderSize(uint32_t bytes) { maxHeaderSize = bytes; }
 
    [[nodiscard]] uint32_t getMaxHeaderSize() const { return maxHeaderSize; }
 
    Result setTransportSetup(Function<Result(HttpAsyncServerTransportSetup&)>&& setup, const void* owner = nullptr)
    {
        SC_TRY(checkTransportMutation(owner));
        transportSetup = move(setup);
        return Result(true);
    }
 
    Result setTransportClose(Function<void(HttpConnection&)>&& close, const void* owner = nullptr)
    {
        SC_TRY(checkTransportMutation(owner));
        transportClose = move(close);
        return Result(true);
    }
 
    Result setTransportReuse(Function<Result(HttpConnection&)>&& reuse, const void* owner = nullptr)
    {
        SC_TRY(checkTransportMutation(owner));
        transportReuse = move(reuse);
        return Result(true);
    }
 
    Result setTransportShutdown(Function<Result(HttpConnection&, Function<void(Result)>)>&& shutdown,
                                const void*                                                 owner = nullptr)
    {
        SC_TRY(checkTransportMutation(owner));
        transportShutdown = move(shutdown);
        return Result(true);
    }
 
    Result clearTransportSetup(const void* owner = nullptr);
 
    Result claimTransport(const void* owner);
 
    Result releaseTransport(const void* owner);
 
    [[nodiscard]] bool isStarted() const { return state == State::Started; }
 
    [[nodiscard]] const HttpConnectionsPool& getConnections() const { return connections; }
 
    Function<void(HttpConnection&)> onRequest;
 
    Function<void(Result)> onError;
 
    void setDefaultKeepAlive(bool enabled) { defaultKeepAlive = enabled; }
 
    [[nodiscard]] bool getDefaultKeepAlive() const { return defaultKeepAlive; }
 
    void setMaxRequestsPerConnection(uint32_t maxRequests) { maxRequestsPerConnection = maxRequests; }
 
    [[nodiscard]] uint32_t getMaxRequestsPerConnection() const { return maxRequestsPerConnection; }
 
  private:
    Result checkTransportMutation(const void* owner) const;
    Result checkTransportQuiescence() const;
 
    HttpConnectionsPool connections;
 
    uint32_t maxHeaderSize = 8 * 1024;
 
    Function<Result(HttpAsyncServerTransportSetup&)>          transportSetup;
    Function<Result(HttpConnection&)>                         transportReuse;
    Function<Result(HttpConnection&, Function<void(Result)>)> transportShutdown;
    Function<void(HttpConnection&)>                           transportClose;
 
    const void* transportOwner = nullptr;
 
    uint32_t transportCallbackDepth = 0;
 
    enum class State
    {
        Stopped,  // Server was not started at all, or it was stopped and wait(ed)ForStopToFinish
        Started,  // Server has been started (successfully)
        Stopping, // Server has stop() called and needs waitForStopToFinish() call
    };
 
    State state = State::Stopped;
 
    bool     defaultKeepAlive         = true; 
    uint32_t maxRequestsPerConnection = 0;    
 
    void   onNewClient(AsyncSocketAccept::Result& result);
    void   closeAsync(HttpConnection& requestClient);
    void   shutdownTransport(HttpConnection& requestClient);
    void   tryDeactivateConnection(HttpConnection& requestClient);
    void   deactivateConnection(HttpConnection& requestClient);
    Result beginHttpConnection(HttpConnection& client);
    Result beginTransportConnection(HttpConnection& client);
    void   onStreamReceive(HttpConnection& client, AsyncBufferView::ID bufferID);
    void   onRequestBodyData(HttpConnection& client, AsyncBufferView::ID bufferID);
    void   onTransportSetupComplete(HttpConnection& client, Result result);
 
    Result waitForStopToFinish();
    Result initInternal(SpanWithStride<HttpConnection> connections);
    Result resizeInternal(SpanWithStride<HttpConnection> connections);
 
    AsyncEventLoop*   eventLoop = nullptr;
    SocketDescriptor  serverSocket;
    AsyncSocketAccept asyncServerAccept;
    bool              externalListener = false;
 
    struct EventDataListener;
    struct EventBodyDataListener;
    struct EventEndListener;
    struct EventCloseListener;
};
} // namespace SC