Struct libp2p_core::network::Network

pub struct Network<TTrans, THandler> where
    TTrans: Transport,
    THandler: IntoConnectionHandler,  { /* private fields */ }

Implementation of Stream that handles the nodes.

Implementations

impl<TTrans, THandler> Network<TTrans, THandler> where
    TTrans: Transport,
    THandler: IntoConnectionHandler, 

pub fn is_connected(&self, peer: &PeerId) -> bool

Checks whether the network has an established connection to a peer.

pub fn is_dialing(&self, peer: &PeerId) -> bool

Checks whether the network has an ongoing dialing attempt to a peer.

impl<TTrans, THandler> Network<TTrans, THandler> where
    TTrans: Transport + Clone + 'static,
    <TTrans as Transport>::Error: Send + 'static,
    THandler: IntoConnectionHandler + Send + 'static, 

pub fn new(
    transport: TTrans,
    local_peer_id: PeerId,
    config: NetworkConfig
) -> Self

Creates a new node events stream.

pub fn transport(&self) -> &TTrans

Returns the transport passed when building this object.

pub fn listen_on(
    &mut self,
    addr: Multiaddr
) -> Result<ListenerId, TransportError<TTrans::Error>>

Start listening on the given multiaddress.

pub fn remove_listener(&mut self, id: ListenerId) -> bool

Remove a previously added listener.

Returns true if there was a listener with this ID, false otherwise.

pub fn listen_addrs(&self) -> impl Iterator<Item = &Multiaddr>

Returns an iterator that produces the list of addresses we are listening on.

pub fn address_translation<'a>(
    &'a self,
    observed_addr: &'a Multiaddr
) -> Vec<Multiaddr> where
    THandler: 'a, 

Maps the given observed_addr, representing an address of the local node observed by a remote peer, onto the locally known listen addresses to yield one or more addresses of the local node that may be publicly reachable.

I.e. this method incorporates the view of other peers into the listen addresses seen by the local node to account for possible IP and port mappings performed by intermediate network devices in an effort to obtain addresses for the local peer that are also reachable for peers other than the peer who reported the observed_addr.

The translation is transport-specific. See Transport::address_translation.

pub fn local_peer_id(&self) -> &PeerId

Returns the peer id of the local node.

pub fn dial(
    &mut self,
    address: &Multiaddr,
    handler: THandler
) -> Result<ConnectionId, DialError<THandler>> where
    TTrans: Transport + Send,
    TTrans::Output: Send + 'static,
    TTrans::Dial: Send + 'static,
    TTrans::Error: Send + 'static,
    TTrans::Dial: Send + 'static, 

Dials a Multiaddr that may or may not encapsulate a specific expected remote peer ID.

The given handler will be used to create the Connection upon success and the connection ID is returned.

pub fn info(&self) -> NetworkInfo

Returns information about the state of the Network.

pub fn incoming_info(&self) -> impl Iterator<Item = IncomingInfo<'_>>

Returns an iterator for information on all pending incoming connections.

pub fn connected_peers(&self) -> impl Iterator<Item = &PeerId>

Returns a list of all connected peers, i.e. peers to whom the Network has at least one established connection.

pub fn is_disconnected(&self, peer: &PeerId) -> bool

Checks whether the network has neither an ongoing dialing attempt, nor an established connection to a peer.

pub fn dialing_peers(&self) -> impl Iterator<Item = &PeerId>

Returns a list of all the peers to whom a new outgoing connection is currently being established.

pub fn peer(&mut self, peer_id: PeerId) -> Peer<'_, TTrans, THandler>

Obtains a view of a Peer with the given ID in the network.

pub fn accept(
    &mut self,
    _: IncomingConnection<TTrans::ListenerUpgrade>,
    handler: THandler
) -> Result<ConnectionId, (ConnectionLimit, THandler)> where
    TTrans: Transport,
    TTrans::Output: Send + 'static,
    TTrans::Error: Send + 'static,
    TTrans::ListenerUpgrade: Send + 'static, 

Accepts a pending incoming connection obtained via NetworkEvent::IncomingConnection, adding it to the Networks connection pool subject to the configured limits.

Once the connection is established and all transport protocol upgrades completed, the connection is associated with the provided handler.

pub fn poll<'a, TMuxer>(
    &'a mut self,
    cx: &mut Context<'_>
) -> Poll<NetworkEvent<'a, TTrans, <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::InEvent, <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::OutEvent, THandler>> where
    TTrans: Transport<Output = (PeerId, TMuxer)>,
    TTrans::Error: Send + 'static,
    TTrans::Dial: Send + 'static,
    TTrans::ListenerUpgrade: Send + 'static,
    TMuxer: StreamMuxer + Send + Sync + 'static,
    TMuxer::Error: Debug,
    TMuxer::OutboundSubstream: Send,
    THandler: IntoConnectionHandler + Send + 'static,
    <THandler::Handler as ConnectionHandler>::Error: Error + Send + 'static,
    <THandler::Handler as ConnectionHandler>::OutboundOpenInfo: Send,
    <THandler::Handler as ConnectionHandler>::Error: Error + Send,
    THandler::Handler: ConnectionHandler<Substream = Substream<TMuxer>> + Send, 

Provides an API similar to Stream, except that it does not terminate.

Trait Implementations

impl<TTrans, THandler> Debug for Network<TTrans, THandler> where
    TTrans: Debug + Transport,
    THandler: Debug + ConnectionHandler, 

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

Formats the value using the given formatter.

impl<TTrans, THandler> Unpin for Network<TTrans, THandler> where
    TTrans: Transport,
    THandler: IntoConnectionHandler,