use fv_value::Value;
use crate::Row;
#[derive(Debug, Clone)]
pub struct LogMessage {
pub key: Option<String>,
pub value: Option<Row>,
}
fn rid_of(row: &Row) -> Option<String> {
row.iter().find(|(k, _)| k == "rid").and_then(|(_, v)| match v {
Value::Str(s) => Some(s.clone()),
_ => None,
})
}
pub fn fold_compacted_log(prior: &[Row], messages: &[LogMessage]) -> Vec<Row> {
let mut order: Vec<String> = Vec::new();
let mut rows: std::collections::HashMap<String, Row> = std::collections::HashMap::new();
for row in prior {
if let Some(rid) = rid_of(row) {
if !rows.contains_key(&rid) {
order.push(rid.clone());
}
rows.insert(rid, row.clone());
}
}
for msg in messages {
match &msg.value {
None => {
if let Some(rid) = &msg.key {
if rows.remove(rid).is_some() {
order.retain(|k| k != rid);
}
}
}
Some(value) => {
let rid = match rid_of(value).or_else(|| msg.key.clone()) {
Some(r) => r,
None => continue, };
let mut row: Row = vec![("rid".to_string(), Value::Str(rid.clone()))];
row.extend(value.iter().filter(|(k, _)| k != "rid").cloned());
if !rows.contains_key(&rid) {
order.push(rid.clone());
}
rows.insert(rid, row);
}
}
}
order.into_iter().filter_map(|rid| rows.remove(&rid)).collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn row(rid: &str, fields: &[(&str, &str)]) -> Row {
let mut r: Row = vec![("rid".into(), Value::Str(rid.into()))];
r.extend(
fields
.iter()
.map(|(k, v)| ((*k).to_string(), Value::Str((*v).to_string()))),
);
r
}
fn msg(key: Option<&str>, value: Option<Row>) -> LogMessage {
LogMessage {
key: key.map(String::from),
value,
}
}
#[test]
fn empty_prior_reconstitutes_full_rows() {
let m = row(
"fv.o.m.object.speed-alert.TEL-1",
&[
("deviceRid", "fv.o.m.object.telematics-device.TEL-1"),
("alert", "OVERSPEED"),
("speedKph", "97"),
],
);
let folded = fold_compacted_log(&[], &[msg(None, Some(m.clone()))]);
assert_eq!(folded, vec![m]);
}
#[test]
fn a_message_is_full_state_not_a_patch() {
let prior = row("r-1", &[("a", "1"), ("b", "2")]);
let update = row("r-1", &[("a", "9")]);
let folded = fold_compacted_log(&[prior], &[msg(None, Some(update.clone()))]);
assert_eq!(folded, vec![update]);
}
#[test]
fn upsert_keeps_position_insert_appends_tombstone_removes() {
let prior = vec![
row("r-1", &[("a", "1")]),
row("r-2", &[("a", "2")]),
row("r-3", &[("a", "3")]),
];
let folded = fold_compacted_log(
&prior,
&[
msg(None, Some(row("r-2", &[("a", "2b")]))), msg(Some("r-1"), None), msg(None, Some(row("r-4", &[("a", "4")]))), ],
);
let rids: Vec<&str> = folded
.iter()
.map(|r| match &r[0].1 {
Value::Str(s) => s.as_str(),
_ => "?",
})
.collect();
assert_eq!(rids, vec!["r-2", "r-3", "r-4"]);
assert_eq!(folded[0], row("r-2", &[("a", "2b")]));
}
#[test]
fn rid_falls_back_to_the_message_key_and_ridless_messages_are_skipped() {
let keyed = fold_compacted_log(
&[],
&[msg(Some("k-1"), Some(vec![("a".into(), Value::Str("1".into()))]))],
);
assert_eq!(keyed, vec![row("k-1", &[("a", "1")])]);
assert!(fold_compacted_log(
&[],
&[
msg(None, Some(vec![("a".into(), Value::Str("1".into()))])),
msg(None, None)
]
)
.is_empty());
}
}