peer_manager.hpp

Go to the documentation of this file.

#ifndef KAGOME_NETWORK_PEERMANAGER
#define KAGOME_NETWORK_PEERMANAGER

#include <optional>
#include <unordered_set>

#include <libp2p/peer/peer_id.hpp>
#include <libp2p/peer/peer_info.hpp>

#include "network/types/block_announce.hpp"
#include "network/types/collator_messages.hpp"
#include "network/types/grandpa_message.hpp"
#include "network/types/status.hpp"
#include "outcome/outcome.hpp"
#include "primitives/common.hpp"
#include "utils/non_copyable.hpp"

namespace kagome::network {

  struct CollatorState {
    network::ParachainId parachain_id;
    network::CollatorPublicKey collator_id;
    std::unordered_set<BlockHash> advertisements;
  };

  struct PendingCollation {
    network::ParachainId para_id;
    BlockHash const &relay_parent;
    libp2p::peer::PeerId const &peer_id;
  };

  /*
   * Parachain state view.
   */
  struct ParachainState {
    std::unordered_map<BlockHash, bool> our_view;
  };

  struct PeerState {
    clock::SteadyClock::TimePoint time;
    Roles roles = 0;
    BlockInfo best_block = {0, {}};
    std::optional<RoundNumber> round_number = std::nullopt;
    std::optional<VoterSetId> set_id = std::nullopt;
    BlockNumber last_finalized = 0;
    std::optional<CollatorState> collator_state = std::nullopt;
  };

  struct StreamEngine;

  class PeerManager {
   public:
    using PeerId = libp2p::peer::PeerId;
    using PeerInfo = libp2p::peer::PeerInfo;
    using BlockInfo = primitives::BlockInfo;
    using AdvResult = outcome::result<
        std::pair<network::CollatorPublicKey const &, network::ParachainId>>;

    virtual ~PeerManager() = default;

    virtual void connectToPeer(const PeerInfo &peer_info) = 0;

    virtual void reserveStreams(const PeerId &peer_id) const = 0;

    virtual std::shared_ptr<StreamEngine> getStreamEngine() = 0;

    virtual void keepAlive(const PeerId &peer_id) = 0;

    virtual void startPingingPeer(const PeerId &peer_id) = 0;

    virtual void updatePeerState(const PeerId &peer_id,
                                 const Status &status) = 0;

    virtual void updatePeerState(const PeerId &peer_id,
                                 const BlockAnnounce &announce) = 0;

    virtual outcome::result<
        std::pair<network::CollatorPublicKey const &, network::ParachainId>>
    insert_advertisement(PeerState &peer_state,
                         ParachainState &parachain_state,
                         primitives::BlockHash para_hash) = 0;

    virtual ParachainState &parachainState() = 0;

    virtual void setCollating(const PeerId &peer_id,
                              network::CollatorPublicKey const &collator_id,
                              network::ParachainId para_id) = 0;

    virtual void updatePeerState(
        const PeerId &peer_id,
        const GrandpaNeighborMessage &neighbor_message) = 0;

    virtual std::optional<std::reference_wrapper<PeerState>> getPeerState(
        const PeerId &peer_id) = 0;

    virtual size_t activePeersNumber() const = 0;

    virtual void forEachPeer(
        std::function<void(const PeerId &)> func) const = 0;

    virtual void forOnePeer(const PeerId &peer_id,
                            std::function<void(const PeerId &)> func) const = 0;
  };
}  // namespace kagome::network

#endif  // KAGOME_NETWORK_PEERMANAGER