status_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 TX_STATUS_CLIENT_H_INC
#define TX_STATUS_CLIENT_H_INC
 
#include "status_interface.hpp"
#include "status_messages.hpp"
#include "util/common/config.hpp"
#include "util/rpc/tcp_client.hpp"
 
namespace cbdc::locking_shard::rpc {
    class status_client : public status_interface {
      public:
        status_client(std::vector<std::vector<network::endpoint_t>>
                          shard_read_only_endpoints,
                      std::vector<config::shard_range_t> shard_ranges,
                      std::chrono::milliseconds timeout
                      = std::chrono::milliseconds::zero());
 
        ~status_client() override = default;
 
        status_client() = delete;
        status_client(const status_client&) = delete;
        auto operator=(const status_client&) -> status_client& = delete;
        status_client(status_client&&) = delete;
        auto operator=(status_client&&) -> status_client& = delete;
 
        auto init() -> bool;
 
        [[nodiscard]] auto check_unspent(const hash_t& uhs_id)
            -> std::optional<bool> override;
 
        [[nodiscard]] auto check_tx_id(const hash_t& tx_id)
            -> std::optional<bool> override;
 
      private:
        std::vector<std::unique_ptr<
            cbdc::rpc::tcp_client<status_request, status_response>>>
            m_shard_clients;
        std::vector<config::shard_range_t> m_shard_ranges;
        std::chrono::milliseconds m_request_timeout;
 
        template<typename T>
        auto make_request(const hash_t& val) -> std::optional<bool> {
            // TODO: optimize the algorithm for shard selection.
            for(size_t i = 0; i < m_shard_ranges.size(); i++) {
                if(config::hash_in_shard_range(m_shard_ranges[i], val)) {
                    return m_shard_clients[i]->call(T{val}, m_request_timeout);
                }
            }
            return std::nullopt;
        }
    };
}
 
#endif