chore(everything): too much honestly

.dockerignore

@@ -0,0 +1 @@
+target

.gitignore

@@ -0,0 +1,3 @@
+/debug
+/target
+Cargo.lock

.gitlab-ci.yml

@@ -0,0 +1,23 @@
+include:
+  - project: 'famedly/infra/templates/ci-cd'
+    ref: 'rust-v1'
+    file: '/rust.yml'
+  - project: 'famedly/infra/templates/ci-cd'
+    ref: 'docker-v1'
+    file: '/docker.yml'
+
+stages:
+  - test
+  - build
+
+cargo-check:
+  extends: .cargo_check
+
+cargo-build:
+  extends: .cargo_build
+
+docker_releases:
+  extends: .docker_releases
+
+docker_tags:
+  extends: .docker_tags

Cargo.toml

@@ -8,9 +8,9 @@ edition = "2021"
 [dependencies]
 config = { version = "0.13.1", features = ["yaml"] }
 serde = { version = "1.0", features = ["derive"] }
-prometheus-client = "0.19.0"
+metrics = "0.21.0"
+metrics-exporter-prometheus = { version = "0.12.1", features = ["http-listener"] }
 futures-util = "0.3.25"
-axum = "0.6.12"
 tokio = { version = "1.21.2", features = ["rt-multi-thread","macros"] }
 rsvici = "0.1"
 anyhow = "1.0.70"

Dockerfile

@@ -0,0 +1,11 @@
+FROM registry.gitlab.com/famedly/infra/containers/rust:main as builder
+COPY . /app
+WORKDIR /app
+
+RUN cargo build --release
+
+FROM debian:stable-slim
+RUN mkdir -p /opt/openmetrics-vici-exporter
+WORKDIR /opt/openmetrics-vici-exporter
+COPY --from=builder /app/target/release/openmetrics-vici-exporter /usr/local/bin/openmetrics-vici-exporter
+CMD ["/usr/local/bin/openmetrics-vici-exporter"]

config.yml

@@ -1,5 +1,7 @@
 ---
-vici_socket: "/var/run/charon.vici"
+vici:
-actix_bind_addr: "0.0.0.0"
+  socket: "/var/run/charon.vici"
-actix_bind_port: "80"
+  interval: 10
-actix_auth_token: ""
+server:
+  address: "0.0.0.0"
+  port: 8001

docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3'
+
+services:
+  ove:
+    restart: "unless-stopped"
+    environment:
+      - VICI_EXPORTER_VICI_SOCKET="/var/run/charon.vici"
+      - VICI_EXPORTER_VICI_INTERVAL=10
+      - VICI_EXPORTER_SERVER_ADDRESS=0.0.0.0
+      - VICI_EXPORTER_SERVER_PORT=8001
+    volumes:
+      #- ./config.yml:/opt/openmetrics-vici-exporter/config.yml
+      - /var/run/charon.vici:/var/run/charon.vici
+    ports:
+      - 8111:80/tcp

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 120

shell.nix

@@ -0,0 +1,5 @@
+{ pkgs ? import <nixpkgs> {} }:
+  pkgs.mkShell {
+    packages = with pkgs; [ rustc cargo gcc rustfmt clippy ];
+    name = "rust-env";
+}

src/config.rs

@@ -0,0 +1,41 @@
+use anyhow::Result;
+use config::Config;
+use serde::Deserialize;
+use std::net::{IpAddr, SocketAddr};
+
+#[derive(Debug, Deserialize)]
+pub struct WebServerConfig {
+    pub address: IpAddr,
+    pub port: u16,
+}
+impl Into<SocketAddr> for &WebServerConfig {
+    fn into(self) -> SocketAddr {
+        SocketAddr::from((self.address, self.port))
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct VICIConfig {
+    pub socket: String,
+    pub interval: u64,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Configuration {
+    pub server: WebServerConfig,
+    pub vici: VICIConfig,
+}
+
+impl Configuration {
+    pub async fn load() -> Result<Configuration> {
+        let mut s = Config::builder();
+        if std::fs::metadata("config").is_ok(){
+            s = s.add_source(config::File::with_name("config"));
+        } else { println!("config file not found. continuing with env vars... ") };
+
+        s = s.add_source(config::Environment::with_prefix("VICI_EXPORTER").separator("_"));
+//        s.build().unwrap();
+        let conf: Configuration = s.build().unwrap().try_deserialize().unwrap();
+        Ok(conf)
+    }
+}

src/main.rs

@@ -1,104 +1,56 @@
-#![allow(dead_code)]
+use metrics::{
-
+    describe_gauge, 
-use axum::{
+    gauge, 
-    response::IntoResponse,
+    describe_counter,
-    http::{
+    counter, 
-        StatusCode,
+    IntoLabels, 
-        header::{self}
+    Unit};
-    },
+use metrics_exporter_prometheus::PrometheusBuilder;
-    extract::State,
+use tokio::time::{interval, Duration, MissedTickBehavior};
-    routing::get,
-    Router,
-};
-
-use prometheus_client::{
-    registry::Registry,
-    metrics::{
-        family::Family,
-    }
-};
-
-use std::{
-//    collections::HashMap,
-//    error::Error,
-    sync::Arc,
-    net::{IpAddr,SocketAddr},
-//    path::Path,
-};
-
-use serde::Deserialize;
-
-use config::Config;
 
+pub mod config;
 pub mod vici;
-pub mod metrics;
-
-
-#[derive(Debug, Deserialize)]
-struct Configuration {
-    vici_socket: String,
-    axum_bind_addr: IpAddr,
-    axum_bind_port: u16,
-}
-
-pub async fn metrics_handler(State(state): State<Arc<AppState>>) -> impl IntoResponse {
-    let state: Arc<AppState> = state.clone();
-    let mut buffer = String::new();
-    prometheus_client::encoding::text::encode(&mut buffer, &state.registry).unwrap();
-    (
-        StatusCode::OK,
-        [(header::CONTENT_TYPE, "application/openmetrics-text; version=1.0.0; charset=utf-8")],
-        buffer,
-    )
-}
-
-pub struct AppState {
-    pub registry: Registry,
-    pub vici: vici::VICIState,
-}
-
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let settings = Config::builder()
+    let conf = config::Configuration::load().await?;
-        .add_source(config::File::with_name("config"))
+    let mut vici_client = rsvici::unix::connect(conf.vici.socket).await?;
-        .add_source(config::Environment::with_prefix("VICI_EXPORTER"))
-        .build()
-        .unwrap();
-    let mut conf: Configuration = settings.try_deserialize().unwrap();
-    let mut vici_client = rsvici::unix::connect(conf.vici_socket).await?;
-    let mut vici_state: vici::VICIState;
 
-    let metrics = Arc::new(metrics::Metrics {
+    let mut interval = interval(Duration::from_secs(conf.vici.interval));
-        sa_uptime: Family::default(),
+    interval.set_missed_tick_behavior(MissedTickBehavior::Skip);
-    });
 
-    let mut initial_registery = Registry::default();
+    PrometheusBuilder::new()
+        .with_http_listener(&conf.server)
+        .install()
+        .expect("failed to install recorder/exporter");
 
-    initial_registery.register(
+    describe_gauge!("sa_uptime", Unit::Seconds, "");
-        "sa_uptime",
+    describe_gauge!("sa_rekey_time", Unit::Seconds, "");
-        "How Long a connection has been established",
-        metrics.sa_uptime.clone(),
-    );
 
-    let mut state = Arc::new(
+    describe_counter!("sa_child_bytes_out", Unit::Bytes, "");
-        AppState {
+    describe_counter!("sa_child_bytes_in", Unit::Bytes, "");
-            registry: initial_registery,
-            vici: vici::VICIState::update(&mut vici_client).await?,
-        },
-    );
 
+    loop {
+        let vici_state = vici::VICIState::update(&mut vici_client).await?;
 
+        for (sa_name, sa_values) in vici_state.security_associations {
+            let mut labels = sa_values.into_labels();
+            labels.push((&("sa_name", sa_name.clone())).into());
 
-    let addr = SocketAddr::from((conf.axum_bind_addr,conf.axum_bind_port));
+            gauge!("sa_uptime", sa_values.established as f64, labels.clone());
-    let app = Router::new()
+            gauge!("sa_rekey_time", sa_values.rekey_time as f64, labels.clone());
-        .route("/metrics",get(metrics_handler))
+            //gauge!("sa_state")
-        .with_state(state);
+            for (sa_child_name, sa_child_values) in sa_values.child_security_associations {
+                let mut child_labels = sa_child_values.into_labels();
+                child_labels.push((&("sa_name", sa_name.clone())).into());
+                child_labels.push((&("sa_child_name", sa_child_name)).into());
+                counter!("sa_child_bytes_in", sa_child_values.bytes_in, child_labels.clone());
+                counter!("sa_child_bytes_out", sa_child_values.bytes_out, child_labels.clone());
+                counter!("sa_child_packets_in", sa_child_values.packets_in, child_labels.clone());
+                counter!("sa_child_packets_out", sa_child_values.packets_out, child_labels.clone());
             
-    axum::Server::bind(&addr)
+            }
-        .serve(app.into_make_service())
+        }
-        .await
+        interval.tick().await;
-        .unwrap();
+    }
-
-    Ok(())
 }

src/metrics.rs

@@ -1,25 +0,0 @@
-use prometheus_client::{
-    metrics::{
-        family::Family,
-        gauge::Gauge,
-    }
-};
-use anyhow::Result;
-
-use crate::vici;
-pub mod labels;
-
-pub struct Metrics {
-    pub sa_uptime: Family<labels::SecurityAssociationLabels, Gauge>,
-}
-
-impl Metrics {
-    pub async fn sa_uptime(&self, security_associations: vici::SecurityAssociations) -> Result<()>{
-        for named_sa in security_associations.into_iter() {
-            let label_set = labels::SecurityAssociationLabels::set_from_sa(&mut named_sa).await?;
-            let (_sa_name, sa_value) = named_sa;
-            self.sa_uptime.get_or_create(&label_set).set(sa_value.established as i64);
-        }
-        Ok(());
-    }
-}

src/metrics/labels.rs

@@ -1,65 +0,0 @@
-use serde::Deserialize;
-use prometheus_client::encoding::{EncodeLabelValue,EncodeLabelSet};
-
-use crate::vici;
-use anyhow::Result;
-
-
-// I don't really wanna define *all* of this here, it's gonna get really tedious and uncomfortable to maintain.
-
-/*
-#[derive(Debug, Deserialize, Clone, Hash, PartialEq, Eq)]
-pub struct SecurityAssociationLabels {
-    pub uniqueid: String,
-    pub local_id: String,
-    pub local_host: String,
-    pub local_port: u16,
-    pub remote_id: String,
-    pub remote_host: String,
-    pub remote_port: u16,
-}
-*/
-#[derive(Debug, Deserialize, Clone, Hash, PartialEq, Eq)]
-pub struct SecurityAssociationInfo {
-    pub uniqueid:       String,
-    pub version:        u8,
-    pub local_host:     String,
-    pub local_port:     u16,
-    pub local_id:       String,
-    pub remote_host:    String,
-    pub remote_port:    u16,
-    pub remote_id:      String,
-    pub if_id_in:       String,
-    pub if_id_out:      String,
-    pub encr_alg:       String,
-    pub encr_keysize:   String,
-    pub integ_alg:      String,
-    pub integ_keysize:  String,
-    pub prf_alg:        String,
-    pub dh_group:       Option<String>,
-    pub local_vips:     Vec<String>,
-    pub remote_vips:    Vec<String>,
-}
-
-#[derive(Debug, Clone, Hash, PartialEq, Eq, EncodeLabelSet)]
-pub struct SecurityAssociationLabels {
-    pub name: String,
-    pub uniqueid: String,
-    pub ike_version: u8,
-    pub local_id: String,
-    pub remote_id: String,
-}
-
-
-impl SecurityAssociationLabels {
-    pub async fn set_from_sa(sa: &mut vici::NamedSecurityAssociation) -> Result<SecurityAssociationLabels> {
-        let (sa_name, sa_value) = sa;
-        Ok(SecurityAssociationLabels {
-            name: sa_name,
-            uniqueid: sa_value.uniqueid,
-            ike_version: sa_value.version,
-            local_id: sa_value.local_id.unwrap(),
-            remote_id: sa_value.remote_id.unwrap(),
-        })
-    }
-}

src/vici.rs

@@ -6,47 +6,57 @@ use std::collections::HashMap;
 use futures_util::stream::StreamExt;
 
 use anyhow::Result;
+use metrics::{IntoLabels,Label};
 
 #[derive(Debug, Deserialize)]
 pub struct VICIState {
-    pub version:                Version,
+    pub version: Version,
-    pub statistics:             Statistics,
+    pub statistics: Statistics,
-    pub policies:               Policies,
+    pub policies: Policies,
-    pub connections:            Connections,
+    pub connections: Connections,
-    pub security_associations:  SecurityAssociations,
+    pub security_associations: SecurityAssociations,
-    pub certificates:           Certificates,
+    pub certificates: Certificates,
-    pub authorities:            Authorities,
+    pub authorities: Authorities,
-    pub pools:                  Pools,
+    pub pools: Pools,
 }
 
 impl VICIState {
     pub async fn update(client: &mut rsvici::Client) -> Result<VICIState> {
         Ok(VICIState {
-                version:                client.request("version", ()).await?,
+            version: client.request("version", ()).await?,
-                statistics:             client.request("statistics", ()).await?,
+            statistics: client.request("statistics", ()).await?,
-                policies:               collected_stream::<NamedPolicy, Policies>(client, "list-policies", "list-policy").await,
+            policies: collected_stream::<NamedPolicy, Policies>(client, "list-policies", "list-policy").await?,
-                connections:            collected_stream::<NamedConnection, Connections>(client, "list-connections", "list-conn").await,
+            connections: collected_stream::<NamedConnection, Connections>(client, "list-connections", "list-conn")
-                security_associations:  collected_stream::<NamedSecurityAssociation, SecurityAssociations>(client, "list-sas", "list-sa").await,
+                .await?,
-                certificates:           collected_stream::<NamedCertificate, Certificates>(client, "list-certs", "list-cert").await,
+            security_associations: collected_stream::<NamedSecurityAssociation, SecurityAssociations>(
-                authorities:            collected_stream::<NamedAuthority, Authorities>(client, "list-authorities", "list-authority").await,
+                client, "list-sas", "list-sa",
-                pools:                  collected_stream::<NamedPool, Pools>(client, "list-pools", "list-pool").await,
+            )
+            .await?,
+            certificates: collected_stream::<NamedCertificate, Certificates>(client, "list-certs", "list-cert").await?,
+            authorities: collected_stream::<NamedAuthority, Authorities>(client, "list-authorities", "list-authority")
+                .await?,
+            pools: collected_stream::<NamedPool, Pools>(client, "list-pools", "list-pool").await?,
         })
     }
 }
 
-async fn collected_stream<N,C>(client: &mut rsvici::Client, command: &str, event: &str) -> C
+async fn collected_stream<N, C>(client: &mut rsvici::Client, command: &str, event: &str) -> Result<C>
 where
     N: for<'de> serde::Deserialize<'de>,
     C: std::iter::Extend<N> + Default,
 {
-    client.stream_request::<(), N>(command, event, ()).filter_map(|event| async move {event.ok()}).collect::<C>().await
+    Ok(client
+        .stream_request::<(), N>(command, event, ())
+        .filter_map(|event| async move { event.ok() })
+        .collect::<C>()
+        .await)
 }
 
 // Structs for parsing the control interface
 
 #[derive(Debug, Deserialize)]
 pub struct Version {
-    pub daemon:  String,
+    pub daemon: String,
     pub version: String,
     pub sysname: String,
     pub release: String,
@@ -55,46 +65,46 @@ pub struct Version {
 
 #[derive(Debug, Deserialize)]
 pub struct Statistics {
-    pub uptime:                   StatisticsUptime,
+    pub uptime: StatisticsUptime,
-    pub workers:                  StatisticsWorkers,
+    pub workers: StatisticsWorkers,
-    pub queues:                   StatisticsJobPriorities,
+    pub queues: StatisticsJobPriorities,
-    pub scheduled:                String,
+    pub scheduled: String,
-    pub ikesecurity_associations: StatisticsIKESecurityAssociations,
+    pub ikesas: StatisticsIKESecurityAssociations,
-    pub plugins:                  Vec<String>,
+    pub plugins: Vec<String>,
-    pub mem:                      Option<StatisticsMem>,
+    pub mem: Option<StatisticsMem>,
-    pub mallinfo:                 Option<StatisticsMallinfo>,
+    pub mallinfo: Option<StatisticsMallinfo>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct StatisticsUptime {
     pub running: String,
-    pub since:   String,
+    pub since: String,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct StatisticsWorkers {
-    pub total:  String,
+    pub total: String,
-    pub idle:   String,
+    pub idle: String,
     pub active: StatisticsJobPriorities,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct StatisticsJobPriorities {
     pub critical: String,
-    pub high:     String,
+    pub high: String,
-    pub medium:   String,
+    pub medium: String,
-    pub low:      String,
+    pub low: String,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct StatisticsIKESecurityAssociations {
-    pub total:     String,
+    pub total: String,
     pub half_open: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct StatisticsMem {
-    pub total:  String,
+    pub total: String,
     pub allocs: String,
 }
 #[derive(Debug, Deserialize)]
@@ -111,19 +121,20 @@ pub type NamedPolicy = (String, Policy);
 
 #[derive(Debug, Deserialize)]
 pub struct Policy {
-    pub child:     String,
+    pub child: String,
-    pub ike:       Option<String>,
+    pub ike: Option<String>,
-    pub mode:      PolicyMode,
+    pub mode: PolicyMode,
-    pub local_ts:  Option<Vec<String>>,
+    pub local_ts: Option<Vec<String>>,
     pub remote_ts: Option<Vec<String>>,
 }
 
 #[derive(Debug, Deserialize)]
+#[serde(rename_all = "snake_case")]
 pub enum PolicyMode {
-    tunnel,
+    Tunnel,
-    transport,
+    Transport,
-    pass,
+    Pass,
-    drop,
+    Drop,
 }
 
 pub type Connections = HashMap<String, Conn>;
@@ -132,45 +143,46 @@ pub type NamedConnection = (String, Conn);
 
 #[derive(Debug, Deserialize)]
 pub struct Conn {
-    pub local_addrs:  Vec<String>,
+    pub local_addrs: Vec<String>,
     pub remote_addrs: Vec<String>,
-    pub version:      String,
+    pub version: String,
-    pub reauth_time:  u32,
+    pub reauth_time: u32,
-    pub rekey_time:   u32,
+    pub rekey_time: u32,
-    pub children:     HashMap<String, ConnChildSection>,
+    pub children: HashMap<String, ConnChildSection>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct ConnAuthSection {
-    pub class:        String,
+    pub class: String,
-    pub eap_type:     Option<String>,
+    pub eap_type: Option<String>,
-    pub eap_vendor:   Option<String>,
+    pub eap_vendor: Option<String>,
-    pub xauth:        Option<String>,
+    pub xauth: Option<String>,
-    pub revocation:   Option<String>,
+    pub revocation: Option<String>,
-    pub id:           String,
+    pub id: String,
-    pub aaa_id:       Option<String>,
+    pub aaa_id: Option<String>,
-    pub eap_id:       Option<String>,
+    pub eap_id: Option<String>,
-    pub xauth_id:     Option<String>,
+    pub xauth_id: Option<String>,
-    pub groups:       Option<Vec<String>>,
+    pub groups: Option<Vec<String>>,
     pub certificates: Option<Vec<String>>,
-    pub cacerts:      Option<Vec<String>>,
+    pub cacerts: Option<Vec<String>>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct ConnChildSection {
-    pub mode:          ChildSecurityAssociationMode,
+    pub mode: ChildSecurityAssociationMode,
-    pub rekey_time:    u32,
+    pub rekey_time: u32,
-    pub rekey_bytes:   u64,
+    pub rekey_bytes: u64,
     pub rekey_packets: u64,
-    pub local_ts:      Option<Vec<String>>,
+    pub local_ts: Option<Vec<String>>,
-    pub remote_ts:     Option<Vec<String>>,
+    pub remote_ts: Option<Vec<String>>,
 }
 
 #[derive(Debug, Deserialize, Clone, Hash, PartialEq, Eq)]
+#[serde(rename_all = "UPPERCASE")]
 pub enum ChildSecurityAssociationMode {
-    TUNNEL,
+    Tunnel,
-    TRANSPORT,
+    Transport,
-    BEET,
+    Beet,
 }
 #[derive(Debug, Deserialize, Clone, Hash, PartialEq, Eq)]
 pub enum ChildSecurityAssociationProtocol {
@@ -182,82 +194,103 @@ pub type SecurityAssociations = HashMap<String, SecurityAssociation>;
 
 pub type NamedSecurityAssociation = (String, SecurityAssociation);
 
-#[derive(Debug, Deserialize)]
+impl IntoLabels for &SecurityAssociation {
-pub struct SecurityAssociation {
+    fn into_labels(self) -> Vec<Label> {
-    pub uniqueid:                    String,
+        vec![
-    pub version:                     u8,
+            (&("uniqueid", self.uniqueid.clone())).into(),
-    pub state:                       String,
+            (&("remote_id", self.remote_id.clone())).into(),
-    pub local_host:                  Option<String>,
+            (&("local_id", self.local_id.clone())).into(),
-    pub local_port:                  Option<u16>,
+        ]
-    pub local_id:                    Option<String>,
+    }
-    pub remote_host:                 Option<String>,
-    pub remote_port:                 Option<u16>,
-    pub remote_id:                   Option<String>,
-    pub remote_xauth_id:             Option<String>,
-    pub remote_epa_id:               Option<String>,
-    pub initiator:                   Option<bool>,
-    pub initiator_spi:               Option<String>,
-    pub responder_spi:               Option<String>,
-    pub nat_local:                   Option<bool>,
-    pub nat_remote:                  Option<bool>,
-    pub nat_fake:                    Option<bool>,
-    pub nat_any:                     Option<bool>,
-    pub if_id_in:                    Option<String>,
-    pub if_id_out:                   Option<String>,
-    pub encr_alg:                    Option<String>,
-    pub encr_keysize:                Option<String>,
-    pub integ_alg:                   Option<String>,
-    pub integ_keysize:               Option<String>,
-    pub prf_alg:                     Option<String>,
-    pub dh_group:                    Option<String>,
-    pub established:                 u64,
-    pub rekey_time:                  Option<u32>,
-    pub reauth_time:                 Option<u32>,
-    pub local_vips:                  Option<Vec<String>>,
-    pub remote_vips:                 Option<Vec<String>>,
-    pub tasks_queued:                Option<Vec<String>>,
-    pub tasks_active:                Option<Vec<String>>,
-    pub tasks_passive:               Option<Vec<String>>,
-    pub child_security_associations: Option<HashMap<String, SecurityAssociationChild>>,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct SecurityAssociation {
+    pub uniqueid: String,
+    pub version: u8,
+    pub state: String,
+    pub local_host: String,
+    pub local_port: u16,
+    pub local_id: String,
+    pub remote_host: String,
+    pub remote_port: u16,
+    pub remote_id: String,
+    pub remote_xauth_id: Option<String>,
+    pub remote_epa_id: Option<String>,
+    pub initiator: Option<bool>,
+    pub initiator_spi: Option<String>,
+    pub responder_spi: Option<String>,
+    pub nat_local: Option<bool>,
+    pub nat_remote: Option<bool>,
+    pub nat_fake: Option<bool>,
+    pub nat_any: Option<bool>,
+    pub if_id_in: Option<String>,
+    pub if_id_out: Option<String>,
+    pub encr_alg: Option<String>,
+    pub encr_keysize: Option<String>,
+    pub integ_alg: Option<String>,
+    pub integ_keysize: Option<String>,
+    pub prf_alg: Option<String>,
+    pub dh_group: Option<String>,
+    pub established: u64,
+    pub rekey_time: u32,
+    pub reauth_time: Option<u32>,
+    pub local_vips: Option<Vec<String>>,
+    pub remote_vips: Option<Vec<String>>,
+    pub tasks_queued: Option<Vec<String>>,
+    pub tasks_active: Option<Vec<String>>,
+    pub tasks_passive: Option<Vec<String>>,
+    pub child_security_associations: HashMap<String, SecurityAssociationChild>,
+}
+
+
+impl IntoLabels for &SecurityAssociationChild {
+    fn into_labels(self) -> Vec<Label> {
+        vec![
+            (&("child_uniqueid", self.uniqueid.clone())).into(),
+            (&("child_reqid", self.reqid.clone())).into(),
+        ]
+    }
+}
+
+
 #[derive(Debug, Deserialize)]
 pub struct SecurityAssociationChild {
-    pub name:           String,
+    pub name: String,
-    pub uniqueid:       String,
+    pub uniqueid: String,
-    pub reqid:          String,
+    pub reqid: String,
-    pub state:          String,
+    pub state: String,
-    pub mode:           ChildSecurityAssociationMode,
+    pub mode: ChildSecurityAssociationMode,
-    pub protocol:       ChildSecurityAssociationProtocol,
+    pub protocol: ChildSecurityAssociationProtocol,
-    pub encap:          Option<bool>,
+    pub encap: Option<bool>,
-    pub spi_in:         String,
+    pub spi_in: String,
-    pub spi_out:        String,
+    pub spi_out: String,
-    pub cpi_in:         Option<String>,
+    pub cpi_in: Option<String>,
-    pub cpi_out:        Option<String>,
+    pub cpi_out: Option<String>,
-    pub mark_in:        Option<String>,
+    pub mark_in: Option<String>,
-    pub mark_mask_in:   Option<String>,
+    pub mark_mask_in: Option<String>,
-    pub mark_out:       Option<String>,
+    pub mark_out: Option<String>,
-    pub mark_mask_out:  Option<String>,
+    pub mark_mask_out: Option<String>,
-    pub if_id_in:       Option<String>,
+    pub if_id_in: Option<String>,
-    pub if_id_out:      Option<String>,
+    pub if_id_out: Option<String>,
-    pub encr_alg:       Option<String>,
+    pub encr_alg: Option<String>,
-    pub encr_keysize:   Option<String>,
+    pub encr_keysize: Option<String>,
-    pub integ_alg:      Option<String>,
+    pub integ_alg: Option<String>,
-    pub integ_keysize:  Option<String>,
+    pub integ_keysize: Option<String>,
-    pub prf_alg:        Option<String>,
+    pub prf_alg: Option<String>,
-    pub dh_group:       Option<String>,
+    pub dh_group: Option<String>,
-    pub esn:            Option<u16>,
+    pub esn: Option<u16>,
-    pub bytes_in:       u64,
+    pub bytes_in: u64,
-    pub packets_in:     u64,
+    pub packets_in: u64,
-    pub use_in:         Option<u32>,
+    pub use_in: Option<u32>,
-    pub bytes_out:      u64,
+    pub bytes_out: u64,
-    pub packets_out:    u64,
+    pub packets_out: u64,
-    pub use_out:        Option<u32>,
+    pub use_out: Option<u32>,
-    pub rekey_time:     Option<u32>,
+    pub rekey_time: u32,
-    pub life_time:      u32,
+    pub life_time: u32,
-    pub install_time:   u64,
+    pub install_time: u64,
-    pub local_ts:       Vec<String>,
+    pub local_ts: Vec<String>,
-    pub remote_ts:      Vec<String>,
+    pub remote_ts: Vec<String>,
 }
 
 pub type Certificates = HashMap<String, Cert>;
@@ -267,21 +300,25 @@ pub type NamedCertificate = (String, Cert);
 #[derive(Debug, Deserialize)]
 pub struct Cert {
     pub r#type: CertType,
-    pub flag:        X509CertFlag,
+    pub flag: X509CertFlag,
     pub has_privkey: Option<String>,
-    pub data:        String,
+    pub data: String,
-    pub subject:     Option<String>,
+    pub subject: Option<String>,
-    pub not_before:  Option<String>,
+    pub not_before: Option<String>,
-    pub not_after:   Option<String>,
+    pub not_after: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
 pub enum CertType {
     X509,
-    X509_AC,
+    #[serde(alias = "X509_AC")]
-    X509_CRL,
+    X509AC,
-    OSCP_RESPONSE,
+    #[serde(alias = "X509_CRL")]
-    PUBKEY,
+    X509CRL,
+    #[serde(alias = "OSCP_RESPONSE")]
+    OSCPResponse,
+    #[serde(alias = "PUBKEY")]
+    PubKey,
 }
 
 #[derive(Debug, Deserialize)]
@@ -298,35 +335,36 @@ pub type NamedAuthority = (String, Authority);
 
 #[derive(Debug, Deserialize)]
 pub struct Authority {
-    pub cacert:         String,
+    pub cacert: String,
-    pub crl_uris:       Vec<String>,
+    pub crl_uris: Vec<String>,
-    pub ocsp_uris:      Vec<String>,
+    pub ocsp_uris: Vec<String>,
-    pub cert_uri_base:  String,
+    pub cert_uri_base: String,
 }
 
 pub type Pools = HashMap<String, Pool>;
 
 pub type NamedPool = (String, Pool);
 
-#[derive(Debug,Deserialize)]
+#[derive(Debug, Deserialize)]
 pub struct Pool {
-    pub name:    String,
+    pub name: String,
-    pub base:    String,
+    pub base: String,
-    pub size:    u128,
+    pub size: u128,
-    pub online:  u128,
+    pub online: u128,
     pub offline: u128,
-    pub leases:  Option<HashMap<u16,PoolLease>>,
+    pub leases: Option<HashMap<u16, PoolLease>>,
-}
-
-#[derive(Debug,Deserialize)]
-pub struct PoolLease {
-    pub address:  String,
-    pub identity: String,
-    pub status:   PoolLeaseStatus,
 }
 
 #[derive(Debug, Deserialize)]
-pub enum PoolLeaseStatus {
+pub struct PoolLease {
-    online,
+    pub address: String,
-    offline,
+    pub identity: String,
+    pub status: PoolLeaseStatus,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PoolLeaseStatus {
+    Online,
+    Offline,
 }