on_demand_connection_manager.hpp

Go to the documentation of this file.

#ifndef IROHA_ON_DEMAND_CONNECTION_MANAGER_HPP
#define IROHA_ON_DEMAND_CONNECTION_MANAGER_HPP

#include "ordering/on_demand_os_transport.hpp"

#include <array>
#include <atomic>
#include <shared_mutex>

#include "logger/logger_fwd.hpp"

namespace iroha {
  namespace ordering {

    class OnDemandConnectionManager : public transport::OdOsNotification {
     public:
      enum PeerType { kRejectConsumer = 0, kCommitConsumer, kIssuer, kCount };

      template <typename T>
      using PeerCollectionType = std::array<T, kCount>;

      struct CurrentPeers {
        PeerCollectionType<std::shared_ptr<shared_model::interface::Peer>>
            peers;
      };

      OnDemandConnectionManager(
          std::shared_ptr<transport::OdOsNotificationFactory> factory,
          logger::LoggerPtr log);

      OnDemandConnectionManager(
          std::shared_ptr<transport::OdOsNotificationFactory> factory,
          CurrentPeers initial_peers,
          logger::LoggerPtr log);

      ~OnDemandConnectionManager() override;

      void onBatches(CollectionType batches) override;

      void onRequestProposal(consensus::Round round) override;

      void initializeConnections(const CurrentPeers &peers);

     private:
      struct CurrentConnections {
        PeerCollectionType<
            std::optional<std::unique_ptr<transport::OdOsNotification>>>
            peers;
      };

      logger::LoggerPtr log_;
      std::shared_ptr<transport::OdOsNotificationFactory> factory_;

      CurrentConnections connections_;

      std::shared_timed_mutex mutex_;
      std::atomic_bool stop_requested_{false};
    };

  }  // namespace ordering
}  // namespace iroha

#endif  // IROHA_ON_DEMAND_CONNECTION_MANAGER_HPP