Struct TokioRustlsRuntime

pub struct TokioRustlsRuntime { /* private fields */ }

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

A Runtime built around a Handle to a tokio runtime, and rustls.

Implementations

impl TokioRustlsRuntime

pub fn create() -> IoResult<Self>

Create a new TokioRustlsRuntime.

The return value will own the underlying Tokio runtime object, which will be dropped when the last copy of this handle is freed.

If you want to use a currently running runtime instead, call TokioRustlsRuntime::current().

pub fn current() -> IoResult<Self>

Return a TokioRustlsRuntime wrapping the currently running Tokio runtime.

Usage note

We should never call this from inside other Arti crates, or from library crates that want to support multiple runtimes! This function is for Arti users who want to wrap some existing Tokio runtime as a Runtime. It is not for library crates that want to work with multiple runtimes.

Once you have a runtime returned by this function, you should just create more handles to it via Clone.

Trait Implementations

impl BlockOn for TokioRustlsRuntime

fn block_on<F: Future>(&self, future: F) -> F::Output

Run future until it is ready, and return its output.

impl Clone for TokioRustlsRuntime

fn clone(&self) -> TokioRustlsRuntime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CoarseTimeProvider for TokioRustlsRuntime

fn now_coarse(&self) -> CoarseInstant

Return the CoarseTimeProvider’s view of the current instant.

impl Debug for TokioRustlsRuntime

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Handle> for TokioRustlsRuntime

fn from(h: Handle) -> Self

Converts to this type from the input type.

impl NetStreamProvider<SocketAddr> for TokioRustlsRuntime

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

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

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

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

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

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

Launch a connection connection to a given socket address.

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

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

Open a listener on a given socket address.

impl NetStreamProvider for TokioRustlsRuntime

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

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

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

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

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

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

Launch a connection connection to a given socket address.

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

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

Open a listener on a given socket address.

impl SleepProvider for TokioRustlsRuntime

type SleepFuture = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as SleepProvider>::SleepFuture

A future returned by SleepProvider::sleep()

fn sleep(&self, duration: Duration) -> Self::SleepFuture

Return a future that will be ready after duration has elapsed.

fn now(&self) -> Instant

Return the SleepProvider’s view of the current instant.

fn wallclock(&self) -> SystemTime

Return the SleepProvider’s view of the current wall-clock time.

fn block_advance<T: Into<String>>(&self, _reason: T)

Signify that a test running under mock time shouldn’t advance time yet, with a given unique reason string. This is useful for making sure (mock) time doesn’t advance while things that might require some (real-world) time to complete do so, such as spawning a task on another thread.

fn release_advance<T: Into<String>>(&self, _reason: T)

Signify that the reason to withhold time advancing provided in a call to block_advance no longer exists, and it’s fine to move time forward if nothing else is blocking advances.

fn allow_one_advance(&self, _dur: Duration)

Allow a test running under mock time to advance time by the provided duration, even if the above block_advance API has been used.

impl Spawn for TokioRustlsRuntime

fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError>

Spawns a future that will be run to completion.

fn status(&self) -> Result<(), SpawnError>

Determines whether the executor is able to spawn new tasks.

impl SpawnBlocking for TokioRustlsRuntime

type Handle<T: Send + 'static> = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as SpawnBlocking>::Handle<T>

The type of handle used to await the result of the task.

fn spawn_blocking<F, T>( &self, f: F, ) -> <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as SpawnBlocking>::Handle<T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Spawn a task on a threadpool specifically for blocking tasks.

impl<S> TlsProvider<S> for TokioRustlsRuntime

where S: AsyncRead + AsyncWrite + StreamOps + Unpin + Send + 'static,

type Connector = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as TlsProvider<S>>::Connector

The Connector object that this provider can return.

type TlsStream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as TlsProvider<S>>::TlsStream

The type of the stream returned by that connector.

fn tls_connector(&self) -> Self::Connector

Return a TLS connector for use with this runtime.

fn supports_keying_material_export(&self) -> bool

Return true iff the keying material exporters (RFC 5705) is supported.

impl UdpProvider for TokioRustlsRuntime

type UdpSocket = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, TokioRuntimeHandle> as UdpProvider>::UdpSocket

The type of Udp Socket returned by Self::bind()

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

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

Bind a local port to send and receive packets from