Struct libp2p_tcp::Transport

pub struct Transport<T>where
    T: Provider + Send,{ /* private fields */ }

An abstract libp2p_core::Transport implementation.

You shouldn’t need to use this type directly. Use one of the following instead:

• tokio::Transport
• [async_io::Transport]

Implementations

impl<T> Transport<T>where T: Provider + Send,

pub fn new(config: Config) -> Self

Create a new instance of Transport.

If you don’t want to specify a Config, use Transport::default.

It is best to call this function through one of the type-aliases of this type:

• tokio::Transport::new
• [async_io::Transport::new]

Trait Implementations

impl<T> Default for Transport<T>where T: Provider + Send,

fn default() -> Self

Creates a Transport with reasonable defaults.

This transport will have port-reuse disabled.

impl<T> Transport for Transport<T>where T: Provider + Send + 'static, T::Listener: Unpin, T::Stream: Unpin,

fn address_translation( &self, listen: &Multiaddr, observed: &Multiaddr ) -> Option<Multiaddr>

When port reuse is disabled and hence ephemeral local ports are used for outgoing connections, the returned address is the observed address with the port replaced by the port of the listen address.

If port reuse is enabled, Some(observed) is returned, as there is a chance that the observed address and port are reachable for other peers if there is a NAT in the way that does endpoint- independent filtering. Furthermore, even if that is not the case and TCP hole punching techniques must be used for NAT traversal, the observed address is still the one that a remote should connect to for the purpose of the hole punching procedure, as it represents the mapped IP and port of the NAT device in front of the local node.

None is returned if one of the given addresses is not a TCP/IP address.

fn poll( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<TransportEvent<Self::ListenerUpgrade, Self::Error>>

Poll all listeners.

type Output = <T as Provider>::Stream

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

type Error = Error

An error that occurred during connection setup.

type Dial = Pin<Box<dyn Future<Output = Result<<Transport<T> as Transport>::Output, <Transport<T> as Transport>::Error>> + Send, Global>>

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

type ListenerUpgrade = Ready<Result<<Transport<T> as Transport>::Output, <Transport<T> as Transport>::Error>>

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

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

Listens on the given Multiaddr for inbound connections.

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

Remove a listener.

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

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

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

As Transport::dial but has the local node act as a listener on the outgoing connection.

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

Applies a function on the connections created by the transport.

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

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

fn or_transport<U>(self, other: U) -> OrTransport<Self, U>where Self: Sized, U: Transport, <U as Transport>::Error: 'static,

Adds a fallback transport that is used when encountering errors while establishing inbound or outbound connections.

fn and_then<C, F, O>(self, f: C) -> AndThen<Self, C>where Self: Sized, C: FnOnce(Self::Output, ConnectedPoint) -> F, F: TryFuture<Ok = O>, <F as TryFuture>::Error: Error + 'static,

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

fn upgrade(self, version: Version) -> Builder<Self>where Self: Sized, Self::Error: 'static,

Begins a series of protocol upgrades via an upgrade::Builder.