porta-rs 0.1.1

Zero-trust CGNAT bypass via WireGuard tunnel
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

use anyhow::{Context, Result};
use chrono::{DateTime, Utc};
use std::fs;
use std::path::PathBuf;

use super::collector::MetricsSnapshot;

/// Metrics storage
pub struct MetricsStorage {
    path: PathBuf,
}

impl MetricsStorage {
    pub fn new(data_dir: &str) -> Self {
        Self {
            path: PathBuf::from(data_dir).join("metrics.json"),
        }
    }

    /// Load metrics from disk
    pub fn load(&self) -> Result<Vec<MetricsSnapshot>> {
        if !self.path.exists() {
            return Ok(Vec::new());
        }

        let content = fs::read_to_string(&self.path)
            .context(format!("Failed to read metrics from {}", self.path.display()))?;

        let snapshots: Vec<MetricsSnapshot> = serde_json::from_str(&content)
            .context("Failed to parse metrics")?;

        Ok(snapshots)
    }

    /// Save metrics to disk
    pub fn save(&self, snapshots: &[MetricsSnapshot]) -> Result<()> {
        let content = serde_json::to_string_pretty(snapshots)
            .context("Failed to serialize metrics")?;

        fs::write(&self.path, content)
            .context(format!("Failed to write metrics to {}", self.path.display()))?;

        Ok(())
    }

    /// Append a snapshot and save
    pub fn append(&self, snapshot: &MetricsSnapshot) -> Result<()> {
        let mut snapshots = self.load()?;
        snapshots.push(snapshot.clone());

        // Keep only last 1000 snapshots
        if snapshots.len() > 1000 {
            let drain_count = snapshots.len() - 1000;
            snapshots.drain(..drain_count);
        }

        self.save(&snapshots)
    }

    /// Get metrics for a time range
    pub fn get_range(&self, start: DateTime<Utc>, end: DateTime<Utc>) -> Result<Vec<MetricsSnapshot>> {
        let snapshots = self.load()?;

        Ok(snapshots
            .into_iter()
            .filter(|s| s.timestamp >= start && s.timestamp <= end)
            .collect())
    }
}