Struct libp2p_identify::IdentifyTransport

pub struct IdentifyTransport<TTrans> { /* private fields */ }

Wraps around an implementation of Transport that yields a muxer. Will use the muxer to open a substream with the remote and retreive its peer id. Then yields a (PeerId, impl StreamMuxer).

This transport can be used if you don’t use any encryption layer, or if you want to make encryption optional, in which case you have no other way to know the PeerId of the remote than to ask for it.

Note: If you use this transport, keep in mind that the PeerId returned by the remote can be anything and shouldn’t necessarily be trusted.

Implementations

impl<TTrans> IdentifyTransport<TTrans>

pub fn new(transport: TTrans) -> Self

Creates an IdentifyTransport that wraps around the given transport.

Trait Implementations

impl<TTrans: Clone> Clone for IdentifyTransport<TTrans>

fn clone(&self) -> IdentifyTransport<TTrans>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TTrans: Debug> Debug for IdentifyTransport<TTrans>

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

Formats the value using the given formatter.

impl<TTrans, TMuxer> Transport for IdentifyTransport<TTrans>where
    TTrans: Transport<Output = TMuxer>,
    TMuxer: StreamMuxer + Send + Sync + 'static,
    TMuxer::Substream: Send + Sync + 'static,

type Output = (PeerId, TMuxer)

The raw connection to a peer.

type Listener = Empty<(<IdentifyTransport<TTrans> as Transport>::ListenerUpgrade, Multiaddr), Error>

The listener produces incoming connections.

type ListenerUpgrade = Empty<<IdentifyTransport<TTrans> as Transport>::Output, Error>

After a connection has been received, we may need to do some asynchronous pre-processing on it (e.g. an intermediary protocol negotiation). While this pre-processing takes place, we want to be able to continue polling on the listener.

type Dial = AndThen<<TTrans as Transport>::Dial, MapErr<IdRetriever<TMuxer>, fn(_: UpgradeError<Error>) -> Error>, fn(_: TMuxer) -> MapErr<IdRetriever<TMuxer>, fn(_: UpgradeError<Error>) -> Error>>

A future which indicates that we are currently dialing to a peer.

fn listen_on(
    self,
    addr: Multiaddr
) -> Result<(Self::Listener, Multiaddr), (Self, Multiaddr)>

Listen on the given multiaddr. Returns a stream of incoming connections, plus a modified version of the Multiaddr. This new Multiaddr is the one that that should be advertised to other nodes, instead of the one passed as parameter.

fn dial(self, addr: Multiaddr) -> Result<Self::Dial, (Self, Multiaddr)>

Dial the given multi-addr.

fn nat_traversal(&self, a: &Multiaddr, b: &Multiaddr) -> Option<Multiaddr>

Takes a multiaddress we’re listening on (server), and tries to convert it to an externally-visible multiaddress. In order to do so, we pass an observed address which a remote node observes for one of our dialers.

fn map<F, O>(self, map: F) -> Map<Self, F>where
    Self: Sized,
    F: FnOnce(Self::Output, ConnectedPoint) -> O + Clone,

Applies a function on the output of the Transport.

fn map_err<F>(self, map_err: F) -> MapErr<Self, F>where
    Self: Sized,
    F: FnOnce(Error) -> Error + Clone,

Applies a function on the errors generated by the futures of the Transport.

fn map_err_dial<F>(self, map_err: F) -> MapErrDial<Self, F>where
    Self: Sized,
    F: FnOnce(Error, Multiaddr) -> Error,

Applies a function on the errors generated by the futures of the Transport when dialing.

fn or_transport<T>(self, other: T) -> OrTransport<Self, T>where
    Self: Sized,

Builds a new struct that implements Transport that contains both self and other.

fn and_then<C, F, O>(self, upgrade: C) -> AndThen<Self, C>where
    Self: Sized,
    C: FnOnce(Self::Output, ConnectedPoint) -> F + Clone,
    F: IntoFuture<Item = O, Error = Error>,

Wraps this transport inside an upgrade. Whenever a connection that uses this transport is established, it is wrapped inside the upgrade.

fn with_timeout(self, timeout: Duration) -> TransportTimeout<Self>where
    Self: Sized,

Adds a timeout to the connection and upgrade steps for all the sockets created by the transport.

fn with_outbound_timeout(self, timeout: Duration) -> TransportTimeout<Self>where
    Self: Sized,

Adds a timeout to the connection and upgrade steps for all the outgoing sockets created by the transport.

fn with_inbound_timeout(self, timeout: Duration) -> TransportTimeout<Self>where
    Self: Sized,

Adds a timeout to the connection and upgrade steps for all the incoming sockets created by the transport.