Struct Router 

pub struct Router<N: Network>(/* private fields */);

The router keeps track of connected and connecting peers. The actual network communication happens in Inbound/Outbound, which is implemented by Validator, Prover, and Client.

Implementations

impl<N: Network> Router<N>

pub async fn handshake<'a>( &'a self, peer_addr: SocketAddr, stream: &'a mut TcpStream, peer_side: ConnectionSide, genesis_header: Header<N>, restrictions_id: Field<N>, ) -> Result<Option<ChallengeRequest<N>>>

Executes the handshake protocol.

impl<N: Network> Router<N>

pub fn send_ping( &self, peer_ip: SocketAddr, block_locators: Option<BlockLocators<N>>, ) -> bool

Sends a “Ping” message to the given peer.

Returns false if the peer does not exist or disconnected.

pub fn send( &self, peer_ip: SocketAddr, message: Message<N>, ) -> Option<Receiver<Result<()>>>

Sends the given message to specified peer.

This function returns as soon as the message is queued to be sent, without waiting for the actual delivery; instead, the caller is provided with a oneshot::Receiver which can be used to determine when and whether the message has been delivered.

This returns None, if the peer does not exist or disconnected.

impl<N: Network> Router<N>

pub async fn new( node_ip: SocketAddr, node_type: NodeType, account: Account<N>, ledger: Arc<dyn LedgerService<N>>, trusted_peers: &[SocketAddr], max_peers: u16, rotate_external_peers: bool, allow_external_peers: bool, storage_mode: StorageMode, is_dev: bool, ) -> Result<Self>

Initializes a new Router instance.

impl<N: Network> Router<N>

pub fn is_valid_message_version(&self, message_version: u32) -> bool

Returns true if the message version is valid.

pub fn node_type(&self) -> NodeType

Returns the node type.

pub fn private_key(&self) -> &PrivateKey<N>

Returns the account private key of the node.

pub fn view_key(&self) -> &ViewKey<N>

Returns the account view key of the node.

pub fn address(&self) -> Address<N>

Returns the account address of the node.

pub fn cache(&self) -> &Cache<N>

Returns a reference to the cache.

pub fn rotate_external_peers(&self) -> bool

Returns true if the node is periodically evicting more external peers.

pub fn allow_external_peers(&self) -> bool

Returns true if the node is engaging in P2P gossip to request more peers.

pub fn resolve_to_listener( &self, connected_addr: SocketAddr, ) -> Option<SocketAddr>

Returns the listener IP address from the (ambiguous) peer address.

pub fn connected_metrics(&self) -> Vec<(SocketAddr, NodeType)>

Returns the list of metrics for the connected peers.

pub fn update_last_seen_for_connected_peer(&self, peer_ip: SocketAddr)

pub fn spawn<T: Future<Output = ()> + Send + 'static>(&self, future: T)

Spawns a task with the given future; it should only be used for long-running tasks.

pub async fn shut_down(&self)

Shuts down the router.

Trait Implementations

impl<N: Clone + Network> Clone for Router<N>

fn clone(&self) -> Router<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Network> CommunicationService for Router<N>

type Message = Message<N>

The message type.

fn prepare_block_request(start_height: u32, end_height: u32) -> Self::Message

Prepares a block request to be sent.

fn send<'life0, 'async_trait>( &'life0 self, peer_ip: SocketAddr, message: Self::Message, ) -> Pin<Box<dyn Future<Output = Option<Receiver<Result<()>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sends the given message to specified peer.

This function returns as soon as the message is queued to be sent, without waiting for the actual delivery; instead, the caller is provided with a [oneshot::Receiver] which can be used to determine when and whether the message has been delivered.

impl<N: Network> Deref for Router<N>

type Target = Arc<InnerRouter<N>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<N: Network> P2P for Router<N>

fn tcp(&self) -> &Tcp

Returns a reference to the TCP instance.

impl<N: Network> PeerPoolHandling<N> for Router<N>

const MAXIMUM_POOL_SIZE: usize = 10_000usize

The maximum number of peers permitted to be stored in the peer pool.

const OWNER: &str = "[Router]"

const PEER_SLASHING_COUNT: usize = 200usize

The number of candidate peers to be removed from the pool once MAXIMUM_POOL_SIZE is reached. It must be lower than MAXIMUM_POOL_SIZE.

fn peer_pool(&self) -> &RwLock<HashMap<SocketAddr, Peer<N>>>

fn resolver(&self) -> &RwLock<Resolver<N>>

fn is_dev(&self) -> bool

Returns true if the owning node is in development mode.

fn local_ip(&self) -> SocketAddr

Returns the listener address of this node.

fn is_local_ip(&self, addr: SocketAddr) -> bool

Returns true if the given IP is this node.

fn is_valid_peer_ip(&self, ip: SocketAddr) -> bool

Returns true if the given IP is not this node, is not a bogon address, and is not unspecified.

fn max_connected_peers(&self) -> usize

Returns the maximum number of connected peers.

fn check_connection_attempt(&self, listener_addr: SocketAddr) -> Result<bool>

Ensure we are allowed to connect to the given listener address of a peer.

fn connect(&self, listener_addr: SocketAddr) -> Option<JoinHandle<bool>>

Attempts to connect to the given peer’s listener address.

fn disconnect(&self, listener_addr: SocketAddr) -> JoinHandle<bool>

Disconnects from the given peer IP, if the peer is connected. The returned boolean indicates whether the peer was actually disconnected from, or if this was a noop.

fn downgrade_peer_to_candidate(&self, listener_addr: SocketAddr)

Downgrades a connected peer to candidate status.

fn insert_candidate_peers(&self, listener_addrs: Vec<(SocketAddr, Option<u32>)>)

Adds new candidate peers to the peer pool, ensuring their validity and following the limit on the number of peers in the pool. The listener addresses may be paired with the last known block height of the associated peer.

fn remove_peer(&self, listener_addr: SocketAddr)

Completely removes an entry from the peer pool.

fn resolve_to_ambiguous(&self, listener_addr: SocketAddr) -> Option<SocketAddr>

Returns the connected peer address from the listener IP address.

fn resolve_to_aleo_addr(&self, listener_addr: SocketAddr) -> Option<Address<N>>

Returns the connected peer aleo address from the listener IP address.

fn is_connecting(&self, listener_addr: SocketAddr) -> bool

Returns true if the node is connecting to the given peer’s listener address.

fn is_connected(&self, listener_addr: SocketAddr) -> bool

Returns true if the node is connected to the given peer listener address.

fn is_trusted(&self, listener_addr: SocketAddr) -> bool

Returns true if the given listener address is trusted.

fn number_of_peers(&self) -> usize

Returns the number of all peers.

fn number_of_connected_peers(&self) -> usize

Returns the number of connected peers.

fn number_of_connecting_peers(&self) -> usize

Returns the number of connecting peers.

fn number_of_candidate_peers(&self) -> usize

Returns the number of candidate peers.

fn get_connected_peer( &self, listener_addr: SocketAddr, ) -> Option<ConnectedPeer<N>>

Returns the connected peer given the peer IP, if it exists.

fn update_connected_peer<F: FnMut(&mut ConnectedPeer<N>)>( &self, listener_addr: &SocketAddr, update_fn: F, ) -> bool

Updates the connected peer - if it exists - given the peer IP and a closure. The returned status indicates whether the update was successful, i.e. the peer had existed.

fn get_peers(&self) -> Vec<Peer<N>>

Returns the list of all peers (connected, connecting, and candidate).

fn get_connected_peers(&self) -> Vec<ConnectedPeer<N>>

Returns all connected peers.

fn get_best_connected_peers( &self, max_entries: Option<usize>, ) -> Vec<ConnectedPeer<N>>

Returns an optionally bounded list of all connected peers sorted by their block height (highest first) and failure count (lowest first).

fn filter_connected_peers<P: FnMut(&ConnectedPeer<N>) -> bool>( &self, predicate: P, ) -> Vec<ConnectedPeer<N>>

Returns all connected peers that satisify the given predicate.

fn connected_peers(&self) -> Vec<SocketAddr>

Returns the list of connected peers.

fn trusted_peers(&self) -> Vec<SocketAddr>

Returns the list of trusted peers.

fn get_candidate_peers(&self) -> Vec<CandidatePeer>

Returns the list of candidate peers.

fn unconnected_trusted_peers(&self) -> HashSet<SocketAddr>

Returns the list of unconnected trusted peers.

fn load_cached_peers( storage_mode: &StorageMode, filename: &str, ) -> Result<Vec<SocketAddr>>

Loads any previously cached peer addresses so they can be introduced as initial candidate peers to connect to.

fn save_best_peers( &self, storage_mode: &StorageMode, filename: &str, max_entries: Option<usize>, ) -> Result<()>

Preserve the peers who have the greatest known block heights, and the lowest number of registered network failures.

fn add_connecting_peer(&self, listener_addr: SocketAddr) -> bool

fn ip_ban_peer(&self, listener_addr: SocketAddr, reason: Option<&str>)

Temporarily IP-ban and disconnect from the peer with the given listener address and an optional reason for the ban. This also removes the peer from the candidate pool.

fn is_ip_banned(&self, ip: IpAddr) -> bool

Check whether the given IP address is currently banned.

fn update_ip_ban(&self, ip: IpAddr)

Insert or update a banned IP.

impl<N: Network> Writing for Router<N>

fn codec(&self, _addr: SocketAddr, _side: ConnectionSide) -> Self::Codec

Creates an [Encoder] used to write the outbound messages to the target stream. The side parameter indicates the connection side from the node’s perspective.

type Codec = MessageCodec<N>

The user-supplied Encoder used to write outbound messages to the target stream.

type Message = Message<N>

The type of the outbound messages; unless their serialization is expensive and the message is broadcasted (in which case it would get serialized multiple times), serialization should be done in the implementation of Self::Codec.

fn message_queue_depth(&self) -> usize

The depth of per-connection queues used to send outbound messages; the greater it is, the more outbound messages the node can enqueue. Setting it to a large value is not recommended, as doing it might obscure potential issues with your implementation (like slow serialization) or network.

fn enable_writing<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Prepares the node to send messages.

fn unicast( &self, addr: SocketAddr, message: Self::Message, ) -> Result<Receiver<Result<(), Error>>, Error>

Sends the provided message to the specified SocketAddr. Returns as soon as the message is queued to be sent, without waiting for the actual delivery; instead, the caller is provided with a oneshot::Receiver which can be used to determine when and whether the message has been delivered.

fn broadcast(&self, message: Self::Message) -> Result<(), Error>

where Self::Message: Clone,

Broadcasts the provided message to all connected peers. Returns as soon as the message is queued to be sent to all the peers, without waiting for the actual delivery. This method doesn’t provide the means to check when and if the messages actually get delivered; you can achieve that by calling Writing::unicast for each address returned by [Tcp::connected_addrs].