on_demand_ordering_init.hpp

Go to the documentation of this file.

#ifndef IROHA_ON_DEMAND_ORDERING_INIT_HPP
#define IROHA_ON_DEMAND_ORDERING_INIT_HPP

#include <rxcpp/rx-lite.hpp>
#include "ametsuchi/storage.hpp"
#include "ametsuchi/tx_presence_cache.hpp"
#include "interfaces/iroha_internal/unsafe_proposal_factory.hpp"
#include "logger/logger_fwd.hpp"
#include "logger/logger_manager_fwd.hpp"
#include "network/impl/async_grpc_client.hpp"
#include "network/ordering_gate.hpp"
#include "network/peer_communication_service.hpp"
#include "ordering.grpc.pb.h"
#include "ordering/impl/on_demand_os_server_grpc.hpp"
#include "ordering/impl/ordering_gate_cache/ordering_gate_cache.hpp"
#include "ordering/on_demand_ordering_service.hpp"
#include "ordering/ordering_service_proposal_creation_strategy.hpp"

namespace iroha {
  namespace network {

    class OnDemandOrderingInit {
     public:
      using TransportFactoryType =
          shared_model::interface::AbstractTransportFactory<
              shared_model::interface::Proposal,
              iroha::protocol::Proposal>;

     private:
      auto createNotificationFactory(
          std::shared_ptr<network::AsyncGrpcClient<google::protobuf::Empty>>
              async_call,
          std::shared_ptr<TransportFactoryType> proposal_transport_factory,
          std::chrono::milliseconds delay,
          const logger::LoggerManagerTreePtr &ordering_log_manager);

      auto createConnectionManager(
          std::shared_ptr<network::AsyncGrpcClient<google::protobuf::Empty>>
              async_call,
          std::shared_ptr<TransportFactoryType> proposal_transport_factory,
          std::chrono::milliseconds delay,
          std::vector<shared_model::interface::types::HashType> initial_hashes,
          const logger::LoggerManagerTreePtr &ordering_log_manager);

      auto createGate(
          std::shared_ptr<ordering::OnDemandOrderingService> ordering_service,
          std::unique_ptr<ordering::transport::OdOsNotification> network_client,
          std::shared_ptr<ordering::cache::OrderingGateCache> cache,
          std::shared_ptr<shared_model::interface::UnsafeProposalFactory>
              proposal_factory,
          std::shared_ptr<ametsuchi::TxPresenceCache> tx_cache,
          std::shared_ptr<ordering::ProposalCreationStrategy> creation_strategy,
          size_t max_number_of_transactions,
          const logger::LoggerManagerTreePtr &ordering_log_manager);

      auto createService(
          size_t max_number_of_transactions,
          std::shared_ptr<shared_model::interface::UnsafeProposalFactory>
              proposal_factory,
          std::shared_ptr<ametsuchi::TxPresenceCache> tx_cache,
          std::shared_ptr<ordering::ProposalCreationStrategy> creation_strategy,
          const logger::LoggerManagerTreePtr &ordering_log_manager);

      rxcpp::composite_subscription sync_event_notifier_lifetime_;
      rxcpp::composite_subscription commit_notifier_lifetime_;

     public:
      OnDemandOrderingInit(logger::LoggerPtr log);

      ~OnDemandOrderingInit();

      std::shared_ptr<network::OrderingGate> initOrderingGate(
          size_t max_number_of_transactions,
          std::chrono::milliseconds delay,
          std::vector<shared_model::interface::types::HashType> initial_hashes,
          std::shared_ptr<
              ordering::transport::OnDemandOsServerGrpc::TransportFactoryType>
              transaction_factory,
          std::shared_ptr<shared_model::interface::TransactionBatchParser>
              batch_parser,
          std::shared_ptr<shared_model::interface::TransactionBatchFactory>
              transaction_batch_factory,
          std::shared_ptr<network::AsyncGrpcClient<google::protobuf::Empty>>
              async_call,
          std::shared_ptr<shared_model::interface::UnsafeProposalFactory>
              proposal_factory,
          std::shared_ptr<TransportFactoryType> proposal_transport_factory,
          std::shared_ptr<ametsuchi::TxPresenceCache> tx_cache,
          std::shared_ptr<ordering::ProposalCreationStrategy> creation_strategy,
          logger::LoggerManagerTreePtr ordering_log_manager);

      std::shared_ptr<ordering::proto::OnDemandOrdering::Service> service;

      rxcpp::subjects::subject<decltype(std::declval<PeerCommunicationService>()
                                            .onSynchronization())::value_type>
          sync_event_notifier;
      rxcpp::subjects::subject<decltype(
          std::declval<iroha::ametsuchi::Storage>().on_commit())::value_type>
          commit_notifier;

     private:
      logger::LoggerPtr log_;

      std::vector<std::shared_ptr<shared_model::interface::Peer>>
          current_peers_;

      enum RoundType { kCurrentRound, kNextRound, kRoundAfterNext, kCount };

      template <RoundType V>
      using RoundTypeConstant = std::integral_constant<RoundType, V>;

      std::array<std::vector<size_t>, kCount> permutations_;
    };
  }  // namespace network
}  // namespace iroha

#endif  // IROHA_ON_DEMAND_ORDERING_INIT_HPP