snops-common 0.1.0

Common types and utilities for snops
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

use crate::format::{DataFormat, DataFormatReader};

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, clap::Parser)]
pub struct PortConfig {
    /// Specify the IP address and port for the node server
    #[clap(long = "node", default_value_t = 4130)]
    pub node: u16,

    /// Specify the IP address and port for the BFT
    #[clap(long = "bft", default_value_t = 5000)]
    pub bft: u16,

    /// Specify the IP address and port for the REST server
    #[clap(long = "rest", default_value_t = 3030)]
    pub rest: u16,

    /// Specify the port for the metrics
    #[clap(long = "metrics", default_value_t = 9000)]
    pub metrics: u16,
}

impl std::fmt::Display for PortConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "bft: {}, node: {}, rest: {}",
            self.bft, self.node, self.rest
        )
    }
}

impl DataFormat for PortConfig {
    type Header = u8;
    const LATEST_HEADER: Self::Header = 1;

    fn write_data<W: std::io::prelude::Write>(
        &self,
        writer: &mut W,
    ) -> Result<usize, crate::format::DataWriteError> {
        let mut written = 0;
        written += self.node.write_data(writer)?;
        written += self.bft.write_data(writer)?;
        written += self.rest.write_data(writer)?;
        written += self.metrics.write_data(writer)?;
        Ok(written)
    }

    fn read_data<R: std::io::prelude::Read>(
        reader: &mut R,
        header: &Self::Header,
    ) -> Result<Self, crate::format::DataReadError> {
        if *header != Self::LATEST_HEADER {
            return Err(crate::format::DataReadError::unsupported(
                "PortConfig",
                Self::LATEST_HEADER,
                *header,
            ));
        }

        Ok(PortConfig {
            node: reader.read_data(&())?,
            bft: reader.read_data(&())?,
            rest: reader.read_data(&())?,
            metrics: reader.read_data(&())?,
        })
    }
}

#[cfg(test)]
mod test {
    use crate::format::DataFormat;
    use crate::state::PortConfig;

    macro_rules! case {
        ($name:ident, $ty:ty, $a:expr, $b:expr) => {
            #[test]
            fn $name() -> Result<(), Box<dyn std::error::Error>> {
                let mut data = Vec::new();
                $a.write_data(&mut data).unwrap();
                assert_eq!(data, $b);

                let mut reader = &data[..];
                let read_value =
                    <$ty>::read_data(&mut reader, &<$ty as DataFormat>::LATEST_HEADER).unwrap();

                // write the data again because not every type implements PartialEq
                let mut data2 = Vec::new();
                read_value.write_data(&mut data2).unwrap();
                assert_eq!(data, data2);
                Ok(())
            }
        };
    }

    case!(
        port_config,
        PortConfig,
        PortConfig {
            node: 0,
            bft: 1,
            rest: 2,
            metrics: 3,
        },
        [0, 0, 1, 0, 2, 0, 3, 0]
    );
}