cm-dashboard/shared/src/agent_data.rs

use serde::{Deserialize, Serialize};
use crate::Status;

/// Complete structured data from an agent
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentData {
    pub hostname: String,
    pub agent_version: String,
    pub build_version: Option<String>,
    pub timestamp: u64,
    pub system: SystemData,
    pub services: Vec<ServiceData>,
    pub backup: BackupData,
}

/// System-level monitoring data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemData {
    pub network: NetworkData,
    pub cpu: CpuData,
    pub memory: MemoryData,
    pub storage: StorageData,
}

/// Network interface monitoring data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkData {
    pub interfaces: Vec<NetworkInterfaceData>,
}

/// Individual network interface data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkInterfaceData {
    pub name: String,
    pub ipv4_addresses: Vec<String>,
    pub ipv6_addresses: Vec<String>,
    pub is_physical: bool,
    pub link_status: Status,
    pub parent_interface: Option<String>,
    pub vlan_id: Option<u16>,
    pub connection_method: Option<String>, // For Tailscale: "direct", "relay", or "proxy"
}

/// CPU C-state usage information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CStateInfo {
    pub name: String,
    pub percent: f32,
}

/// CPU monitoring data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuData {
    pub load_1min: f32,
    pub load_5min: f32,
    pub load_15min: f32,
    pub cstates: Vec<CStateInfo>, // C-state usage percentages (C1, C6, C10, etc.) - indicates CPU idle depth distribution
    pub temperature_celsius: Option<f32>,
    pub load_status: Status,
    pub temperature_status: Status,
    // Static CPU information (collected once at startup)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub core_count: Option<u32>,
}

/// Memory monitoring data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryData {
    pub usage_percent: f32,
    pub total_gb: f32,
    pub used_gb: f32,
    pub available_gb: f32,
    pub swap_total_gb: f32,
    pub swap_used_gb: f32,
    pub tmpfs: Vec<TmpfsData>,
    pub usage_status: Status,
}

/// Tmpfs filesystem data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TmpfsData {
    pub mount: String,
    pub usage_percent: f32,
    pub used_gb: f32,
    pub total_gb: f32,
}

/// Storage monitoring data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StorageData {
    pub drives: Vec<DriveData>,
    pub pools: Vec<PoolData>,
}

/// Individual drive data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriveData {
    pub name: String,
    pub serial_number: Option<String>,
    pub health: String,
    pub temperature_celsius: Option<f32>,
    pub wear_percent: Option<f32>,
    pub filesystems: Vec<FilesystemData>,
    pub temperature_status: Status,
    pub health_status: Status,
}

/// Filesystem on a drive
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FilesystemData {
    pub mount: String,
    pub usage_percent: f32,
    pub used_gb: f32,
    pub total_gb: f32,
    pub usage_status: Status,
}

/// Storage pool (MergerFS, RAID, etc.)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolData {
    pub name: String,
    pub mount: String,
    pub pool_type: String, // "mergerfs", "raid", etc.
    pub health: String,
    pub usage_percent: f32,
    pub used_gb: f32,
    pub total_gb: f32,
    pub data_drives: Vec<PoolDriveData>,
    pub parity_drives: Vec<PoolDriveData>,
    pub health_status: Status,
    pub usage_status: Status,
}

/// Drive in a storage pool
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolDriveData {
    pub name: String,
    pub serial_number: Option<String>,
    pub temperature_celsius: Option<f32>,
    pub wear_percent: Option<f32>,
    pub health: String,
    pub health_status: Status,
    pub temperature_status: Status,
}

/// Service monitoring data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServiceData {
    pub name: String,
    pub user_stopped: bool,
    pub service_status: Status,
    pub sub_services: Vec<SubServiceData>,
    /// Memory usage in bytes (from MemoryCurrent)
    pub memory_bytes: Option<u64>,
    /// Number of service restarts (from NRestarts)
    pub restart_count: Option<u32>,
    /// Uptime in seconds (calculated from ExecMainStartTimestamp)
    pub uptime_seconds: Option<u64>,
}

/// Sub-service data (nginx sites, docker containers, etc.)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubServiceData {
    pub name: String,
    pub service_status: Status,
    pub metrics: Vec<SubServiceMetric>,
    /// Type of sub-service: "nginx_site", "container", "image"
    #[serde(default)]
    pub service_type: String,
}

/// Individual metric for a sub-service
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubServiceMetric {
    pub label: String,
    pub value: f32,
    pub unit: Option<String>,
}

/// Backup system data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BackupData {
    pub last_backup_time: Option<String>,
    pub backup_status: Status,
    pub repositories: Vec<BackupRepositoryData>,
}

/// Individual backup repository information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BackupRepositoryData {
    pub name: String,
    pub archive_count: i64,
    pub repo_size_gb: f32,
    pub status: Status,
}

impl AgentData {
    /// Create new agent data with current timestamp
    pub fn new(hostname: String, agent_version: String) -> Self {
        Self {
            hostname,
            agent_version,
            build_version: None,
            timestamp: chrono::Utc::now().timestamp() as u64,
            system: SystemData {
                network: NetworkData {
                    interfaces: Vec::new(),
                },
                cpu: CpuData {
                    load_1min: 0.0,
                    load_5min: 0.0,
                    load_15min: 0.0,
                    cstates: Vec::new(),
                    temperature_celsius: None,
                    load_status: Status::Unknown,
                    temperature_status: Status::Unknown,
                    model_name: None,
                    core_count: None,
                },
                memory: MemoryData {
                    usage_percent: 0.0,
                    total_gb: 0.0,
                    used_gb: 0.0,
                    available_gb: 0.0,
                    swap_total_gb: 0.0,
                    swap_used_gb: 0.0,
                    tmpfs: Vec::new(),
                    usage_status: Status::Unknown,
                },
                storage: StorageData {
                    drives: Vec::new(),
                    pools: Vec::new(),
                },
            },
            services: Vec::new(),
            backup: BackupData {
                last_backup_time: None,
                backup_status: Status::Unknown,
                repositories: Vec::new(),
            },
        }
    }
}