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#[derive(Clone, Debug)]
22pub struct ProcessHandle {
23    id: ProcessId,
24    handle: ProcessManagerHandle,
25}
26
27impl ProcessHandle {
28    /// Creates a new `ProcessHandle` from given process identifier and manager handle.
29    pub fn new(id: ProcessId, handle: ProcessManagerHandle) -> Self {
30        Self { id, handle }
31    }
32
33    /// Returns a process identifier associated with a handle.
34    pub fn id(&self) -> &ProcessId {
35        &self.id
36    }
37
38    /// See [`ProcessManagerHandle::send_message`] docs.
39    pub async fn send_message<M>(&self, message: M) -> Result<(), WriteMessageError>
40    where
41        M: Into<Message>,
42    {
43        self.handle.send_message(self.id, message).await
44    }
45
46    /// See [`ProcessManagerHandle::subscribe_message_stream`] docs.
47    pub async fn subscribe_message_stream(
48        &self,
49    ) -> Result<impl Stream<Item = Result<Message, ReceiveMessageError>>, ReadMessageError> {
50        self.handle.subscribe_message_stream(self.id).await
51    }
52
53    /// See [`ProcessManagerHandle::get_logs_stdout`] docs.
54    pub async fn get_logs_stdout(&self, query: LogsQuery) -> Result<Vec<String>, GetLogsError> {
55        self.handle.get_logs_stdout(self.id, query).await
56    }
57
58    /// See [`ProcessManagerHandle::get_logs_stderr`] docs.
59    pub async fn get_logs_stderr(&self, query: LogsQuery) -> Result<Vec<String>, GetLogsError> {
60        self.handle.get_logs_stderr(self.id, query).await
61    }
62
63    /// See [`ProcessManagerHandle::get_process_info`] docs.
64    pub async fn get_process_info(&self) -> Result<ProcessInfo, GetProcessInfoError> {
65        self.handle.get_process_info(self.id).await
66    }
67
68    /// See [`ProcessManagerHandle::wait`] docs.
69    pub fn wait(
70        &self,
71        poll_interval: Duration,
72    ) -> JoinHandle<Result<ProcessInfo, GetProcessInfoError>> {
73        self.handle.wait(self.id, poll_interval)
74    }
75
76    /// See [`ProcessManagerHandle::kill`] docs.
77    pub async fn kill(&self) -> Result<(), KillProcessError> {
78        self.handle.kill(self.id).await
79    }
80}