[−][src]Struct tokio::net::process::Child
Representation of a child process spawned onto an event loop.
This type is also a future which will yield the ExitStatus
of the
underlying child process. A Child
here also provides access to information
like the OS-assigned identifier and the stdio streams.
Note: The behavior of
drop
on a child in this crate is different than the behavior of the standard library. If atokio_net::process::Child
is dropped before the process finishes then the process will be terminated. In the standard library, however, the process continues executing. This is done because futures in general takedrop
as a sign of cancellation, and thisChild
is itself a future. If you'd like to run a process in the background, though, you may use theforget
method.
Methods
impl Child
[src]
pub fn id(&self) -> u32
[src]
Returns the OS-assigned process identifier associated with this child.
pub fn kill(&mut self) -> Result<(), Error>
[src]
Forces the child to exit.
This is equivalent to sending a SIGKILL on unix platforms.
pub fn stdin(&mut self) -> &mut Option<ChildStdin>
[src]
Returns a handle for writing to the child's stdin, if it has been captured.
pub fn stdout(&mut self) -> &mut Option<ChildStdout>
[src]
Returns a handle for reading from the child's stdout, if it has been captured.
pub fn stderr(&mut self) -> &mut Option<ChildStderr>
[src]
Returns a handle for reading from the child's stderr, if it has been captured.
pub fn wait_with_output(
__arg0: Self
) -> impl Future<Output = Result<Output, Error>>
[src]
__arg0: Self
) -> impl Future<Output = Result<Output, Error>>
Returns a future that will resolve to an Output
, containing the exit
status, stdout, and stderr of the child process.
The returned future will simultaneously waits for the child to exit and
collect all remaining output on the stdout/stderr handles, returning an
Output
instance.
The stdin handle to the child process, if any, will be closed before waiting. This helps avoid deadlock: it ensures that the child does not block waiting for input from the parent, while the parent waits for the child to exit.
By default, stdin, stdout and stderr are inherited from the parent. In
order to capture the output into this Output
it is necessary to create
new pipes between parent and child. Use stdout(Stdio::piped())
or
stderr(Stdio::piped())
, respectively, when creating a Command
.
pub fn forget(self)
[src]
Drop this Child
without killing the underlying process.
Normally a Child
is killed if it's still alive when dropped, but this
method will ensure that the child may continue running once the Child
instance is dropped.
Note: this method may leak OS resources depending on your platform. To ensure resources are eventually cleaned up, consider sending the
Child
instance into an event loop as an alternative to this method.
let child = Command::new("echo").arg("hello").arg("world") .spawn() .expect("failed to spawn"); tokio::spawn(async { let _ = child.await; });
Trait Implementations
impl Future for Child
[src]
type Output = Result<ExitStatus, Error>
The type of value produced on completion.
fn poll(
self: Pin<&mut Child>,
cx: &mut Context
) -> Poll<<Child as Future>::Output>
[src]
self: Pin<&mut Child>,
cx: &mut Context
) -> Poll<<Child as Future>::Output>
impl Debug for Child
[src]
Auto Trait Implementations
impl Send for Child
impl Unpin for Child
impl Sync for Child
impl !UnwindSafe for Child
impl !RefUnwindSafe for Child
Blanket Implementations
impl<T> FutureExt for T where
T: Future + ?Sized,
[src]
T: Future + ?Sized,
ⓘImportant traits for Timeout<T>fn timeout(self, timeout: Duration) -> Timeout<Self> where
Self: Sized,
[src]
Self: Sized,
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Ffn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized,
[src]
F: Future<Output = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
fn try_poll(self: Pin<&mut F>, cx: &mut Context) -> Poll<<F as Future>::Output>
[src]
impl<T> FutureExt for T where
T: Future + ?Sized,
[src]
T: Future + ?Sized,
ⓘImportant traits for Map<Fut, F>fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,
[src]
F: FnOnce(Self::Output) -> U,
ⓘImportant traits for Then<Fut1, Fut2, F>fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
[src]
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
ⓘImportant traits for Either<A, B>fn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,
[src]
B: Future<Output = Self::Output>,
ⓘImportant traits for Either<A, B>fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,
[src]
A: Future<Output = Self::Output>,
fn into_stream(self) -> IntoStream<Self>
[src]
ⓘImportant traits for Flatten<Fut>fn flatten(self) -> Flatten<Self> where
Self::Output: Future,
[src]
Self::Output: Future,
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
[src]
Self::Output: Stream,
ⓘImportant traits for Fuse<Fut>fn fuse(self) -> Fuse<Self>
[src]
ⓘImportant traits for Inspect<Fut, F>fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),
[src]
F: FnOnce(&Self::Output),
ⓘImportant traits for CatchUnwind<Fut>fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
ⓘImportant traits for Shared<Fut>fn shared(self) -> Shared<Self> where
Self::Output: Clone,
[src]
Self::Output: Clone,
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)
[src]
ⓘImportant traits for Pin<P>fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send>> where
Self: Send + 'a,
[src]
Self: Send + 'a,
ⓘImportant traits for Pin<P>fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> where
Self: 'a,
[src]
Self: 'a,
ⓘImportant traits for UnitError<Fut>fn unit_error(self) -> UnitError<Self>
[src]
ⓘImportant traits for NeverError<Fut>fn never_error(self) -> NeverError<Self>
[src]
fn poll_unpin(&mut self, cx: &mut Context) -> Poll<Self::Output> where
Self: Unpin,
[src]
Self: Unpin,
fn now_or_never(self) -> Option<Self::Output>
[src]
impl<Fut> TryFutureExt for Fut where
Fut: TryFuture + ?Sized,
[src]
Fut: TryFuture + ?Sized,
fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok> where
Self::Ok: Sink<Item>,
<Self::Ok as Sink<Item>>::Error == Self::Error,
[src]
Self::Ok: Sink<Item>,
<Self::Ok as Sink<Item>>::Error == Self::Error,
ⓘImportant traits for MapOk<Fut, F>fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnOnce(Self::Ok) -> T,
[src]
F: FnOnce(Self::Ok) -> T,
ⓘImportant traits for MapErr<Fut, F>fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnOnce(Self::Error) -> E,
[src]
F: FnOnce(Self::Error) -> E,
ⓘImportant traits for ErrInto<Fut, E>fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
[src]
Self::Error: Into<E>,
ⓘImportant traits for AndThen<Fut1, Fut2, F>fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
[src]
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
ⓘImportant traits for OrElse<Fut1, Fut2, F>fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
[src]
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
ⓘImportant traits for InspectOk<Fut, F>fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnOnce(&Self::Ok),
[src]
F: FnOnce(&Self::Ok),
ⓘImportant traits for InspectErr<Fut, F>fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnOnce(&Self::Error),
[src]
F: FnOnce(&Self::Error),
fn try_flatten_stream(self) -> TryFlattenStream<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,
[src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,
ⓘImportant traits for UnwrapOrElse<Fut, F>fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> where
F: FnOnce(Self::Error) -> Self::Ok,
[src]
F: FnOnce(Self::Error) -> Self::Ok,
ⓘImportant traits for IntoFuture<Fut>fn into_future(self) -> IntoFuture<Self>
[src]
fn try_poll_unpin(
&mut self,
cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: Unpin,
[src]
&mut self,
cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: Unpin,