Trait Spawn 

pub trait Spawn<E: ?Sized> {
    type Error;

    // Required method
    fn spawn<'life0, 'life1, 'async_trait>(
        &'life0 self,
        env: &'life1 mut E,
    ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'static, ExitStatus>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}

A trait for spawning commands.

Spawning a command is separated into two distinct parts: a future that requires a mutable environment to make progress, and a future which no longer needs any context and can make progress on its own.

This distinction allows a caller to drop an environment as soon as it is no longer needed, which will free up resources, and especially important in preventing deadlocks between pipelines (since the parent process will contain extra reader/writer ends of a pipe and may prevent processes from exiting).

Required Associated Types

type Error

The type of error that can arise if there is an error during spawning.

Required Methods

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'static, ExitStatus>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Spawn the command as a future which returns another future.

The first, or “outer” future returned is allowed to maintain references to both the type being spawned, and the environment itself. Once the command no longer needs a reference to the environment or any other data, it should return a second future which represents the final result of the command.

This separation allows the caller (or poller) to drop the environment as son as it is no longer needed, which will free up resources, and especially important in preventing deadlocks between pipelines (since the parent process will contain extra reader/writer ends of a pipe and may prevent processes from exiting).

Although the implementation is free to make any optimizations or pre-computations, there should be no observable side-effects until the very first call to poll or .await on the future. That way a constructed future that was never polled could be dropped without the risk of unintended side effects.

Implementations on Foreign Types

impl<'a, T, E> Spawn<E> for &'a T

where T: ?Sized + Spawn<E>, E: ?Sized,

type Error = <T as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<N, S, C, F, E> Spawn<E> for PipeableCommand<N, S, C, Arc<F>>

where S: Spawn<E>, C: Spawn<E, Error = S::Error>, N: Sync + Clone, F: Spawn<E, Error = S::Error> + Send + Sync + 'static, E: ?Sized + Send + FunctionEnvironment, E::FnName: From<N>, E::Fn: From<Arc<dyn Spawn<E, Error = S::Error> + Send + Sync>>,

type Error = <S as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<S, E> Spawn<E> for ListableCommand<S>

where S: Send + Sync + Spawn<E>, S::Error: From<Error> + IsFatalError, E: ?Sized + Send + Sync + FileDescEnvironment + FileDescOpener + ReportErrorEnvironment + SubEnvironment, E::FileHandle: From<E::OpenedFileHandle>, E::OpenedFileHandle: Send,

type Error = <S as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<S, R, E> Spawn<E> for CompoundCommand<S, R>

where S: Send + Sync + Spawn<E>, S::Error: From<RedirectionError> + From<R::Error>, R: Send + Sync + RedirectEval<E, Handle = E::FileHandle>, E: ?Sized + Sync + Send + AsyncIoEnvironment + ExportedVariableEnvironment + FileDescEnvironment + FileDescOpener + UnsetVariableEnvironment, E::FileHandle: Clone + Send + From<E::OpenedFileHandle>, E::IoHandle: Send + From<E::FileHandle>, E::VarName: Send + Clone, E::Var: Send + Clone,

type Error = <S as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'static, ExitStatus>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T, E> Spawn<E> for Command<T>

where T: Spawn<E>, T::Error: From<RuntimeError>, E: Send + ?Sized + LastStatusEnvironment,

type Error = <T as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T, E> Spawn<E> for Box<T>

where T: ?Sized + Spawn<E>, E: ?Sized,

type Error = <T as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T, E> Spawn<E> for Arc<T>

where T: ?Sized + Spawn<E>, E: ?Sized,

type Error = <T as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T, E> Spawn<E> for AndOrList<T>

where T: Sync + Spawn<E>, T::Error: IsFatalError, E: Send + ?Sized + LastStatusEnvironment + ReportErrorEnvironment,

type Error = <T as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T, E> Spawn<E> for AtomicTopLevelCommand<T>

where T: 'static + StringWrapper + Display + Send + Sync, E: ?Sized + Send + Sync + AsyncIoEnvironment + ArgumentsEnvironment<Arg = T> + BuiltinEnvironment<BuiltinName = <E as FunctionEnvironment>::FnName> + ExecutableEnvironment + ExportedVariableEnvironment<VarName = T, Var = T> + FileDescEnvironment + FileDescOpener + FunctionEnvironment + FunctionFrameEnvironment + IsInteractiveEnvironment + LastStatusEnvironment + ReportErrorEnvironment + SetArgumentsEnvironment + SubEnvironment + UnsetVariableEnvironment + WorkingDirectoryEnvironment, E::Args: Send + From<VecDeque<E::Arg>>, for<'a> E::Builtin: Send + Sync + BuiltinUtility<'a, Vec<T>, EnvRestorer<'a, E>, E>, E::FileHandle: Send + Sync + Clone + FileDescWrapper + From<E::OpenedFileHandle>, E::OpenedFileHandle: Send, E::FnName: Send + Sync + From<T>, E::Fn: Send + Sync + Clone + From<Arc<dyn Spawn<E, Error = RuntimeError> + Send + Sync + 'static>> + Spawn<E, Error = RuntimeError>, E::IoHandle: Send + Sync + From<E::FileHandle> + From<E::OpenedFileHandle>,

type Error = RuntimeError

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> BoxFuture<'async_trait, Result<BoxFuture<'static, ExitStatus>, Self::Error>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<V, W, R, E> Spawn<E> for SimpleCommand<V, W, R>

where R: Send + Sync + RedirectEval<E, Handle = E::FileHandle>, R::Error: 'static + Send + Sync + Error + From<RedirectionError>, V: Send + Sync + Clone, W: Send + Sync + WordEval<E>, W::EvalResult: Send, W::Error: 'static + Send + Sync + Error, E: ?Sized + Send + Sync + AsyncIoEnvironment + BuiltinEnvironment<BuiltinName = <E as FunctionEnvironment>::FnName> + ExecutableEnvironment + ExportedVariableEnvironment + FileDescEnvironment + FileDescOpener + FunctionEnvironment + FunctionFrameEnvironment + SetArgumentsEnvironment + UnsetVariableEnvironment + WorkingDirectoryEnvironment, E::Arg: Send + From<W::EvalResult>, E::Args: Send + From<VecDeque<E::Arg>>, for<'a> E::Builtin: Send + Sync + BuiltinUtility<'a, Vec<W::EvalResult>, EnvRestorer<'a, E>, E>, E::FileHandle: Send + Sync + Clone + FileDescWrapper + From<E::OpenedFileHandle>, E::FnName: Send + Sync + From<W::EvalResult>, E::Fn: Send + Sync + Clone + Spawn<E>, <E::Fn as Spawn<E>>::Error: From<CommandError> + From<RedirectionError> + From<R::Error> + From<W::Error>, E::IoHandle: Send + Sync + From<E::FileHandle>, E::VarName: Send + Sync + Clone + Borrow<String> + From<V>, E::Var: Send + Sync + Clone + Borrow<String> + From<W::EvalResult>,

type Error = <<E as FunctionEnvironment>::Fn as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'static, ExitStatus>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<V, W, S, E> Spawn<E> for CompoundCommandKind<V, W, S>

where V: Send + Sync + Clone, W: Sync + WordEval<E>, W::Error: Send + IsFatalError, S: Send + Sync + Spawn<E>, S::Error: From<W::Error> + IsFatalError, E: ?Sized + Send + Sync + ArgumentsEnvironment + LastStatusEnvironment + ReportErrorEnvironment + SubEnvironment + VariableEnvironment, E::Var: Send + From<E::Arg> + From<W::EvalResult>, E::VarName: Send + Clone + From<V>,

type Error = <S as Spawn<E>>::Error

fn spawn<'life0, 'life1, 'async_trait>( &'life0 self, env: &'life1 mut E, ) -> Pin<Box<dyn Future<Output = Result<BoxFuture<'static, ExitStatus>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Implementors

impl<'a, S, E> Spawn<E> for SequenceSlice<'a, S>

where S: Send + Sync + Spawn<E>, S::Error: IsFatalError, E: ?Sized + Send + LastStatusEnvironment + ReportErrorEnvironment,

type Error = <S as Spawn<E>>::Error