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() -> TokioExecutorService

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<<TokioExecutorService as ExecutorService>::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, ) -> <TokioExecutorService as ExecutorService>::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: Send + 'static, E: Send + 'static> = TokioTaskHandle<R, E>

Handle returned for an accepted task.

type Termination<'a> = Pin<Box<dyn Future<Output = ()> + Send + 'a>> where TokioExecutorService: '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.