Struct tor_rtcompat::tokio::TokioNativeTlsRuntime

pub struct TokioNativeTlsRuntime { /* private fields */ }

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 BlockOn for TokioNativeTlsRuntime

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

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

impl Clone for TokioNativeTlsRuntime

fn clone(&self) -> TokioNativeTlsRuntime

Returns a copy of the value.

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

Performs copy-assignment from source.

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 SleepProvider for TokioNativeTlsRuntime

type SleepFuture = <CompoundRuntime<TokioRuntimeHandle, 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 TcpProvider for TokioNativeTlsRuntime

type TcpStream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as TcpProvider>::TcpStream

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

type TcpListener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, TokioRuntimeHandle> as TcpProvider>::TcpListener

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

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

Launch a TCP connection to a given socket address.

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

Open a TCP listener on a given socket address.

impl<S> TlsProvider<S> for TokioNativeTlsRuntime where
    S: AsyncRead + AsyncWrite + Unpin + Send + 'static, 

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

The Connector object that this provider can return.

type TlsStream = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, TokioRuntimeHandle, NativeTlsProvider, 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.

impl UdpProvider for TokioNativeTlsRuntime

type UdpSocket = <CompoundRuntime<TokioRuntimeHandle, 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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Bind a local port to send and receive packets from