grapl_graph_descriptions_py/
process_node.rs

1use grapl_graph_descriptions::graph_description::Process as InnerProcess;
2use grapl_graph_descriptions::graph_description::ProcessBuilder;
3
4use pyo3::create_exception;
5use pyo3::prelude::*;
6
7create_exception!(process_node, ProcessBuilderError, pyo3::exceptions::ValueError);
8
9#[pyclass]
10#[derive(Clone)]
11pub struct ProcessNode {
12    pub(crate) inner_node: InnerProcess,
13}
14
15impl<'source> pyo3::FromPyObject<'source> for ProcessNode {
16    fn extract(ob: &'source pyo3::types::PyAny) -> pyo3::PyResult<Self> {
17        Ok(
18            pyo3::PyTryFrom::try_from(ob).map(|x: &Self| x.clone())?
19        )
20    }
21}
22
23#[pyclass]
24#[derive(Clone, Default)]
25pub struct ProcessNodeBuilder {
26    builder: ProcessBuilder,
27}
28
29#[pymethods]
30impl ProcessNodeBuilder {
31    #[new]
32    fn new(
33        obj: &PyRawObject,
34    ) {
35        obj.init(
36            Self::default()
37        )
38    }
39
40    pub fn with_asset_id(&mut self, asset_id: Option<String>) -> Self {
41        self.builder.asset_id(asset_id);
42        self.clone()
43    }
44
45    pub fn with_hostname(&mut self, hostname: Option<String>) -> Self {
46        self.builder.hostname(hostname);
47        self.clone()
48    }
49
50    pub fn with_state(&mut self, state: u32) -> Self {
51        self.builder.state(state);
52
53        self.clone()
54    }
55
56    pub fn with_process_id(&mut self, process_id: u64) -> Self {
57        self.builder.process_id(process_id);
58        self.clone()
59    }
60
61    pub fn with_created_timestamp_ms(&mut self, timestamp: u64) -> Self {
62        self.builder.created_timestamp(timestamp);
63        self.clone()
64    }
65
66    pub fn with_last_seen_timestamp_ms(&mut self, timestamp: u64) -> Self {
67        self.builder.last_seen_timestamp(timestamp);
68        self.clone()
69    }
70
71    pub fn with_terminated_timestamp_ms(&mut self, timestamp: u64) -> Self {
72        self.builder.terminated_timestamp(timestamp);
73        self.clone()
74    }
75
76    pub fn with_process_name(&mut self, process_name: Option<String>) -> Self {
77        self.builder.process_name(process_name.unwrap_or_default());
78        self.clone()
79    }
80
81    pub fn with_operating_system(&mut self, operating_system: Option<String>) -> Self {
82        self.builder.operating_system(operating_system.unwrap_or_default());
83        self.clone()
84    }
85
86    pub fn with_process_command_line(&mut self, process_command_line: Option<String>) -> Self {
87        self.builder.process_command_line(process_command_line.unwrap_or_default());
88        self.clone()
89    }
90
91    pub fn with_process_guid(&mut self, process_guid: Option<String>) -> Self {
92        self.builder.process_guid(process_guid.unwrap_or_default());
93        self.clone()
94    }
95
96    pub fn build(&self) -> PyResult<ProcessNode> {
97
98        let built_node = match self.builder.build() {
99            Ok(built_node) => built_node,
100            Err(e) => {
101                return Err(
102                    PyErr::new::<ProcessBuilderError, _>(format!("{}", e))
103                )
104            }
105        };
106
107        Ok(
108            ProcessNode {
109                inner_node: built_node
110            }
111        )
112    }
113}