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 <chrono>
#include <vector>

#include <rxcpp/rx-lite.hpp>
#include "interfaces/common_objects/types.hpp"
#include "logger/logger_fwd.hpp"
#include "logger/logger_manager_fwd.hpp"

namespace google {
  namespace protobuf {
    class Empty;
  }
}  // namespace google

namespace grpc {
  class Service;
}

namespace shared_model {
  namespace interface {
    class Proposal;
    class Transaction;
    class Block;
    template <typename Interface, typename Transport>
    class AbstractTransportFactory;
    class UnsafeProposalFactory;
    class TransactionBatchParser;
    class TransactionBatchFactory;
  }  // namespace interface
}  // namespace shared_model

namespace iroha {
  namespace network {
    class GenericClientFactory;
    template <typename Response>
    class AsyncGrpcClient;
    class OrderingGate;
  }  // namespace network
  namespace protocol {
    class Proposal;
    class Transaction;
  }  // namespace protocol
  namespace ametsuchi {
    class TxPresenceCache;
  }
  namespace synchronizer {
    struct SynchronizationEvent;
  }
  namespace ordering {
    class OnDemandOrderingService;
    class ProposalCreationStrategy;
    namespace transport {
      class OdOsNotification;
    }
    namespace cache {
      class OrderingGateCache;
    }

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

     private:
      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,
          std::shared_ptr<iroha::network::GenericClientFactory> client_factory);

      auto createGate(
          std::shared_ptr<OnDemandOrderingService> ordering_service,
          std::unique_ptr<transport::OdOsNotification> network_client,
          std::shared_ptr<shared_model::interface::UnsafeProposalFactory>
              proposal_factory,
          std::shared_ptr<ametsuchi::TxPresenceCache> tx_cache,
          std::shared_ptr<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<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<shared_model::interface::AbstractTransportFactory<
              shared_model::interface::Transaction,
              iroha::protocol::Transaction>> 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<ProposalCreationStrategy> creation_strategy,
          logger::LoggerManagerTreePtr ordering_log_manager,
          std::shared_ptr<iroha::network::GenericClientFactory> client_factory);

      std::shared_ptr<grpc::Service> service;

      rxcpp::subjects::subject<synchronizer::SynchronizationEvent>
          sync_event_notifier;
      rxcpp::subjects::subject<
          std::shared_ptr<shared_model::interface::Block const>>
          commit_notifier;

     private:
      logger::LoggerPtr log_;
    };
  }  // namespace ordering
}  // namespace iroha

#endif  // IROHA_ON_DEMAND_ORDERING_INIT_HPP