sk-store 2.1.0

SimKube trace store library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use std::collections::VecDeque;
use std::ops::Index;

use sk_core::prelude::*;
use tracing::*;

use crate::{
    TraceAction,
    TraceEvent,
};

#[derive(Clone, Default)]
pub struct TraceEventList(VecDeque<TraceEvent>);

impl TraceEventList {
    pub(crate) fn append(&mut self, ts: i64, obj: &DynamicObject, action: TraceAction) {
        info!(
            "{:?} @ {ts}: {} {}",
            action,
            obj.types
                .clone()
                .map(|tm| format!("{}.{}", tm.api_version, tm.kind))
                .unwrap_or("<unknown type>".into()),
            obj.namespaced_name(),
        );

        let obj = obj.clone();
        match self.0.back_mut() {
            Some(evt) if evt.ts == ts => match action {
                TraceAction::ObjectApplied => evt.applied_objs.push(obj),
                TraceAction::ObjectDeleted => evt.deleted_objs.push(obj),
            },
            _ => {
                let evt = match action {
                    TraceAction::ObjectApplied => TraceEvent { ts, applied_objs: vec![obj], ..Default::default() },
                    TraceAction::ObjectDeleted => TraceEvent { ts, deleted_objs: vec![obj], ..Default::default() },
                };
                self.0.push_back(evt);
            },
        }
    }

    pub(crate) fn back(&self) -> Option<&TraceEvent> {
        self.0.back()
    }

    pub(crate) fn front(&self) -> Option<&TraceEvent> {
        self.0.front()
    }

    pub(crate) fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    pub(crate) fn len(&self) -> usize {
        self.0.len()
    }
}

impl Index<usize> for TraceEventList {
    type Output = TraceEvent;

    fn index(&self, i: usize) -> &Self::Output {
        &self.0[i]
    }
}

impl From<VecDeque<TraceEvent>> for TraceEventList {
    fn from(v: VecDeque<TraceEvent>) -> TraceEventList {
        TraceEventList(v)
    }
}

impl From<Vec<TraceEvent>> for TraceEventList {
    fn from(v: Vec<TraceEvent>) -> TraceEventList {
        TraceEventList(v.into())
    }
}

impl FromIterator<TraceEvent> for TraceEventList {
    fn from_iter<T: IntoIterator<Item = TraceEvent>>(ii: T) -> Self {
        TraceEventList(ii.into_iter().collect())
    }
}