use ciborium::value::Value;
use serde::{Deserialize, Serialize};
use crate::cbor;
use crate::error::{FcbError, Result};
pub const BUILTIN_STREAM_TYPES: &[&str] = &["fcb.syslog.v1", "fcb.netflow.v1", "fcb.json.v1"];
pub fn is_builtin_type(stream_type: &str) -> bool {
BUILTIN_STREAM_TYPES.contains(&stream_type)
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StreamManifest {
pub id: String,
#[serde(rename = "type")]
pub stream_type: String,
pub records: u64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StreamData {
pub id: String,
pub records: Vec<Value>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct DecodedStream {
pub id: String,
pub stream_type: String,
pub records: Vec<Value>,
pub is_builtin: bool,
}
#[derive(Debug, Default, Serialize, Deserialize)]
struct StreamsMeta {
#[serde(default)]
streams: Vec<StreamManifest>,
}
pub fn manifest_to_meta(manifest: &[StreamManifest]) -> Result<Value> {
cbor::to_value(&StreamsMeta {
streams: manifest.to_vec(),
})
}
pub fn manifest_from_meta(meta: &Value) -> Result<Vec<StreamManifest>> {
let m: StreamsMeta = cbor::from_value(meta)?;
Ok(m.streams)
}
pub fn decode_streams(
manifest: &[StreamManifest],
payload: &[StreamData],
) -> Result<Vec<DecodedStream>> {
manifest
.iter()
.map(|m| {
let data = payload
.iter()
.find(|s| s.id == m.id)
.ok_or_else(|| FcbError::Malformed(format!("payload missing stream {}", m.id)))?;
Ok(DecodedStream {
id: m.id.clone(),
stream_type: m.stream_type.clone(),
records: data.records.clone(),
is_builtin: is_builtin_type(&m.stream_type),
})
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn rec(n: i64) -> Value {
Value::Integer(n.into())
}
fn mixed_manifest() -> Vec<StreamManifest> {
vec![
StreamManifest {
id: "s0".into(),
stream_type: "fcb.syslog.v1".into(),
records: 2,
},
StreamManifest {
id: "s1".into(),
stream_type: "acme.edr.v1".into(),
records: 1,
},
]
}
#[test]
fn manifest_round_trips_through_meta() {
let manifest = mixed_manifest();
let meta = manifest_to_meta(&manifest).unwrap();
assert_eq!(manifest_from_meta(&meta).unwrap(), manifest);
}
#[test]
fn builtin_and_third_party_types_both_listed() {
let manifest = mixed_manifest();
let payload = vec![
StreamData {
id: "s0".into(),
records: vec![rec(1), rec(2)],
},
StreamData {
id: "s1".into(),
records: vec![rec(9)],
},
];
let decoded = decode_streams(&manifest, &payload).unwrap();
assert_eq!(decoded.len(), 2);
assert_eq!(decoded[0].stream_type, "fcb.syslog.v1");
assert!(decoded[0].is_builtin);
assert_eq!(decoded[1].stream_type, "acme.edr.v1");
assert!(!decoded[1].is_builtin);
}
#[test]
fn unknown_type_does_not_abort_other_streams() {
let manifest = vec![
StreamManifest {
id: "a".into(),
stream_type: "fcb.syslog.v1".into(),
records: 1,
},
StreamManifest {
id: "b".into(),
stream_type: "vendor.unknown.v3".into(),
records: 1,
},
StreamManifest {
id: "c".into(),
stream_type: "fcb.json.v1".into(),
records: 1,
},
];
let payload = vec![
StreamData {
id: "a".into(),
records: vec![rec(1)],
},
StreamData {
id: "b".into(),
records: vec![rec(2)],
},
StreamData {
id: "c".into(),
records: vec![rec(3)],
},
];
let decoded = decode_streams(&manifest, &payload).unwrap();
assert_eq!(decoded.len(), 3);
assert!(!decoded[1].is_builtin);
assert!(decoded[0].is_builtin && decoded[2].is_builtin);
}
}