Struct PeerManager 

pub struct PeerManager { /* private fields */ }

The PeerManager provides functionality to add, find and delete peers. It wraps synchronous WAL-enabled SQLite database access and provides an async interface to the rest of the code base.

Every database call is dispatched to tokio’s blocking thread pool by [BlockingPeerStorage], so a contended peer database can never park a tokio worker thread. See that type’s documentation for why that matters.

Implementations

impl PeerManager

pub fn new( database: CommsDatabase, transport_protocols: Vec<TransportProtocol>, ) -> Result<PeerManager, PeerManagerError>

Constructs a new empty PeerManager

pub fn this_peer_identity(&self) -> ThisPeerIdentity

Get this peer’s identity

pub async fn count(&self) -> usize

Get the number of peers in the PeerManager - any error will translate to a size of zero

pub async fn add_or_update_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 soft_delete_peer( &self, node_id: &NodeId, ) -> Result<(), PeerManagerError>

The peer with the specified node id will be soft deleted (marked as deleted)

pub async fn get_peers_by_node_ids( &self, node_ids: &[NodeId], ) -> Result<Vec<Peer>, PeerManagerError>

Get all peers based on a list of their node_ids

pub async fn get_peer_public_keys_by_node_ids( &self, node_ids: &[NodeId], ) -> Result<Vec<CommsPublicKey>, PeerManagerError>

Get all peers based on a list of their node_ids

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

Get all banned peers

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

Find the peer with the provided NodeID

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

gets all seed peers

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

Find the peer with the provided PublicKey

pub async fn find_all_starts_with( &self, partial: &[u8], ) -> Result<Vec<Peer>, PeerManagerError>

Find the peer with the provided substring. This currently only compares the given bytes to the NodeId

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

Check if a peer exist using the specified public_key

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

Check if a peer exist using the specified node_id

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

Returns all peers

pub async fn get_available_dial_candidates( &self, exclude_node_ids: &[NodeId], limit: Option<usize>, exclude_failed: bool, randomize: bool, ) -> Result<Vec<Peer>, PeerManagerError>

Get available dial candidates that are communication nodes, not banned, not deleted, reachable optionally not failed, optionally at random, and not in the excluded node IDs list

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

Return “good” peers for syncing Criteria:

• Peer is not banned
• Peer has been seen within a defined time span (1 week)
• Returns at most max_n peers (the caller’s configured serve cap); a max_n of 0 falls back to the peer manager default

pub async fn add_or_update_online_peer( &self, pubkey: &CommsPublicKey, node_id: &NodeId, addresses: &[Multiaddr], peer_features: &PeerFeatures, source: &PeerAddressSource, ) -> 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 get_not_banned_or_deleted_peers( &self, ) -> Result<Vec<Peer>, PeerManagerError>

Fetch all peers (except banned ones)

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

Fetch n random peers that are Communication Nodes and have at least one external address

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 unban_all_peers(&self) -> Result<usize, PeerManagerError>

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

pub async fn reset_offline_non_wallet_peers( &self, ) -> Result<usize, PeerManagerError>

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 is_peer_banned( &self, node_id: &NodeId, ) -> Result<bool, PeerManagerError>

Get the ban status of a peer

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

Get the peer’s features

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

Get a peer’s multiaddresses

pub async fn get_peers_multi_addresses( &self, node_ids: &[NodeId], ) -> Result<Vec<(NodeId, MultiaddressesWithStats)>, PeerManagerError>

Get multiple peers’ multiaddresses

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 Clone for PeerManager

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PeerManager

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

Formats the value using the given formatter.