Struct Runtime 

pub struct Runtime { /* private fields */ }

Available on crate feature std only.

A cloneable, continuously driven Tokio runtime for blocking API boundaries.

Implementations

impl Runtime

pub fn try_new() -> Result<Runtime, Error>

Create a dedicated runtime with default settings.

pub fn builder() -> RuntimeBuilder

Create a RuntimeBuilder.

pub fn handle(&self) -> OwnedRuntimeHandle

Return a cloneable handle targeting this runtime and telemetry session.

pub fn flavor(&self) -> RuntimeFlavor

Return the scheduler flavor backing this runtime.

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

where F: Future,

Run future to completion, blocking the calling thread.

This directly drives the future and does not create a dial9-tracked task. Prefer block_on_task for owned work.

Panics

Panics when Tokio rejects synchronously driving the runtime, such as directly from an asynchronous task executor thread. It can be called from ordinary synchronous threads, [tokio::task::spawn_blocking], and [tokio::task::block_in_place].

pub fn block_on_task<F>(&self, future: F) -> <F as Future>::Output

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Run an owned future as a task on this runtime and block until it completes.

This is the preferred entry point for blocking boundaries. With dial9 enabled, the task is routed through the runtime’s telemetry handle so wake tracking and Rama protocol events are preserved.

Panics

Panics when Tokio rejects synchronously driving the runtime, such as directly from an asynchronous task executor thread. It can be called from ordinary synchronous threads, [tokio::task::spawn_blocking], and [tokio::task::block_in_place].

pub fn with_context<T>(&self, f: impl FnOnce() -> T) -> T

Enter this runtime while synchronously constructing a runtime-bound value.

This is primarily intended for protocol wrappers whose constructors synchronously call tokio::spawn.

Work spawned directly by the closure only has Tokio context. Use OwnedRuntimeHandle::spawn through handle for tasks that must retain dial9 tracking.

pub fn service<S>(&self, service: S) -> Service<S>

Wrap an asynchronous Rama service in a blocking boundary.

pub fn stream<S>(&self, stream: S) -> Stream<S>

where S: Stream,

Wrap an asynchronous stream as a blocking iterator.

pub fn io<T>(&self, io: T) -> Io<T>

where T: Unpin,

Wrap asynchronous I/O as blocking std::io traits.

Trait Implementations

impl Clone for Runtime

fn clone(&self) -> Runtime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Runtime

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

Formats the value using the given formatter.