Struct tari_comms::PeerManager

pub struct PeerManager { /* fields omitted */ }

The PeerManager consist of a routing table of previously discovered peers. It also provides functionality to add, find and delete peers.

Implementations

impl PeerManager

pub fn new(
    database: CommsDatabase,
    file_lock: Option<File>
) -> Result<PeerManager, PeerManagerError>

Constructs a new empty PeerManager

pub fn migrate_lmdb(database: &LMDBDatabase) -> Result<(), PeerManagerError>

Migrate the peer database, this only applies to the LMDB database

pub async fn count(&self) -> usize

pub async fn add_peer(&self, peer: Peer) -> Result<PeerId, PeerManagerError>

Adds a peer to the routing table of the PeerManager if the peer does not already exist. When a peer already exist, the stored version will be replaced with the newly provided peer.

pub async fn delete_peer(
    &self,
    node_id: &NodeId
) -> Result<(), PeerManagerError>

The peer with the specified public_key will be removed from the PeerManager

pub async fn perform_query(
    &self,
    peer_query: PeerQuery<'_>
) -> Result<Vec<Peer>, PeerManagerError>

Performs the given PeerQuery.

pub async fn find_by_node_id(
    &self,
    node_id: &NodeId
) -> Result<Peer, PeerManagerError>

Find the peer with the provided NodeID

pub async fn find_by_public_key(
    &self,
    public_key: &CommsPublicKey
) -> Result<Peer, PeerManagerError>

Find the peer with the provided PublicKey

pub async fn exists(&self, public_key: &CommsPublicKey) -> bool

Check if a peer exist using the specified public_key

pub async fn exists_node_id(&self, node_id: &NodeId) -> bool

Check if a peer exist using the specified node_id

pub async fn all(&self) -> Result<Vec<Peer>, PeerManagerError>

Returns all peers

pub async fn add_or_update_online_peer(
    &self,
    pubkey: &CommsPublicKey,
    node_id: NodeId,
    addresses: Vec<Multiaddr>,
    peer_features: PeerFeatures
) -> Result<Peer, PeerManagerError>

Adds or updates a peer and sets the last connection as successful. If the peer is marked as offline, it will be unmarked.

pub async fn direct_identity_node_id(
    &self,
    node_id: &NodeId
) -> Result<Option<Peer>, PeerManagerError>

Get a peer matching the given node ID

pub async fn direct_identity_public_key(
    &self,
    public_key: &CommsPublicKey
) -> Result<Option<Peer>, PeerManagerError>

Get a peer matching the given public key

pub async fn flood_peers(&self) -> Result<Vec<Peer>, PeerManagerError>

Fetch all peers (except banned ones)

pub async fn for_each<F>(&self, f: F) -> Result<(), PeerManagerError> where
    F: FnMut(Peer) -> IterationResult, 

pub async fn closest_peers(
    &self,
    node_id: &NodeId,
    n: usize,
    excluded_peers: &[NodeId],
    features: Option<PeerFeatures>
) -> Result<Vec<Peer>, PeerManagerError>

Fetch n nearest neighbours. If features are supplied, the function will return the closest peers matching that feature

pub async fn random_peers(
    &self,
    n: usize,
    excluded: &[NodeId]
) -> Result<Vec<Peer>, PeerManagerError>

Fetch n random peers

pub async fn in_network_region(
    &self,
    node_id: &NodeId,
    region_node_id: &NodeId,
    n: usize
) -> Result<bool, PeerManagerError>

Check if a specific node_id is in the network region of the N nearest neighbours of the region specified by region_node_id

pub async fn calc_region_threshold(
    &self,
    region_node_id: &NodeId,
    n: usize,
    features: PeerFeatures
) -> Result<NodeDistance, PeerManagerError>

pub async fn unban_peer(&self, node_id: &NodeId) -> Result<(), PeerManagerError>

Unbans the peer if it is banned. This function is idempotent.

pub async fn ban_peer(
    &self,
    public_key: &CommsPublicKey,
    duration: Duration,
    reason: String
) -> Result<NodeId, PeerManagerError>

Ban the peer for a length of time specified by the duration

pub async fn ban_peer_by_node_id(
    &self,
    node_id: &NodeId,
    duration: Duration,
    reason: String
) -> Result<NodeId, PeerManagerError>

Ban the peer for a length of time specified by the duration

pub async fn set_offline(
    &self,
    node_id: &NodeId,
    is_offline: bool
) -> Result<bool, PeerManagerError>

Changes the offline flag bit of the peer. Return the previous offline state.

pub async fn add_net_address(
    &self,
    node_id: &NodeId,
    net_address: &Multiaddr
) -> Result<(), PeerManagerError>

Adds a new net address to the peer if it doesn't yet exist

pub async fn update_each<F>(&self, f: F) -> Result<usize, PeerManagerError> where
    F: FnMut(Peer) -> Option<Peer>, 

pub async fn get_peer_features(
    &self,
    node_id: &NodeId
) -> Result<PeerFeatures, PeerManagerError>

pub async fn set_peer_metadata(
    &self,
    node_id: &NodeId,
    key: u8,
    data: Vec<u8>
) -> Result<Option<Vec<u8>>, PeerManagerError>

This will store metadata inside of the metadata field in the peer provided by the nodeID. It will return None if the value was empty and the old value if the value was updated

Trait Implementations

impl Debug for PeerManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.