wip

2025-07-30 22:13:58 +02:00
parent af48990cf7
commit 357790ac34
21 changed files with 4257 additions and 110 deletions
--- a/system_monitor/README.md
+++ b/system_monitor/README.md
@@ -0,0 +1,329 @@
+# System Monitor
+
+Une crate Rust pour surveiller les ressources système (CPU, mémoire, swap, disque) avec des seuils configurables.
+
+## 📋 Description
+
+Cette crate fournit une API complète pour surveiller les ressources système et détecter les dépassements de seuils. Elle encapsule la complexité de `sysinfo` dans une interface simple et extensible, parfaite pour des systèmes d'alerte et de monitoring.
+
+## 🚀 Fonctionnalités
+
+- ✅ Surveillance du CPU, mémoire, swap et disque
+- ✅ Seuils configurables pour déclencher des alertes
+- ✅ API simple et extensible
+- ✅ Support pour des fonctions de surveillance personnalisées
+- ✅ Gestion automatique des cas d'erreur (division par zéro, etc.)
+- ✅ Structure orientée objet avec `SystemMonitor`
+- ✅ Surveillance spécifique des points de montage (`/` et `/home`)
+
+## 📦 Installation
+
+Ajoutez cette dépendance à votre `Cargo.toml` :
+
+```toml
+[dependencies]
+system_monitor = { path = "path/to/system_monitor" }
+```
+
+## 🔧 Utilisation
+
+### Utilisation basique
+
+```rust
+use system_monitor::SystemMonitor;
+
+// Utilisation avec les seuils par défaut
+let mut monitor = SystemMonitor::new();
+
+// Vérifier les seuils et obtenir les alertes
+let alerts = monitor.check_thresholds();
+for alert in alerts {
+    println!("🚨 Alerte: {}", alert);
+}
+
+// Obtenir un résumé du système
+let summary = monitor.get_system_summary();
+println!("📊 État système:\n{}", summary);
+```
+
+### Seuils personnalisés
+
+```rust
+use system_monitor::{SystemMonitor, ResourceThreshold, get_cpu_usage, get_memory_usage};
+
+// Créer des seuils personnalisés
+let custom_thresholds = vec![
+    ResourceThreshold::new(
+        "CPU".to_string(),
+        get_cpu_usage,
+        90.0, // Seuil à 90% au lieu de 80%
+        "CPU critique ! Intervention requise".to_string(),
+    ),
+    ResourceThreshold::new(
+        "Memory".to_string(),
+        get_memory_usage,
+        85.0, // Seuil mémoire à 85%
+        "Mémoire élevée détectée".to_string(),
+    ),
+];
+
+let mut monitor = SystemMonitor::new_with_thresholds(custom_thresholds);
+```
+
+### Surveillance continue
+
+```rust
+use system_monitor::SystemMonitor;
+use std::time::Duration;
+use std::thread;
+
+let mut monitor = SystemMonitor::new();
+
+loop {
+    // Actualiser les données système
+    monitor.refresh();
+    
+    // Vérifier les seuils
+    let alerts = monitor.check_thresholds();
+    
+    if !alerts.is_empty() {
+        for alert in alerts {
+            println!("🚨 {}", alert);
+            // Ici vous pourriez envoyer une notification
+        }
+    } else {
+        println!("✅ Système OK");
+    }
+    
+    // Attendre 30 secondes avant la prochaine vérification
+    thread::sleep(Duration::from_secs(30));
+}
+```
+
+## 📊 Métriques surveillées
+
+### Seuils par défaut
+
+- **CPU**: 80% - Utilisation globale du processeur
+- **Mémoire**: 80% - RAM utilisée vs totale
+- **Swap**: 80% - Espace swap utilisé vs total
+- **Disque**: 80% - Espace utilisé sur les points de montage `/` et `/home`
+
+### Détails des métriques
+
+#### CPU
+- Mesure l'utilisation globale du CPU en pourcentage
+- Basé sur la moyenne de tous les cœurs
+- Actualisé à chaque appel de `refresh()`
+
+#### Mémoire
+- Calcule le pourcentage de RAM utilisée
+- Inclut les buffers et cache système
+- Formule : `(mémoire_utilisée / mémoire_totale) * 100`
+
+#### Swap
+- Surveille l'utilisation de l'espace swap
+- Important pour détecter la saturation mémoire
+- Retourne 0% si aucun swap n'est configuré
+
+#### Disque
+- Surveille spécifiquement `/` (racine) et `/home`
+- Calcule l'espace utilisé combiné
+- Formule : `((total - disponible) / total) * 100`
+
+## 🎛️ API Reference
+
+### `SystemMonitor`
+
+#### Constructeurs
+
+```rust
+// Avec seuils par défaut
+pub fn new() -> Self
+
+// Avec seuils personnalisés
+pub fn new_with_thresholds(thresholds: Vec<ResourceThreshold>) -> Self
+```
+
+#### Méthodes
+
+```rust
+// Actualise les données système
+pub fn refresh(&mut self)
+
+// Vérifie les seuils et retourne les alertes
+pub fn check_thresholds(&mut self) -> Vec<String>
+
+// Retourne un résumé des ressources système
+pub fn get_system_summary(&self) -> String
+```
+
+### `ResourceThreshold`
+
+Structure pour définir des seuils personnalisés :
+
+```rust
+pub struct ResourceThreshold {
+    pub name: String,                                    // Nom de la ressource
+    pub get_usage_fn: fn(&System, &Disks) -> f32,      // Fonction de mesure
+    pub threshold: f32,                                  // Seuil (en %)
+    pub value: f32,                                      // Valeur actuelle
+    pub message: String,                                 // Message d'alerte
+}
+
+impl ResourceThreshold {
+    pub fn new(name: String, get_usage_fn: fn(&System, &Disks) -> f32, threshold: f32, message: String) -> Self
+    pub fn check(&mut self, sys: &System, disks: &Disks) -> Option<String>
+}
+```
+
+### Fonctions de surveillance
+
+```rust
+// Utilisation du CPU (%)
+pub fn get_cpu_usage(sys: &System, _: &Disks) -> f32
+
+// Utilisation de la mémoire (%)
+pub fn get_memory_usage(sys: &System, _: &Disks) -> f32
+
+// Utilisation du swap (%)
+pub fn get_swap_usage(sys: &System, _: &Disks) -> f32
+
+// Utilisation du disque (%)
+pub fn get_disk_usage(_: &System, disks: &Disks) -> f32
+
+// Seuils par défaut
+pub fn get_default_resource_thresholds() -> Vec<ResourceThreshold>
+```
+
+## 🔧 Surveillance personnalisée
+
+### Créer une fonction de surveillance custom
+
+```rust
+use system_monitor::{ResourceThreshold, SystemMonitor};
+use sysinfo::{System, Disks};
+
+// Fonction personnalisée pour surveiller la température CPU (exemple)
+fn get_cpu_temperature(sys: &System, _: &Disks) -> f32 {
+    // Implémentation exemple (nécessite une crate additionnelle)
+    // Retourne la température en degrés Celsius
+    65.0 // Valeur d'exemple
+}
+
+// Utilisation
+let custom_threshold = ResourceThreshold::new(
+    "CPU Temperature".to_string(),
+    get_cpu_temperature,
+    80.0, // Alerte si > 80°C
+    "Température CPU élevée !".to_string(),
+);
+
+let monitor = SystemMonitor::new_with_thresholds(vec![custom_threshold]);
+```
+
+### Surveiller des processus spécifiques
+
+```rust
+use sysinfo::{System, ProcessExt, Pid};
+
+fn get_process_memory_usage(sys: &System, _: &Disks) -> f32 {
+    if let Some(process) = sys.process(Pid::from(1234)) { // PID du processus
+        let process_memory = process.memory() as f32;
+        let total_memory = sys.total_memory() as f32;
+        (process_memory / total_memory) * 100.0
+    } else {
+        0.0
+    }
+}
+```
+
+## 🧪 Tests
+
+```bash
+# Exécuter tous les tests
+cargo test
+
+# Tests avec logs détaillés
+RUST_LOG=debug cargo test
+
+# Tests de performance
+cargo test --release
+```
+
+### Exemple de test
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cpu_usage() {
+        let sys = System::new_all();
+        let disks = Disks::new();
+        
+        let usage = get_cpu_usage(&sys, &disks);
+        assert!(usage >= 0.0 && usage <= 100.0);
+    }
+
+    #[test]
+    fn test_threshold_check() {
+        let mut threshold = ResourceThreshold::new(
+            "Test".to_string(),
+            |_, _| 85.0, // Fonction qui retourne toujours 85%
+            80.0,        // Seuil à 80%
+            "Test alert".to_string(),
+        );
+
+        let sys = System::new();
+        let disks = Disks::new();
+        
+        // Devrait déclencher une alerte
+        assert!(threshold.check(&sys, &disks).is_some());
+    }
+}
+```
+
+## 🔧 Dépannage
+
+### Problèmes courants
+
+**Valeurs de métrique à 0**
+- Sur certains systèmes, l'initialisation peut prendre du temps
+- Appelez `refresh()` et attendez quelques secondes
+
+**Permissions insuffisantes**
+- Certaines métriques peuvent nécessiter des privilèges élevés
+- Exécutez avec `sudo` si nécessaire
+
+**Pas de disque détecté**
+- Vérifiez que `/` et `/home` sont montés
+- Adaptez la fonction `get_disk_usage()` pour vos points de montage
+
+### Debug
+
+```rust
+// Activer les logs sysinfo
+RUST_LOG=sysinfo=debug cargo run
+
+// Inspecter les valeurs
+let monitor = SystemMonitor::new();
+println!("Disques détectés:");
+for disk in &monitor.disks {
+    println!("- {}: {} bytes", disk.mount_point().display(), disk.total_space());
+}
+```
+
+## 🚀 Extensions possibles
+
+- Surveillance réseau (bande passante, latence)
+- Surveillance de la température
+- Métriques de processus spécifiques
+- Historique des valeurs
+- Export vers des formats standards (Prometheus, etc.)
+- Surveillance de services système
+
+## 📄 Licence
+
+Cette crate est sous licence MIT.