Struct libp2p_relay::v2::client::transport::ClientTransport

pub struct ClientTransport { /* private fields */ }

A Transport enabling client relay capabilities.

Note: The transport only handles listening and dialing on relayed Multiaddr, and depends on an other transport to do the actual transmission of data. They should be combined through the OrTransport.

Allows the local node to:

1. Establish relayed connections by dialing /p2p-circuit addresses.

   let actual_transport = MemoryTransport::default();
   let (relay_transport, behaviour) = client::Client::new_transport_and_behaviour(
       PeerId::random(),
   );
   let mut transport = OrTransport::new(relay_transport, actual_transport);
   let dst_addr_via_relay = Multiaddr::empty()
       .with(Protocol::Memory(40)) // Relay address.
       .with(Protocol::P2p(relay_id.into())) // Relay peer id.
       .with(Protocol::P2pCircuit) // Signal to connect via relay and not directly.
       .with(Protocol::P2p(destination_id.into())); // Destination peer id.
   transport.dial(dst_addr_via_relay).unwrap();

2. Listen for incoming relayed connections via specific relay.

   let actual_transport = MemoryTransport::default();
   let (relay_transport, behaviour) = client::Client::new_transport_and_behaviour(
      local_peer_id,
   );
   let mut transport = OrTransport::new(relay_transport, actual_transport);
   let relay_addr = Multiaddr::empty()
       .with(Protocol::Memory(40)) // Relay address.
       .with(Protocol::P2p(relay_id.into())) // Relay peer id.
       .with(Protocol::P2pCircuit); // Signal to listen via remote relay node.
   transport.listen_on(relay_addr).unwrap();

Trait Implementations

impl Transport for ClientTransport

type Output = RelayedConnection

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

type Error = RelayError

An error that occurred during connection setup.

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

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

type Dial = Pin<Box<dyn Future<Output = Result<RelayedConnection, RelayError>> + Send + 'static, Global>>

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

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>>where
    Self: Sized,

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

fn address_translation(
    &self,
    _server: &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 poll(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<TransportEvent<Self::ListenerUpgrade, Self::Error>>where
    Self: Sized,

Poll for TransportEvents.

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: 'static + Error,

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.