util/rpc/client.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef OPENCBDC_TX_SRC_RPC_CLIENT_H_
#define OPENCBDC_TX_SRC_RPC_CLIENT_H_
 
#include "format.hpp"
#include "messages.hpp"
#include "util/serialization/util.hpp"
 
#include <atomic>
#include <cassert>
#include <chrono>
#include <functional>
#include <optional>
 
namespace cbdc::rpc {
    template<typename Request, typename Response>
    class client {
      public:
        client() = default;
        client(client&&) noexcept = default;
        auto operator=(client&&) noexcept -> client& = default;
        client(const client&) = delete;
        auto operator=(const client&) -> client& = delete;
 
        virtual ~client() = default;
 
        using request_type = request<Request>;
        using response_type = response<Response>;
 
        using response_callback_type
            = std::function<void(std::optional<Response>)>;
 
        [[nodiscard]] auto call(Request request_payload,
                                std::chrono::milliseconds timeout
                                = std::chrono::milliseconds::zero())
            -> std::optional<Response> {
            auto [request_buf, request_id]
                = make_request(std::move(request_payload));
            auto resp = call_raw(std::move(request_buf), request_id, timeout);
            if(!resp.has_value()) {
                return std::nullopt;
            }
            assert(resp.value().m_header.m_request_id == request_id);
            return resp.value().m_payload;
        }
 
        auto call(Request request_payload,
                  response_callback_type response_callback) -> bool {
            auto [request_buf, request_id]
                = make_request(std::move(request_payload));
            auto ret = call_raw(std::move(request_buf),
                                request_id,
                                [resp_cb = std::move(response_callback)](
                                    std::optional<response_type> resp) {
                                    if(!resp.has_value()) {
                                        return;
                                    }
                                    resp_cb(std::move(resp.value().m_payload));
                                });
            return ret;
        }
 
      protected:
        auto deserialize_response(cbdc::buffer& response_buf)
            -> std::optional<response_type> {
            return from_buffer<response_type>(response_buf);
        }
 
        using raw_callback_type
            = std::function<void(std::optional<response_type>)>;
 
      private:
        std::atomic<uint64_t> m_current_request_id{};
 
        virtual auto call_raw(cbdc::buffer request_buf,
                              request_id_type request_id,
                              std::chrono::milliseconds timeout)
            -> std::optional<response_type> = 0;
 
        virtual auto call_raw(cbdc::buffer request_buf,
                              request_id_type request_id,
                              raw_callback_type response_callback) -> bool
            = 0;
 
        auto make_request(Request request_payload)
            -> std::pair<cbdc::buffer, request_id_type> {
            auto request_id = m_current_request_id++;
            auto req = request_type{{request_id}, std::move(request_payload)};
            return {make_buffer(req), request_id};
        }
    };
}
 
#endif