Struct NetTransport

pub struct NetTransport<I, A, S, R>
where
    I: Id,
    A: AddressResolver<ResolvedAddress = SocketAddr, Runtime = R>,
    S: StreamLayer<Runtime = R>,
    R: Runtime,
{ /* private fields */ }

The net transport based on TCP/TLS and UDP

Trait Implementations

impl<I, A, S, R> Drop for NetTransport<I, A, S, R>

where I: Id, A: AddressResolver<ResolvedAddress = SocketAddr, Runtime = R>, S: StreamLayer<Runtime = R>, R: Runtime,

fn drop(&mut self)

Executes the destructor for this type.

impl<I, A, S, R> Transport for NetTransport<I, A, S, R>

where I: Id + Data + Send + Sync + 'static, A: AddressResolver<ResolvedAddress = SocketAddr, Runtime = R>, A::Address: Data + Send + Sync + 'static, S: StreamLayer<Runtime = R>, R: Runtime,

type Error = NetTransportError<<NetTransport<I, A, S, R> as Transport>::Resolver>

The error type for the transport

type Id = I

The id type used to identify nodes

type Address = <A as AddressResolver>::Address

The address type of the node

type ResolvedAddress = SocketAddr

The resolved address type of the node

type Resolver = A

The address resolver used to resolve addresses

type Connection = <S as StreamLayer>::Stream

The promised connection used to send and receive messages

type Runtime = <<NetTransport<I, A, S, R> as Transport>::Resolver as AddressResolver>::Runtime

The async runtime

type Options = NetTransportOptions<<NetTransport<I, A, S, R> as Transport>::Id, <NetTransport<I, A, S, R> as Transport>::Resolver, S>

The options used to construct the transport

async fn new(transport_opts: Self::Options) -> Result<Self, Self::Error>

Creates a new transport with the given options

async fn resolve( &self, addr: &<Self::Resolver as AddressResolver>::Address, ) -> Result<<Self::Resolver as AddressResolver>::ResolvedAddress, Self::Error>

Resolves the given address to a resolved address

fn local_id(&self) -> &Self::Id

Returns the local id of the node

fn local_address(&self) -> &<Self::Resolver as AddressResolver>::Address

Returns the local address of the node

fn advertise_address( &self, ) -> &<Self::Resolver as AddressResolver>::ResolvedAddress

Returns the advertise address of the node

fn max_packet_size(&self) -> usize

Returns the maximum size of a packet that can be sent

fn header_overhead(&self) -> usize

Returns the header overhead in bytes this transport.

fn blocked_address( &self, addr: &<Self::Resolver as AddressResolver>::ResolvedAddress, ) -> Result<(), Self::Error>

Returns an error if the given address is blocked

async fn send_to( &self, addr: &<Self::Resolver as AddressResolver>::ResolvedAddress, packets: Payload, ) -> Result<(usize, <Self::Runtime as RuntimeLite>::Instant), Self::Error>

A packet-oriented interface that fires off the given payload to the given address in a connectionless fashion.

async fn open( &self, addr: &<Self::Resolver as AddressResolver>::ResolvedAddress, deadline: <Self::Runtime as RuntimeLite>::Instant, ) -> Result<Self::Connection, Self::Error>

Used to create a bidirection connection that allows us to perform two-way communication with a peer. This is generally more expensive than packet connections so is used for more infrequent operations such as anti-entropy or fallback probes if the packet-oriented probe failed.

fn packet( &self, ) -> PacketSubscriber<<Self::Resolver as AddressResolver>::ResolvedAddress, <Self::Runtime as RuntimeLite>::Instant>

Returns a packet subscriber that can be used to receive incoming packets

fn stream( &self, ) -> StreamSubscriber<<Self::Resolver as AddressResolver>::ResolvedAddress, Self::Connection>

Returns a receiver that can be read to handle incoming stream connections from other peers. How this is set up for listening is left as an exercise for the concrete transport implementations.

fn packet_reliable(&self) -> bool

Returns true if the transport provides provides reliable packets delivery.

fn packet_secure(&self) -> bool

Returns true if the transport provides packets security.

fn stream_secure(&self) -> bool

Returns true if the transport provides stream security.

async fn shutdown(&self) -> Result<(), Self::Error>

Shutdown the transport

fn read( &self, from: &Self::ResolvedAddress, conn: &mut <Self::Connection as Connection>::Reader, ) -> impl Future<Output = Result<usize, Self::Error>> + Send

This is a hook that allows the transport to perform any extra work when the memberlist accepts a new connection from a remote node.

fn write( &self, conn: &mut <Self::Connection as Connection>::Writer, payload: Payload, ) -> impl Future<Output = Result<usize, Self::Error>> + Send

Sends a message to the remote node by promised connection.