Struct tor_rtcompat::tokio::TokioRustlsRuntime

pub struct TokioRustlsRuntime { /* private fields */ }

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

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

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

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

type TcpListener = <CompoundRuntime<TokioRuntimeHandle, TokioRuntimeHandle, TokioRuntimeHandle, RustlsProvider, 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 TokioRustlsRuntime where
    S: AsyncRead + AsyncWrite + Unpin + Send + 'static, 

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

The Connector object that this provider can return.

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

impl UdpProvider for TokioRustlsRuntime

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

Bind a local port to send and receive packets from