Struct TokioNativeTlsRuntime 

pub struct TokioNativeTlsRuntime { /* private fields */ }

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

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

Limitations

Note that Arti requires that the runtime should have working implementations for Tokio’s time, net, and io facilities, but we have no good way to check that when creating this object.

Implementations

impl TokioNativeTlsRuntime

pub fn create() -> IoResult<Self>

Create a new TokioNativeTlsRuntime.

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 TokioNativeTlsRuntime::current().

pub fn current() -> IoResult<Self>

Return a TokioNativeTlsRuntime 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 Blocking for TokioNativeTlsRuntime

type ThreadHandle<T: Send + 'static> = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as Blocking>::ThreadHandle<T>

Future from spawn_blocking

fn spawn_blocking<F, T>( &self, f: F, ) -> <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as Blocking>::ThreadHandle<T>

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

Spawn a thread for blocking IO or CPU-bound work.

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

where F: Future, F::Output: Send + 'static,

Block on a future, from within Blocking::spawn_blocking

fn blocking_io<F, T>(&self, f: F) -> impl Future<Output = T>

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

Perform some blocking IO from an async future

impl Clone for TokioNativeTlsRuntime

fn clone(&self) -> TokioNativeTlsRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CoarseTimeProvider for TokioNativeTlsRuntime

fn now_coarse(&self) -> CoarseInstant

Return the CoarseTimeProvider’s view of the current instant.

impl Debug for TokioNativeTlsRuntime

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

Formats the value using the given formatter.

impl From<Handle> for TokioNativeTlsRuntime

fn from(h: Handle) -> Self

Converts to this type from the input type.

impl NetStreamProvider for TokioNativeTlsRuntime

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

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

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

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

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

The options that can be passed to Self::connect().

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

The options that can be passed to Self::listen().

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

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

Launch a connection connection to a given socket address.

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

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

Open a listener on a given socket address.

impl NetStreamProvider<SocketAddr> for TokioNativeTlsRuntime

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

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

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

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

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

The options that can be passed to Self::connect().

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

The options that can be passed to Self::listen().

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

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

Launch a connection connection to a given socket address.

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

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

Open a listener on a given socket address.

impl SleepProvider for TokioNativeTlsRuntime

type SleepFuture = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, 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 TokioNativeTlsRuntime

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<S> TlsProvider<S> for TokioNativeTlsRuntime

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

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

The Connector object that this provider can return.

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

The type of the stream returned by that connector.

type Acceptor = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as TlsProvider<S>>::Acceptor

The Acceptor object that this provider can return, for handling incoming connections.

type TlsServerStream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as TlsProvider<S>>::TlsServerStream

The type of stream returned by that Acceptor.

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

Return a TLS connector for use with this runtime.

fn tls_acceptor(&self, settings: TlsAcceptorSettings) -> Result<Self::Acceptor>

Return a TLS acceptor for use with this runtime.

fn supports_keying_material_export(&self) -> bool

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

impl ToplevelBlockOn for TokioNativeTlsRuntime

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

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

impl UdpProvider for TokioNativeTlsRuntime

type UdpSocket = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, RealCoarseTimeProvider, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, 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