Struct libp2p_combined_transport::CombinedTransport

pub struct CombinedTransport<TBase, TOuter> where
    TBase: Transport + Clone,
    TBase::Error: Send + 'static,
    TBase::Output: 'static,  { /* fields omitted */ }

Transport combining two transports. One of which is the base transport (like TCP), and another one is a higher-level transport (like WebSocket). Similar to [OrTransport], this tries to dial first with the outer connection, and if that fails, with the base one. The main difference is that incoming connections can be accepted on either one of them. For this to work, a switch must be provided when handling incoming connections. For TCP, this can be achieved with the peek method on the underlying [TcpStream]. [ListenerEvent]s from the base transport are cloned and routed to the outer transport via the ProxyTransport, with the exception of upgrades.

For a usage example, have a look at the TCP-Websocket example.

Implementations

impl<TBase, TOuter> CombinedTransport<TBase, TOuter> where
    TBase: Transport + Clone,
    TBase::Error: Send + 'static,
    TBase::Output: 'static, 

pub fn new(
    base: TBase,
    construct_outer: fn(_: ProxyTransport<TBase>) -> TOuter,
    try_upgrade: fn(_: <TBase as Transport>::Output) -> BoxFuture<'static, Result<<TBase as Transport>::Output, <TBase as Transport>::Output>>,
    map_base_addr_to_outer: fn(_: Multiaddr) -> Multiaddr
) -> Self

Construct a new combined transport, given a base transport, a function to construct the outer transport given the base transport, a function to try the upgrade to the outer transport given incoming base connections, and a function to map base addresses to outer addresses (if necessary).

Trait Implementations

impl<TBase, TOuter> Clone for CombinedTransport<TBase, TOuter> where
    TBase: Transport + Clone,
    TBase::Error: Send + 'static,
    TBase::Output: 'static, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TBase, TOuter> Transport for CombinedTransport<TBase, TOuter> where
    TBase: Transport + Clone,
    TBase::Listener: Send + 'static,
    TBase::ListenerUpgrade: Send + 'static,
    TBase::Error: Send + 'static,
    TBase::Output: Send + 'static,
    TBase::Dial: Send + 'static,
    TOuter: Transport,
    TOuter::Listener: Send + 'static,
    TOuter::ListenerUpgrade: Send + 'static,
    TOuter::Error: 'static,
    TOuter::Output: 'static,
    TOuter::Dial: Send + 'static, 

type Output = EitherOutput<TBase::Output, TOuter::Output>

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

type Error = CombinedError<TBase::Error, TOuter::Error>

An error that occurred during connection setup.

type Listener = BoxStream<'static, Result<ListenerEvent<Self::ListenerUpgrade, Self::Error>, Self::Error>>

A stream of Outputs for inbound connections.

type ListenerUpgrade = BoxFuture<'static, Result<Self::Output, Self::Error>>

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

type Dial = BoxFuture<'static, Result<Self::Output, Self::Error>>

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

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

Listens on the given [Multiaddr], producing a stream of pending, inbound connections and addresses this transport is listening on (cf. [ListenerEvent]).

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

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

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

Performs a transport-specific mapping of an address observed by a remote onto a local listen address to yield an address for the local node that may be reachable for other peers.

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

Boxes the transport, including custom transport errors.

fn map<F, O>(self, f: 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, E>(self, f: F) -> MapErr<Self, F> where
    F: FnOnce(Self::Error) -> E + Clone, 

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

fn or_transport<U>(self, other: U) -> OrTransport<Self, U> where
    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
    C: FnOnce(Self::Output, ConnectedPoint) -> F + Clone,
    F: TryFuture<Ok = O>,
    <F as TryFuture>::Error: 'static,
    <F as TryFuture>::Error: Error, 

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

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

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