Premier commit

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-11 01:55:32 +02:00
révision 0f79f0e2e4
32 fichiers modifiés
+7043

Aucun fichier ne correspond à votre recherche

+66
Voir le fichier
@@ -0,0 +1,66 @@
# --- double-push : exclusions generiques (secrets, builds, binaires, gros fichiers) ---
target/
node_modules/
build/
build-*/
dist/
out/
.gradle/
.idea/
venv/
.venv/
env/
__pycache__/
*.pyc
.cache/
.next/
.env
.env.*
!.env.example
accounts.json
Clee.API/
*.pem
*.key
*.p12
*.pfx
*.jks
*.keystore
keystore.properties
id_rsa*
id_ed25519*
*.kdbx
*.odt
*.sqlite
*.sqlite3
*.db
*.log
*.exe
*.dll
*.msi
*.jar
*.zip
*.7z
*.rar
*.tar
*.tar.gz
*.tgz
*.gguf
*.safetensors
*.onnx
*.pt
*.pth
*.bin
*.iso
*.gws
*.apk
*.aab
*.so
*.o
*.a
*.lib
*.pdb
*.mp4
*.mkv
*.wav
*.flac
+4
Voir le fichier
@@ -0,0 +1,4 @@
# Generated by Cargo
# will have compiled files and executables
/target/
/gen/schemas
+4516
Voir le fichier
Diff désactivé car ce fichier est trop long. Voir la Diff
+44
Voir le fichier
@@ -0,0 +1,44 @@
[package]
name = "verif-etat"
version = "1.0.0"
description = "Vérificateur SMART et diagnostic disque haute précision"
authors = ["VerifEtat"]
edition = "2021"
[lib]
name = "verif_etat_lib"
crate-type = ["staticlib", "cdylib", "rlib"]
[build-dependencies]
tauri-build = { version = "2.6.3", features = [] }
[dependencies]
tauri = { version = "2.11.3", features = [] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
chrono = { version = "0.4", features = ["serde"] }
windows-sys = { version = "0.59", features = [
"Win32_Foundation",
"Win32_Storage_FileSystem",
"Win32_System_Ioctl",
"Win32_System_IO",
"Win32_Security",
"Win32_System_Threading",
"Win32_UI_Shell",
"Win32_System_Console",
] }
[[bin]]
name = "verif-etat"
path = "src/main.rs"
[[bin]]
name = "verifetat"
path = "src/cli_main.rs"
[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
panic = "abort"
strip = true
+3
Voir le fichier
@@ -0,0 +1,3 @@
fn main() {
tauri_build::build()
}
+11
Voir le fichier
@@ -0,0 +1,11 @@
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"description": "enables the default permissions",
"windows": [
"main"
],
"permissions": [
"core:default"
]
}
BIN
Voir le fichier
Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 11 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 23 KiB

BIN
Voir le fichier
Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 2.2 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 9.0 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 12 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 13 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 25 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 2.0 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 28 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 3.3 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 5.9 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 7.4 KiB

Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 3.9 KiB

BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 37 KiB

BIN
Voir le fichier
Fichier binaire non affiché.

Après

Largeur:  |  Hauteur:  |  Taille: 49 KiB

+95
Voir le fichier
@@ -0,0 +1,95 @@
use crate::diagnostic::DiagnosticEngine;
use crate::models::{BatchEntry, BatchSessionState, DiskInfo};
use crate::smart_reader::SmartReader;
use chrono::Local;
use std::collections::HashSet;
use std::sync::Mutex;
pub struct BatchManager {
is_running: bool,
ignored_indices: HashSet<u32>,
seen_identifiers: HashSet<String>,
registered_disks: Vec<BatchEntry>,
}
impl BatchManager {
pub fn new() -> Self {
Self {
is_running: false,
ignored_indices: HashSet::new(),
seen_identifiers: HashSet::new(),
registered_disks: Vec::new(),
}
}
pub fn start(&mut self, ignored: Vec<u32>) {
self.is_running = true;
self.ignored_indices = ignored.into_iter().collect();
self.seen_identifiers.clear();
self.registered_disks.clear();
// Enregistrer les disques déjà présents qui sont ignorés pour ne pas les enregistrer par erreur
let current_disks = SmartReader::scan_disks();
for disk in &current_disks {
if self.ignored_indices.contains(&disk.index) {
let id = Self::disk_identifier(disk);
self.seen_identifiers.insert(id);
}
}
}
pub fn stop(&mut self) {
self.is_running = false;
}
pub fn poll(&mut self) -> Vec<BatchEntry> {
if !self.is_running {
return Vec::new();
}
let mut newly_registered = Vec::new();
let disks = SmartReader::scan_disks();
for disk in disks {
// Ignorer si dans la liste d'exclusion
if self.ignored_indices.contains(&disk.index) {
continue;
}
let id = Self::disk_identifier(&disk);
if !self.seen_identifiers.contains(&id) {
self.seen_identifiers.insert(id.clone());
let diagnostic = DiagnosticEngine::evaluate(&disk);
let entry = BatchEntry {
timestamp: Local::now().format("%d/%m/%Y %H:%M:%S").to_string(),
disk,
diagnostic,
};
self.registered_disks.push(entry.clone());
newly_registered.push(entry);
}
}
newly_registered
}
pub fn get_state(&self) -> BatchSessionState {
BatchSessionState {
is_running: self.is_running,
ignored_disk_indices: self.ignored_indices.iter().copied().collect(),
registered_disks: self.registered_disks.clone(),
}
}
fn disk_identifier(disk: &DiskInfo) -> String {
if !disk.serial_number.is_empty() {
format!("{}_{}", disk.serial_number, disk.model)
} else {
format!("{}_{}_{}", disk.device_id, disk.model, disk.size_bytes)
}
}
}
pub struct BatchState(pub Mutex<BatchManager>);
+382
Voir le fichier
@@ -0,0 +1,382 @@
use crate::diagnostic::DiagnosticEngine;
use crate::models::{DiskInfo, DriveType, EvaluatedDisk};
use crate::smart_reader::SmartReader;
pub struct CliRunner;
impl CliRunner {
/// Active le support ANSI (couleurs) dans la console Windows
fn enable_ansi_colors() {
#[cfg(windows)]
unsafe {
use windows_sys::Win32::System::Console::{
GetConsoleMode, GetStdHandle, SetConsoleMode, ENABLE_VIRTUAL_TERMINAL_PROCESSING,
STD_OUTPUT_HANDLE,
};
let handle = GetStdHandle(STD_OUTPUT_HANDLE);
let mut mode = 0u32;
if GetConsoleMode(handle, &mut mode) != 0 {
SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
}
}
}
/// Point d'entrée principal de la CLI
pub fn run(args: &[String]) -> i32 {
Self::enable_ansi_colors();
let is_elevated = SmartReader::is_elevated();
// Analyse des arguments
let mut target = String::new();
let mut json_mode = false;
let mut raw_mode = false;
for arg in args.iter().skip(1) {
let a = arg.trim();
if a.eq_ignore_ascii_case("--json") || a.eq_ignore_ascii_case("-j") || a.eq_ignore_ascii_case("json") {
json_mode = true;
} else if a.eq_ignore_ascii_case("--raw") || a.eq_ignore_ascii_case("-r") || a.eq_ignore_ascii_case("raw") {
raw_mode = true;
} else if a.eq_ignore_ascii_case("--help") || a.eq_ignore_ascii_case("-h") || a.eq_ignore_ascii_case("help") {
Self::print_help();
return 0;
} else if target.is_empty() {
target = a.to_string();
}
}
if target.is_empty() {
Self::print_help();
return 0;
}
let disks = SmartReader::scan_disks();
if target.eq_ignore_ascii_case("all") {
Self::handle_all(&disks, json_mode, is_elevated)
} else {
Self::handle_single(&disks, &target, json_mode, raw_mode, is_elevated)
}
}
fn print_help() {
println!("\x1b[1;36mVerifEtat - Diagnostic SMART & Intégrité Disques (CLI)\x1b[0m");
println!("Utilitaire d'audit matériel et d'analyse prédictive de santé des disques.\n");
println!("\x1b[1mUTILISATION:\x1b[0m");
println!(" verifetat all [--json] Lister tous les disques et leur état");
println!(" verifetat <disque|lettre|chemin> [--json] Examiner un disque en détail avec codes d'erreur bruts\n");
println!("\x1b[1mEXEMPLES:\x1b[0m");
println!(" verifetat all");
println!(" verifetat all --json");
println!(" verifetat C:");
println!(" verifetat D:");
println!(" verifetat 0");
println!(" verifetat \\\\.\\PhysicalDrive0");
println!(" verifetat D: --json\n");
}
/// Commande : verifetat all
fn handle_all(disks: &[DiskInfo], json_mode: bool, is_elevated: bool) -> i32 {
let mut evaluated_disks = Vec::new();
for disk in disks {
let diagnostic = DiagnosticEngine::evaluate(disk);
evaluated_disks.push(EvaluatedDisk {
disk: disk.clone(),
diagnostic,
});
}
if json_mode {
match serde_json::to_string_pretty(&evaluated_disks) {
Ok(json_str) => {
println!("{}", json_str);
return 0;
}
Err(err) => {
eprintln!("Erreur de sérialisation JSON: {}", err);
return 1;
}
}
}
// Affichage synthétique console
println!("\x1b[1;34m╔═══════════════════════════════════════════════════════════════════════════════════════════╗\x1b[0m");
println!("\x1b[1;34m║\x1b[0m \x1b[1;37mVerifEtat - Audit des disques détectés ({} disque(s) au total)\x1b[0m", disks.len());
println!("\x1b[1;34m╚═══════════════════════════════════════════════════════════════════════════════════════════╝\x1b[0m");
if !is_elevated {
println!("\x1b[33m[!] Note: Exécution en mode standard. Pour les registres SMART IOCTL bas niveau complets,\n lancez PowerShell en tant qu'Administrateur.\x1b[0m\n");
}
if evaluated_disks.is_empty() {
println!("\x1b[31mAucun disque physique détecté.\x1b[0m");
return 0;
}
for (idx, item) in evaluated_disks.iter().enumerate() {
let disk = &item.disk;
let diag = &item.diagnostic;
let smart = &disk.smart;
let letters_str = if !disk.mount_points.is_empty() {
format!(" [{}]", disk.mount_points.join(", "))
} else if disk.is_system_drive {
" [C: (Système)]".to_string()
} else {
String::new()
};
let score_color = if diag.health_score >= 85 {
"\x1b[1;32m" // Vert
} else if diag.health_score >= 60 {
"\x1b[1;33m" // Jaune
} else if diag.health_score >= 30 {
"\x1b[1;35m" // Orange/Magenta
} else {
"\x1b[1;31m" // Rouge
};
let type_label = match disk.drive_type {
DriveType::Nvme => "NVMe",
DriveType::Ssd => "SSD SATA",
DriveType::Hdd => "HDD",
DriveType::Unknown => "Inconnu",
};
let temp_str = smart
.temperature_celsius
.map(|t| format!("{} °C", t))
.unwrap_or_else(|| "N/A".to_string());
let wear_str = match smart.ssd_wear_percentage {
Some(w) => format!("{}% usé", w),
None => {
if disk.drive_type == DriveType::Hdd {
"N/A (Plateaux)".to_string()
} else {
"N/A".to_string()
}
}
};
println!(
" \x1b[1;36m#{}\x1b[0m \x1b[1;37m{}\x1b[0m\x1b[1;33m{}\x1b[0m (\\PhysicalDrive{})",
idx, disk.model, letters_str, disk.index
);
println!(
" \x1b[90m├─\x1b[0m Type: \x1b[1m{}\x1b[0m | Capacité: \x1b[1m{}\x1b[0m | Température: \x1b[1m{}\x1b[0m | Usure Flash: \x1b[1m{}\x1b[0m",
type_label, disk.size_formatted, temp_str, wear_str
);
println!(
" \x1b[90m├─\x1b[0m Compteurs: \x1b[1m{} h\x1b[0m | \x1b[1m{} cycles\x1b[0m | Réalloués: \x1b[1m{}\x1b[0m | En attente: \x1b[1m{}\x1b[0m | Incorrigibles: \x1b[1m{}\x1b[0m | CRC: \x1b[1m{}\x1b[0m",
smart.power_on_hours, smart.power_cycles, smart.reallocated_sectors, smart.pending_sectors, smart.uncorrectable_sectors, smart.crc_errors
);
println!(
" \x1b[90m└─\x1b[0m Santé: {}{}% \x1b[0m| Verdict: {}{}\x1b[0m",
score_color, diag.health_score, score_color, diag.verdict_title
);
println!();
}
println!("\x1b[90mAstuce: Pour examiner un disque spécifique et extraire tous ses codes d'erreur bruts en JSON:\x1b[0m");
println!("\x1b[90m verifetat C: ou verifetat 0 ou verifetat all --json\x1b[0m");
0
}
/// Commande : verifetat [lettre|chemin|index]
fn handle_single(disks: &[DiskInfo], target: &str, json_mode: bool, _raw_mode: bool, is_elevated: bool) -> i32 {
let matched = SmartReader::resolve_disk(target, disks);
let disk = match matched {
Some(d) => d,
None => {
eprintln!("\x1b[1;31m[Erreur] Disque introuvable pour la cible '{}'.\x1b[0m", target);
eprintln!("Disques et lettres disponibles sur ce système :");
for d in disks {
let letters = if !d.mount_points.is_empty() {
d.mount_points.join(", ")
} else if d.is_system_drive {
"C:".to_string()
} else {
"Aucune lettre assignée".to_string()
};
eprintln!(" - Index {}: {} [{}] ({})", d.index, d.model, letters, d.device_id);
}
return 1;
}
};
let diagnostic = DiagnosticEngine::evaluate(disk);
let evaluated = EvaluatedDisk {
disk: disk.clone(),
diagnostic: diagnostic.clone(),
};
// Si mode purement JSON demandé
if json_mode {
match serde_json::to_string_pretty(&evaluated) {
Ok(json_str) => {
println!("{}", json_str);
return 0;
}
Err(err) => {
eprintln!("Erreur de sérialisation JSON: {}", err);
return 1;
}
}
}
// Affichage détaillé structuré
let smart = &disk.smart;
let score_color = if diagnostic.health_score >= 85 {
"\x1b[1;32m" // Vert
} else if diagnostic.health_score >= 60 {
"\x1b[1;33m" // Jaune
} else if diagnostic.health_score >= 30 {
"\x1b[1;35m" // Orange
} else {
"\x1b[1;31m" // Rouge
};
let letters_str = if !disk.mount_points.is_empty() {
disk.mount_points.join(", ")
} else if disk.is_system_drive {
"C: (Système)".to_string()
} else {
"Non assignée".to_string()
};
println!("\x1b[1;34m╔═══════════════════════════════════════════════════════════════════════════════════════════╗\x1b[0m");
println!("\x1b[1;34m║\x1b[0m \x1b[1;37mVerifEtat - Audit Détaillé & Télémétrie SMART : {}\x1b[0m", disk.model);
println!("\x1b[1;34m╚═══════════════════════════════════════════════════════════════════════════════════════════╝\x1b[0m");
if !is_elevated {
println!("\x1b[33m[!] Note: Mode standard actif. Pour déverrouiller tous les registres SMART IOCTL,\n exécutez PowerShell en tant qu'Administrateur.\x1b[0m\n");
}
// 1. Informations générales
println!("\x1b[1;36m[IDENTIFICATION MATÉRIELLE]\x1b[0m");
println!(" • Modèle : \x1b[1m{}\x1b[0m", disk.model);
println!(" • Numéro de série : \x1b[1m{}\x1b[0m", if disk.serial_number.is_empty() { "N/A" } else { &disk.serial_number });
println!(" • Périphérique : {}", disk.device_id);
println!(" • Point(s) de montage : \x1b[1;33m{}\x1b[0m", letters_str);
println!(" • Capacité : \x1b[1m{}\x1b[0m ({} octets)", disk.size_formatted, disk.size_bytes);
println!(" • Protocole & Type : {:?} ({:?})", disk.bus_protocol, disk.drive_type);
if let Some(rpm) = disk.rpm {
println!(" • Vitesse rotation : {} RPM", rpm);
} else {
println!(" • Vitesse rotation : Mémoire Flash (Sans rotation)");
}
println!();
// 2. Verdict & Synthèse
println!("\x1b[1;36m[VERDICT OFFICIEL & SCORE DE SANTÉ]\x1b[0m");
println!(" • Indice de santé : {}{}% / 100%\x1b[0m", score_color, diagnostic.health_score);
println!(" • Verdict officiel : {}{}\x1b[0m", score_color, diagnostic.verdict_title);
println!(" • Synthèse : {}", diagnostic.primary_summary);
if let Some(years) = diagnostic.server_recommended_years {
println!(" • Sérénité 24/7 : \x1b[1;32mRecommandé pour ~{} an(s) avant surveillance renforcée\x1b[0m", years);
}
println!();
// 3. Points clés de l'évaluation
println!("\x1b[1;36m[POINTS CLÉS DE L'AUDIT ALGORITHMIQUE]\x1b[0m");
for phrase in &diagnostic.highlighted_phrases {
println!(" \x1b[32m✔\x1b[0m {}", phrase);
}
println!();
// 4. Compteurs Principaux
println!("\x1b[1;36m[MÉTRIQUES SMART PRINCIPALES]\x1b[0m");
println!(" • Heures de fonctionnement : \x1b[1m{} heures\x1b[0m (~{:.1} ans continus)", smart.power_on_hours, (smart.power_on_hours as f64) / 8760.0);
println!(" • Cycles d'alimentation : \x1b[1m{} cycles\x1b[0m", smart.power_cycles);
println!(" • Température actuelle : {}", smart.temperature_celsius.map(|t| format!("{} °C", t)).unwrap_or_else(|| "N/A".to_string()));
println!(" • Secteurs réalloués (05) : {}", format_error_counter(smart.reallocated_sectors));
println!(" • Secteurs en attente (C5) : {}", format_error_counter(smart.pending_sectors));
println!(" • Secteurs incorrigibles : {}", format_error_counter(smart.uncorrectable_sectors));
println!(" • Erreurs CRC liaison (C7) : {}", format_error_counter(smart.crc_errors));
if let Some(w) = smart.ssd_wear_percentage {
println!(" • Usure des cellules Flash : \x1b[1m{}% usé\x1b[0m (Santé restante: \x1b[1m{}%\x1b[0m)", w, 100 - w);
}
if let Some(s) = smart.nvme_available_spare {
println!(" • Réserve NVMe (Spare) : \x1b[1m{}% disponible\x1b[0m", s);
}
if let Some(sh) = smart.unsafe_shutdowns {
println!(" • Coupures de courant inopinées: {} fois", sh);
}
println!();
// 5. Tableau des codes d'erreur bruts et attributs SMART complets (ATA)
if !smart.raw_ata_attributes.is_empty() {
println!("\x1b[1;36m[TABLEAU DES CODES D'ERREUR BRUTS & REGISTRES SMART ATA]\x1b[0m");
println!("┌──────┬───────────────────────────────────────────┬────────┬──────┬──────────────────────────────┐");
println!("│ ID │ Nom de l'attribut │ Actuel │ Pire │ Valeur brute (Hex / Décimal) │");
println!("├──────┼───────────────────────────────────────────┼────────┼──────┼──────────────────────────────┤");
for attr in &smart.raw_ata_attributes {
let is_critical = matches!(attr.id, 0x05 | 0xC5 | 0xC6 | 0xB8);
let has_errors = is_critical && attr.raw_value > 0;
let color_prefix = if has_errors { "\x1b[1;31m" } else { "" };
let color_suffix = if has_errors { "\x1b[0m" } else { "" };
println!(
"│ {}{:<4}\x1b[0m │ {}{:<41}\x1b[0m │ {:<6} │ {:<4} │ {}{:<12} ({:<10}){}\x1b[0m │",
color_prefix, attr.id_hex,
color_prefix, truncate_str(&attr.name, 41),
attr.current, attr.worst,
color_prefix, attr.raw_hex, attr.raw_value, color_suffix
);
}
println!("└──────┴───────────────────────────────────────────┴────────┴──────┴──────────────────────────────┘");
println!();
}
// 6. Télémétrie brute NVMe si disponible
if let Some(raw_nvme) = &smart.raw_nvme_health {
println!("\x1b[1;36m[REGISTRES BRUTS DU CONTRÔLEUR NVMe (LOG PAGE 0x02)]\x1b[0m");
println!(" • Critical Warning Flags : 0x{:02X}", raw_nvme.critical_warning);
println!(" • Available Spare : {}%", raw_nvme.available_spare_percentage);
println!(" • Percentage Used (Wear) : {}%", raw_nvme.percentage_used);
println!(" • Data Units Read : {} ({:.2} To)", raw_nvme.data_units_read, (raw_nvme.data_units_read as f64 * 512_000.0) / 1e12);
println!(" • Data Units Written : {} ({:.2} To)", raw_nvme.data_units_written, (raw_nvme.data_units_written as f64 * 512_000.0) / 1e12);
println!(" • Host Read Commands : {}", raw_nvme.host_read_commands);
println!(" • Host Write Commands : {}", raw_nvme.host_write_commands);
println!(" • Controller Busy Time : {} minutes", raw_nvme.controller_busy_time_minutes);
println!(" • Media & Integrity Errs : {}", raw_nvme.media_and_data_integrity_errors);
println!(" • Error Log Entries : {}", raw_nvme.number_of_error_information_log_entries);
println!();
}
// 7. Dump JSON complet demandé par l'utilisateur
println!("\x1b[1;36m[EXTRACTION JSON COMPLÈTE DU DISQUE & CODES D'ERREURS]\x1b[0m");
match serde_json::to_string_pretty(&evaluated) {
Ok(json_str) => {
println!("{}", json_str);
}
Err(e) => {
eprintln!("Erreur affichage JSON: {}", e);
}
}
0
}
}
fn format_error_counter(val: u64) -> String {
if val == 0 {
"\x1b[1;32m0 (Aucune erreur)\x1b[0m".to_string()
} else {
format!("\x1b[1;31m{} [ANOMALIE DÉTECTÉE]\x1b[0m", val)
}
}
fn truncate_str(s: &str, max_len: usize) -> String {
if s.len() <= max_len {
s.to_string()
} else {
format!("{}...", &s[..max_len.saturating_sub(3)])
}
}
+8
Voir le fichier
@@ -0,0 +1,8 @@
use std::env;
use verif_etat_lib::cli::CliRunner;
fn main() {
let args: Vec<String> = env::args().collect();
let code = CliRunner::run(&args);
std::process::exit(code);
}
+90
Voir le fichier
@@ -0,0 +1,90 @@
use crate::batch::BatchState;
use crate::diagnostic::DiagnosticEngine;
use crate::models::{BatchEntry, BatchSessionState, EvaluatedDisk};
use crate::smart_reader::SmartReader;
use std::env;
use std::ptr::null_mut;
use tauri::State;
use windows_sys::Win32::UI::Shell::ShellExecuteW;
#[tauri::command]
pub fn check_is_elevated() -> bool {
SmartReader::is_elevated()
}
#[tauri::command]
pub fn request_admin_relaunch() -> Result<(), String> {
if let Ok(exe_path) = env::current_exe() {
let exe_path_w: Vec<u16> = exe_path
.to_string_lossy()
.encode_utf16()
.chain(std::iter::once(0))
.collect();
let verb: Vec<u16> = "runas\0".encode_utf16().collect();
unsafe {
let res = ShellExecuteW(
null_mut(),
verb.as_ptr(),
exe_path_w.as_ptr(),
null_mut(),
null_mut(),
1, // SW_SHOWNORMAL
);
if (res as isize) > 32 {
std::process::exit(0);
} else {
return Err("Échec de la demande d'élévation Administrateur.".to_string());
}
}
}
Err("Impossible de localiser l'exécutable.".to_string())
}
#[tauri::command]
pub fn get_disks_with_diagnostic() -> Vec<EvaluatedDisk> {
let disks = SmartReader::scan_disks();
let mut results = Vec::new();
for disk in disks {
let diagnostic = DiagnosticEngine::evaluate(&disk);
results.push(EvaluatedDisk { disk, diagnostic });
}
results
}
#[tauri::command]
pub fn start_batch_session(
ignored_indices: Vec<u32>,
state: State<'_, BatchState>,
) -> Result<BatchSessionState, String> {
let mut batch = state.0.lock().map_err(|e| e.to_string())?;
batch.start(ignored_indices);
Ok(batch.get_state())
}
#[tauri::command]
pub fn stop_batch_session(state: State<'_, BatchState>) -> Result<BatchSessionState, String> {
let mut batch = state.0.lock().map_err(|e| e.to_string())?;
batch.stop();
Ok(batch.get_state())
}
#[tauri::command]
pub fn poll_batch_session(state: State<'_, BatchState>) -> Result<Vec<BatchEntry>, String> {
let mut batch = state.0.lock().map_err(|e| e.to_string())?;
let new_entries = batch.poll();
Ok(new_entries)
}
#[tauri::command]
pub fn get_batch_state(state: State<'_, BatchState>) -> Result<BatchSessionState, String> {
let batch = state.0.lock().map_err(|e| e.to_string())?;
Ok(batch.get_state())
}
#[tauri::command]
pub fn export_batch_json_data(entries: Vec<BatchEntry>) -> Result<String, String> {
serde_json::to_string_pretty(&entries).map_err(|e| e.to_string())
}
+535
Voir le fichier
@@ -0,0 +1,535 @@
use crate::models::{DiagnosticResult, DiskInfo, DriveType, VerdictLevel};
pub struct DiagnosticEngine;
impl DiagnosticEngine {
/// 20 phrases détaillées pour Verdict 1 : Usage 24/24 serveur possible
pub fn phrases_verdict_1() -> Vec<&'static str> {
vec![
"Intégrité de surface immaculée : aucun secteur réalloué, aucun bloc défectueux n'a été substitué par le contrôleur.",
"Table de réallocation vierge garantissant des temps d'accès constants et une absence de latence sur les entrées/sorties.",
"Aucun secteur instable en attente de réécriture (Pending Sectors = 0), assurant une intégrité parfaite des blocs de données.",
"Compteur d'erreurs incorrigibles hors-ligne à zéro : la surface magnétique/flash ne présente aucune zone opaque.",
"Bus de transfert parfaitement stable avec zéro erreur UltraDMA CRC, attestant d'une liaison câble/fond de panier sans parasite.",
"Compteur d'allumages cohérent avec un historique propre et un faible stress mécanique lié aux cycles Start/Stop.",
"Profil thermique idéal dans les plages constructeur optimales, limitant le vieillissement prématuré des composants électroniques.",
"Mécanique d'actuateur et paliers fluides : les tests acoustiques et de temps de montée en régime confirment une santé nominale.",
"Taux d'usure de la mémoire Flash minime : réserve de cellules de rechange (spare blocks) intacte à plus de 95%.",
"Contrôleur en parfait état de synchronisation sans réinitialisation intempestive ni réexécution de commande I/O.",
"Adapté pour intégration immédiate en grappe RAID 1, RAID 5, RAID 6 ou ZFS (Z1/Z2) sans risque d'affaiblir la résilience.",
"Volumétrie et capacité brute stables, sans aucune altération de table d'allocation bas niveau.",
"Cycles d'atterrissage des têtes (Load/Unload Cycle Count) largement inférieurs aux limites critiques d'usure mécanique.",
"Endurance estimée suffisante pour assumer des écritures continues en environnement virtualisé ou base de données.",
"Télémétrie SMART validée avec succès sur l'ensemble des registres critiques selon les spécifications ATA/NVMe.",
"Vitesse de rotation vérifiée et parfaitement synchrone, éliminant tout risque de désynchronisation de broche (spindle).",
"Absence d'arrêt d'urgence ou de coupure brutale anormale dans le journal d'incidents (Unsafe Shutdowns).",
"Écart entre la valeur courante et le seuil critique (Worst/Threshold) au maximum de la marge de sécurité constructeur.",
"Algorithme prédictif : risque de panne à court terme calculé à moins de 0.2% dans des conditions normales de dissipation thermique.",
"Conclusion certifiée : support homologué pour service continu 24h/24 en baie serveur ou NAS haute disponibilité.",
]
}
/// 20 phrases détaillées pour Verdict 2 : Usage serveur à surveiller quotidiennement
pub fn phrases_verdict_2() -> Vec<&'static str> {
vec![
"Nombre d'heures de fonctionnement avancé témoignant d'une exploitation prolongée : la probabilité statistique de fatigue mécanique augmente.",
"Présence mineure de réallocations isolées contenues par le microcode, nécessitant un suivi scrupuleux de l'évolution hebdomadaire.",
"Quelques anomalies de parité CRC enregistrées sur le bus SATA : inspectez ou remplacez le câble de données avant toute remise en charge.",
"Secteurs de réserve entamés à faible dose : le pool de spare blocks reste fonctionnel mais sa décroissance doit être tracée.",
"Le disque reste opérationnel pour des services non-critiques sous réserve d'alertes automatisées configurées dans le système hôte.",
"Usure des cellules de mémoire Flash ayant dépassé le cap des 50% : planifiez un roulement préventif dans les prochains mois.",
"Rapport cycles/heures atypique indiquant de multiples redémarrages qui ont sollicité le moteur de rotation et la bobine d'asservissement.",
"Temps de réponse I/O occasionnellement fluctuant lors des accès séquentiels longs : surveillez la file d'attente du contrôleur.",
"Une surveillance quotidienne via cron/smartd ou télémétrie Prometheus est impérative pour détecter toute envolée des compteurs.",
"Tolérance de panne réduite : ne pas utiliser comme disque unique sans miroir RAID matériel ou ZFS Mirror temps réel.",
"Historique thermique révélant des épisodes de surchauffe modérée ayant pu accélérer la dégradation des lubrifiants d'axe.",
"Contrôle d'intégrité SMART global encore positif (Status PASSED), mais l'écart avec les seuils de panne s'est réduit.",
"Pas de secteurs en attente immédiate, mais la prudence recommande d'anticiper l'achat d'un disque de spare dédié.",
"Comportement adapté pour un serveur de pré-production, un nœud de calcul temporaire ou un environnement de test interne.",
"Contrôlez impérativement la régularité des sauvegardes automatiques vers une cible tierce chaque nuit.",
"Vérifiez que le châssis serveur dispose d'une ventilation active suffisante pour maintenir le disque sous les 40°C.",
"Compteur de recalibration mécanique au-dessus de la valeur neutre : signe précurseur d'un guidage de têtes moins précis.",
"Évitez les écritures massives destructrices ou les reconstructions RAID intensives de plus de 48h sans surveillance.",
"Dérive lente des métriques enregistrée : un gel du compteur sur 30 jours confirmera la stabilisation du plateau.",
"Conclusion certifiée : disque toléré en exploitation serveur à la condition expresse d'une veille télémétrique quotidienne.",
]
}
/// 20 phrases détaillées pour Verdict 3 : Usage occasionnel ou de double sauvegarde uniquement
pub fn phrases_verdict_3() -> Vec<&'static str> {
vec![
"Défaillance de surface constatée : des secteurs ont dû être retirés du pool actif et remappés sur la zone de réserve.",
"Secteurs en attente (Current Pending Sectors) détectés : des blocs sont illisibles et attendent une tentative de réécriture.",
"Risque élevé de blocage I/O ou de kernel panic si ce disque subit des accès concurrents continus 24h/24.",
"Interdiction absolue d'intégrer ce disque dans une grappe de production, une baie NAS principale ou un système d'exploitation hôte.",
"Réservé exclusivement au stockage secondaire 'froid' (Cold Storage) pour contenir une copie miroir non-unique.",
"Convient uniquement pour des transferts ponctuels de fichiers volumineux, de la vidéo ou des archives non-stratégiques.",
"Usure très prononcée des cellules Flash NAND : risque d'épuisement imminent des blocs de rechange et passage en lecture seule.",
"Le moteur ou la mécanique d'asservissement présente un kilométrage excessif incompatible avec les vibrations d'un rack multi-disques.",
"Un arrêt inopiné lors d'une écriture peut corrompre irrémédiablement le système de fichiers (NTFS, EXT4 ou Btrfs).",
"Taux d'erreurs de lecture brutes (Raw Read Error Rate) au-delà des seuils de confiance élémentaires.",
"Ce disque ne doit jamais constituer votre unique copie de sauvegarde : appliquez la règle 3-2-1 avec d'autres supports sains.",
"Les temps d'accès sur les zones dégradées peuvent chuter brutalement et provoquer des timeouts système de plusieurs secondes.",
"Capacité de rétention de charge électrique des cellules Flash potentiellement affaiblie hors tension prolongée.",
"Effectuez une écriture complète de zéros (Zero-Fill) pour vérifier si les secteurs en attente sont stabilisés ou incorrigibles.",
"Utilisation recommandée : brancher en externe via dock USB pour effectuer une duplication d'archive, puis déconnecter.",
"Les métadonnées de partitionnement peuvent devenir instables en cas de sollicitation I/O prolongée.",
"Le contrôleur montre des signes de saturation dans la gestion de sa table de défauts internes (G-List / P-List).",
"Sensibilité accrue aux variations thermiques : tout confinement sans flux d'air accélérera la perte définitive de blocs.",
"N'hébergez aucun système de base de données, machine virtuelle ou conteneur Docker sur ce support.",
"Conclusion certifiée : support relégué au rang de média d'appoint occasionnel ou de seconde sauvegarde redondante.",
]
}
/// 20 phrases détaillées pour Verdict 4 : Ne pas toucher à ce disque, prêt pour la recyclerie
pub fn phrases_verdict_4() -> Vec<&'static str> {
vec![
"Alerte critique absolue : le disque a franchi les seuils de rupture physique irréversible définis par le fabricant.",
"Prolifération massive de secteurs défectueux incorrigibles rendant toute lecture ou écriture dangereusement aléatoire.",
"La zone de réserve (Spare Area) est totalement saturée : le contrôleur n'a plus aucun bloc sain pour relocaliser les pannes.",
"Danger immédiat de perte totale et irréversible de vos données à tout instant ou au prochain redémarrage.",
"La surface magnétique présente un atterrissage de tête destructeur (Head Crash) ou une pulvérisation de couche d'oxyde.",
"Pour les SSD : la mémoire Flash a dépassé son endurance physique maximale, les cellules sont perforées et incapables de retenir les charges.",
"Tentatives répétées de recalibration mécanique en échec complet avec bruits de claquage caractéristiques (Click of Death).",
"Le contrôleur signale officiellement le statut SMART 'FAILED / BAD' : la panne générale est imminente.",
"Toute tentative d'écriture supplémentaire risque d'endommager davantage le support et d'annihiler les chances de récupération.",
"Ne tentez aucun reformatage ni test de charge : cela précipitera la rupture définitive du média.",
"Si des données cruciales sont encore présentes, procédez immédiatement à une image brute (ddrescue) sans redémarrer.",
"Déconnexions intempestives du bus de données causées par le crash interne du firmware ou du circuit électronique PCB.",
"Risque de court-circuit partiel ou de surchauffe anormale pouvant perturber l'alimentation des autres disques du système.",
"Taux d'erreurs incorrigibles supérieur à la capacité des algorithmes ECC (Error-Correcting Code) du contrôleur.",
"Inutilisable même comme disque de test : l'instabilité matérielle provoquera des gels complets du système d'exploitation.",
"Blocs critiques de métadonnées (MFT, Superblock, table de partitions GPT) corrompus ou irrécupérables.",
"Les têtes de lecture sont décalées ou endommagées, produisant des erreurs de recherche (Seek Errors) catastrophiques.",
"Durée de vie résiduelle nulle : la probabilité de survie à 24 heures sous tension est inférieure à 5%.",
"Ne gaspillez ni énergie ni temps sur ce composant matériel définitivement hors d'usage.",
"Conclusion certifiée : support condamné, à isoler d'urgence et à déposer au centre de recyclage électronique (DEEE).",
]
}
/// Évalue un disque et génère le diagnostic complet
pub fn evaluate(disk: &DiskInfo) -> DiagnosticResult {
let smart = &disk.smart;
let is_ssd_or_nvme = disk.drive_type == DriveType::Ssd || disk.drive_type == DriveType::Nvme;
// Facteurs clés
let reallocated = smart.reallocated_sectors;
let pending = smart.pending_sectors;
let uncorrectable = smart.uncorrectable_sectors;
let hours = smart.power_on_hours;
let crc = smart.crc_errors;
let wear = smart.ssd_wear_percentage.unwrap_or(0);
let spare = smart.nvme_available_spare.unwrap_or(100);
let nvme_warning = smart.nvme_critical_warning.unwrap_or(0);
// --- VERDICT 4 : RECYCLERIE IMMÉDIATE ---
// Conditions :
// - Secteurs réalloués massifs (>= 50)
// - Secteurs incorrigibles élevés (>= 5)
// - Secteurs en attente très élevés (>= 20)
// - Alerte critique NVMe ou spare = 0
// - Usure SSD >= 99%
if reallocated >= 50
|| uncorrectable >= 5
|| pending >= 20
|| nvme_warning != 0
|| (is_ssd_or_nvme && spare == 0)
|| (is_ssd_or_nvme && wear >= 99)
{
let full_phrases = Self::phrases_verdict_4();
let mut highlighted = Vec::new();
if reallocated >= 50 {
highlighted.push(format!(
"Seuil critique dépassé : {} secteurs réalloués enregistrés sur le média.",
reallocated
));
}
if pending > 0 {
highlighted.push(format!(
"Présence alarmante de {} secteurs instables en attente de réallocation.",
pending
));
}
if uncorrectable > 0 {
highlighted.push(format!(
"Détection de {} secteurs définitivement incorrigibles.",
uncorrectable
));
}
if is_ssd_or_nvme && wear >= 95 {
highlighted.push(format!(
"Usure des puces Flash critique (taux d'usure: {}%).",
wear
));
}
highlighted.push(full_phrases[0].to_string());
highlighted.push(full_phrases[7].to_string());
highlighted.push(full_phrases[19].to_string());
return DiagnosticResult {
verdict: VerdictLevel::Verdict4ScrapRecycle,
verdict_title: "4. Ne pas toucher à ce disque, prêt pour la recyclerie".to_string(),
verdict_badge_color: "#ef4444".to_string(), // Rouge vif
health_score: 5,
server_recommended_years: None,
primary_summary: "Média gravement défaillant avec dégradation physique irréversible. Risque imminent de perte de données.".to_string(),
highlighted_phrases: highlighted,
full_phrases_library: full_phrases.into_iter().map(String::from).collect(),
};
}
// --- VERDICT 3 : USAGE OCCASIONNEL OU DOUBLE SAUVEGARDE UNIQUEMENT ---
// Conditions :
// - Quelques secteurs réalloués (6 à 49)
// - Présence de secteurs en attente (1 à 19)
// - Quelques secteurs incorrigibles (1 à 4)
// - Usure SSD très élevée (>= 80% et < 99%)
// - Heures très élevées (> 60 000 h) avec petites faiblesses
if (reallocated > 5 && reallocated < 50)
|| (pending > 0 && pending < 20)
|| (uncorrectable > 0 && uncorrectable < 5)
|| (is_ssd_or_nvme && wear >= 80)
|| (hours > 60_000 && (reallocated > 0 || crc > 10))
{
let full_phrases = Self::phrases_verdict_3();
let mut highlighted = Vec::new();
if reallocated > 0 {
highlighted.push(format!(
"Dégradation modérée constatée : {} secteurs réalloués dans la réserve.",
reallocated
));
}
if pending > 0 {
highlighted.push(format!(
"Point de fragilité : {} secteur(s) en attente (Current Pending Sectors).",
pending
));
}
if is_ssd_or_nvme && wear >= 80 {
highlighted.push(format!(
"Endurance Flash fortement entamée : {}% d'usure déclarée.",
wear
));
}
if hours > 50_000 {
highlighted.push(format!(
"Temps sous tension considérable : {} heures cumulées.",
hours
));
}
highlighted.push(full_phrases[4].to_string());
highlighted.push(full_phrases[10].to_string());
highlighted.push(full_phrases[19].to_string());
let score = if reallocated > 20 { 30 } else { 45 };
return DiagnosticResult {
verdict: VerdictLevel::Verdict3OccasionalBackup,
verdict_title: "3. Usage occasionnel ou de double sauvegarde uniquement".to_string(),
verdict_badge_color: "#f97316".to_string(), // Orange
health_score: score,
server_recommended_years: None,
primary_summary: "Média altéré incapable de supporter une charge continue. Acceptable uniquement en sauvegarde secondaire miroir.".to_string(),
highlighted_phrases: highlighted,
full_phrases_library: full_phrases.into_iter().map(String::from).collect(),
};
}
// --- VERDICT 2 : USAGE SERVEUR À SURVEILLER QUOTIDIENNEMENT ---
// Conditions :
// - Secteurs réalloués minimes (1 à 5) mais pas de pending ni uncorrectable
// - Ou Heures élevées (> 40 000 h) même sans secteur défectueux
// - Ou Erreurs CRC significatives (câble instable, crc > 5)
// - Ou Usure SSD notable (50% à 79%)
// - Ou Cycles d'allumage très élevés pour un serveur (> 5 000 cycles)
if (reallocated >= 1 && reallocated <= 5)
|| hours >= 40_000
|| crc > 5
|| (is_ssd_or_nvme && wear >= 50 && wear < 80)
|| smart.power_cycles > 5_000
{
let full_phrases = Self::phrases_verdict_2();
let mut highlighted = Vec::new();
if reallocated > 0 {
highlighted.push(format!(
"Léger signe de vieillissement : {} secteur(s) réalloué(s) stabilisé(s).",
reallocated
));
}
if hours >= 40_000 {
highlighted.push(format!(
"Volume horaire important : {} heures de service au compteur.",
hours
));
}
if crc > 5 {
highlighted.push(format!(
"Attention liaison bus : {} erreurs de contrôle de redondance CRC détectées.",
crc
));
}
if is_ssd_or_nvme && wear >= 50 {
highlighted.push(format!(
"Taux d'usure des cellules Flash à {}% : anticiper le renouvellement.",
wear
));
}
highlighted.push(full_phrases[8].to_string());
highlighted.push(full_phrases[14].to_string());
highlighted.push(full_phrases[19].to_string());
return DiagnosticResult {
verdict: VerdictLevel::Verdict2ServerDailyWatch,
verdict_title: "2. Usage serveur à surveiller quotidiennement".to_string(),
verdict_badge_color: "#eab308".to_string(), // Jaune ambre
health_score: 75,
server_recommended_years: None,
primary_summary: "Disque fonctionnel mais présentant un kilométrage élevé ou de légères anomalies. Surveillance continue recommandée.".to_string(),
highlighted_phrases: highlighted,
full_phrases_library: full_phrases.into_iter().map(String::from).collect(),
};
}
// --- VERDICT 1 : USAGE 24/24 SERVEUR POSSIBLE (AVEC ANNÉES PRÉCISÉES) ---
// Conditions :
// - Zéro secteur défectueux (0 réalloué, 0 pending, 0 uncorrectable)
// - Erreurs CRC nulles ou insignifiantes (<= 5)
// - Usure SSD < 50%
// - Heures < 40 000 h
let full_phrases = Self::phrases_verdict_1();
// Calcul mathématique précis des années restantes recommandées avant surveillance SMART renforcée :
// - Pour un HDD en fonctionnement 24/7 (8 760 heures par an) : seuil de sérénité fixé à ~40 000 - 45 000 h
// - Pour un SSD / NVMe : calcul basé sur l'endurance restante et les heures annuelles
let recommended_years = if is_ssd_or_nvme {
// Basé sur le taux d'usure restant
let remaining_wear = 100u32.saturating_sub(wear);
if hours > 0 && wear > 0 {
let yearly_wear = (wear as f64) / ((hours as f64) / 8760.0).max(0.2);
let years = (remaining_wear as f64 / yearly_wear.max(5.0)).round() as u32;
years.clamp(1, 7)
} else {
// SSD quasi neuf
5
}
} else {
// HDD : calcul d'espérance avant 40 000 h de service continu
let remaining_hours = 40_000u64.saturating_sub(hours);
let years = ((remaining_hours as f64) / 8760.0).round() as u32;
years.clamp(1, 6)
};
let mut highlighted = Vec::new();
highlighted.push(format!(
"Intégrité parfaite : 0 secteur réalloué, 0 en attente, 0 incorrigible."
));
if is_ssd_or_nvme {
highlighted.push(format!(
"Mémoire Flash saine : usure mesurée à seulement {}% (réserve intacte à {}%).",
wear, spare
));
} else {
let rpm_text = disk.rpm.map(|r| format!("{} RPM", r)).unwrap_or_else(|| "Vitesse nominale".to_string());
highlighted.push(format!(
"Mécanique optimale : {} et seulement {} heures de fonctionnement cumulées.",
rpm_text, hours
));
}
highlighted.push(format!(
"Projection de sérénité : surveillance SMART renforcée préconisée à partir de {} an(s).",
recommended_years
));
highlighted.push(full_phrases[0].to_string());
highlighted.push(full_phrases[10].to_string());
highlighted.push(full_phrases[19].to_string());
let health_score = if is_ssd_or_nvme {
if wear > 0 {
100u32.saturating_sub(wear).max(70)
} else {
100u32.saturating_sub((hours / 8000) as u32).max(85)
}
} else {
100u32.saturating_sub((hours / 4000) as u32).max(85)
};
DiagnosticResult {
verdict: VerdictLevel::Verdict1Server247,
verdict_title: format!(
"1. Usage 24/24 serveur possible (surveiller à partir de {} an{})",
recommended_years,
if recommended_years > 1 { "s" } else { "" }
),
verdict_badge_color: "#22c55e".to_string(), // Vert émeraude
health_score,
server_recommended_years: Some(recommended_years),
primary_summary: format!(
"Disque en excellente condition matérielle. Parfaitement éligible pour un service ininterrompu 24h/24 en production serveur/NAS. Surveillance SMART renforcée recommandée à partir de {} an{}.",
recommended_years,
if recommended_years > 1 { "s" } else { "" }
),
highlighted_phrases: highlighted,
full_phrases_library: full_phrases.into_iter().map(String::from).collect(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::{BusProtocol, DriveType, SmartAttributes};
fn make_test_disk(smart: SmartAttributes, drive_type: DriveType, rpm: Option<u32>) -> DiskInfo {
DiskInfo {
device_id: "\\\\.\\PhysicalDrive0".to_string(),
index: 0,
model: "Test Drive Model".to_string(),
serial_number: "TEST123456".to_string(),
size_bytes: 1_000_000_000_000,
size_formatted: "1000 Go".to_string(),
drive_type,
bus_protocol: BusProtocol::Sata,
rpm,
is_system_drive: false,
mount_points: vec!["D:".to_string()],
smart,
}
}
#[test]
fn test_verdict_1_pristine_drive() {
let smart = SmartAttributes {
power_on_hours: 5000,
power_cycles: 120,
reallocated_sectors: 0,
pending_sectors: 0,
uncorrectable_sectors: 0,
crc_errors: 0,
temperature_celsius: Some(32),
ssd_wear_percentage: None,
nvme_available_spare: None,
nvme_critical_warning: None,
unsafe_shutdowns: Some(2),
raw_ata_attributes: Vec::new(),
raw_nvme_health: None,
};
let disk = make_test_disk(smart, DriveType::Hdd, Some(7200));
let diag = DiagnosticEngine::evaluate(&disk);
assert_eq!(diag.verdict, VerdictLevel::Verdict1Server247);
assert!(diag.server_recommended_years.is_some());
assert!(diag.health_score >= 85);
assert_eq!(diag.full_phrases_library.len(), 20);
}
#[test]
fn test_sandisk_ssd_health_score_96() {
// Reproduction exacte du SanDisk SD7SB6S128G1001 de l'utilisateur
let smart = SmartAttributes {
power_on_hours: 8732,
power_cycles: 1884,
reallocated_sectors: 0,
pending_sectors: 0,
uncorrectable_sectors: 0,
crc_errors: 0,
temperature_celsius: Some(29),
ssd_wear_percentage: Some(4), // E9: Media Wearout Indicator à 96% santé -> 4% usure
nvme_available_spare: None,
nvme_critical_warning: None,
unsafe_shutdowns: Some(36),
raw_ata_attributes: Vec::new(),
raw_nvme_health: None,
};
let mut disk = make_test_disk(smart, DriveType::Ssd, None);
disk.model = "SanDisk SD7SB6S128G1001".to_string();
disk.serial_number = "161601802225".to_string();
disk.size_formatted = "128.0 Go".to_string();
let diag = DiagnosticEngine::evaluate(&disk);
assert_eq!(diag.verdict, VerdictLevel::Verdict1Server247);
assert_eq!(diag.health_score, 96); // Exactement 96% comme dans CrystalDiskInfo !
assert_eq!(diag.verdict_badge_color, "#22c55e");
}
#[test]
fn test_verdict_2_high_hours_or_minor_reallocated() {
let smart = SmartAttributes {
power_on_hours: 45000,
power_cycles: 200,
reallocated_sectors: 2,
pending_sectors: 0,
uncorrectable_sectors: 0,
crc_errors: 0,
temperature_celsius: Some(36),
ssd_wear_percentage: None,
nvme_available_spare: None,
nvme_critical_warning: None,
unsafe_shutdowns: None,
raw_ata_attributes: Vec::new(),
raw_nvme_health: None,
};
let disk = make_test_disk(smart, DriveType::Hdd, Some(5400));
let diag = DiagnosticEngine::evaluate(&disk);
assert_eq!(diag.verdict, VerdictLevel::Verdict2ServerDailyWatch);
assert_eq!(diag.full_phrases_library.len(), 20);
}
#[test]
fn test_verdict_3_pending_sectors_occasional_backup() {
let smart = SmartAttributes {
power_on_hours: 15000,
power_cycles: 500,
reallocated_sectors: 8,
pending_sectors: 2,
uncorrectable_sectors: 0,
crc_errors: 1,
temperature_celsius: Some(38),
ssd_wear_percentage: None,
nvme_available_spare: None,
nvme_critical_warning: None,
unsafe_shutdowns: None,
raw_ata_attributes: Vec::new(),
raw_nvme_health: None,
};
let disk = make_test_disk(smart, DriveType::Hdd, Some(7200));
let diag = DiagnosticEngine::evaluate(&disk);
assert_eq!(diag.verdict, VerdictLevel::Verdict3OccasionalBackup);
assert_eq!(diag.full_phrases_library.len(), 20);
}
#[test]
fn test_verdict_4_failing_scrap_recycle() {
let smart = SmartAttributes {
power_on_hours: 25000,
power_cycles: 1000,
reallocated_sectors: 120,
pending_sectors: 25,
uncorrectable_sectors: 15,
crc_errors: 30,
temperature_celsius: Some(45),
ssd_wear_percentage: None,
nvme_available_spare: None,
nvme_critical_warning: None,
unsafe_shutdowns: None,
raw_ata_attributes: Vec::new(),
raw_nvme_health: None,
};
let disk = make_test_disk(smart, DriveType::Hdd, Some(7200));
let diag = DiagnosticEngine::evaluate(&disk);
assert_eq!(diag.verdict, VerdictLevel::Verdict4ScrapRecycle);
assert_eq!(diag.full_phrases_library.len(), 20);
assert!(diag.health_score <= 10);
}
#[test]
fn test_all_phrase_libraries_contain_20_phrases() {
assert_eq!(DiagnosticEngine::phrases_verdict_1().len(), 20);
assert_eq!(DiagnosticEngine::phrases_verdict_2().len(), 20);
assert_eq!(DiagnosticEngine::phrases_verdict_3().len(), 20);
assert_eq!(DiagnosticEngine::phrases_verdict_4().len(), 20);
}
}
+28
Voir le fichier
@@ -0,0 +1,28 @@
pub mod batch;
pub mod cli;
pub mod commands;
pub mod diagnostic;
pub mod models;
pub mod smart_reader;
use batch::{BatchManager, BatchState};
use commands::*;
use std::sync::Mutex;
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
tauri::Builder::default()
.manage(BatchState(Mutex::new(BatchManager::new())))
.invoke_handler(tauri::generate_handler![
check_is_elevated,
request_admin_relaunch,
get_disks_with_diagnostic,
start_batch_session,
stop_batch_session,
poll_batch_session,
get_batch_state,
export_batch_json_data,
])
.run(tauri::generate_context!())
.expect("Erreur lors de l'exécution de l'application VerifEtat");
}
+17
Voir le fichier
@@ -0,0 +1,17 @@
// Prevents additional console window on Windows in release
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
fn main() {
let args: Vec<String> = std::env::args().collect();
if args.len() > 1 {
#[cfg(windows)]
unsafe {
use windows_sys::Win32::System::Console::{AttachConsole, ATTACH_PARENT_PROCESS};
AttachConsole(ATTACH_PARENT_PROCESS);
}
let code = verif_etat_lib::cli::CliRunner::run(&args);
std::process::exit(code);
} else {
verif_etat_lib::run();
}
}
+129
Voir le fichier
@@ -0,0 +1,129 @@
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum DriveType {
Hdd,
Ssd,
Nvme,
Unknown,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum BusProtocol {
Sata,
Nvme,
Usb,
Scsi,
Sas,
Ata,
Raid,
Unknown,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RawSmartAttribute {
pub id: u8,
pub id_hex: String, // e.g. "0x05", "0xE9"
pub name: String, // Official or friendly name
pub current: u8, // Normalized current value
pub worst: u8, // Normalized worst value
pub threshold: Option<u8>, // Threshold if known
pub raw_value: u64, // Raw decimal value
pub raw_hex: String, // Raw 12-char hex string, e.g. "00000000221C"
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RawNvmeHealth {
pub critical_warning: u8,
pub temperature_celsius: i32,
pub available_spare_percentage: u8,
pub percentage_used: u8,
pub data_units_read: u128,
pub data_units_written: u128,
pub host_read_commands: u128,
pub host_write_commands: u128,
pub controller_busy_time_minutes: u128,
pub power_cycles: u128,
pub power_on_hours: u128,
pub unsafe_shutdowns: u128,
pub media_and_data_integrity_errors: u128,
pub number_of_error_information_log_entries: u128,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SmartAttributes {
pub power_on_hours: u64,
pub power_cycles: u64,
pub reallocated_sectors: u64,
pub pending_sectors: u64,
pub uncorrectable_sectors: u64,
pub crc_errors: u64,
pub temperature_celsius: Option<i32>,
pub ssd_wear_percentage: Option<u32>, // 0-100% wear
pub nvme_available_spare: Option<u32>, // % spare remaining
pub nvme_critical_warning: Option<u32>,
pub unsafe_shutdowns: Option<u64>,
#[serde(default)]
pub raw_ata_attributes: Vec<RawSmartAttribute>,
#[serde(default)]
pub raw_nvme_health: Option<RawNvmeHealth>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DiskInfo {
pub device_id: String, // e.g. "\\.\PhysicalDrive0"
pub index: u32, // e.g. 0
pub model: String, // e.g. "Samsung SSD 990 PRO 1TB"
pub serial_number: String, // e.g. "S6B0NJ0W..."
pub size_bytes: u64, // in bytes
pub size_formatted: String, // e.g. "931.5 Go" or "3.64 To"
pub drive_type: DriveType, // Hdd, Ssd, Nvme
pub bus_protocol: BusProtocol, // Sata, Nvme, Usb, etc.
pub rpm: Option<u32>, // 5400, 7200, or None (for SSD/NVMe)
pub is_system_drive: bool, // Whether it contains C:
#[serde(default)]
pub mount_points: Vec<String>, // e.g. ["C:"], ["D:"]
pub smart: SmartAttributes,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum VerdictLevel {
Verdict1Server247, // 1. Usage 24/24 serveur possible (avec années précisées)
Verdict2ServerDailyWatch, // 2. Usage serveur à surveiller quotidiennement
Verdict3OccasionalBackup, // 3. Usage occasionnel ou de double sauvegarde uniquement
Verdict4ScrapRecycle, // 4. Ne pas toucher à ce disque, prêt pour la recyclerie
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DiagnosticResult {
pub verdict: VerdictLevel,
pub verdict_title: String,
pub verdict_badge_color: String,
pub health_score: u32, // 0 to 100%
pub server_recommended_years: Option<u32>, // e.g. 3 years for Verdict 1
pub primary_summary: String,
pub highlighted_phrases: Vec<String>, // Specific contextual phrases
pub full_phrases_library: Vec<String>, // The ~20 phrases of the verdict category
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EvaluatedDisk {
pub disk: DiskInfo,
pub diagnostic: DiagnosticResult,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchEntry {
pub timestamp: String,
pub disk: DiskInfo,
pub diagnostic: DiagnosticResult,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchSessionState {
pub is_running: bool,
pub ignored_disk_indices: Vec<u32>,
pub registered_disks: Vec<BatchEntry>,
}
+1069
Voir le fichier
Diff désactivé car ce fichier est trop long. Voir la Diff
+46
Voir le fichier
@@ -0,0 +1,46 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "VerifEtat",
"version": "1.0.0",
"identifier": "com.verifetat.app",
"build": {
"frontendDist": "../dist"
},
"app": {
"withGlobalTauri": true,
"windows": [
{
"label": "main",
"title": "VerifEtat - Diagnostic SMART & Audit Disques",
"width": 1150,
"height": 780,
"minWidth": 950,
"minHeight": 650,
"resizable": true,
"fullscreen": false
}
],
"security": {
"csp": null
}
},
"bundle": {
"active": true,
"targets": ["nsis", "msi"],
"icon": [
"icons/32x32.png",
"icons/128x128.png",
"icons/128x128@2x.png",
"icons/icon.icns",
"icons/icon.ico"
],
"windows": {
"wix": {
"language": "fr-FR"
},
"nsis": {
"languages": ["French"]
}
}
}
}