HttpAsyncFileServer.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Async/Async.h"
#include "../AsyncStreams/AsyncRequestStreams.h"
#include "HttpConnection.h"
#include "HttpMultipartParser.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT HttpAsyncFileServer
{
    using ReadableFileStream = AsyncReadableFileStream<AsyncEventLoop>;
    using WritableFileStream = AsyncWritableFileStream<AsyncEventLoop>;
    struct SC_COMPILER_EXPORT Stream
    {
        ReadableFileStream  readableFileStream;
        WritableFileStream  writableFileStream;
        AsyncTaskSequence   readableFileStreamTask;
        AsyncTaskSequence   writableFileStreamTask;
        HttpMultipartParser multipartParser;
        AsyncFileSend       asyncFileSend;
        FileDescriptor      sourceFileDescriptor;
 
        struct MultipartListener
        {
            HttpAsyncFileServer* server     = nullptr;
            Stream*              stream     = nullptr;
            HttpConnection*      connection = nullptr;
 
            FileDescriptor currentFd; // TODO: Reuse the above sourceFileDescriptor
            StringPath     currentFilePath;
            StringSpan     currentFileName;
            StringSpan     currentHeaderName;
            bool           isContentDisposition = false;
 
            void onData(AsyncBufferView::ID bufferID);
        } multipartListener;
 
        struct PutFileListener
        {
            HttpConnection* connection     = nullptr;
            size_t          remainingBytes = 0;
 
            void onData(AsyncBufferView::ID bufferID);
            void onDrain();
        } putFileListener;
    };
 
    template <int RequestsSize>
    struct SC_COMPILER_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 handleRequest(HttpAsyncFileServer::Stream& stream, HttpConnection& connection);
 
  private:
    bool   useAsyncFileSend = true;
    Result putFile(HttpAsyncFileServer::Stream& stream, HttpConnection& connection, StringSpan filePath);
    Result getFile(HttpAsyncFileServer::Stream& stream, HttpConnection& connection, StringSpan filePath);
    Result postMultipart(HttpAsyncFileServer::Stream& stream, HttpConnection& connection);
 
    StringPath directory;
 
    AsyncEventLoop* eventLoop  = nullptr;
    ThreadPool*     threadPool = nullptr;
    struct Internal;
};
 
} // namespace SC