use std::time::{Duration, SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::{Map, Value};
pub const INPUT_TYPE_GELF_UDP: &str = "org.graylog2.inputs.gelf.udp.GELFUDPInput";
pub const INPUT_TYPE_GELF_TCP: &str = "org.graylog2.inputs.gelf.tcp.GELFTCPInput";
pub const INPUT_TYPE_GELF_HTTP: &str = "org.graylog2.inputs.gelf.http.GELFHttpInput";
pub const INPUT_TYPE_OTEL_GRPC: &str = "org.graylog.inputs.otel.OTelGrpcInput";
pub const INPUT_STATE_RUNNING: &str = "RUNNING";
pub const INPUT_STATE_FAILED: &str = "FAILED";
pub const STREAM_RULE_EXACT: i64 = 1;
pub const STREAM_RULE_REGEX: i64 = 2;
pub const STREAM_RULE_GREATER: i64 = 3;
pub const STREAM_RULE_SMALLER: i64 = 4;
pub const STREAM_RULE_PRESENCE: i64 = 5;
pub const STREAM_RULE_CONTAINS: i64 = 6;
pub const STREAM_RULE_ALWAYS_MATCH: i64 = 7;
pub const STREAM_RULE_MATCH_INPUT: i64 = 8;
pub(crate) fn parse_graylog_time(s: &str) -> Option<SystemTime> {
let s = s.trim();
if s.is_empty() {
return None;
}
if s.len() > 16 {
let (base, tail) = s.split_at(s.len() - 6);
let b = tail.as_bytes();
if (b[0] == b'+' || b[0] == b'-') && b[3] == b':' {
let h: u64 = tail[1..3].parse().ok()?;
let m: u64 = tail[4..].parse().ok()?;
let t = humantime::parse_rfc3339_weak(base).ok()?;
let off = Duration::from_secs(h * 3600 + m * 60);
return if b[0] == b'+' {
t.checked_sub(off)
} else {
t.checked_add(off)
};
}
}
humantime::parse_rfc3339_weak(s.trim_end_matches('Z')).ok()
}
pub(crate) fn format_graylog_time(t: SystemTime) -> String {
let t = if t < UNIX_EPOCH { UNIX_EPOCH } else { t };
let ms = t.duration_since(UNIX_EPOCH).unwrap_or_default().as_millis() as u64;
let rounded = UNIX_EPOCH + Duration::from_millis(ms);
humantime::format_rfc3339_millis(rounded).to_string()
}
fn de_time<'de, D: Deserializer<'de>>(d: D) -> Result<Option<SystemTime>, D::Error> {
let v = Option::<Value>::deserialize(d)?;
Ok(v.as_ref()
.and_then(Value::as_str)
.and_then(parse_graylog_time))
}
fn de_string<'de, D: Deserializer<'de>>(d: D) -> Result<String, D::Error> {
Ok(match Option::<Value>::deserialize(d)? {
Some(Value::String(s)) => s,
_ => String::new(),
})
}
fn de_bool<'de, D: Deserializer<'de>>(d: D) -> Result<bool, D::Error> {
Ok(matches!(
Option::<Value>::deserialize(d)?,
Some(Value::Bool(true))
))
}
fn de_i64<'de, D: Deserializer<'de>>(d: D) -> Result<i64, D::Error> {
Ok(Option::<Value>::deserialize(d)?
.as_ref()
.and_then(Value::as_i64)
.unwrap_or(0))
}
fn de_map<'de, D: Deserializer<'de>>(d: D) -> Result<Map<String, Value>, D::Error> {
Ok(match Option::<Value>::deserialize(d)? {
Some(Value::Object(m)) => m,
_ => Map::new(),
})
}
fn de_rules<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<StreamRule>, D::Error> {
Ok(Option::<Vec<StreamRule>>::deserialize(d)?.unwrap_or_default())
}
#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
pub struct SystemInfo {
#[serde(default, deserialize_with = "de_string")]
pub facility: String,
#[serde(default, deserialize_with = "de_string")]
pub codename: String,
#[serde(default, deserialize_with = "de_string")]
pub node_id: String,
#[serde(default, deserialize_with = "de_string")]
pub cluster_id: String,
#[serde(default, deserialize_with = "de_string")]
pub version: String,
#[serde(default, deserialize_with = "de_time")]
pub started_at: Option<SystemTime>,
#[serde(default, deserialize_with = "de_string")]
pub hostname: String,
#[serde(default, deserialize_with = "de_string")]
pub lifecycle: String,
#[serde(default, deserialize_with = "de_string")]
pub lb_status: String,
#[serde(default, deserialize_with = "de_string")]
pub timezone: String,
#[serde(default, deserialize_with = "de_string")]
pub operating_system: String,
#[serde(default, deserialize_with = "de_bool")]
pub is_leader: bool,
#[serde(default, deserialize_with = "de_bool")]
pub is_processing: bool,
}
#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
pub struct Input {
#[serde(default, deserialize_with = "de_string")]
pub id: String,
#[serde(default, deserialize_with = "de_string")]
pub title: String,
#[serde(default, rename = "type", deserialize_with = "de_string")]
pub input_type: String,
#[serde(default, deserialize_with = "de_string")]
pub name: String,
#[serde(default, deserialize_with = "de_bool")]
pub global: bool,
#[serde(default, deserialize_with = "de_string")]
pub node: String,
#[serde(default, deserialize_with = "de_time")]
pub created_at: Option<SystemTime>,
#[serde(default, deserialize_with = "de_string")]
pub creator_user_id: String,
#[serde(default, deserialize_with = "de_map")]
pub attributes: Map<String, Value>,
#[serde(default, deserialize_with = "de_map")]
pub static_fields: Map<String, Value>,
}
impl Input {
pub fn port(&self) -> u16 {
match self.attributes.get("port") {
Some(Value::Number(n)) => n
.as_u64()
.or_else(|| n.as_f64().map(|f| f as u64))
.and_then(|p| u16::try_from(p).ok())
.unwrap_or(0),
Some(Value::String(s)) => s.trim().parse().unwrap_or(0),
_ => 0,
}
}
pub fn bind_address(&self) -> &str {
self.attributes
.get("bind_address")
.and_then(Value::as_str)
.unwrap_or("")
}
}
#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
pub struct InputState {
#[serde(default, deserialize_with = "de_string")]
pub id: String,
#[serde(default, deserialize_with = "de_string")]
pub state: String,
#[serde(default, deserialize_with = "de_time")]
pub started_at: Option<SystemTime>,
#[serde(default, deserialize_with = "de_string")]
pub detailed_message: String,
#[serde(default, rename = "message_input")]
pub input: Input,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StreamRule {
#[serde(default, deserialize_with = "de_string", skip_serializing)]
pub id: String,
#[serde(default, deserialize_with = "de_string")]
pub field: String,
#[serde(default, rename = "type", deserialize_with = "de_i64")]
pub rule_type: i64,
#[serde(default, deserialize_with = "de_string")]
pub value: String,
#[serde(default, deserialize_with = "de_bool")]
pub inverted: bool,
#[serde(default, deserialize_with = "de_string")]
pub description: String,
}
impl StreamRule {
pub fn exact(field: impl Into<String>, value: impl Into<String>) -> Self {
StreamRule {
field: field.into(),
rule_type: STREAM_RULE_EXACT,
value: value.into(),
..StreamRule::default()
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
pub struct Stream {
#[serde(default, deserialize_with = "de_string")]
pub id: String,
#[serde(default, deserialize_with = "de_string")]
pub title: String,
#[serde(default, deserialize_with = "de_string")]
pub description: String,
#[serde(default, deserialize_with = "de_rules")]
pub rules: Vec<StreamRule>,
#[serde(default, deserialize_with = "de_bool")]
pub disabled: bool,
#[serde(default, deserialize_with = "de_string")]
pub index_set_id: String,
#[serde(default, deserialize_with = "de_bool")]
pub is_default: bool,
#[serde(default, deserialize_with = "de_string")]
pub matching_type: String,
#[serde(default, deserialize_with = "de_bool")]
pub remove_matches_from_default_stream: bool,
#[serde(default, deserialize_with = "de_time")]
pub created_at: Option<SystemTime>,
#[serde(default, deserialize_with = "de_string")]
pub creator_user_id: String,
}
#[derive(Debug, Clone, Default, PartialEq)]
pub struct StreamPage {
pub streams: Vec<Stream>,
pub total: u64,
pub page: u32,
pub per_page: u32,
}
#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
pub struct IndexSet {
#[serde(default, deserialize_with = "de_string")]
pub id: String,
#[serde(default, deserialize_with = "de_string")]
pub title: String,
#[serde(default, deserialize_with = "de_string")]
pub description: String,
#[serde(default, deserialize_with = "de_string")]
pub index_prefix: String,
#[serde(default, deserialize_with = "de_bool")]
pub default: bool,
#[serde(default, deserialize_with = "de_bool")]
pub writable: bool,
#[serde(default, deserialize_with = "de_i64")]
pub shards: i64,
#[serde(default, deserialize_with = "de_i64")]
pub replicas: i64,
}