mprobe-vis 0.2.0

A library for visualizing MongoDB FTDC metrics
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
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

use std::fmt::Display;
use std::format;
use std::io::Seek;
use std::io::Write;
use std::marker::PhantomData;
use std::sync::Arc;

use crate::chart::Series;

const COMMON_RESERVED_BYTES: usize =
26 /* static characters */ +
8 /* spaces */ +
32 /* 2 * 16 bytes for two usizes */ +
1 /* new line */;

pub struct SeriesWriter<W, X, Y> {
    writer: W,
    index: usize,
    series: Arc<Series>,
    xtype: PhantomData<X>,
    ytype: PhantomData<Y>,
}

impl<W: Write + Seek, X: Display, Y: Display> SeriesWriter<W, X, Y> {
    pub fn new(writer: W, series: Arc<Series>) -> Self {
        Self {
            writer,
            index: 0,
            series,
            xtype: PhantomData,
            ytype: PhantomData,
        }
    }

    pub fn start(&mut self) -> Result<(), std::io::Error> {
        let total_reserved_bytes =
            COMMON_RESERVED_BYTES + self.series.xs.len() + self.series.xs.len();
        let whitespaces = b" ".repeat(total_reserved_bytes);

        self.writer.write_all(&whitespaces)?;
        self.writer.write_all(b"\n")
    }

    pub fn write(&mut self, x: X, y: Y) -> Result<(), std::io::Error> {
        let line = format!(
            "{xs}[{idx}] = {x}; {ys}[{idx}] = {y};\n",
            xs = self.series.xs,
            ys = self.series.ys,
            idx = self.index,
            x = x,
            y = y
        );

        self.writer.write_all(line.as_bytes())?;
        self.index += 1;

        Ok(())
    }

    pub fn end(mut self) -> Result<(), std::io::Error> {
        // TODO: Handle the error when rewind fails due to buffer flush
        self.writer.rewind()?;

        let first_line = format!(
            "let {xs} = new Array({size}), {ys} = new Array({size});\n",
            xs = self.series.xs,
            ys = self.series.ys,
            size = self.index
        );

        self.writer.write_all(first_line.as_bytes())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Cursor;

    #[test]
    fn write_chart_data() -> Result<(), std::io::Error> {
        let buffer: Vec<u8> = Vec::new();
        let mut writer: Cursor<Vec<u8>> = Cursor::new(buffer);
        let series = Arc::new(Series::new(String::from("xs"), String::from("ys")));
        let mut series = SeriesWriter::new(&mut writer, series);

        let xs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
        let ys = vec![1.0, 2.0, 3.0, 4.0, 5.0];

        let expected_output = b"let xs = new Array(5), ys = new Array(5);
                             
xs[0] = 1; ys[0] = 1;
xs[1] = 2; ys[1] = 2;
xs[2] = 3; ys[2] = 3;
xs[3] = 4; ys[3] = 4;
xs[4] = 5; ys[4] = 5;
";
        let expected_output = std::str::from_utf8(expected_output).unwrap();

        series.start()?;

        for (x, y) in xs.into_iter().zip(ys) {
            series.write(x, y)?;
        }

        series.end()?;

        let buff = writer.into_inner();
        let content = std::str::from_utf8(&buff).unwrap();

        assert_eq!(expected_output, content);

        Ok(())
    }
}