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<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, is_dev: bool, ) -> Result<Self>

Initializes a new Router instance.

impl<N: Network> Router<N>

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

Attempts to connect to the given peer IP.

Returns None if we are already connected to the peer or cannot connect. Otherwise, it returns a handle to the tokio tasks that sets up the connection.

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

Disconnects from the given peer IP, if the peer is connected.

pub fn local_ip(&self) -> SocketAddr

Returns the IP address of this node.

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

Returns true if the given IP is this node.

pub 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.

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 is_dev(&self) -> bool

Returns true if the node is in development mode.

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 resolve_to_ambiguous( &self, listener_addr: &SocketAddr, ) -> Option<SocketAddr>

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

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

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

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

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

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

Returns true if the given listener address is trusted.

pub fn max_connected_peers(&self) -> usize

Returns the maximum number of connected peers.

pub fn number_of_connected_peers(&self) -> usize

Returns the number of connected peers.

pub fn number_of_candidate_peers(&self) -> usize

Returns the number of candidate peers.

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

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

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

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

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

Returns all connected peers.

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

Returns all connected peers that satisify the given predicate.

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

Returns the list of connected peers.

pub fn candidate_peers(&self) -> HashSet<SocketAddr>

Returns the list of candidate peers.

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

Returns the list of unconnected trusted peers.

pub fn bootstrap_peers(&self) -> Vec<SocketAddr>

Returns the list of bootstrap peers.

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

Returns the list of metrics for the connected peers.

pub fn insert_candidate_peers(&self, peers: &[SocketAddr])

Inserts the given peer IPs to the set of candidate peers.

This method skips adding any given peers if the combined size exceeds the threshold, as the peer providing this list could be subverting the protocol.

pub fn update_last_seen_for_connected_peer(&self, peer_ip: SocketAddr)

pub fn remove_connected_peer(&self, peer_ip: SocketAddr)

Removes the connected peer and adds them to the candidate peers.

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> 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> 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].