483 lines
18 KiB
Rust
483 lines
18 KiB
Rust
use cm_dashboard_shared::{Metric, Status};
|
|
use ratatui::{
|
|
layout::{Constraint, Direction, Layout, Rect},
|
|
widgets::Paragraph,
|
|
Frame,
|
|
};
|
|
use tracing::debug;
|
|
|
|
use super::Widget;
|
|
use crate::ui::theme::{StatusIcons, Typography};
|
|
|
|
/// Backup widget displaying backup status, services, and repository information
|
|
#[derive(Clone)]
|
|
pub struct BackupWidget {
|
|
/// Overall backup status
|
|
overall_status: Status,
|
|
/// Last backup duration in seconds
|
|
duration_seconds: Option<i64>,
|
|
/// Last backup timestamp
|
|
last_run_timestamp: Option<i64>,
|
|
/// Total number of backup services
|
|
total_services: Option<i64>,
|
|
/// Total repository size in GB
|
|
total_repo_size_gb: Option<f32>,
|
|
/// Total disk space for backups in GB
|
|
backup_disk_total_gb: Option<f32>,
|
|
/// Used disk space for backups in GB
|
|
backup_disk_used_gb: Option<f32>,
|
|
/// Backup disk product name from SMART data
|
|
backup_disk_product_name: Option<String>,
|
|
/// Backup disk serial number from SMART data
|
|
backup_disk_serial_number: Option<String>,
|
|
/// Backup disk filesystem label
|
|
backup_disk_filesystem_label: Option<String>,
|
|
/// Number of completed services
|
|
services_completed_count: Option<i64>,
|
|
/// Number of failed services
|
|
services_failed_count: Option<i64>,
|
|
/// Number of disabled services
|
|
services_disabled_count: Option<i64>,
|
|
/// All individual service metrics for detailed display
|
|
service_metrics: Vec<ServiceMetricData>,
|
|
/// Last update indicator
|
|
has_data: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct ServiceMetricData {
|
|
name: String,
|
|
status: Status,
|
|
exit_code: Option<i64>,
|
|
archive_count: Option<i64>,
|
|
repo_size_gb: Option<f32>,
|
|
}
|
|
|
|
impl BackupWidget {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
overall_status: Status::Unknown,
|
|
duration_seconds: None,
|
|
last_run_timestamp: None,
|
|
total_services: None,
|
|
total_repo_size_gb: None,
|
|
backup_disk_total_gb: None,
|
|
backup_disk_used_gb: None,
|
|
backup_disk_product_name: None,
|
|
backup_disk_serial_number: None,
|
|
backup_disk_filesystem_label: None,
|
|
services_completed_count: None,
|
|
services_failed_count: None,
|
|
services_disabled_count: None,
|
|
service_metrics: Vec::new(),
|
|
has_data: false,
|
|
}
|
|
}
|
|
|
|
/// Check if the backup widget has any data to display
|
|
pub fn has_data(&self) -> bool {
|
|
self.has_data
|
|
}
|
|
|
|
|
|
/// Format duration for display
|
|
fn format_duration(&self) -> String {
|
|
match self.duration_seconds {
|
|
Some(seconds) => {
|
|
if seconds >= 3600 {
|
|
format!("{:.1}h", seconds as f32 / 3600.0)
|
|
} else if seconds >= 60 {
|
|
format!("{:.1}m", seconds as f32 / 60.0)
|
|
} else {
|
|
format!("{}s", seconds)
|
|
}
|
|
}
|
|
None => "—".to_string(),
|
|
}
|
|
}
|
|
|
|
/// Format timestamp for display
|
|
fn format_last_run(&self) -> String {
|
|
match self.last_run_timestamp {
|
|
Some(timestamp) => {
|
|
let duration = chrono::Utc::now().timestamp() - timestamp;
|
|
if duration < 3600 {
|
|
format!("{}m ago", duration / 60)
|
|
} else if duration < 86400 {
|
|
format!("{}h ago", duration / 3600)
|
|
} else {
|
|
format!("{}d ago", duration / 86400)
|
|
}
|
|
}
|
|
None => "—".to_string(),
|
|
}
|
|
}
|
|
|
|
/// Format disk usage in format "usedGB/totalGB"
|
|
fn format_repo_size(&self) -> String {
|
|
match (self.backup_disk_used_gb, self.backup_disk_total_gb) {
|
|
(Some(used_gb), Some(total_gb)) => {
|
|
let used_str = Self::format_size_with_proper_units(used_gb);
|
|
let total_str = Self::format_size_with_proper_units(total_gb);
|
|
format!("{}/{}", used_str, total_str)
|
|
}
|
|
(Some(used_gb), None) => {
|
|
// Fallback to just used size if total not available
|
|
Self::format_size_with_proper_units(used_gb)
|
|
}
|
|
_ => "—".to_string(),
|
|
}
|
|
}
|
|
|
|
/// Format size with proper units (xxxkB/MB/GB/TB)
|
|
fn format_size_with_proper_units(size_gb: f32) -> String {
|
|
if size_gb >= 1000.0 {
|
|
// TB range
|
|
format!("{:.1}TB", size_gb / 1000.0)
|
|
} else if size_gb >= 1.0 {
|
|
// GB range
|
|
format!("{:.1}GB", size_gb)
|
|
} else if size_gb >= 0.001 {
|
|
// MB range (size_gb * 1024 = MB)
|
|
let size_mb = size_gb * 1024.0;
|
|
format!("{:.1}MB", size_mb)
|
|
} else if size_gb >= 0.000001 {
|
|
// kB range (size_gb * 1024 * 1024 = kB)
|
|
let size_kb = size_gb * 1024.0 * 1024.0;
|
|
format!("{:.0}kB", size_kb)
|
|
} else {
|
|
// B range (size_gb * 1024^3 = bytes)
|
|
let size_bytes = size_gb * 1024.0 * 1024.0 * 1024.0;
|
|
format!("{:.0}B", size_bytes)
|
|
}
|
|
}
|
|
|
|
/// Format product name display
|
|
fn format_product_name(&self) -> String {
|
|
if let Some(ref product_name) = self.backup_disk_product_name {
|
|
format!("P/N: {}", product_name)
|
|
} else {
|
|
"P/N: Unknown".to_string()
|
|
}
|
|
}
|
|
|
|
/// Format serial number display
|
|
fn format_serial_number(&self) -> String {
|
|
if let Some(ref serial) = self.backup_disk_serial_number {
|
|
format!("S/N: {}", serial)
|
|
} else {
|
|
"S/N: Unknown".to_string()
|
|
}
|
|
}
|
|
|
|
/// Extract service name from metric name (e.g., "backup_service_gitea_status" -> "gitea")
|
|
fn extract_service_name(metric_name: &str) -> Option<String> {
|
|
if metric_name.starts_with("backup_service_") {
|
|
let name_part = &metric_name[15..]; // Remove "backup_service_" prefix
|
|
|
|
// Try to extract service name by removing known suffixes
|
|
if let Some(service_name) = name_part.strip_suffix("_status") {
|
|
Some(service_name.to_string())
|
|
} else if let Some(service_name) = name_part.strip_suffix("_exit_code") {
|
|
Some(service_name.to_string())
|
|
} else if let Some(service_name) = name_part.strip_suffix("_archive_count") {
|
|
Some(service_name.to_string())
|
|
} else if let Some(service_name) = name_part.strip_suffix("_repo_size_gb") {
|
|
Some(service_name.to_string())
|
|
} else if let Some(service_name) = name_part.strip_suffix("_repo_path") {
|
|
Some(service_name.to_string())
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Widget for BackupWidget {
|
|
fn update_from_metrics(&mut self, metrics: &[&Metric]) {
|
|
debug!("Backup widget updating with {} metrics", metrics.len());
|
|
for metric in metrics {
|
|
debug!(
|
|
"Backup metric: {} = {:?} (status: {:?})",
|
|
metric.name, metric.value, metric.status
|
|
);
|
|
}
|
|
|
|
// Also debug the service_data after processing
|
|
debug!("Processing individual service metrics...");
|
|
|
|
// Log how many metrics are backup service metrics
|
|
let service_metric_count = metrics
|
|
.iter()
|
|
.filter(|m| m.name.starts_with("backup_service_"))
|
|
.count();
|
|
debug!(
|
|
"Found {} backup_service_ metrics out of {} total backup metrics",
|
|
service_metric_count,
|
|
metrics.len()
|
|
);
|
|
|
|
// Reset service metrics
|
|
self.service_metrics.clear();
|
|
let mut service_data: std::collections::HashMap<String, ServiceMetricData> =
|
|
std::collections::HashMap::new();
|
|
|
|
for metric in metrics {
|
|
match metric.name.as_str() {
|
|
"backup_overall_status" => {
|
|
let status_str = metric.value.as_string();
|
|
self.overall_status = match status_str.as_str() {
|
|
"ok" => Status::Ok,
|
|
"warning" => Status::Warning,
|
|
"critical" => Status::Critical,
|
|
_ => Status::Unknown,
|
|
};
|
|
}
|
|
"backup_duration_seconds" => {
|
|
self.duration_seconds = metric.value.as_i64();
|
|
}
|
|
"backup_last_run_timestamp" => {
|
|
self.last_run_timestamp = metric.value.as_i64();
|
|
}
|
|
"backup_total_services" => {
|
|
self.total_services = metric.value.as_i64();
|
|
}
|
|
"backup_total_repo_size_gb" => {
|
|
self.total_repo_size_gb = metric.value.as_f32();
|
|
}
|
|
"backup_disk_total_gb" => {
|
|
self.backup_disk_total_gb = metric.value.as_f32();
|
|
}
|
|
"backup_disk_used_gb" => {
|
|
self.backup_disk_used_gb = metric.value.as_f32();
|
|
}
|
|
"backup_disk_product_name" => {
|
|
self.backup_disk_product_name = Some(metric.value.as_string());
|
|
}
|
|
"backup_disk_serial_number" => {
|
|
self.backup_disk_serial_number = Some(metric.value.as_string());
|
|
}
|
|
"backup_disk_filesystem_label" => {
|
|
self.backup_disk_filesystem_label = Some(metric.value.as_string());
|
|
}
|
|
"backup_services_completed_count" => {
|
|
self.services_completed_count = metric.value.as_i64();
|
|
}
|
|
"backup_services_failed_count" => {
|
|
self.services_failed_count = metric.value.as_i64();
|
|
}
|
|
"backup_services_disabled_count" => {
|
|
self.services_disabled_count = metric.value.as_i64();
|
|
}
|
|
_ => {
|
|
// Handle individual service metrics
|
|
if let Some(service_name) = Self::extract_service_name(&metric.name) {
|
|
debug!(
|
|
"Extracted service name '{}' from metric '{}'",
|
|
service_name, metric.name
|
|
);
|
|
let entry = service_data.entry(service_name.clone()).or_insert_with(|| {
|
|
ServiceMetricData {
|
|
name: service_name,
|
|
status: Status::Unknown,
|
|
exit_code: None,
|
|
archive_count: None,
|
|
repo_size_gb: None,
|
|
}
|
|
});
|
|
|
|
if metric.name.ends_with("_status") {
|
|
entry.status = metric.status;
|
|
debug!("Set status for {}: {:?}", entry.name, entry.status);
|
|
} else if metric.name.ends_with("_exit_code") {
|
|
entry.exit_code = metric.value.as_i64();
|
|
} else if metric.name.ends_with("_archive_count") {
|
|
entry.archive_count = metric.value.as_i64();
|
|
debug!(
|
|
"Set archive_count for {}: {:?}",
|
|
entry.name, entry.archive_count
|
|
);
|
|
} else if metric.name.ends_with("_repo_size_gb") {
|
|
entry.repo_size_gb = metric.value.as_f32();
|
|
debug!(
|
|
"Set repo_size_gb for {}: {:?}",
|
|
entry.name, entry.repo_size_gb
|
|
);
|
|
}
|
|
} else {
|
|
debug!(
|
|
"Could not extract service name from metric: {}",
|
|
metric.name
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert service data to sorted vector
|
|
let mut services: Vec<ServiceMetricData> = service_data.into_values().collect();
|
|
services.sort_by(|a, b| a.name.cmp(&b.name));
|
|
self.service_metrics = services;
|
|
|
|
self.has_data = !metrics.is_empty();
|
|
|
|
debug!(
|
|
"Backup widget updated: status={:?}, services={}, total_size={:?}GB",
|
|
self.overall_status,
|
|
self.service_metrics.len(),
|
|
self.total_repo_size_gb
|
|
);
|
|
|
|
// Debug individual service data
|
|
for service in &self.service_metrics {
|
|
debug!(
|
|
"Service {}: status={:?}, archives={:?}, size={:?}GB",
|
|
service.name, service.status, service.archive_count, service.repo_size_gb
|
|
);
|
|
}
|
|
}
|
|
|
|
fn render(&mut self, frame: &mut Frame, area: Rect) {
|
|
// Split area into header and services list
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(6), // Header with "Latest backup" title, status, P/N, and S/N
|
|
Constraint::Min(0), // Service list
|
|
])
|
|
.split(area);
|
|
|
|
// Render backup overview
|
|
self.render_backup_overview(frame, chunks[0]);
|
|
|
|
// Render services list
|
|
self.render_services_list(frame, chunks[1]);
|
|
}
|
|
}
|
|
|
|
impl BackupWidget {
|
|
/// Render backup overview section
|
|
fn render_backup_overview(&self, frame: &mut Frame, area: Rect) {
|
|
let content_chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(1), // "Latest backup" header
|
|
Constraint::Length(1), // Status line
|
|
Constraint::Length(1), // Duration and last run
|
|
Constraint::Length(1), // Repository size
|
|
Constraint::Length(1), // Product name
|
|
Constraint::Length(1), // Serial number
|
|
Constraint::Min(0), // Remaining space
|
|
])
|
|
.split(area);
|
|
|
|
// "Latest backup" header
|
|
let header_para = Paragraph::new("Latest backup:").style(Typography::widget_title());
|
|
frame.render_widget(header_para, content_chunks[0]);
|
|
|
|
// Status line
|
|
let status_text = format!(
|
|
"Status: {}",
|
|
match self.overall_status {
|
|
Status::Ok => "OK",
|
|
Status::Warning => "Warning",
|
|
Status::Critical => "Failed",
|
|
Status::Unknown => "Unknown",
|
|
}
|
|
);
|
|
let status_spans = StatusIcons::create_status_spans(self.overall_status, &status_text);
|
|
let status_para = Paragraph::new(ratatui::text::Line::from(status_spans));
|
|
frame.render_widget(status_para, content_chunks[1]);
|
|
|
|
// Duration and last run
|
|
let time_text = format!(
|
|
"Duration: {} • Last: {}",
|
|
self.format_duration(),
|
|
self.format_last_run()
|
|
);
|
|
let time_para = Paragraph::new(time_text).style(Typography::secondary());
|
|
frame.render_widget(time_para, content_chunks[2]);
|
|
|
|
// Repository size
|
|
let size_text = format!("Disk usage: {}", self.format_repo_size());
|
|
let size_para = Paragraph::new(size_text).style(Typography::secondary());
|
|
frame.render_widget(size_para, content_chunks[3]);
|
|
|
|
// Product name
|
|
let product_text = self.format_product_name();
|
|
let product_para = Paragraph::new(product_text).style(Typography::secondary());
|
|
frame.render_widget(product_para, content_chunks[4]);
|
|
|
|
// Serial number
|
|
let serial_text = self.format_serial_number();
|
|
let serial_para = Paragraph::new(serial_text).style(Typography::secondary());
|
|
frame.render_widget(serial_para, content_chunks[5]);
|
|
}
|
|
|
|
/// Render services list section
|
|
fn render_services_list(&self, frame: &mut Frame, area: Rect) {
|
|
if area.height < 1 {
|
|
return;
|
|
}
|
|
|
|
let available_lines = area.height as usize;
|
|
let services_to_show = self.service_metrics.iter().take(available_lines);
|
|
|
|
let mut y_offset = 0;
|
|
for service in services_to_show {
|
|
if y_offset >= available_lines {
|
|
break;
|
|
}
|
|
|
|
let service_area = Rect {
|
|
x: area.x,
|
|
y: area.y + y_offset as u16,
|
|
width: area.width,
|
|
height: 1,
|
|
};
|
|
|
|
let service_info = if let (Some(archives), Some(size_gb)) =
|
|
(service.archive_count, service.repo_size_gb)
|
|
{
|
|
let size_str = Self::format_size_with_proper_units(size_gb);
|
|
format!(" {} archives {}", archives, size_str)
|
|
} else {
|
|
String::new()
|
|
};
|
|
|
|
let service_text = format!("{}{}", service.name, service_info);
|
|
let service_spans = StatusIcons::create_status_spans(service.status, &service_text);
|
|
let service_para = Paragraph::new(ratatui::text::Line::from(service_spans));
|
|
|
|
frame.render_widget(service_para, service_area);
|
|
y_offset += 1;
|
|
}
|
|
|
|
// If there are more services than we can show, indicate that
|
|
if self.service_metrics.len() > available_lines {
|
|
let more_count = self.service_metrics.len() - available_lines;
|
|
if available_lines > 0 {
|
|
let last_line_area = Rect {
|
|
x: area.x,
|
|
y: area.y + (available_lines - 1) as u16,
|
|
width: area.width,
|
|
height: 1,
|
|
};
|
|
|
|
let more_text = format!("... and {} more services", more_count);
|
|
let more_para = Paragraph::new(more_text).style(Typography::muted());
|
|
|
|
frame.render_widget(more_para, last_line_area);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for BackupWidget {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|