tame-protocol 0.2.0

RillRate Agent
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use rill_protocol::flow::core::{Flow, TimedEvent};
use rill_protocol::flow::location::Location;
use rill_protocol::io::provider::StreamType;
use serde::{Deserialize, Serialize};

pub const LOCATION: Location = Location::new("system:process_monitor");

pub type Pid = u32;
pub type ExitCode = i32;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Command {
    pub command: String,
    pub args: Vec<String>,
    pub workdir: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ProcessStatus {
    NotDetected,
    Alive { pid: Option<Pid> },
    Terminated { code: Option<ExitCode> },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProcessMonitorState {
    pub command: Command,
    pub process_status: ProcessStatus,
}

#[allow(clippy::new_without_default)]
impl ProcessMonitorState {
    pub fn new(command: Command) -> Self {
        Self {
            command,
            process_status: ProcessStatus::NotDetected,
        }
    }
}

impl Flow for ProcessMonitorState {
    type Action = ProcessMonitorAction;
    type Event = ProcessMonitorEvent;

    fn stream_type() -> StreamType {
        StreamType::from("rillrate::agent::process_monitor::v0")
    }

    fn apply(&mut self, event: TimedEvent<Self::Event>) {
        match event.event {
            ProcessMonitorEvent::AssignPid { pid } => {
                self.process_status = ProcessStatus::Alive { pid };
            }
            ProcessMonitorEvent::SetExitCode { code } => {
                self.process_status = ProcessStatus::Terminated { code };
            }
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ProcessMonitorAction {
    /// This action is available for terminated processes only
    Respawn,
    /// This action is available for alive processes only
    Kill,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ProcessMonitorEvent {
    AssignPid { pid: Option<Pid> },
    SetExitCode { code: Option<ExitCode> },
}