Skip to main content

lighty_event/module/
console.rs

1use serde::{Deserialize, Serialize};
2use std::time::SystemTime;
3
4/// Event emitted when a game instance is launched.
5#[derive(Debug, Clone, Serialize, Deserialize)]
6pub struct InstanceLaunchedEvent {
7    pub pid: u32,
8    pub instance_name: String,
9    pub version: String,
10    pub username: String,
11    #[serde(with = "system_time_serializer")]
12    pub timestamp: SystemTime,
13}
14
15/// Event emitted when a game instance window appears.
16#[derive(Debug, Clone, Serialize, Deserialize)]
17pub struct InstanceWindowAppearedEvent {
18    pub pid: u32,
19    pub instance_name: String,
20    pub version: String,
21    #[serde(with = "system_time_serializer")]
22    pub timestamp: SystemTime,
23}
24
25/// Event emitted when a game instance exits.
26#[derive(Debug, Clone, Serialize, Deserialize)]
27pub struct InstanceExitedEvent {
28    pub pid: u32,
29    pub instance_name: String,
30    pub exit_code: Option<i32>,
31    #[serde(with = "system_time_serializer")]
32    pub timestamp: SystemTime,
33}
34
35/// Event emitted for each line of console output.
36#[derive(Debug, Clone, Serialize, Deserialize)]
37pub struct ConsoleOutputEvent {
38    pub pid: u32,
39    pub instance_name: String,
40    pub stream: ConsoleStream,
41    pub line: String,
42    #[serde(with = "system_time_serializer")]
43    pub timestamp: SystemTime,
44}
45
46/// Event emitted when an instance is deleted.
47#[derive(Debug, Clone, Serialize, Deserialize)]
48pub struct InstanceDeletedEvent {
49    pub instance_name: String,
50    #[serde(with = "system_time_serializer")]
51    pub timestamp: SystemTime,
52}
53
54/// Console stream type.
55#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
56#[serde(rename_all = "lowercase")]
57pub enum ConsoleStream {
58    Stdout,
59    Stderr,
60}
61
62mod system_time_serializer {
63    use serde::{Deserialize, Deserializer, Serializer};
64    use std::time::{SystemTime, UNIX_EPOCH};
65
66    pub fn serialize<S>(time: &SystemTime, serializer: S) -> Result<S::Ok, S::Error>
67    where
68        S: Serializer,
69    {
70        let duration = time
71            .duration_since(UNIX_EPOCH)
72            .expect("Time went backwards");
73        serializer.serialize_u64(duration.as_secs())
74    }
75
76    pub fn deserialize<'de, D>(deserializer: D) -> Result<SystemTime, D::Error>
77    where
78        D: Deserializer<'de>,
79    {
80        let secs = u64::deserialize(deserializer)?;
81        Ok(UNIX_EPOCH + std::time::Duration::from_secs(secs))
82    }
83}