WsConnection.hpp

#pragma once
 
#include "util/log/Logger.hpp"
#include "util/requests/Types.hpp"
 
#include <boost/asio/bind_cancellation_slot.hpp>
#include <boost/asio/cancellation_signal.hpp>
#include <boost/asio/cancellation_type.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/beast/core/tcp_stream.hpp>
#include <boost/beast/websocket/stream.hpp>
 
#include <chrono>
#include <expected>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace util::requests {

class WsConnection {
public:
    virtual ~WsConnection() = default;

    virtual std::expected<std::string, RequestError>
    read(
        boost::asio::yield_context yield,
        std::optional<std::chrono::steady_clock::duration> timeout = std::nullopt
    ) = 0;

    virtual std::optional<RequestError>
    write(
        std::string const& message,
        boost::asio::yield_context yield,
        std::optional<std::chrono::steady_clock::duration> timeout = std::nullopt
    ) = 0;

    virtual std::optional<RequestError>
    close(
        boost::asio::yield_context yield,
        std::chrono::steady_clock::duration timeout = kDEFAULT_TIMEOUT
    ) = 0;
 
    static constexpr std::chrono::seconds kDEFAULT_TIMEOUT{
        5
    }; 
};
using WsConnectionPtr = std::unique_ptr<WsConnection>;

class WsConnectionBuilder {
    util::Logger log_{"WsConnectionBuilder"};
    std::string host_;
    std::string port_;
    std::vector<HttpHeader> headers_;
    std::chrono::steady_clock::duration connectionTimeout_{kDEFAULT_TIMEOUT};
    std::chrono::steady_clock::duration wsHandshakeTimeout_{kDEFAULT_TIMEOUT};
    std::string target_{"/"};
 
public:
    WsConnectionBuilder(std::string host, std::string port);

    WsConnectionBuilder&
    addHeader(HttpHeader header);

    WsConnectionBuilder&
    addHeaders(std::vector<HttpHeader> headers);

    WsConnectionBuilder&
    setTarget(std::string target);

    WsConnectionBuilder&
    setConnectionTimeout(std::chrono::steady_clock::duration timeout);

    WsConnectionBuilder&
    setWsHandshakeTimeout(std::chrono::steady_clock::duration timeout);

    std::expected<WsConnectionPtr, RequestError>
    sslConnect(boost::asio::yield_context yield) const;

    std::expected<WsConnectionPtr, RequestError>
    plainConnect(boost::asio::yield_context yield) const;

    std::expected<WsConnectionPtr, RequestError>
    connect(boost::asio::yield_context yield) const;
 
    static constexpr std::chrono::seconds kDEFAULT_TIMEOUT{
        5
    }; 
 
private:
    template <typename StreamDataType>
    std::expected<WsConnectionPtr, RequestError>
    connectImpl(StreamDataType&& streamData, boost::asio::yield_context yield) const;
};
 
}  // namespace util::requests