proc_heim/process/
process_handle.rs

1use std::fmt::Debug;
2use std::time::Duration;
3
4use crate::manager::{
5    GetLogsError, GetProcessInfoError, KillProcessError, LogsQuery, ProcessId, ProcessInfo,
6    ProcessManagerHandle, ReadMessageError, ReceiveMessageError, WriteMessageError,
7};
8
9use tokio::task::JoinHandle;
10use tokio_stream::Stream;
11
12use super::message::Message;
13
14/// `ProcessManagerHandle` wrapper used to interact with only one spawned process.
15///
16/// `ProcessHandle` mimics [`ProcessManagerHandle`] API, but does not require passing [`ProcessId`] as methods parameter.
17/// It can be created by [`ProcessManagerHandle::spawn_with_handle`] method or manually by [`ProcessHandle::new`].
18/// Like a `ProcessManagerHandle` it can be cheaply cloned and used by many threads safely.
19///
20/// See [`ProcessManagerHandle`] docs for more information.
21///
22/// If you want to kill the child process automatically on [`Drop`], then use the [`ScopedProcessHandle`](struct@crate::manager::ScopedProcessHandle).
23#[derive(Clone, Debug)]
24pub struct ProcessHandle {
25    id: ProcessId,
26    pub(crate) handle: ProcessManagerHandle,
27}
28
29impl ProcessHandle {
30    /// Creates a new `ProcessHandle` from given process identifier and manager handle.
31    pub fn new(id: ProcessId, handle: ProcessManagerHandle) -> Self {
32        Self { id, handle }
33    }
34
35    /// Returns a process identifier associated with a handle.
36    pub fn id(&self) -> &ProcessId {
37        &self.id
38    }
39
40    /// See [`ProcessManagerHandle::send_message`] docs.
41    pub async fn send_message<M>(&self, message: M) -> Result<(), WriteMessageError>
42    where
43        M: Into<Message>,
44    {
45        self.handle.send_message(self.id, message).await
46    }
47
48    /// See [`ProcessManagerHandle::subscribe_message_stream`] docs.
49    pub async fn subscribe_message_stream(
50        &self,
51    ) -> Result<impl Stream<Item = Result<Message, ReceiveMessageError>>, ReadMessageError> {
52        self.handle.subscribe_message_stream(self.id).await
53    }
54
55    /// See [`ProcessManagerHandle::get_logs_stdout`] docs.
56    pub async fn get_logs_stdout(&self, query: LogsQuery) -> Result<Vec<String>, GetLogsError> {
57        self.handle.get_logs_stdout(self.id, query).await
58    }
59
60    /// See [`ProcessManagerHandle::get_logs_stderr`] docs.
61    pub async fn get_logs_stderr(&self, query: LogsQuery) -> Result<Vec<String>, GetLogsError> {
62        self.handle.get_logs_stderr(self.id, query).await
63    }
64
65    /// See [`ProcessManagerHandle::get_process_info`] docs.
66    pub async fn get_process_info(&self) -> Result<ProcessInfo, GetProcessInfoError> {
67        self.handle.get_process_info(self.id).await
68    }
69
70    /// See [`ProcessManagerHandle::wait`] docs.
71    pub fn wait(
72        &self,
73        poll_interval: Duration,
74    ) -> JoinHandle<Result<ProcessInfo, GetProcessInfoError>> {
75        self.handle.wait(self.id, poll_interval)
76    }
77
78    /// See [`ProcessManagerHandle::kill`] docs.
79    pub async fn kill(&self) -> Result<(), KillProcessError> {
80        self.handle.kill(self.id).await
81    }
82}