on_demand_os_client_grpc.hpp

Go to the documentation of this file.

#ifndef IROHA_ON_DEMAND_OS_TRANSPORT_CLIENT_GRPC_HPP
#define IROHA_ON_DEMAND_OS_TRANSPORT_CLIENT_GRPC_HPP

#include "ordering/on_demand_os_transport.hpp"

#include "common/result.hpp"
#include "interfaces/iroha_internal/abstract_transport_factory.hpp"
#include "logger/logger_fwd.hpp"
#include "ordering.grpc.pb.h"
#include "ordering/impl/on_demand_common.hpp"

namespace iroha {
  namespace network {
    template <typename Service>
    class ClientFactory;
  }
  namespace ordering {
    namespace transport {

      class OnDemandOsClientGrpc : public OdOsNotification {
       public:
        using TransportFactoryType =
            shared_model::interface::AbstractTransportFactory<
                shared_model::interface::Proposal,
                iroha::protocol::Proposal>;
        using TimepointType = std::chrono::system_clock::time_point;
        using TimeoutType = std::chrono::milliseconds;

        OnDemandOsClientGrpc(
            std::shared_ptr<proto::OnDemandOrdering::StubInterface> stub,
            std::shared_ptr<TransportFactoryType> proposal_factory,
            std::function<TimepointType()> time_provider,
            std::chrono::milliseconds proposal_request_timeout,
            logger::LoggerPtr log,
            std::function<void(ProposalEvent)> callback);

        void onBatches(CollectionType batches) override;

        void onRequestProposal(consensus::Round round) override;

       private:
        logger::LoggerPtr log_;
        std::shared_ptr<proto::OnDemandOrdering::StubInterface> stub_;
        std::shared_ptr<TransportFactoryType> proposal_factory_;
        std::function<TimepointType()> time_provider_;
        std::chrono::milliseconds proposal_request_timeout_;
        std::function<void(ProposalEvent)> callback_;
        std::weak_ptr<grpc::ClientContext> context_;
      };

      class OnDemandOsClientGrpcFactory : public OdOsNotificationFactory {
       public:
        using Service = proto::OnDemandOrdering;
        using ClientFactory = iroha::network::ClientFactory<Service>;

        using TransportFactoryType = OnDemandOsClientGrpc::TransportFactoryType;
        OnDemandOsClientGrpcFactory(
            std::shared_ptr<TransportFactoryType> proposal_factory,
            std::function<OnDemandOsClientGrpc::TimepointType()> time_provider,
            OnDemandOsClientGrpc::TimeoutType proposal_request_timeout,
            logger::LoggerPtr client_log,
            std::unique_ptr<ClientFactory> client_factory,
            std::function<void(ProposalEvent)> callback);

        iroha::expected::Result<std::unique_ptr<OdOsNotification>, std::string>
        create(const shared_model::interface::Peer &to) override;

       private:
        std::shared_ptr<TransportFactoryType> proposal_factory_;
        std::function<OnDemandOsClientGrpc::TimepointType()> time_provider_;
        std::chrono::milliseconds proposal_request_timeout_;
        logger::LoggerPtr client_log_;
        std::unique_ptr<ClientFactory> client_factory_;
        std::function<void(ProposalEvent)> callback_;
      };

    }  // namespace transport
  }    // namespace ordering
}  // namespace iroha

#endif  // IROHA_ON_DEMAND_OS_TRANSPORT_CLIENT_GRPC_HPP