ACurl.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <cstddef>
#include <optional>
#include <queue>
#include <AUI/ACurl.h>
 
#include "AUI/IO/AEOFException.h"
#include "AUI/IO/IInputStream.h"
#include "AUI/Traits/values.h"
#include "AFormMultipart.h"
#include <AUI/IO/APipe.h>
#include <AUI/Common/AByteBufferView.h>
#include <AUI/Common/AByteBuffer.h>
#include <AUI/Common/ASignal.h>
#include <AUI/Reflect/AEnumerate.h>
#include <AUI/Thread/AFuture.h>
 
class AString;
class ACurlMulti;
 
class API_AUI_CURL ACurl: public AObject {
friend class ACurlMulti;
public:
    enum class Http {
        VERSION_NONE, /* setting this means we don't care, and that we'd
                         like the library to choose the best possible
                         for us! */
        VERSION_1_0,  /* please use HTTP 1.0 in the request */
        VERSION_1_1,  /* please use HTTP 1.1 in the request */
        VERSION_2_0,  /* please use HTTP 2 in the request */
        VERSION_2TLS, /* use version 2 for HTTPS, version 1.1 for HTTP */
        VERSION_2_PRIOR_KNOWLEDGE,  /* please use HTTP 2 without HTTP/1.1
                                       Upgrade */
        VERSION_3 = 30, /* Makes use of explicit HTTP/3 without fallback.
                           Use CURLOPT_ALTSVC to enable HTTP/3 upgrade */
        VERSION_LAST /* *ILLEGAL* http version */
    };
 
    enum class ResponseCode {
        HTTP_100_CONTINUE                        = 100,
        HTTP_101_SWITCHING_PROTOCOL              = 101,
        HTTP_102_PROCESSING                      = 102,
        HTTP_103_EARLY_HINTS                     = 103,
        HTTP_200_OK                              = 200,
        HTTP_201_CREATED                         = 201,
        HTTP_202_ACCEPTED                        = 202,
        HTTP_203_NON_AUTHORITATIVE_INFORMATION   = 203,
        HTTP_204_NO_CONTENT                      = 204,
        HTTP_205_RESET_CONTENT                   = 205,
        HTTP_206_PARTIAL_CONTENT                 = 206,
        HTTP_300_MULTIPLE_CHOICE                 = 300,
        HTTP_301_MOVED_PERMANENTLY               = 301,
        HTTP_302_FOUND                           = 302,
        HTTP_303_SEE_OTHER                       = 303,
        HTTP_304_NOT_MODIFIED                    = 304,
        HTTP_305_USE_PROXY                       = 305,
        HTTP_306_SWITCH_PROXY                    = 306,
        HTTP_307_TEMPORARY_REDIRECT              = 307,
        HTTP_308_PERMANENT_REDIRECT              = 308,
        HTTP_400_BAD_REQUEST                     = 400,
        HTTP_401_UNAUTHORIZED                    = 401,
        HTTP_402_PAYMENT_REQUIRED                = 402,
        HTTP_403_FORBIDDEN                       = 403,
        HTTP_404_NOT_FOUND                       = 404,
        HTTP_405_METHOD_NOT_ALLOWED              = 405,
        HTTP_406_NOT_ACCEPTABLE                  = 406,
        HTTP_407_PROXY_AUTHENTICATION_REQUIRED   = 407,
        HTTP_408_REQUEST_TIMEOUT                 = 408,
        HTTP_409_CONFLICT                        = 409,
        HTTP_410_GONE                            = 410,
        HTTP_411_LENGTH_REQUIRED                 = 411,
        HTTP_412_PRECONDITION_FAILED             = 412,
        HTTP_413_REQUEST_ENTITY_TOO_LARGE        = 413,
        HTTP_414_REQUEST_URI_TOO_LONG            = 414,
        HTTP_415_UNSUPPORTED_MEDIA_TYPE          = 415,
        HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
        HTTP_417_EXPECTATION_FAILED              = 417,
        HTTP_500_INTERNAL_SERVER_ERROR           = 500,
        HTTP_501_NOT_IMPLEMENTED                 = 501,
        HTTP_502_BAD_GATEWAY                     = 502,
        HTTP_503_SERVICE_UNAVAILABLE             = 503,
        HTTP_504_GATEWAY_TIMEOUT                 = 504,
        HTTP_505_HTTP_VERSION_NOT_SUPPORTED      = 505,
 
        /* don't forget to update AUI_ENUM_VALUES at the bottom */
    };
 
    enum class Method {
        HTTP_GET,
        HTTP_POST,
        HTTP_PUT,
        HTTP_DELETE,
    };
 
    struct Response {
        ResponseCode code;
        AString contentType;
        AByteBuffer body;
    };
 
 
    struct API_AUI_CURL ErrorDescription {
        int curlStatus;
        AString description;
 
        void throwException() const;
    };
 
    using WriteCallback = std::function<size_t(AByteBufferView data)>;
 
    using ReadCallback = std::function<std::size_t(char* dst, size_t maxLen)>;
    using HeaderCallback = std::function<void(AByteBufferView)>;
    using ErrorCallback = std::function<void(const ErrorDescription& description)>;
 
 
    class Exception: public AIOException {
    public:
        using AIOException::AIOException;
        Exception(const ErrorDescription& errorDescription): AIOException(errorDescription.description),
                                                             mCurlStatus(errorDescription.curlStatus) {
 
        }
 
        [[nodiscard]]
        int curlStatus() const noexcept {
            return mCurlStatus;
        }
 
    private:
        int mCurlStatus;
    };
 
    class API_AUI_CURL Builder {
    friend class ACurl;
    private:
        void* mCURL;
        WriteCallback mWriteCallback;
        ReadCallback mReadCallback;
        ErrorCallback mErrorCallback;
        HeaderCallback mHeaderCallback;
        bool mThrowExceptionOnError = false;
        AVector<AString> mHeaders;
        AString mUrl, mParams;
        Method mMethod = Method::HTTP_GET;
        std::function<void(ACurl&)> mOnSuccess;
 
    public:
        explicit Builder(AString url);
        Builder(const Builder&) = delete;
        ~Builder();
 
        Builder& withWriteCallback(WriteCallback callback) {
            AUI_ASSERTX(mWriteCallback == nullptr, "write callback already set");
            mWriteCallback = std::move(callback);
            return *this;
        }
 
         Builder& withMultipart(const AFormMultipart& multipart) {
            withInputStream(multipart.makeInputStream());
            mHeaders.push_back("Content-Type: multipart/form-data; boundary={}"_format(multipart.boundary()));
            return *this;
         }
 
        Builder& withBody(ReadCallback callback) {
            AUI_ASSERTX(mReadCallback == nullptr, "write callback already set");
            mReadCallback = std::move(callback);
            return *this;
        }
 
        Builder& withInputStream(_<IInputStream> inputStream) {
            withBody([inputStream = std::move(inputStream)](char* dst, std::size_t length) {
                auto v = inputStream->read(dst, length);
                if (v == 0) {
                    throw AEOFException();
                }
                return v;
            });
            return *this;
        }
 
        Builder& withTimeout(std::chrono::seconds timeout);
 
        Builder& withBody(std::string contents) {
            AUI_ASSERTX(mReadCallback == nullptr, "write callback already set");
 
            struct Body {
                explicit Body(std::string b) : contents(std::move(b)), i(contents.begin()) {}
 
                std::string contents;
                std::string::iterator i;
            };
            auto b = _new<Body>(std::move(contents));
 
            mReadCallback = [body = std::move(b)](char* dst, std::size_t length) mutable {
                if (body->i == body->contents.end()) {
                    throw AEOFException();
                }
                std::size_t remaining = std::distance(body->i, body->contents.end());
                length = glm::min(length, remaining);
                std::memcpy(dst, &*body->i, length);
                body->i += length;
                return length;
            };
 
            return *this;
        }
 
        Builder& withHeaderCallback(HeaderCallback headerCallback) {
            mHeaderCallback = std::move(headerCallback);
            return *this;
        }
 
        Builder& withErrorCallback(ErrorCallback callback) {
            AUI_ASSERTX(mErrorCallback == nullptr, "error callback already set");
            mErrorCallback = std::move(callback);
            return *this;
        }
 
        Builder& withDestinationBuffer(aui::constraint::avoid_copy<AByteBuffer> dst) {
            return withWriteCallback([dst](AByteBufferView b) {
                (*dst) << b;
                return b.size();
            });
        }
 
        Builder& withOutputStream(_<IOutputStream> dst) {
            return withWriteCallback([dst = std::move(dst)](AByteBufferView b) {
                (*dst) << b;
                return b.size();
            });
        }
 
        Builder& throwExceptionOnError(bool throwExceptionOnError) noexcept {
            mThrowExceptionOnError = throwExceptionOnError;
            return *this;
        }
 
        Builder& withRanges(size_t begin, size_t end);
 
        Builder& withRanges(size_t begin) {
            return withRanges(begin, 0);
        }
 
        Builder& withLowSpeedLimit(size_t speed);
 
        Builder& withLowSpeedTime(std::chrono::seconds duration);
 
 
        Builder& withHttpVersion(Http version);
        Builder& withUpload(bool upload);
        Builder& withCustomRequest(const AString& v);
        Builder& withOnSuccess(std::function<void(ACurl&)> onSuccess) {
            mOnSuccess = std::move(onSuccess);
            return *this;
        }
 
        template<aui::invocable OnSuccess>
        Builder& withOnSuccess(OnSuccess&& onSuccess) {
            mOnSuccess = [onSuccess = std::forward<OnSuccess>(onSuccess)](ACurl&) {
                onSuccess();
            };
            return *this;
        }
 
        Builder& withMethod(Method method) noexcept {
            mMethod = method;
            return *this;
        };
 
 
        Builder& withParams(const AVector<std::pair<AString /* key */, AString /* value */>>& params);
 
        Builder& withParams(AString params) noexcept {
            mParams = std::move(params);
            return *this;
        };
 
        Builder& withHeaders(AVector<AString> headers) {
            mHeaders = std::move(headers);
            return *this;
        }
 
        _unique<IInputStream> toInputStream();
 
        Response runBlocking();
 
         AFuture<Response> runAsync();
 
         AFuture<Response> runAsync(ACurlMulti& curlMulti);
    };
 
    explicit ACurl(Builder& builder):
        ACurl(std::move(builder))
    {
 
    }
    explicit ACurl(Builder&& builder) noexcept {
        operator=(std::move(builder));
    }
    ACurl(ACurl&& o) noexcept {
        operator=(std::move(o));
    }
 
    virtual ~ACurl();
 
    ACurl& operator=(Builder&& o) noexcept;
    ACurl& operator=(ACurl&& o) noexcept;
 
    int64_t getContentLength() const;
    int64_t getNumberOfBytesDownloaded() const;
    AString getContentType() const;
 
    void run();
 
    virtual void close();
 
    [[nodiscard]]
    void* handle() const noexcept {
        return mCURL;
    }
 
    [[nodiscard]]
    ResponseCode getResponseCode() const;
 
    [[nodiscard]]
    AString getErrorString() const noexcept {
        return AString::fromLatin1(mErrorBuffer);
    }
 
private:
    void* mCURL;
    struct curl_slist* mCurlHeaders = nullptr;
    char mErrorBuffer[256];
    bool mCloseRequested = false;
    std::string mPostFieldsStorage;
 
    static size_t writeCallback(char* ptr, size_t size, size_t nmemb, void* userdata) noexcept;
    static size_t readCallback(char* ptr, size_t size, size_t nmemb, void* userdata) noexcept;
    static size_t headerCallback(char *buffer, size_t size, size_t nitems, void *userdata) noexcept;
 
    WriteCallback mWriteCallback;
    ReadCallback mReadCallback;
    HeaderCallback mHeaderCallback;
 
    void reportSuccess() {
        emit success;
    }
 
    void reportFail(int statusCode) {
        emit fail(ErrorDescription{statusCode, AString::fromLatin1(mErrorBuffer)});
    }
 
    template<typename Ret>
    Ret getInfo(int curlInfo) const;
 
 
signals:
 
    emits<ErrorDescription> fail;
 
    emits<> success;
 
 
    emits<> closeRequested;
};
 
 
AUI_ENUM_VALUES(ACurl::ResponseCode,
                ACurl::ResponseCode::HTTP_100_CONTINUE,
                ACurl::ResponseCode::HTTP_101_SWITCHING_PROTOCOL,
                ACurl::ResponseCode::HTTP_102_PROCESSING,
                ACurl::ResponseCode::HTTP_103_EARLY_HINTS,
                ACurl::ResponseCode::HTTP_200_OK,
                ACurl::ResponseCode::HTTP_201_CREATED,
                ACurl::ResponseCode::HTTP_202_ACCEPTED,
                ACurl::ResponseCode::HTTP_203_NON_AUTHORITATIVE_INFORMATION,
                ACurl::ResponseCode::HTTP_204_NO_CONTENT,
                ACurl::ResponseCode::HTTP_205_RESET_CONTENT,
                ACurl::ResponseCode::HTTP_206_PARTIAL_CONTENT,
                ACurl::ResponseCode::HTTP_300_MULTIPLE_CHOICE,
                ACurl::ResponseCode::HTTP_301_MOVED_PERMANENTLY,
                ACurl::ResponseCode::HTTP_302_FOUND,
                ACurl::ResponseCode::HTTP_303_SEE_OTHER,
                ACurl::ResponseCode::HTTP_304_NOT_MODIFIED,
                ACurl::ResponseCode::HTTP_305_USE_PROXY,
                ACurl::ResponseCode::HTTP_306_SWITCH_PROXY,
                ACurl::ResponseCode::HTTP_307_TEMPORARY_REDIRECT,
                ACurl::ResponseCode::HTTP_308_PERMANENT_REDIRECT,
                ACurl::ResponseCode::HTTP_400_BAD_REQUEST,
                ACurl::ResponseCode::HTTP_401_UNAUTHORIZED,
                ACurl::ResponseCode::HTTP_402_PAYMENT_REQUIRED,
                ACurl::ResponseCode::HTTP_403_FORBIDDEN,
                ACurl::ResponseCode::HTTP_404_NOT_FOUND,
                ACurl::ResponseCode::HTTP_405_METHOD_NOT_ALLOWED,
                ACurl::ResponseCode::HTTP_406_NOT_ACCEPTABLE,
                ACurl::ResponseCode::HTTP_407_PROXY_AUTHENTICATION_REQUIRED,
                ACurl::ResponseCode::HTTP_408_REQUEST_TIMEOUT,
                ACurl::ResponseCode::HTTP_409_CONFLICT,
                ACurl::ResponseCode::HTTP_410_GONE,
                ACurl::ResponseCode::HTTP_411_LENGTH_REQUIRED,
                ACurl::ResponseCode::HTTP_412_PRECONDITION_FAILED,
                ACurl::ResponseCode::HTTP_413_REQUEST_ENTITY_TOO_LARGE,
                ACurl::ResponseCode::HTTP_414_REQUEST_URI_TOO_LONG,
                ACurl::ResponseCode::HTTP_415_UNSUPPORTED_MEDIA_TYPE,
                ACurl::ResponseCode::HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
                ACurl::ResponseCode::HTTP_417_EXPECTATION_FAILED,
                ACurl::ResponseCode::HTTP_500_INTERNAL_SERVER_ERROR,
                ACurl::ResponseCode::HTTP_501_NOT_IMPLEMENTED,
                ACurl::ResponseCode::HTTP_502_BAD_GATEWAY,
                ACurl::ResponseCode::HTTP_503_SERVICE_UNAVAILABLE,
                ACurl::ResponseCode::HTTP_504_GATEWAY_TIMEOUT,
                ACurl::ResponseCode::HTTP_505_HTTP_VERSION_NOT_SUPPORTED)