grafbabe 0.1.1

Simple openmetrics stats collector
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

use super::parse_ini::ParseError;
use super::version;
use log::Level;
use std::fmt;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::path::{Path, PathBuf};
use std::time::Duration;

pub const DEFAULT_PORT: u16 = 4242;
const DEFAULT_LISTEN_ADDR: SocketAddr = if cfg!(debug_assertions) {
    SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), DEFAULT_PORT)
} else {
    SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), DEFAULT_PORT)
};

#[derive(Debug)]
pub struct Config {
    pub command: Command,
    pub info_command: Option<InfoCommand>,
    pub listen_addrs: Vec<SocketAddr>,
    pub frontend_dir: Option<String>,
    pub prometheus_addr: String,
    pub poll_rate_mins: u64,
    pub state_location: PathBuf,
    pub database_name: String,
    pub log_level: Level,
    pub log_format: LogFormat,
    pub log_target: LogTarget,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            command: Command::Serve,
            info_command: None,
            listen_addrs: vec![DEFAULT_LISTEN_ADDR],
            frontend_dir: if cfg!(debug_assertions) {
                Some("frontend".to_string())
            } else {
                None
            },
            prometheus_addr: "http://localhost/metrics".to_string(),
            poll_rate_mins: 1,
            state_location: PathBuf::from("."),
            database_name: version::NAME.into(),
            log_level: Level::Info,
            log_format: LogFormat::Plain,
            log_target: LogTarget::Stderr,
        }
    }
}

impl Config {
    pub fn database_name(&self) -> PathBuf {
        Path::new(&self.database_name).with_added_extension("db3")
    }

    pub fn database_path(&self) -> PathBuf {
        self.state_location.join(self.database_name())
    }

    pub fn poll_rate_duration(&self) -> Duration {
        Duration::from_mins(self.poll_rate_mins)
    }
}

#[derive(Clone, Debug, Default)]
pub enum Command {
    #[default]
    Serve,
    #[cfg(feature = "mock_data")]
    ServeMockData(String),
    #[cfg(feature = "mock_data")]
    Seed(String),
}

#[derive(Clone, Copy, Debug)]
pub enum InfoCommand {
    Usage,
    Version,
    VersionMore,
}

#[derive(Copy, Clone, Debug, Default)]
pub enum LogFormat {
    #[default]
    Plain,
    Pretty,
}

#[derive(Copy, Clone, Debug, Default)]
pub enum LogTarget {
    None,
    Stdout,
    #[default]
    Stderr,
}

#[derive(Debug)]
pub enum ConfigError {
    MissingArgument(String),
    #[cfg(feature = "mock_data")]
    MissingCommandArgument(String),
    UnrecognizedArgument(String),
    UnrecognizedCommand(String),
    ParseError(PathBuf, ParseError),
}

impl fmt::Display for ConfigError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ConfigError::MissingArgument(s) => {
                write!(f, "the flag {s} is missing its following argument")
            }
            #[cfg(feature = "mock_data")]
            ConfigError::MissingCommandArgument(s) => {
                write!(f, "the command {s} is missing its following argument")
            }
            ConfigError::UnrecognizedArgument(s) => write!(f, "unrecognized argument {s}"),
            ConfigError::UnrecognizedCommand(s) => write!(f, "unrecognized command {s}"),
            ConfigError::ParseError(p, e) => {
                write!(f, "error parsing config file {}: {e}", p.to_string_lossy())
            }
        }
    }
}