Struct tokio_util::context::TokioContext

pub struct TokioContext<F> { /* fields omitted */ }

This is supported on crate feature rt only.

TokioContext allows running futures that must be inside Tokio’s context on a non-Tokio runtime.

It contains a Handle to the runtime. A handle to the runtime can be obtain by calling the Runtime::handle() method.

Note that the TokioContext wrapper only works if the Runtime it is connected to has not yet been destroyed. You must keep the Runtime alive until the future has finished executing.

Warning: If TokioContext is used together with a current thread runtime, that runtime must be inside a call to block_on for the wrapped future to work. For this reason, it is recommended to use a multi thread runtime, even if you configure it to only spawn one worker thread.

Examples

This example creates two runtimes, but only enables time on one of them. It then uses the context of the runtime with the timer enabled to execute a sleep future on the runtime with timing disabled.

use tokio::time::{sleep, Duration};
use tokio_util::context::RuntimeExt;

// This runtime has timers enabled.
let rt = tokio::runtime::Builder::new_multi_thread()
    .enable_all()
    .build()
    .unwrap();

// This runtime has timers disabled.
let rt2 = tokio::runtime::Builder::new_multi_thread()
    .build()
    .unwrap();

// Wrap the sleep future in the context of rt.
let fut = rt.wrap(async { sleep(Duration::from_millis(2)).await });

// Execute the future on rt2.
rt2.block_on(fut);

Implementations

impl<F> TokioContext<F>

pub fn new(future: F, handle: Handle) -> TokioContext<F>

Associate the provided future with the context of the runtime behind the provided Handle.

This constructor uses a 'static lifetime to opt-out of checking that the runtime still exists.

Examples

This is the same as the example above, but uses the new constructor rather than RuntimeExt::wrap.

use tokio::time::{sleep, Duration};
use tokio_util::context::TokioContext;

// This runtime has timers enabled.
let rt = tokio::runtime::Builder::new_multi_thread()
    .enable_all()
    .build()
    .unwrap();

// This runtime has timers disabled.
let rt2 = tokio::runtime::Builder::new_multi_thread()
    .build()
    .unwrap();

let fut = TokioContext::new(
    async { sleep(Duration::from_millis(2)).await },
    rt.handle().clone(),
);

// Execute the future on rt2.
rt2.block_on(fut);

pub fn handle(&self) -> &Handle

Obtain a reference to the handle inside this TokioContext.

pub fn into_inner(self) -> F

Remove the association between the Tokio runtime and the wrapped future.

Trait Implementations

impl<F: Future> Future for TokioContext<F>

type Output = F::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'__pin, F> Unpin for TokioContext<F> where
    __Origin<'__pin, F>: Unpin,