telelogs 0.3.1

Telelogs desktop app: a native log viewer for Docker and Kubernetes
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Which sources are on, kept between launches for each server.
//!
//! Kubernetes pod names change with every rollout, so a namespace's checkbox is saved by
//! namespace and decides for pods that haven't been seen before. A source toggled on its own is
//! saved by name and overrides its namespace.

use std::collections::BTreeMap;
use std::path::PathBuf;

use serde::{Deserialize, Serialize};

use super::namespace_of;

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Selections {
    /// Kubernetes namespaces turned all on or all off with their checkbox.
    #[serde(default)]
    pub namespaces: BTreeMap<String, bool>,
    /// Sources toggled one at a time, by name.
    #[serde(default)]
    pub targets: BTreeMap<String, bool>,
}

impl Selections {
    /// The saved choice for a source, if there is one.
    pub fn choice(&self, kubernetes: bool, name: &str) -> Option<bool> {
        self.targets.get(name).copied().or_else(|| {
            kubernetes
                .then(|| self.namespaces.get(namespace_of(name)).copied())
                .flatten()
        })
    }

    pub fn set_target(&mut self, name: &str, on: bool) {
        self.targets.insert(name.to_string(), on);
    }

    /// A namespace's checkbox sets all its pods, so it replaces their own choices.
    pub fn set_namespace(&mut self, namespace: &str, on: bool) {
        let prefix = format!("{namespace}/");
        self.targets.retain(|name, _| !name.starts_with(&prefix));
        self.namespaces.insert(namespace.to_string(), on);
    }

    /// The selections saved for `server`, or none if there are none or the file can't be read.
    pub fn load(server: &str) -> Self {
        let Some(path) = file() else {
            return Self::default();
        };
        read_all(&path).remove(server).unwrap_or_default()
    }

    /// Saves these selections for `server`, keeping other servers' as they are.
    pub fn save(&self, server: &str) {
        let Some(path) = file() else {
            return;
        };
        let mut all = read_all(&path);
        all.insert(server.to_string(), self.clone());
        if let Err(e) = write_all(&path, &all) {
            eprintln!("telelogs: saving source selections to {}: {e}", path.display());
        }
    }
}

fn file() -> Option<PathBuf> {
    Some(dirs::config_dir()?.join("telelogs").join("selections.json"))
}

fn read_all(path: &PathBuf) -> BTreeMap<String, Selections> {
    std::fs::read(path)
        .ok()
        .and_then(|bytes| serde_json::from_slice(&bytes).ok())
        .unwrap_or_default()
}

/// Writes through a temporary file, so a crash mid-write can't leave half a file behind.
fn write_all(path: &PathBuf, all: &BTreeMap<String, Selections>) -> std::io::Result<()> {
    if let Some(dir) = path.parent() {
        std::fs::create_dir_all(dir)?;
    }
    let tmp = path.with_extension("json.tmp");
    std::fs::write(&tmp, serde_json::to_vec_pretty(all)?)?;
    std::fs::rename(tmp, path)
}

#[cfg(test)]
mod tests {
    use super::Selections;

    #[test]
    fn namespace_decides_for_new_pods() {
        let mut s = Selections::default();
        s.set_namespace("kube-system", false);
        assert_eq!(s.choice(true, "kube-system/coredns-7d9f-x2k4p/coredns"), Some(false));
        assert_eq!(s.choice(true, "default/auth-svc-54bf-t2xv7/auth"), None);
        // Docker names aren't namespaced, even when they contain a slash.
        assert_eq!(s.choice(false, "kube-system/odd"), None);
    }

    #[test]
    fn a_source_overrides_its_namespace_until_the_namespace_is_set_again() {
        let mut s = Selections::default();
        s.set_namespace("kafka", false);
        s.set_target("kafka/kafka-0/kafka", true);
        assert_eq!(s.choice(true, "kafka/kafka-0/kafka"), Some(true));
        assert_eq!(s.choice(true, "kafka/kafka-1/kafka"), Some(false));

        s.set_namespace("kafka", true);
        assert!(s.targets.is_empty());
        assert_eq!(s.choice(true, "kafka/kafka-0/kafka"), Some(true));
    }

    #[test]
    fn docker_sources_are_saved_by_name() {
        let mut s = Selections::default();
        s.set_target("postgres", false);
        assert_eq!(s.choice(false, "postgres"), Some(false));
        assert_eq!(s.choice(false, "redis"), None);
    }

    #[test]
    fn round_trips_through_json() {
        let mut s = Selections::default();
        s.set_namespace("cert-manager", false);
        s.set_target("api-1", true);
        let json = serde_json::to_string(&s).unwrap();
        assert_eq!(serde_json::from_str::<Selections>(&json).unwrap(), s);
        // A file from an older or newer version with fields missing still loads.
        assert_eq!(serde_json::from_str::<Selections>("{}").unwrap(), Selections::default());
    }
}