Struct Gateway

pub struct Gateway<N: Network> { /* private fields */ }

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], 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 const fn account(&self) -> &Account<N>

Returns the account of the node.

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

Returns the dev identifier of the node.

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 resolver(&self) -> &Resolver<N>

Returns the resolver.

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

Returns true if the node is connected to the given Aleo address.

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

Returns true if the node is connected to the given peer IP.

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

Returns true if the node is connecting to the given peer IP.

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 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 connected_addresses(&self) -> HashSet<Address<N>>

Returns the list of connected addresses.

pub fn connected_peers(&self) -> &RwLock<IndexSet<SocketAddr>>

Returns the list of connected peers.

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

Attempts to connect to the given peer IP.

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

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

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 copy 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> 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_000u64

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

const MESSAGE_QUEUE_DEPTH: usize

The maximum queue depth of incoming messages for a single peer.

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.

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 = 1_048_576usize

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>

const MESSAGE_QUEUE_DEPTH: usize

The maximum queue depth of outgoing messages for a single peer.

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.

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