HttpAsyncFileServer.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Async/Async.h"
#include "../AsyncStreams/AsyncRequestStreams.h"
#include "HttpConnection.h"
#include "HttpExport.h"
#include "HttpMultipartParser.h"
 
namespace SC
{
struct SC_HTTP_EXPORT HttpAsyncFileServerOptions
{
    StringSpan spaFallbackPath = {};
 
    bool enableValidators = true;
 
    bool enableRangeRequests = true;
 
    bool enableUploads = true;
 
    size_t maxUploadBytes = 0;
};
 
struct SC_HTTP_EXPORT HttpAsyncFileServer
{
    using ReadableFileStream = AsyncReadableFileStream<AsyncEventLoop>;
    using WritableFileStream = AsyncWritableFileStream<AsyncEventLoop>;
    struct SC_HTTP_EXPORT Stream
    {
        ReadableFileStream  readableFileStream;
        WritableFileStream  writableFileStream;
        AsyncTaskSequence   readableFileStreamTask;
        AsyncTaskSequence   writableFileStreamTask;
        HttpMultipartParser multipartParser;
        AsyncFileSend       asyncFileSend;
        FileDescriptor      sourceFileDescriptor;
        size_t              fileSendOffset = 0;
        size_t              fileSendLength = 0;
 
        struct MultipartListener
        {
            HttpAsyncFileServer* server     = nullptr;
            Stream*              stream     = nullptr;
            HttpConnection*      connection = nullptr;
 
            FileDescriptor               currentFd; // TODO: Reuse the above sourceFileDescriptor
            StringPath                   currentFilePath;
            StringSpan                   currentHeaderName;
            HttpMultipartPartHeadersView partHeaders;
            bool                         rejectedFileName = false;
 
            void onData(AsyncBufferView::ID bufferID);
        } multipartListener;
 
        struct PutFileListener
        {
            HttpConnection* connection = nullptr;
 
            void onFinish();
        } putFileListener;
    };
 
    template <int RequestsSize>
    struct SC_HTTP_EXPORT StreamQueue : public Stream
    {
        static_assert(RequestsSize >= 2, "HttpAsyncFileServer::StreamQueue requires RequestsSize >= 2");
 
        StreamQueue()
        {
            readableFileStream.setReadQueue(readQueue);
            writableFileStream.setWriteQueue(writeQueue);
        }
        AsyncReadableStream::Request readQueue[RequestsSize];
        AsyncWritableStream::Request writeQueue[RequestsSize];
    };
 
    Result init(ThreadPool& threadPool, AsyncEventLoop& loop, StringSpan directoryToServe);
 
    Result close();
 
    void setUseAsyncFileSend(bool value);
 
    [[nodiscard]] bool getUseAsyncFileSend() const { return useAsyncFileSend; }
 
    Result setOptions(const HttpAsyncFileServerOptions& options);
 
    Result handleRequest(HttpAsyncFileServer::Stream& stream, HttpConnection& connection);
 
  private:
    bool                       useAsyncFileSend = true;
    HttpAsyncFileServerOptions options          = {};
 
    Result putFile(HttpAsyncFileServer::Stream& stream, HttpConnection& connection, StringSpan filePath);
    Result getFile(HttpAsyncFileServer::Stream& stream, HttpConnection& connection, StringSpan filePath, bool sendBody,
                   bool allowSpaFallback);
    Result postMultipart(HttpAsyncFileServer::Stream& stream, HttpConnection& connection);
 
    StringPath directory;
 
    AsyncEventLoop* eventLoop  = nullptr;
    ThreadPool*     threadPool = nullptr;
    struct Internal;
};
 
} // namespace SC