Struct Gateway 

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

The gateway maintains connections to other validators. For connections with clients and provers, the Router logic is used.

Implementations

impl<N: Network> Gateway<N>

pub fn new( account: Account<N>, storage: Storage<N>, ledger: Arc<dyn LedgerService<N>>, ip: Option<SocketAddr>, trusted_validators: &[SocketAddr], trusted_peers_only: bool, node_data_dir: NodeDataDir, dev: Option<u16>, ) -> Result<Self>

Initializes a new gateway.

pub async fn run( &self, primary_sender: PrimarySender<N>, worker_senders: IndexMap<u8, WorkerSender<N>>, sync_sender: Option<SyncSender<N>>, )

Run the gateway.

impl<N: Network> Gateway<N>

pub fn account(&self) -> &Account<N>

Returns the account of the node.

pub fn dev(&self) -> Option<u16>

Returns the dev identifier of the node.

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

Returns the resolver.

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

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

pub fn primary_sender(&self) -> &PrimarySender<N>

Returns the primary sender.

pub fn num_workers(&self) -> u8

Returns the number of workers.

pub fn get_worker_sender(&self, worker_id: u8) -> Option<&WorkerSender<N>>

Returns the worker sender for the given worker ID.

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

Returns true if the given peer IP is an authorized validator.

pub fn is_authorized_validator_address( &self, validator_address: Address<N>, ) -> bool

Returns true if the given address is an authorized validator.

pub fn connected_addresses(&self) -> HashSet<Address<N>>

Returns the list of connected addresses.

pub async fn shut_down(&self)

Shuts down the gateway.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

type Message = Event<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 Gateway<N>

type Target = Arc<InnerGateway<N>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<N: Network> Disconnect for Gateway<N>

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

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

Any extra operations to be performed during a disconnect.

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

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

Attaches the behavior specified in Disconnect::handle_disconnect to every occurrence of the node disconnecting from a peer.

impl<N: Network> Handshake for Gateway<N>

fn perform_handshake<'life0, 'async_trait>( &'life0 self, connection: Connection, ) -> Pin<Box<dyn Future<Output = Result<Connection>> + Send + 'async_trait>>

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

Performs the handshake protocol.

const TIMEOUT_MS: u64 = 3_000

The maximum time allowed for a connection to perform a handshake before it is rejected.

fn enable_handshake<'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 perform specified network handshakes.

fn borrow_stream<'a>(&self, conn: &'a mut Connection) -> &'a mut TcpStream

Borrows the full connection stream to be used in the implementation of Handshake::perform_handshake.

fn take_stream(&self, conn: &mut Connection) -> TcpStream

Assumes full control of a connection’s stream in the implementation of Handshake::perform_handshake, by the end of which it must be followed by Handshake::return_stream.

fn return_stream<T>(&self, conn: &mut Connection, stream: T)

where T: AsyncRead + AsyncWrite + Send + Sync + 'static,

This method only needs to be called if Handshake::take_stream had been called before; it is used to return a (potentially modified) stream back to the applicable connection.

impl<N: Network> OnConnect for Gateway<N>

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

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

Any initial actions to be executed after the handshake is concluded; in order to be able to communicate with the peer in the usual manner (i.e. via [Writing]), only its SocketAddr (as opposed to the related [Connection] object) is provided as an argument.

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

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

Attaches the behavior specified in OnConnect::on_connect right after every successful handshake.

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

fn tcp(&self) -> &Tcp

Returns a reference to the TCP instance.

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

const MAXIMUM_POOL_SIZE: usize = 200

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

const OWNER: &str = CONTEXT

const PEER_SLASHING_COUNT: usize = 20

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

Returns true if the node is in trusted peers only mode.

fn node_type(&self) -> NodeType

Returns the node type.

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, Error>

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) -> bool

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_connected_address(&self, aleo_address: Address<N>) -> bool

Returns true if the node is connected to the given Aleo 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>( &self, listener_addr: &SocketAddr, update_fn: F, ) -> bool

where F: FnMut(&mut ConnectedPeer<N>),

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>(&self, predicate: P) -> Vec<ConnectedPeer<N>>

where P: FnMut(&ConnectedPeer<N>) -> bool,

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(path: &Path) -> Result<Vec<SocketAddr>, Error>

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

fn save_best_peers( &self, path: &Path, max_entries: Option<usize>, store_ports: bool, ) -> Result<(), Error>

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> Reading for Gateway<N>

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

Creates a [Decoder] used to interpret messages from the network. The side param indicates the connection side from the node’s perspective.

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

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

Processes a message received from the network.

fn message_queue_depth(&self) -> usize

Computes the depth of per-connection queues used to process inbound messages, sufficient to process the maximum expected load at any givent moment. The greater it is, the more inbound messages the node can enqueue, but a too large value can make the node more susceptible to DoS attacks.

type Codec = EventCodec<N>

The user-supplied Decoder used to interpret inbound messages.

type Message = Event<N>

The final (deserialized) type of inbound messages.

const INITIAL_BUFFER_SIZE: usize = _

The initial size of a per-connection buffer for reading inbound messages. Can be set to the maximum expected size of the inbound message in order to only allocate it once.

fn enable_reading<'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 receive messages.

impl<N: Network> Transport<N> for Gateway<N>

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

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

Sends the given event to specified peer.

This method is rate limited to prevent spamming the peer.

This function returns as soon as the event 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 event has been delivered.

fn broadcast(&self, event: Event<N>)

Broadcasts the given event to all connected peers.

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

fn codec(&self, _peer_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.

fn message_queue_depth(&self) -> usize

Computes the depth of per-connection queues used to send outbound messages, sufficient to process the maximum expected load at any givent moment. The greater it is, the more outbound messages the node can enqueue. A too large value large value might obscure potential issues with your implementation (like slow serialization) or network.

type Codec = EventCodec<N>

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

type Message = Event<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 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].