Enum libp2p::core::transport::TransportEvent

pub enum TransportEvent<TUpgr, TErr> {
    NewAddress {
        listener_id: ListenerId,
        listen_addr: Multiaddr,
    },
    AddressExpired {
        listener_id: ListenerId,
        listen_addr: Multiaddr,
    },
    Incoming {
        listener_id: ListenerId,
        upgrade: TUpgr,
        local_addr: Multiaddr,
        send_back_addr: Multiaddr,
    },
    ListenerClosed {
        listener_id: ListenerId,
        reason: Result<(), TErr>,
    },
    ListenerError {
        listener_id: ListenerId,
        error: TErr,
    },
}

Event produced by Transports.

Variants

NewAddress

A new address is being listened on.

Fields

listener_id: ListenerId

The listener that is listening on the new address.

listen_addr: Multiaddr

The new address that is being listened on.

AddressExpired

An address is no longer being listened on.

Fields

listener_id: ListenerId

The listener that is no longer listening on the address.

listen_addr: Multiaddr

The new address that is being listened on.

Incoming

A connection is incoming on one of the listeners.

Fields

listener_id: ListenerId

The listener that produced the upgrade.

upgrade: TUpgr

The produced upgrade.

local_addr: Multiaddr

Local connection address.

send_back_addr: Multiaddr

Address used to send back data to the incoming client.

ListenerClosed

A listener closed.

Fields

listener_id: ListenerId

The ID of the listener that closed.

reason: Result<(), TErr>

Reason for the closure. Contains Ok(()) if the stream produced None, or Err if the stream produced an error.

ListenerError

A listener errored.

The listener will continue to be polled for new events and the event is for informational purposes only.

Fields

listener_id: ListenerId

The ID of the listener that errored.

error: TErr

The error value.

Implementations

impl<TUpgr, TErr> TransportEvent<TUpgr, TErr>

pub fn map_upgrade<U>( self, map: impl FnOnce(TUpgr) -> U, ) -> TransportEvent<U, TErr>

In case this TransportEvent is an upgrade, apply the given function to the upgrade and produce another transport event based the the function’s result.

pub fn map_err<E>( self, map_err: impl FnOnce(TErr) -> E, ) -> TransportEvent<TUpgr, E>

In case this TransportEvent is an ListenerError, or ListenerClosed apply the given function to the error and produce another transport event based on the function’s result.

pub fn is_upgrade(&self) -> bool

Returns true if this is an Incoming transport event.

pub fn into_incoming(self) -> Option<(TUpgr, Multiaddr)>

Try to turn this transport event into the upgrade parts of the incoming connection.

Returns None if the event is not actually an incoming connection, otherwise the upgrade and the remote address.

pub fn is_new_address(&self) -> bool

Returns true if this is a TransportEvent::NewAddress.

pub fn into_new_address(self) -> Option<Multiaddr>

Try to turn this transport event into the new Multiaddr.

Returns None if the event is not actually a TransportEvent::NewAddress, otherwise the address.

pub fn is_address_expired(&self) -> bool

Returns true if this is an TransportEvent::AddressExpired.

pub fn into_address_expired(self) -> Option<Multiaddr>

Try to turn this transport event into the expire Multiaddr.

Returns None if the event is not actually a TransportEvent::AddressExpired, otherwise the address.

pub fn is_listener_error(&self) -> bool

Returns true if this is an TransportEvent::ListenerError transport event.

pub fn into_listener_error(self) -> Option<TErr>

Try to turn this transport event into the listener error.

Returns None if the event is not actually a TransportEvent::ListenerError`, otherwise the error.

Trait Implementations

impl<TUpgr, TErr> Debug for TransportEvent<TUpgr, TErr>

where TErr: Debug,

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

Formats the value using the given formatter.