Enum spirit_tokio::runtime::Tokio

#[non_exhaustive]
pub enum Tokio<O, C> {
    Default,
    SingleThreaded,
    Custom(Box<dyn FnMut(&O, &Arc<C>) -> Result<Runtime, AnyError> + Send>),
    FromCfg(Box<dyn FnMut(&O, &C) -> Config + Send>, Box<dyn FnMut(Builder) -> Result<Runtime, AnyError> + Send>),
}

A spirit Extension to inject a tokio runtime.

This, when inserted into spirit Builder with the with_singleton will provide the application with a tokio runtime.

This will:

• Run the application body inside the runtime (to allow spawning tasks and creating tokio resources).
• Run the configuration/termination/signal hooks inside the async context of the runtime (for similar reasons).
• Keep the runtime running until terminate is invoked (either explicitly or by CTRL+C or similar).

A default instance (Tokio::Default) is inserted by pipelines containing the FutureInstaller.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Default

Provides the equivalent of Runtime::new.

SingleThreaded

A singlethreaded runtime.

Custom(Box<dyn FnMut(&O, &Arc<C>) -> Result<Runtime, AnyError> + Send>)

Allows the caller to provide arbitrary constructor for the Runtime.

This variant also allows creating the basic (non-threaded) scheduler if needed. Note that some operations with such runtime are prone to cause deadlocks.

Tuple Fields of Custom

0: Box<dyn FnMut(&O, &Arc<C>) -> Result<Runtime, AnyError> + Send>

FromCfg(Box<dyn FnMut(&O, &C) -> Config + Send>, Box<dyn FnMut(Builder) -> Result<Runtime, AnyError> + Send>)

Uses configuration for constructing the Runtime.

This’ll use the extractor (the first closure) to get a Config, create a Builder based on that. It’ll explicitly enable all the drivers and enable threaded runtime. Then it calls the postprocessor (the second closure) to turn it into the Runtime.

This is the more general form. If you’re fine with just basing it on the configuration without much tweaking, you can use Tokio::from_cfg (which will create this variant with reasonable value of preprocessor).

This is available only with the [rt-from-cfg] feature enabled.

Tuple Fields of FromCfg

0: Box<dyn FnMut(&O, &C) -> Config + Send>1: Box<dyn FnMut(Builder) -> Result<Runtime, AnyError> + Send>

Implementations

impl<O, C> Tokio<O, C>

pub fn from_cfg<E>(extractor: E) -> Self where
    E: FnMut(&C) -> Config + Send + 'static, 

Simplified construction from configuration.

This is similar to Tokio::FromCfg. However, the extractor takes only the configuration structure, not the command line options. Furthermore, post-processing is simply calling Builder::build, without a chance to tweak.

pub fn create(&mut self, opts: &O, cfg: &Arc<C>) -> Result<Runtime, AnyError>

Method to create the runtime.

This can be used when not taking advantage of the spirit auto-management features.

Trait Implementations

impl<O, C> Default for Tokio<O, C>

fn default() -> Self

Returns the “default value” for a type.

impl<E> Extension<E> for Tokio<E::Opts, E::Config> where
    E: Extensible<Ok = E>,
    E::Config: DeserializeOwned + Send + Sync + 'static,
    E::Opts: StructOpt + Send + Sync + 'static, 

fn apply(self, ext: E) -> Result<E, AnyError>

Perform the transformation on the given extensible.