Struct libp2p_core::network::Network

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

Implementation of Stream that handles the nodes.

Implementations

impl<TTrans, TInEvent, TOutEvent, TMuxer, THandler> Network<TTrans, TInEvent, TOutEvent, THandler> where
    TTrans: Transport + Clone,
    TMuxer: StreamMuxer,
    THandler: IntoConnectionHandler + Send + 'static,
    THandler::Handler: ConnectionHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent> + Send,
    <THandler::Handler as ConnectionHandler>::OutboundOpenInfo: Send,
    <THandler::Handler as ConnectionHandler>::Error: Error + Send, 

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) -> Result<(), ()>

Remove a previously added listener.

Returns Ok(()) if a listener with this ID was in the list.

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
    TMuxer: 'a,
    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> where
    TTrans: Transport<Output = (PeerId, TMuxer)>,
    TTrans::Error: Send + 'static,
    TTrans::Dial: Send + 'static,
    TMuxer: Send + Sync + 'static,
    TMuxer::OutboundSubstream: Send,
    TInEvent: Send + 'static,
    TOutEvent: 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 unknown_dials(&self) -> impl Iterator<Item = &Multiaddr>

Returns the list of addresses we’re currently dialing without knowing the PeerId of.

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

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, TInEvent, TOutEvent, THandler>

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

pub fn accept(
    &mut self,
    connection: IncomingConnection<TTrans::ListenerUpgrade>,
    handler: THandler
) -> Result<ConnectionId, ConnectionLimit> where
    TInEvent: Send + 'static,
    TOutEvent: Send + 'static,
    TMuxer: StreamMuxer + Send + Sync + 'static,
    TMuxer::OutboundSubstream: Send,
    TTrans: Transport<Output = (PeerId, TMuxer)>,
    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>(
    &'a mut self,
    cx: &mut Context<'_>
) -> Poll<NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler>> where
    TTrans: Transport<Output = (PeerId, TMuxer)>,
    TTrans::Error: Send + 'static,
    TTrans::Dial: Send + 'static,
    TTrans::ListenerUpgrade: Send + 'static,
    TMuxer: Send + Sync + 'static,
    TMuxer::OutboundSubstream: Send,
    TInEvent: Send + 'static,
    TOutEvent: Send + 'static,
    THandler: IntoConnectionHandler + Send + 'static,
    THandler::Handler: ConnectionHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent> + Send + 'static,
    <THandler::Handler as ConnectionHandler>::Error: Error + Send + 'static, 

Provides an API similar to Stream, except that it cannot error.

Trait Implementations

impl<TTrans, TInEvent, TOutEvent, THandler> Debug for Network<TTrans, TInEvent, TOutEvent, 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, TInEvent, TOutEvent, THandler> Unpin for Network<TTrans, TInEvent, TOutEvent, THandler> where
    TTrans: Transport,
    THandler: IntoConnectionHandler,