Struct TokioExecutorService 

pub struct TokioExecutorService { /* private fields */ }

Tokio-backed service for submitted blocking tasks.

The service accepts fallible Runnable and Callable tasks, runs them through Tokio, and returns awaitable handles for their final results.

Implementations

impl TokioExecutorService

pub fn new() -> Self

Creates a new service instance.

Returns

A Tokio-backed executor service.

Trait Implementations

impl Clone for TokioExecutorService

fn clone(&self) -> TokioExecutorService

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for TokioExecutorService

fn default() -> TokioExecutorService

Returns the “default value” for a type.

impl ExecutorService for TokioExecutorService

fn submit_callable<C, R, E>( &self, task: C, ) -> Result<Self::Handle<R, E>, RejectedExecution>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Accepts a callable and runs it through Tokio.

Parameters

• task - Callable to execute on Tokio’s blocking task pool.

Returns

A TokioTaskHandle for the accepted task.

Errors

Returns RejectedExecution::Shutdown if shutdown has already been requested before the task is accepted.

fn shutdown(&self)

Stops accepting new tasks.

Already accepted tasks are allowed to finish unless they are cancelled before their blocking closure starts.

fn shutdown_now(&self) -> ShutdownReport

Stops accepting new tasks and requests abort for tracked Tokio tasks.

Tokio cannot abort blocking tasks that have already started. Such tasks continue running and keep the service active until their closure returns.

Returns

A report with zero queued tasks, the observed active task count, and the number of Tokio abort handles signalled.

fn is_shutdown(&self) -> bool

Returns whether shutdown has been requested.

fn is_terminated(&self) -> bool

Returns whether shutdown was requested and all tasks are finished.

fn await_termination(&self) -> Self::Termination<'_>

Waits until the service has terminated.

Returns

A future that resolves after shutdown has been requested and all accepted Tokio blocking tasks have finished or were cancelled before their closures started.

type Handle<R, E> = TokioTaskHandle<R, E> where R: Send + 'static, E: Send + 'static

Handle returned for an accepted task.

type Termination<'a> = Pin<Box<dyn Future<Output = ()> + Send + 'a>> where Self: 'a

Future returned when waiting for service termination.

fn submit<T, E>( &self, task: T, ) -> Result<Self::Handle<(), E>, RejectedExecution>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Submits a runnable task to this service.