Trait NetStreamProvider

pub trait NetStreamProvider<ADDR = SocketAddr>:
    Clone
    + Send
    + Sync
    + 'static {
    type Stream: AsyncRead + AsyncWrite + StreamOps + Send + Sync + Unpin + 'static;
    type Listener: NetStreamListener<ADDR, Stream = Self::Stream> + Send + Sync + Unpin + 'static;

    // Required methods
    fn connect<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 ADDR,
    ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn listen<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 ADDR,
    ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}

Trait for a runtime that can create and accept connections over network sockets.

(In Arti we use the [AsyncRead] and [AsyncWrite] traits from [futures::io] as more standard, even though the ones from Tokio can be a bit more efficient. Let’s hope that they converge in the future.)

Required Associated Types

type Stream: AsyncRead + AsyncWrite + StreamOps + Send + Sync + Unpin + 'static

The type for the connections returned by Self::connect().

type Listener: NetStreamListener<ADDR, Stream = Self::Stream> + Send + Sync + Unpin + 'static

The type for the listeners returned by Self::listen().

Required Methods

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 ADDR, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Launch a connection connection to a given socket address.

Note that unlike std::net:TcpStream::connect, we do not accept any types other than a single ADDR. We do this because we must be absolutely sure not to perform unnecessary DNS lookups.

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 ADDR, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open a listener on a given socket address.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl NetStreamProvider for AsyncStd

Available on (crate features native-tls or rustls) and (crate features async-std or tokio) and crate feature async-std only.

type Stream = TcpStream

type Listener = TcpListener

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl NetStreamProvider<SocketAddr> for AsyncStd

Available on (crate features native-tls or rustls) and (crate features async-std or tokio) and crate feature async-std only.

type Stream = UnixStream

type Listener = UnixListener

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Stream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn listen<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 SocketAddr, ) -> Pin<Box<dyn Future<Output = IoResult<Self::Listener>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Implementors

impl NetStreamProvider for AsyncStdNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature async-std only.

type Stream = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, NativeTlsProvider, AsyncStd> as NetStreamProvider>::Stream

type Listener = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, NativeTlsProvider, AsyncStd> as NetStreamProvider>::Listener

impl NetStreamProvider for AsyncStdRustlsRuntime

Available on (crate features native-tls or rustls) and crate feature async-std only.

type Stream = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, RustlsProvider, AsyncStd> as NetStreamProvider>::Stream

type Listener = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, RustlsProvider, AsyncStd> as NetStreamProvider>::Listener

impl NetStreamProvider for PreferredRuntime

type Stream = <TokioNativeTlsRuntime as NetStreamProvider>::Stream

type Listener = <TokioNativeTlsRuntime as NetStreamProvider>::Listener

impl NetStreamProvider for TokioNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type Stream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider>::Stream

type Listener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider>::Listener

impl NetStreamProvider for TokioRustlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type Stream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as NetStreamProvider>::Stream

type Listener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as NetStreamProvider>::Listener

impl NetStreamProvider<SocketAddr> for AsyncStdNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature async-std only.

type Stream = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, NativeTlsProvider, AsyncStd> as NetStreamProvider<SocketAddr>>::Stream

type Listener = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, NativeTlsProvider, AsyncStd> as NetStreamProvider<SocketAddr>>::Listener

impl NetStreamProvider<SocketAddr> for AsyncStdRustlsRuntime

Available on (crate features native-tls or rustls) and crate feature async-std only.

type Stream = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, RustlsProvider, AsyncStd> as NetStreamProvider<SocketAddr>>::Stream

type Listener = <CompoundRuntime<AsyncStd, AsyncStd, RealCoarseTimeProvider, AsyncStd, AsyncStd, RustlsProvider, AsyncStd> as NetStreamProvider<SocketAddr>>::Listener

impl NetStreamProvider<SocketAddr> for PreferredRuntime

type Stream = <TokioNativeTlsRuntime as NetStreamProvider<SocketAddr>>::Stream

type Listener = <TokioNativeTlsRuntime as NetStreamProvider<SocketAddr>>::Listener

impl NetStreamProvider<SocketAddr> for TokioNativeTlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type Stream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider<SocketAddr>>::Stream

type Listener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as NetStreamProvider<SocketAddr>>::Listener

impl NetStreamProvider<SocketAddr> for TokioRustlsRuntime

Available on (crate features native-tls or rustls) and crate feature tokio only.

type Stream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as NetStreamProvider<SocketAddr>>::Stream

type Listener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as NetStreamProvider<SocketAddr>>::Listener

impl<T> NetStreamProvider<SocketAddr> for T

where T: NetStreamProvider<SocketAddr> + NetStreamProvider<SocketAddr>,

type Stream = Stream

type Listener = Listener

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> NetStreamProvider for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where TcpR: NetStreamProvider<SocketAddr> + Send + Sync + 'static, TaskR: Send + Sync + 'static, SleepR: Send + Sync + 'static, CoarseTimeR: Send + Sync + 'static, UnixR: Clone + Send + Sync + 'static, TlsR: Send + Sync + 'static, UdpR: Send + Sync + 'static,

type Stream = <TcpR as NetStreamProvider>::Stream

type Listener = <TcpR as NetStreamProvider>::Listener

impl<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR> NetStreamProvider<SocketAddr> for CompoundRuntime<TaskR, SleepR, CoarseTimeR, TcpR, UnixR, TlsR, UdpR>

where UnixR: NetStreamProvider<SocketAddr> + Clone + Send + Sync + 'static, TaskR: Send + Sync + 'static, SleepR: Send + Sync + 'static, CoarseTimeR: Send + Sync + 'static, TcpR: Send + Sync + 'static, TlsR: Send + Sync + 'static, UdpR: Send + Sync + 'static,

type Stream = <UnixR as NetStreamProvider<SocketAddr>>::Stream

type Listener = <UnixR as NetStreamProvider<SocketAddr>>::Listener

impl<R: NetStreamProvider + Send + Sync> NetStreamProvider for Counting<R>

impl<R: NetStreamProvider + SleepProvider> NetStreamProvider for BrokenTcpProvider<R>

impl NetStreamProvider for MockNetProvider

impl NetStreamProvider for MockRuntime

impl NetStreamProvider<SocketAddr> for MockRuntime

impl<R: Runtime> NetStreamProvider for MockNetRuntime<R>

impl<R: Runtime> NetStreamProvider for MockSleepRuntime<R>

impl<R: Runtime> NetStreamProvider<SocketAddr> for MockNetRuntime<R>

impl<R: Runtime> NetStreamProvider<SocketAddr> for MockSleepRuntime<R>