Struct tor_rtcompat::PreferredRuntime

pub struct PreferredRuntime { /* private fields */ }

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

The runtime that we prefer to use, out of all the runtimes compiled into the tor-rtcompat crate.

If tokio and async-std are both available, we prefer tokio for its performance. If native_tls and rustls are both available, we prefer native_tls since it has been used in Arti for longer.

Implementations

impl PreferredRuntime

pub fn current() -> Result<Self>

Obtain a PreferredRuntime from the currently running asynchronous runtime. Generally, this is what you want.

This tries to get a handle to a currently running asynchronous runtime, and wraps it; the returned PreferredRuntime isn’t the same thing as the asynchronous runtime object itself (e.g. tokio::runtime::Runtime).

Panics

When tor-rtcompat is compiled with the tokio feature enabled (regardless of whether the async-std feature is also enabled), panics if called outside of Tokio runtime context. See tokio::runtime::Handle::current.

Usage notes

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

Limitations

If the tor-rtcompat crate was compiled with tokio support, this function will never return a runtime based on async_std.

pub fn create() -> Result<Self>

Create and return a new instance of the default Runtime.

Generally you should call this function at most once, and then use Clone::clone() to create additional references to that runtime.

Tokio users may want to avoid this function and instead obtain a runtime using PreferredRuntime::current: this function always builds a runtime, and if you already have a runtime, that isn’t what you want with Tokio.

If you need more fine-grained control over a runtime, you can create it using an appropriate builder type or function.

Trait Implementations

impl BlockOn for PreferredRuntime

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

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

impl Clone for PreferredRuntime

fn clone(&self) -> PreferredRuntime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PreferredRuntime

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

Formats the value using the given formatter.

impl SleepProvider for PreferredRuntime

type SleepFuture = <TokioNativeTlsRuntime 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 PreferredRuntime

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 PreferredRuntime

type TcpStream = <TokioNativeTlsRuntime as TcpProvider>::TcpStream

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

type TcpListener = <TokioNativeTlsRuntime 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 PreferredRuntimewhere
    S: AsyncRead + AsyncWrite + Unpin + Send + 'static,

type Connector = <TokioNativeTlsRuntime as TlsProvider<S>>::Connector

The Connector object that this provider can return.

type TlsStream = <TokioNativeTlsRuntime 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 PreferredRuntime

type UdpSocket = <TokioNativeTlsRuntime 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