1use std::time::{Duration, SystemTime, UNIX_EPOCH};
4
5use serde::{Deserialize, Deserializer, Serialize};
6use serde_json::{Map, Value};
7
8pub const INPUT_TYPE_GELF_UDP: &str = "org.graylog2.inputs.gelf.udp.GELFUDPInput";
10pub const INPUT_TYPE_GELF_TCP: &str = "org.graylog2.inputs.gelf.tcp.GELFTCPInput";
12pub const INPUT_TYPE_GELF_HTTP: &str = "org.graylog2.inputs.gelf.http.GELFHttpInput";
14pub const INPUT_TYPE_OTEL_GRPC: &str = "org.graylog.inputs.otel.OTelGrpcInput";
16pub const INPUT_STATE_RUNNING: &str = "RUNNING";
18pub const INPUT_STATE_FAILED: &str = "FAILED";
20
21pub const STREAM_RULE_EXACT: i64 = 1;
23pub const STREAM_RULE_REGEX: i64 = 2;
25pub const STREAM_RULE_GREATER: i64 = 3;
27pub const STREAM_RULE_SMALLER: i64 = 4;
29pub const STREAM_RULE_PRESENCE: i64 = 5;
31pub const STREAM_RULE_CONTAINS: i64 = 6;
33pub const STREAM_RULE_ALWAYS_MATCH: i64 = 7;
35pub const STREAM_RULE_MATCH_INPUT: i64 = 8;
37
38pub(crate) fn parse_graylog_time(s: &str) -> Option<SystemTime> {
40 let s = s.trim();
41 if s.is_empty() {
42 return None;
43 }
44 if s.len() > 16 {
46 let (base, tail) = s.split_at(s.len() - 6);
47 let b = tail.as_bytes();
48 if (b[0] == b'+' || b[0] == b'-') && b[3] == b':' {
49 let h: u64 = tail[1..3].parse().ok()?;
50 let m: u64 = tail[4..].parse().ok()?;
51 let t = humantime::parse_rfc3339_weak(base).ok()?;
52 let off = Duration::from_secs(h * 3600 + m * 60);
53 return if b[0] == b'+' {
54 t.checked_sub(off)
55 } else {
56 t.checked_add(off)
57 };
58 }
59 }
60 humantime::parse_rfc3339_weak(s.trim_end_matches('Z')).ok()
61}
62
63pub(crate) fn format_graylog_time(t: SystemTime) -> String {
65 let t = if t < UNIX_EPOCH { UNIX_EPOCH } else { t };
66 let ms = t.duration_since(UNIX_EPOCH).unwrap_or_default().as_millis() as u64;
67 let rounded = UNIX_EPOCH + Duration::from_millis(ms);
68 humantime::format_rfc3339_millis(rounded).to_string()
69}
70
71fn de_time<'de, D: Deserializer<'de>>(d: D) -> Result<Option<SystemTime>, D::Error> {
72 let v = Option::<Value>::deserialize(d)?;
73 Ok(v.as_ref()
74 .and_then(Value::as_str)
75 .and_then(parse_graylog_time))
76}
77
78fn de_string<'de, D: Deserializer<'de>>(d: D) -> Result<String, D::Error> {
79 Ok(match Option::<Value>::deserialize(d)? {
80 Some(Value::String(s)) => s,
81 _ => String::new(),
82 })
83}
84
85fn de_bool<'de, D: Deserializer<'de>>(d: D) -> Result<bool, D::Error> {
86 Ok(matches!(
87 Option::<Value>::deserialize(d)?,
88 Some(Value::Bool(true))
89 ))
90}
91
92fn de_i64<'de, D: Deserializer<'de>>(d: D) -> Result<i64, D::Error> {
93 Ok(Option::<Value>::deserialize(d)?
94 .as_ref()
95 .and_then(Value::as_i64)
96 .unwrap_or(0))
97}
98
99fn de_map<'de, D: Deserializer<'de>>(d: D) -> Result<Map<String, Value>, D::Error> {
100 Ok(match Option::<Value>::deserialize(d)? {
101 Some(Value::Object(m)) => m,
102 _ => Map::new(),
103 })
104}
105
106fn de_rules<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<StreamRule>, D::Error> {
107 Ok(Option::<Vec<StreamRule>>::deserialize(d)?.unwrap_or_default())
108}
109
110#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
112pub struct SystemInfo {
113 #[serde(default, deserialize_with = "de_string")]
115 pub facility: String,
116 #[serde(default, deserialize_with = "de_string")]
118 pub codename: String,
119 #[serde(default, deserialize_with = "de_string")]
121 pub node_id: String,
122 #[serde(default, deserialize_with = "de_string")]
124 pub cluster_id: String,
125 #[serde(default, deserialize_with = "de_string")]
127 pub version: String,
128 #[serde(default, deserialize_with = "de_time")]
130 pub started_at: Option<SystemTime>,
131 #[serde(default, deserialize_with = "de_string")]
133 pub hostname: String,
134 #[serde(default, deserialize_with = "de_string")]
136 pub lifecycle: String,
137 #[serde(default, deserialize_with = "de_string")]
139 pub lb_status: String,
140 #[serde(default, deserialize_with = "de_string")]
142 pub timezone: String,
143 #[serde(default, deserialize_with = "de_string")]
145 pub operating_system: String,
146 #[serde(default, deserialize_with = "de_bool")]
148 pub is_leader: bool,
149 #[serde(default, deserialize_with = "de_bool")]
151 pub is_processing: bool,
152}
153
154#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
156pub struct Input {
157 #[serde(default, deserialize_with = "de_string")]
159 pub id: String,
160 #[serde(default, deserialize_with = "de_string")]
162 pub title: String,
163 #[serde(default, rename = "type", deserialize_with = "de_string")]
165 pub input_type: String,
166 #[serde(default, deserialize_with = "de_string")]
168 pub name: String,
169 #[serde(default, deserialize_with = "de_bool")]
171 pub global: bool,
172 #[serde(default, deserialize_with = "de_string")]
174 pub node: String,
175 #[serde(default, deserialize_with = "de_time")]
177 pub created_at: Option<SystemTime>,
178 #[serde(default, deserialize_with = "de_string")]
180 pub creator_user_id: String,
181 #[serde(default, deserialize_with = "de_map")]
183 pub attributes: Map<String, Value>,
184 #[serde(default, deserialize_with = "de_map")]
186 pub static_fields: Map<String, Value>,
187}
188
189impl Input {
190 pub fn port(&self) -> u16 {
192 match self.attributes.get("port") {
193 Some(Value::Number(n)) => n
194 .as_u64()
195 .or_else(|| n.as_f64().map(|f| f as u64))
196 .and_then(|p| u16::try_from(p).ok())
197 .unwrap_or(0),
198 Some(Value::String(s)) => s.trim().parse().unwrap_or(0),
199 _ => 0,
200 }
201 }
202
203 pub fn bind_address(&self) -> &str {
205 self.attributes
206 .get("bind_address")
207 .and_then(Value::as_str)
208 .unwrap_or("")
209 }
210}
211
212#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
214pub struct InputState {
215 #[serde(default, deserialize_with = "de_string")]
217 pub id: String,
218 #[serde(default, deserialize_with = "de_string")]
220 pub state: String,
221 #[serde(default, deserialize_with = "de_time")]
223 pub started_at: Option<SystemTime>,
224 #[serde(default, deserialize_with = "de_string")]
226 pub detailed_message: String,
227 #[serde(default, rename = "message_input")]
229 pub input: Input,
230}
231
232#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
234pub struct StreamRule {
235 #[serde(default, deserialize_with = "de_string", skip_serializing)]
237 pub id: String,
238 #[serde(default, deserialize_with = "de_string")]
240 pub field: String,
241 #[serde(default, rename = "type", deserialize_with = "de_i64")]
243 pub rule_type: i64,
244 #[serde(default, deserialize_with = "de_string")]
246 pub value: String,
247 #[serde(default, deserialize_with = "de_bool")]
249 pub inverted: bool,
250 #[serde(default, deserialize_with = "de_string")]
252 pub description: String,
253}
254
255impl StreamRule {
256 pub fn exact(field: impl Into<String>, value: impl Into<String>) -> Self {
258 StreamRule {
259 field: field.into(),
260 rule_type: STREAM_RULE_EXACT,
261 value: value.into(),
262 ..StreamRule::default()
263 }
264 }
265}
266
267#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
269pub struct Stream {
270 #[serde(default, deserialize_with = "de_string")]
272 pub id: String,
273 #[serde(default, deserialize_with = "de_string")]
275 pub title: String,
276 #[serde(default, deserialize_with = "de_string")]
278 pub description: String,
279 #[serde(default, deserialize_with = "de_rules")]
281 pub rules: Vec<StreamRule>,
282 #[serde(default, deserialize_with = "de_bool")]
284 pub disabled: bool,
285 #[serde(default, deserialize_with = "de_string")]
287 pub index_set_id: String,
288 #[serde(default, deserialize_with = "de_bool")]
290 pub is_default: bool,
291 #[serde(default, deserialize_with = "de_string")]
293 pub matching_type: String,
294 #[serde(default, deserialize_with = "de_bool")]
296 pub remove_matches_from_default_stream: bool,
297 #[serde(default, deserialize_with = "de_time")]
299 pub created_at: Option<SystemTime>,
300 #[serde(default, deserialize_with = "de_string")]
302 pub creator_user_id: String,
303}
304
305#[derive(Debug, Clone, Default, PartialEq)]
307pub struct StreamPage {
308 pub streams: Vec<Stream>,
310 pub total: u64,
312 pub page: u32,
314 pub per_page: u32,
316}
317
318#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
320pub struct IndexSet {
321 #[serde(default, deserialize_with = "de_string")]
323 pub id: String,
324 #[serde(default, deserialize_with = "de_string")]
326 pub title: String,
327 #[serde(default, deserialize_with = "de_string")]
329 pub description: String,
330 #[serde(default, deserialize_with = "de_string")]
332 pub index_prefix: String,
333 #[serde(default, deserialize_with = "de_bool")]
335 pub default: bool,
336 #[serde(default, deserialize_with = "de_bool")]
338 pub writable: bool,
339 #[serde(default, deserialize_with = "de_i64")]
341 pub shards: i64,
342 #[serde(default, deserialize_with = "de_i64")]
344 pub replicas: i64,
345}