HttpServer.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "HttpParser.h"
 
#include "../Containers/ArenaMapKey.h"
#include "../Containers/Vector.h"
#include "../Foundation/Buffer.h"
#include "../Foundation/Function.h"
#include "../Strings/StringView.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT HttpServer;
struct SC_COMPILER_EXPORT HttpRequest;
struct SC_COMPILER_EXPORT HttpResponse;
struct SC_COMPILER_EXPORT HttpRequest;
 
struct AsyncEventLoop;
struct SocketDescriptor;
struct HttpServerClient;
} // namespace SC
 
 
namespace SC
{
namespace detail
{
struct SC_COMPILER_EXPORT HttpHeaderOffset
{
    HttpParser::Result result = HttpParser::Result::Method;
 
    uint32_t start  = 0;
    uint32_t length = 0;
};
} // namespace detail
 
#if !DOXYGEN
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Vector<detail::HttpHeaderOffset>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT ArenaMapKey<HttpServerClient>;
#endif
} // namespace SC
 
struct SC::HttpRequest
{
    [[nodiscard]] bool find(HttpParser::Result result, StringView& res) const;
 
    const HttpParser& getParser() const { return parser; }
 
    StringView getURL() const { return url; }
 
  private:
    friend struct HttpServer;
    using HttpHeaderOffset = detail::HttpHeaderOffset; // TODO: hide class implementation
 
    bool headersEndReceived = false; 
    bool parsedSuccessfully = true;  
 
    HttpParser parser;       
    StringView url;          
    Buffer     headerBuffer; 
 
    Vector<HttpHeaderOffset> headerOffsets; 
};
 
struct SC::HttpResponse
{
    ArenaMapKey<HttpServerClient> getClientKey() const { return key; }
 
    [[nodiscard]] Result startResponse(int httpCode);
 
    [[nodiscard]] Result addHeader(StringView headerName, StringView headerValue);
 
    [[nodiscard]] Result write(Span<const char> data);
 
    [[nodiscard]] Result end(Span<const char> data);
 
    HttpServer& getServer() { return *server; }
 
  private:
    friend struct HttpServer;
    [[nodiscard]] bool mustBeFlushed() const { return responseEnded or outputBuffer.size() > highwaterMark; }
 
    HttpServer* server = nullptr;
 
    ArenaMapKey<HttpServerClient> key;
 
    Buffer outputBuffer;
 
    bool   responseEnded = false;
    size_t highwaterMark = 1024;
};
 
namespace SC
{
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Function<void(HttpRequest&, HttpResponse&)>;
}
 
struct SC::HttpServer
{
    HttpServer();
    ~HttpServer();
    HttpServer(const HttpServer&)            = delete;
    HttpServer& operator=(const HttpServer&) = delete;
    HttpServer(HttpServer&&)                 = delete;
    HttpServer& operator=(HttpServer&&)      = delete;
 
    [[nodiscard]] Result start(AsyncEventLoop& loop, uint32_t maxConcurrentRequests, StringView address, uint16_t port);
 
    [[nodiscard]] Result stopAsync();
 
    [[nodiscard]] Result stopSync();
 
    [[nodiscard]] bool isStarted() const;
 
    Function<void(HttpRequest&, HttpResponse&)> onRequest;
 
    [[nodiscard]] HttpRequest* getRequest(ArenaMapKey<HttpServerClient> key) const;
 
    [[nodiscard]] HttpResponse* getResponse(ArenaMapKey<HttpServerClient> key) const;
 
    [[nodiscard]] SocketDescriptor* getSocket(ArenaMapKey<HttpServerClient> key) const;
 
    [[nodiscard]] uint32_t getMaxConcurrentRequests() const;
 
  private:
    struct Internal;
#if SC_PLATFORM_WINDOWS
    uint64_t internalRaw[72];
#else
    uint64_t internalRaw[32];
#endif
    Internal& internal;
};