Struct libp2p_identify::IdentifyTransport

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

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.

Methods

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>,
    TTrans::Error: 'static,
    TMuxer: StreamMuxer + Send + Sync + 'static,
    TMuxer::Substream: Send + Sync + 'static, 

type Output = (PeerId, TMuxer)

The result of a connection setup process, including protocol upgrades.

type Error = TransportUpgradeError<TTrans::Error, IoError>

An error that occurred during connection setup.

type Listener = Empty<(Self::ListenerUpgrade, Multiaddr), Self::Error>

A stream of Outputs for inbound connections.

type ListenerUpgrade = Empty<Self::Output, Self::Error>

A pending Output for an inbound connection, obtained from the Listener stream.

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

A pending Output for an outbound connection, obtained from dialing.

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

Listens on the given [Multiaddr], producing a stream of pending, inbound connections.

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

Dials the given [Multiaddr], returning a future for a pending outbound connection.

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

Takes a [Multiaddr] that represents a listening address together with an an address observed by another node and tries to incoporate information from the observed address into the listening address, yielding an externally-visible address.

fn boxed(self) -> Boxed<Self::Output, Self::Error> where
    Self: Clone + Send + Sync + 'static,
    Self::Dial: Send,
    Self::Dial: 'static,
    Self::Listener: Send,
    Self::Listener: 'static,
    Self::ListenerUpgrade: Send,
    Self::ListenerUpgrade: 'static, 

Turns this Transport into an abstract boxed transport.

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

Applies a function on the connections created by the transport.

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

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

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

Builds a new transport that falls back to another transport when encountering errors on dialing or listening for connections.

fn with_upgrade<U, O, E>(self, upgrade: U) -> Upgrade<Self, U> where
    U: InboundUpgrade<Self::Output, Output = O, Error = E> + OutboundUpgrade<Self::Output, Output = O, Error = E>,
    Self::Output: AsyncRead,
    Self::Output: AsyncWrite, 

Wraps this transport inside an [Upgrade].

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

Applies a function producing an asynchronous result to every connection created by this transport.

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

Adds a timeout to the connection setup (including upgrades) for all inbound and outbound connection attempts.

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

Adds a timeout to the connection setup (including upgrades) for all outbound connection attempts.

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

Adds a timeout to the connection setup (including upgrades) for all inbound connection attempts.