http_client.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include "ravennakit/core/net/http/detail/http_fmt_adapters.hpp"
 
#include <boost/asio.hpp>
#include <boost/url.hpp>
 
#include <string>
#include <queue>
 
namespace rav {
 
namespace http = boost::beast::http;
using tcp = boost::asio::ip::tcp;
 
class HttpClientBase {
  public:
    virtual ~HttpClientBase() = default;

    static constexpr auto k_default_port = "80";
 
    using Request = http::request<http::string_body>;
    using Response = http::response<http::string_body>;

    using ResponseCallback = std::function<void(boost::system::result<http::response<http::string_body>> response)>;

    virtual void set_host(const boost::urls::url& url) = 0;

    virtual void set_host(std::string_view url) = 0;

    virtual void set_host(std::string_view host, std::string_view service) = 0;

    virtual void get_async(std::string_view target, ResponseCallback callback) = 0;

    virtual void post_async(std::string_view target, std::string body, ResponseCallback callback, std::string_view content_type) = 0;

    virtual void delete_async(std::string_view target, ResponseCallback callback) = 0;

    virtual void request_async(
        http::verb method, std::string_view target, std::string body, std::string_view content_type, ResponseCallback callback
    ) = 0;

    virtual void cancel_outstanding_requests() = 0;

    [[nodiscard]] virtual const std::string& get_host() const = 0;

    [[nodiscard]] virtual const std::string& get_service() const = 0;
};

class HttpClient: public HttpClientBase {
  public:
    explicit HttpClient(boost::asio::io_context& io_context, std::chrono::milliseconds timeout_seconds = std::chrono::seconds(30));

    HttpClient(
        boost::asio::io_context& io_context, std::string_view url, std::chrono::milliseconds timeout_seconds = std::chrono::seconds(30)
    );

    HttpClient(
        boost::asio::io_context& io_context, const boost::urls::url& url,
        std::chrono::milliseconds timeout_seconds = std::chrono::seconds(30)
    );

    HttpClient(
        boost::asio::io_context& io_context, const boost::asio::ip::tcp::endpoint& endpoint,
        std::chrono::milliseconds timeout_seconds = std::chrono::seconds(30)
    );

    HttpClient(
        boost::asio::io_context& io_context, const boost::asio::ip::address& address, uint16_t port,
        std::chrono::milliseconds timeout_seconds = std::chrono::seconds(30)
    );
 
    ~HttpClient() override;
 
    HttpClient(const HttpClient&) = delete;
    HttpClient& operator=(const HttpClient&) = delete;
    HttpClient(HttpClient&&) = delete;
    HttpClient& operator=(HttpClient&&) = delete;

    void set_host(const boost::urls::url& url) override;

    void set_host(std::string_view url) override;

    void set_host(std::string_view host, std::string_view service) override;

    void get_async(std::string_view target, ResponseCallback callback) override;

    void post_async(std::string_view target, std::string body, ResponseCallback callback, std::string_view content_type) override;

    void request_async(
        http::verb method, std::string_view target, std::string body, std::string_view content_type, ResponseCallback callback
    ) override;

    void delete_async(std::string_view target, ResponseCallback callback) override;

    void cancel_outstanding_requests() override;

    [[nodiscard]] const std::string& get_host() const override;

    [[nodiscard]] const std::string& get_service() const override;
 
  private:
    class Session: public std::enable_shared_from_this<Session> {
      public:
        enum class State { disconnected, resolving, connecting, connected, waiting_for_send, waiting_for_response };
        explicit Session(boost::asio::io_context& io_context, HttpClient* owner, std::chrono::milliseconds timeout_seconds);
 
        void send_requests();
        void clear_owner();
 
        ResponseCallback callback_;
 
      private:
        HttpClient* owner_ = nullptr;
        std::chrono::milliseconds timeout_seconds_ = std::chrono::seconds(30);
        boost::asio::ip::tcp::resolver resolver_;
        boost::beast::tcp_stream stream_;
        http::request<http::string_body> request_;
        http::response<http::string_body> response_;
        boost::beast::flat_buffer buffer_;
        State state_ = State::disconnected;
 
        void async_connect();
        void async_send();
        void on_resolve(const boost::beast::error_code& ec, const tcp::resolver::results_type& results);
        void on_connect(const boost::beast::error_code& ec, const tcp::resolver::results_type::endpoint_type&);
        void on_write(const boost::beast::error_code& ec, std::size_t bytes_transferred);
        void on_read(boost::beast::error_code ec, std::size_t bytes_transferred);
 
        bool take_next_request();
    };
 
    boost::asio::io_context& io_context_;
    std::chrono::milliseconds timeout_seconds_ = std::chrono::seconds(30);
    std::string host_;
    std::string service_;
    std::queue<std::pair<http::request<http::string_body>, ResponseCallback>> requests_;
    std::shared_ptr<Session> session_;
};
 
}  // namespace rav