Struct TokioRuntimeHandle

pub struct TokioRuntimeHandle {
    owned: Option<TokioTp>,
    handle: Handle,
}

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

Wrapper around a Handle to a tokio runtime.

Ideally, this type would go away, and we would just use tokio::runtime::Handle directly. Unfortunately, we can’t implement futures::Spawn on it ourselves because of Rust’s orphan rules, so we need to define a new type here.

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.

Fields

owned: Option<TokioTp>

If present, the tokio executor that we’ve created (and which we own).

We never access this directly; only through handle. We keep it here so that our Runtime types can be agnostic about whether they own the executor.

handle: Handle

The underlying Handle.

Implementations

impl TokioRuntimeHandle

pub(crate) fn new(handle: Handle) -> Self

Wrap a tokio runtime handle into a format that Arti can use.

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.

pub fn is_owned(&self) -> bool

Return true if this handle owns the executor that it points to.

Trait Implementations

impl Blocking for TokioRuntimeHandle

type ThreadHandle<T: Send + 'static> = BlockingHandle<T>

Future from spawn_blocking

fn spawn_blocking<F, T>(&self, f: F) -> BlockingHandle<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: Future>(&self, future: F) -> F::Output

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 TokioRuntimeHandle

fn clone(&self) -> TokioRuntimeHandle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TokioRuntimeHandle

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

Formats the value using the given formatter.

impl From<Handle> for TokioRuntimeHandle

fn from(handle: Handle) -> Self

Converts to this type from the input type.

impl From<TokioTp> for TokioRuntimeHandle

fn from(owner: TokioTp) -> TokioRuntimeHandle

Converts to this type from the input type.

impl NetStreamProvider<SocketAddr> for TokioRuntimeHandle

type Stream = UnixStream

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

type Listener = UnixListener

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 = IoResult<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 = IoResult<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 TokioRuntimeHandle

type Stream = TcpStream

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

type Listener = TcpListener

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 = IoResult<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 = IoResult<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 TokioRuntimeHandle

type SleepFuture = Sleep

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 TokioRuntimeHandle

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 ToplevelBlockOn for TokioRuntimeHandle

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

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

impl UdpProvider for TokioRuntimeHandle

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