144 lines
4.5 KiB
Rust
144 lines
4.5 KiB
Rust
use chrony_candm::reply;
|
|
use figment::{
|
|
providers::{Format, Serialized, Toml},
|
|
util::map,
|
|
value::Map,
|
|
Figment,
|
|
};
|
|
use gethostname::gethostname;
|
|
use influxdb2::models::DataPoint;
|
|
use serde_derive::{Deserialize, Serialize};
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
use std::{
|
|
net::{IpAddr, Ipv4Addr},
|
|
path::Path,
|
|
};
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct InfluxConfig {
|
|
pub url: String,
|
|
pub org: String,
|
|
pub bucket: String,
|
|
pub token: String,
|
|
pub tags: Map<String, String>,
|
|
}
|
|
|
|
impl Default for InfluxConfig {
|
|
fn default() -> Self {
|
|
let host = gethostname().into_string().unwrap();
|
|
InfluxConfig {
|
|
url: "http://localhost:8086".into(),
|
|
org: "default".into(),
|
|
bucket: "default".into(),
|
|
token: "".into(),
|
|
tags: map! { "host".into() => host },
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct ChronyConfig {
|
|
pub enabled: bool,
|
|
pub timeout: u64,
|
|
pub poll_interval: u64,
|
|
pub measurement_prefix: String,
|
|
pub tracking_measurement: String,
|
|
pub sources_measurement: String,
|
|
pub host: IpAddr,
|
|
pub port: u16,
|
|
}
|
|
|
|
impl Default for ChronyConfig {
|
|
fn default() -> Self {
|
|
ChronyConfig {
|
|
enabled: false,
|
|
timeout: 5,
|
|
poll_interval: 60,
|
|
measurement_prefix: "chrony.".into(),
|
|
tracking_measurement: "tracking".into(),
|
|
sources_measurement: "sources".into(),
|
|
host: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
|
|
port: 323,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone, Default)]
|
|
pub struct SourcesConfig {
|
|
pub chrony: ChronyConfig,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone, Default)]
|
|
pub struct Config {
|
|
pub influxdb: InfluxConfig,
|
|
pub sources: SourcesConfig,
|
|
}
|
|
|
|
pub fn load_config(filename: &Path) -> Result<Config, Box<dyn std::error::Error>> {
|
|
let config = Figment::from(Serialized::defaults(Config::default()))
|
|
.merge(Toml::file(filename))
|
|
.extract()?;
|
|
Ok(config)
|
|
}
|
|
|
|
pub fn datapoint_from_tracking(
|
|
t: &reply::Tracking,
|
|
config: &Config,
|
|
) -> Result<DataPoint, Box<dyn std::error::Error>> {
|
|
let now = SystemTime::now().duration_since(UNIX_EPOCH)?;
|
|
let measurement = config.sources.chrony.measurement_prefix.to_owned()
|
|
+ &config.sources.chrony.tracking_measurement;
|
|
let mut builder =
|
|
DataPoint::builder(&measurement).timestamp(now.as_nanos().try_into().unwrap());
|
|
for (key, value) in &config.influxdb.tags {
|
|
builder = builder.tag(key, value);
|
|
}
|
|
|
|
let point = builder
|
|
.field("ref_id", t.ref_id as i64)
|
|
.field("ref_ip_addr", t.ip_addr.to_string())
|
|
.field("stratum", t.stratum as i64)
|
|
.field("leap_status", t.leap_status as i64)
|
|
.field("current_correction", f64::from(t.current_correction))
|
|
.field("last_offset", f64::from(t.last_offset))
|
|
.field("rms_offset", f64::from(t.rms_offset))
|
|
.field("freq_ppm", f64::from(t.freq_ppm))
|
|
.field("resid_freq_ppm", f64::from(t.resid_freq_ppm))
|
|
.field("skew_ppm", f64::from(t.skew_ppm))
|
|
.field("root_delay", f64::from(t.root_delay))
|
|
.field("root_dispersion", f64::from(t.root_dispersion))
|
|
.field("last_update_interval", f64::from(t.last_update_interval))
|
|
.build()?;
|
|
|
|
Ok(point)
|
|
}
|
|
|
|
pub fn datapoint_from_sourcedata(
|
|
d: &reply::SourceData,
|
|
config: &Config,
|
|
) -> Result<DataPoint, Box<dyn std::error::Error>> {
|
|
let now = SystemTime::now().duration_since(UNIX_EPOCH)?;
|
|
let measurement = config.sources.chrony.measurement_prefix.to_owned()
|
|
+ &config.sources.chrony.sources_measurement;
|
|
let mut builder =
|
|
DataPoint::builder(&measurement).timestamp(now.as_nanos().try_into().unwrap());
|
|
for (key, value) in &config.influxdb.tags {
|
|
builder = builder.tag(key, value)
|
|
}
|
|
builder = builder
|
|
.tag("ref_id", d.ip_addr.to_string())
|
|
.tag("mode", (d.mode as i64).to_string())
|
|
.tag("state", (d.state as i64).to_string())
|
|
.field("poll", d.poll as i64)
|
|
.field("stratum", d.stratum as i64)
|
|
.field("flags", d.flags.bits() as i64)
|
|
.field("reachability", d.reachability as i64)
|
|
.field("since_sample", d.since_sample as i64)
|
|
.field("orig_latest_meas", f64::from(d.orig_latest_meas))
|
|
.field("latest_meas", f64::from(d.latest_meas))
|
|
.field("latest_meas_err", f64::from(d.latest_meas_err));
|
|
let point = builder.build()?;
|
|
|
|
Ok(point)
|
|
}
|