Struct network::transport::DiemNetTransport

pub struct DiemNetTransport<TTransport> { /* fields omitted */ }

The common DiemNet Transport.

The base transport layer is pluggable, so long as it provides a reliable, ordered, connection-oriented, byte-stream abstraction (e.g., TCP). We currently use either MemoryTransport or TcpTransport as this base layer.

Inbound and outbound connections are first established with the base_transport and then negotiate a secure, authenticated transport layer (currently Noise protocol). Finally, we negotiate common supported application protocols with the Handshake protocol.

Implementations

impl<TTransport> DiemNetTransport<TTransport> where
    TTransport: Transport<Error = Error>,
    TTransport::Output: TSocket,
    TTransport::Outbound: Send + 'static,
    TTransport::Inbound: Send + 'static,
    TTransport::Listener: Send + 'static, 

pub fn new(
    base_transport: TTransport,
    network_context: NetworkContext,
    time_service: TimeService,
    identity_key: PrivateKey,
    auth_mode: HandshakeAuthMode,
    handshake_version: u8,
    chain_id: ChainId,
    application_protocols: ProtocolIdSet,
    enable_proxy_protocol: bool
) -> Self

pub fn dial(
    &self,
    peer_id: PeerId,
    addr: NetworkAddress
) -> Result<impl Future<Output = Result<Connection<NoiseStream<TTransport::Output>>>> + Send + 'static>

Dial a peer at addr. If the addr is not supported or formatted correctly, return Err. Otherwise, return a Future that resolves to Err if there was some issue dialing the peer and Ok with a fully upgraded connection to that peer if our dial was successful.

Dialing NetworkAddress format

We parse the dial address like:

/<base_transport> + /ln-noise-ik/<pubkey>/ln-handshake/<version>

If the base transport is MemoryTransport, then /<base_transport> is:

/memory/<port>

If the base transport is TcpTransport, then /<base_transport> is:

/ip4/<ipaddr>/tcp/<port> or /ip6/<ipaddr>/tcp/<port> or /dns/<ipaddr>/tcp/<port> or /dns4/<ipaddr>/tcp/<port> or /dns6/<ipaddr>/tcp/<port>

pub fn listen_on(
    &self,
    addr: NetworkAddress
) -> Result<(impl Stream<Item = Result<(impl Future<Output = Result<Connection<NoiseStream<TTransport::Output>>>> + Send + 'static, NetworkAddress)>> + Send + 'static, NetworkAddress)>

Listen on address addr. If the addr is not supported or formatted correctly, return Err. Otherwise, return a Stream of fully upgraded inbound connections and the dialer’s observed network address.

Listening NetworkAddress format

When listening, we only expect the base transport format. For example, if the base transport is MemoryTransport, then we expect:

/memory/<port>

If the base transport is TcpTransport, then we expect:

/ip4/<ipaddr>/tcp/<port> or /ip6/<ipaddr>/tcp/<port>

Trait Implementations

impl<TTransport: Transport> Transport for DiemNetTransport<TTransport> where
    TTransport: Transport<Error = Error> + Send + 'static,
    TTransport::Output: TSocket,
    TTransport::Outbound: Send + 'static,
    TTransport::Inbound: Send + 'static,
    TTransport::Listener: Send + 'static, 

type Output = Connection<NoiseStream<TTransport::Output>>

The result of establishing a connection.

type Error = Error

The Error type of errors which can happen while establishing a connection.

type Inbound = Pin<Box<dyn Future<Output = Result<Self::Output>> + Send + 'static>>

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

type Outbound = Pin<Box<dyn Future<Output = Result<Self::Output>> + Send + 'static>>

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

type Listener = Pin<Box<dyn Stream<Item = Result<(Self::Inbound, NetworkAddress)>> + Send + 'static>>

A stream of Inbound connections and the address of the dialer.

fn dial(&self, peer_id: PeerId, addr: NetworkAddress) -> Result<Self::Outbound>

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

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

Listens on the given NetworkAddress, returning a stream of incoming connections.