645 lines
21 KiB
Markdown
645 lines
21 KiB
Markdown
# Améliorations Nanometrics — Plan d'implémentation
|
||
|
||
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
||
|
||
**Goal:** Ajouter métriques réseau enrichies, hardware, config bidirectionnelle, API REST complète, taille police globale.
|
||
|
||
**Architecture:**
|
||
- Métriques lentes (réseau, hardware) : collecte au démarrage + une fois/jour à heure fixe (config `slow_daily_time`)
|
||
- Stockage dans la table `agents` (colonnes JSON), pas dans `metrics` — ces données changent rarement
|
||
- API REST expose tout via les mêmes endpoints enrichis
|
||
|
||
**Tech Stack:** Rust (agent), Go (server), SQLite, Vanilla JS (dashboard)
|
||
|
||
---
|
||
|
||
## Fichiers concernés
|
||
|
||
| Fichier | Action |
|
||
|---------|--------|
|
||
| `agent/src/payload.rs` | Ajout `NetworkInterface`, `HardwareInfo`, champs dans `AgentMetrics` |
|
||
| `agent/src/config.rs` | Ajout `slow_daily_time`, `network_info`, `hardware_info` dans `MetricsConfig` |
|
||
| `agent/src/metrics/network_info.rs` | Nouveau module |
|
||
| `agent/src/metrics/hardware.rs` | Nouveau module |
|
||
| `agent/src/metrics/mod.rs` | Déclarer les 2 nouveaux modules |
|
||
| `agent/src/main.rs` | Intégration scheduler, collecte slow |
|
||
| `agent/Cargo.toml` | Bump version 0.1.6 |
|
||
| `deploy/install.sh` | Ajout `iperf3`, `dmidecode` dans paquets |
|
||
| `server/models/models.go` | Structs Go `NetworkInterface`, `HardwareInfo` |
|
||
| `server/db/db.go` | Migrations + `UpsertAgent` + `GetLastMetrics` |
|
||
| `server/handlers/agents.go` | Handler GET `/api/agents/{id}` |
|
||
| `server/main.go` | Route `/api/agents/{id}` |
|
||
| `server/docker-compose.yml` | Service iperf3 |
|
||
| `dashboard/js/popups.js` | Sections réseau + hardware dans popup détail |
|
||
| `dashboard/css/app.css` | Styles network/hardware section + fix font-size global |
|
||
| `dashboard/js/app.js` | Fix font-size sur `html` element |
|
||
|
||
---
|
||
|
||
## Task 1 — Agent : structs payload + config
|
||
|
||
**Files:**
|
||
- Modify: `agent/src/payload.rs`
|
||
- Modify: `agent/src/config.rs`
|
||
|
||
- [ ] **Ajouter dans `payload.rs`** les nouveaux types et champs :
|
||
|
||
```rust
|
||
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
|
||
pub struct NetworkInterface {
|
||
pub name: String,
|
||
pub if_type: String, // "ethernet" | "wifi"
|
||
pub speed_mbps: Option<i64>,
|
||
pub mac: String,
|
||
pub wol: Option<bool>,
|
||
pub iperf_mbps: Option<f64>,
|
||
}
|
||
|
||
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
|
||
pub struct HardwareInfo {
|
||
pub motherboard_vendor: Option<String>,
|
||
pub motherboard_model: Option<String>,
|
||
pub cpu_model: Option<String>,
|
||
pub ram_type: Option<String>,
|
||
pub ram_speed_mhz: Option<i64>,
|
||
pub ram_slots_used: Option<i64>,
|
||
pub ram_slots_total: Option<i64>,
|
||
}
|
||
```
|
||
|
||
Dans `AgentMetrics`, ajouter après `smart` :
|
||
```rust
|
||
pub network_info: Option<Vec<NetworkInterface>>,
|
||
pub hardware_info: Option<HardwareInfo>,
|
||
```
|
||
|
||
- [ ] **Ajouter dans `config.rs`** — `SlowMetricsConfig` + champs dans `MetricsConfig` :
|
||
|
||
```rust
|
||
#[derive(Deserialize, Debug, Clone)]
|
||
pub struct SlowMetricsConfig {
|
||
#[serde(default)]
|
||
pub udp: bool,
|
||
#[serde(default)]
|
||
pub mqtt: bool,
|
||
}
|
||
|
||
impl Default for SlowMetricsConfig {
|
||
fn default() -> Self { Self { udp: true, mqtt: false } }
|
||
}
|
||
```
|
||
|
||
Dans `MetricsConfig`, ajouter :
|
||
```rust
|
||
#[serde(default)]
|
||
pub network_info: SlowMetricsConfig,
|
||
#[serde(default)]
|
||
pub hardware_info: SlowMetricsConfig,
|
||
#[serde(default = "default_slow_time")]
|
||
pub slow_daily_time: String, // "HH:MM"
|
||
```
|
||
|
||
```rust
|
||
fn default_slow_time() -> String { "03:00".to_string() }
|
||
```
|
||
|
||
- [ ] **Vérifier** : `cargo check --manifest-path agent/Cargo.toml`
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add agent/src/payload.rs agent/src/config.rs
|
||
git commit -m "feat(agent): structs NetworkInterface + HardwareInfo + config slow_daily_time"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 2 — Agent : module network_info
|
||
|
||
**Files:**
|
||
- Create: `agent/src/metrics/network_info.rs`
|
||
- Modify: `agent/src/metrics/mod.rs`
|
||
|
||
- [ ] **Créer `agent/src/metrics/network_info.rs`** :
|
||
|
||
```rust
|
||
use std::mem::MaybeUninit;
|
||
|
||
fn local_hhmm() -> (u32, u32) {
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::SystemTime::UNIX_EPOCH)
|
||
.unwrap_or_default()
|
||
.as_secs() as i64;
|
||
let mut tm = MaybeUninit::<libc::tm>::uninit();
|
||
unsafe { libc::localtime_r(&now, tm.as_mut_ptr()) };
|
||
let tm = unsafe { tm.assume_init() };
|
||
(tm.tm_hour as u32, tm.tm_min as u32)
|
||
}
|
||
|
||
pub fn current_hhmm() -> (u32, u32) { local_hhmm() }
|
||
|
||
fn is_physical(name: &str) -> bool {
|
||
// Exclure loopback, virtuels, docker, bridges
|
||
if name == "lo" { return false; }
|
||
for prefix in &["veth", "docker", "br-", "virbr", "vir", "tun", "tap", "dummy"] {
|
||
if name.starts_with(prefix) { return false; }
|
||
}
|
||
true
|
||
}
|
||
|
||
fn read_sysfs(iface: &str, file: &str) -> Option<String> {
|
||
std::fs::read_to_string(format!("/sys/class/net/{}/{}", iface, file))
|
||
.ok()
|
||
.map(|s| s.trim().to_string())
|
||
}
|
||
|
||
fn is_wifi(name: &str) -> bool {
|
||
std::path::Path::new(&format!("/sys/class/net/{}/wireless", name)).exists()
|
||
}
|
||
|
||
fn wol_status(name: &str) -> Option<bool> {
|
||
let out = std::process::Command::new("ethtool")
|
||
.arg(name).output().ok()?;
|
||
let text = String::from_utf8_lossy(&out.stdout);
|
||
for line in text.lines() {
|
||
let t = line.trim();
|
||
if t.starts_with("Wake-on:") {
|
||
let val = t.split(':').nth(1)?.trim();
|
||
return Some(val != "d" && !val.is_empty());
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn iperf_mbps(server_ip: &str) -> Option<f64> {
|
||
// Vérifier que iperf3 est disponible
|
||
if !std::process::Command::new("which").arg("iperf3")
|
||
.output().map(|o| o.status.success()).unwrap_or(false) {
|
||
return None;
|
||
}
|
||
let out = std::process::Command::new("iperf3")
|
||
.args(["-c", server_ip, "-J", "-t", "5", "-P", "1"])
|
||
.output().ok()?;
|
||
let json = String::from_utf8_lossy(&out.stdout);
|
||
// parser "end" > "sum_received" > "bits_per_second"
|
||
let v: serde_json::Value = serde_json::from_str(&json).ok()?;
|
||
let bps = v["end"]["sum_received"]["bits_per_second"].as_f64()?;
|
||
Some(bps / 1_000_000.0)
|
||
}
|
||
|
||
pub fn collect(server_ip: &str) -> Vec<crate::payload::NetworkInterface> {
|
||
let entries = match std::fs::read_dir("/sys/class/net") {
|
||
Ok(e) => e, Err(_) => return vec![],
|
||
};
|
||
let mut ifaces: Vec<String> = entries
|
||
.flatten()
|
||
.map(|e| e.file_name().into_string().unwrap_or_default())
|
||
.filter(|n| is_physical(n))
|
||
.collect();
|
||
ifaces.sort();
|
||
|
||
// Lancer iperf une seule fois pour tous (pas par interface)
|
||
let iperf = iperf_mbps(server_ip);
|
||
|
||
ifaces.iter().map(|name| {
|
||
let speed = read_sysfs(name, "speed")
|
||
.and_then(|s| s.parse::<i64>().ok())
|
||
.filter(|&v| v > 0);
|
||
let mac = read_sysfs(name, "address").unwrap_or_default();
|
||
crate::payload::NetworkInterface {
|
||
name: name.clone(),
|
||
if_type: if is_wifi(name) { "wifi".to_string() } else { "ethernet".to_string() },
|
||
speed_mbps: speed,
|
||
mac,
|
||
wol: if is_wifi(name) { None } else { wol_status(name) },
|
||
iperf_mbps: iperf,
|
||
}
|
||
}).collect()
|
||
}
|
||
```
|
||
|
||
- [ ] **Ajouter dans `agent/src/metrics/mod.rs`** : `pub mod network_info;`
|
||
|
||
- [ ] **Vérifier** : `cargo check --manifest-path agent/Cargo.toml`
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add agent/src/metrics/network_info.rs agent/src/metrics/mod.rs
|
||
git commit -m "feat(agent): module network_info (interfaces, WoL, iperf3)"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 3 — Agent : module hardware
|
||
|
||
**Files:**
|
||
- Create: `agent/src/metrics/hardware.rs`
|
||
- Modify: `agent/src/metrics/mod.rs`
|
||
|
||
- [ ] **Créer `agent/src/metrics/hardware.rs`** :
|
||
|
||
```rust
|
||
fn run_dmidecode(type_num: u8) -> String {
|
||
std::process::Command::new("dmidecode")
|
||
.args(["-t", &type_num.to_string()])
|
||
.output()
|
||
.map(|o| String::from_utf8_lossy(&o.stdout).into_owned())
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn extract_field<'a>(text: &'a str, key: &str) -> Option<String> {
|
||
for line in text.lines() {
|
||
let t = line.trim();
|
||
if t.starts_with(key) {
|
||
let val = t[key.len()..].trim().trim_start_matches(':').trim();
|
||
if !val.is_empty() && val != "Not Specified" && val != "Unknown" {
|
||
return Some(val.to_string());
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
pub fn is_available() -> bool {
|
||
std::process::Command::new("which").arg("dmidecode")
|
||
.output().map(|o| o.status.success()).unwrap_or(false)
|
||
}
|
||
|
||
pub fn collect() -> Option<crate::payload::HardwareInfo> {
|
||
if !is_available() { return None; }
|
||
|
||
// Type 2 = Baseboard, Type 4 = Processor, Type 17 = Memory Device
|
||
let board = run_dmidecode(2);
|
||
let cpu = run_dmidecode(4);
|
||
let mem = run_dmidecode(17);
|
||
|
||
let mut slots_total: i64 = 0;
|
||
let mut slots_used: i64 = 0;
|
||
let mut ram_type: Option<String> = None;
|
||
let mut ram_speed: Option<i64> = None;
|
||
|
||
// Compter les slots mémoire
|
||
for block in mem.split("\n\n") {
|
||
if block.contains("Memory Device") {
|
||
slots_total += 1;
|
||
if let Some(size) = extract_field(block, "Size") {
|
||
if !size.contains("No Module") {
|
||
slots_used += 1;
|
||
}
|
||
}
|
||
if ram_type.is_none() {
|
||
ram_type = extract_field(block, "Type");
|
||
}
|
||
if ram_speed.is_none() {
|
||
if let Some(spd) = extract_field(block, "Speed") {
|
||
// "3200 MT/s" → 3200
|
||
ram_speed = spd.split_whitespace().next()
|
||
.and_then(|s| s.parse().ok());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Some(crate::payload::HardwareInfo {
|
||
motherboard_vendor: extract_field(&board, "Manufacturer"),
|
||
motherboard_model: extract_field(&board, "Product Name"),
|
||
cpu_model: extract_field(&cpu, "Version"),
|
||
ram_type,
|
||
ram_speed_mhz: ram_speed,
|
||
ram_slots_used: if slots_total > 0 { Some(slots_used) } else { None },
|
||
ram_slots_total: if slots_total > 0 { Some(slots_total) } else { None },
|
||
})
|
||
}
|
||
```
|
||
|
||
- [ ] **Ajouter dans `agent/src/metrics/mod.rs`** : `pub mod hardware;`
|
||
|
||
- [ ] **Vérifier** : `cargo check --manifest-path agent/Cargo.toml`
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add agent/src/metrics/hardware.rs agent/src/metrics/mod.rs
|
||
git commit -m "feat(agent): module hardware (dmidecode — carte mère, CPU, RAM)"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 4 — Agent : scheduler + intégration main.rs + install.sh + version
|
||
|
||
**Files:**
|
||
- Modify: `agent/src/main.rs`
|
||
- Modify: `agent/Cargo.toml`
|
||
- Modify: `deploy/install.sh`
|
||
|
||
- [ ] **Bump version** dans `agent/Cargo.toml` : `0.1.5` → `0.1.6`
|
||
|
||
- [ ] **Ajouter dans `deploy/install.sh`** les paquets `iperf3` et `dmidecode` :
|
||
```bash
|
||
for pkg in curl python3 smartmontools ethtool iperf3 dmidecode; do
|
||
```
|
||
|
||
- [ ] **Ajouter dans `agent/src/main.rs`** le scheduler slow + appels modules. Après les variables `first_slow` / `last_slow`, ajouter :
|
||
|
||
```rust
|
||
// Scheduler métriques lentes (startup + 1×/jour à l'heure configurée)
|
||
let slow_time: (u32, u32) = {
|
||
let parts: Vec<&str> = cfg.metrics.slow_daily_time.split(':').collect();
|
||
let h = parts.get(0).and_then(|s| s.parse().ok()).unwrap_or(3);
|
||
let m = parts.get(1).and_then(|s| s.parse().ok()).unwrap_or(0);
|
||
(h, m)
|
||
};
|
||
let mut slow_daily_done = false;
|
||
let mut slow_last_date: u32 = 0; // tm_yday pour détecter changement de jour
|
||
|
||
// Collecte immédiate au démarrage
|
||
if cfg.metrics.network_info.udp || cfg.metrics.network_info.mqtt {
|
||
let ni = metrics::network_info::collect(&cfg.server.ip);
|
||
if !ni.is_empty() { m.network_info = Some(ni); }
|
||
}
|
||
if cfg.metrics.hardware_info.udp || cfg.metrics.hardware_info.mqtt {
|
||
m.hardware_info = metrics::hardware::collect();
|
||
}
|
||
```
|
||
|
||
Dans la boucle principale, ajouter la vérification de l'heure après le bloc `first_slow` :
|
||
|
||
```rust
|
||
// Métriques lentes quotidiennes
|
||
{
|
||
use std::mem::MaybeUninit;
|
||
let now_ts = std::time::SystemTime::now()
|
||
.duration_since(std::time::SystemTime::UNIX_EPOCH)
|
||
.unwrap_or_default().as_secs() as i64;
|
||
let mut tm = MaybeUninit::<libc::tm>::uninit();
|
||
unsafe { libc::localtime_r(&now_ts, tm.as_mut_ptr()) };
|
||
let tm = unsafe { tm.assume_init() };
|
||
let (cur_h, cur_m) = (tm.tm_hour as u32, tm.tm_min as u32);
|
||
let cur_yday = tm.tm_yday as u32;
|
||
|
||
if cur_yday != slow_last_date {
|
||
slow_last_date = cur_yday;
|
||
slow_daily_done = false;
|
||
}
|
||
if !slow_daily_done && cur_h == slow_time.0 && cur_m == slow_time.1 {
|
||
slow_daily_done = true;
|
||
if cfg.metrics.network_info.udp || cfg.metrics.network_info.mqtt {
|
||
let ni = metrics::network_info::collect(&cfg.server.ip);
|
||
if !ni.is_empty() { m.network_info = Some(ni); }
|
||
}
|
||
if cfg.metrics.hardware_info.udp || cfg.metrics.hardware_info.mqtt {
|
||
m.hardware_info = metrics::hardware::collect();
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Vérifier** : `cargo check --manifest-path agent/Cargo.toml`
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add agent/src/main.rs agent/Cargo.toml deploy/install.sh
|
||
git commit -m "feat(agent v0.1.6): scheduler slow metrics + réseau + hardware + iperf3/dmidecode dans install.sh"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 5 — Serveur : modèles Go + migrations DB + stockage
|
||
|
||
**Files:**
|
||
- Modify: `server/models/models.go`
|
||
- Modify: `server/db/db.go`
|
||
|
||
- [ ] **Ajouter dans `server/models/models.go`** :
|
||
|
||
```go
|
||
type NetworkInterface struct {
|
||
Name string `json:"name"`
|
||
IfType string `json:"if_type"`
|
||
SpeedMbps *int64 `json:"speed_mbps"`
|
||
MAC string `json:"mac"`
|
||
WoL *bool `json:"wol"`
|
||
IperfMbps *float64 `json:"iperf_mbps"`
|
||
}
|
||
|
||
type HardwareInfo struct {
|
||
MotherboardVendor *string `json:"motherboard_vendor"`
|
||
MotherboardModel *string `json:"motherboard_model"`
|
||
CPUModel *string `json:"cpu_model"`
|
||
RAMType *string `json:"ram_type"`
|
||
RAMSpeedMHz *int64 `json:"ram_speed_mhz"`
|
||
RAMSlotsUsed *int64 `json:"ram_slots_used"`
|
||
RAMSlotsTotal *int64 `json:"ram_slots_total"`
|
||
}
|
||
```
|
||
|
||
Dans `AgentMetrics`, ajouter :
|
||
```go
|
||
NetworkInfo []NetworkInterface `json:"network_info"`
|
||
HardwareInfo *HardwareInfo `json:"hardware_info"`
|
||
```
|
||
|
||
Dans `Agent`, ajouter :
|
||
```go
|
||
NetworkInfo []NetworkInterface `json:"network_info,omitempty"`
|
||
HardwareInfo *HardwareInfo `json:"hardware_info,omitempty"`
|
||
```
|
||
|
||
- [ ] **Dans `server/db/db.go`** — migrations :
|
||
|
||
Dans `migrate()`, ajouter :
|
||
```go
|
||
_, _ = d.conn.Exec(`ALTER TABLE agents ADD COLUMN network_info_json TEXT`)
|
||
_, _ = d.conn.Exec(`ALTER TABLE agents ADD COLUMN hardware_info_json TEXT`)
|
||
```
|
||
|
||
- [ ] **Dans `UpsertAgent()`** — stocker les données lentes si présentes :
|
||
|
||
```go
|
||
func (d *DB) UpsertAgent(m *models.AgentMetrics) error {
|
||
ts := time.Now().Unix()
|
||
var netJSON, hwJSON interface{}
|
||
if len(m.NetworkInfo) > 0 {
|
||
if b, err := json.Marshal(m.NetworkInfo); err == nil {
|
||
netJSON = string(b)
|
||
}
|
||
}
|
||
if m.HardwareInfo != nil {
|
||
if b, err := json.Marshal(m.HardwareInfo); err == nil {
|
||
hwJSON = string(b)
|
||
}
|
||
}
|
||
_, err := d.conn.Exec(`
|
||
INSERT INTO agents (id, hostname, ip, status, last_seen, version)
|
||
VALUES (?, ?, ?, ?, ?, ?)
|
||
ON CONFLICT(id) DO UPDATE SET
|
||
ip=excluded.ip, status=excluded.status, last_seen=excluded.last_seen,
|
||
version=CASE WHEN excluded.version != '' THEN excluded.version ELSE version END,
|
||
network_info_json=CASE WHEN ?7 IS NOT NULL THEN ?7 ELSE network_info_json END,
|
||
hardware_info_json=CASE WHEN ?8 IS NOT NULL THEN ?8 ELSE hardware_info_json END`,
|
||
m.Hostname, m.Hostname, m.IP, m.Status, ts, m.Version, netJSON, hwJSON)
|
||
return err
|
||
}
|
||
```
|
||
|
||
- [ ] **Dans `GetAgents()`** — lire et désérialiser les colonnes JSON :
|
||
|
||
```go
|
||
func (d *DB) GetAgents() ([]models.Agent, error) {
|
||
rows, err := d.conn.Query(`SELECT id, hostname, ip, status, last_seen, version,
|
||
network_info_json, hardware_info_json FROM agents`)
|
||
// ...
|
||
var netJSON, hwJSON *string
|
||
if err := rows.Scan(&a.ID, &a.Hostname, &a.IP, &a.Status, &a.LastSeen, &a.Version,
|
||
&netJSON, &hwJSON); err != nil { ... }
|
||
if netJSON != nil { _ = json.Unmarshal([]byte(*netJSON), &a.NetworkInfo) }
|
||
if hwJSON != nil { _ = json.Unmarshal([]byte(*hwJSON), &a.HardwareInfo) }
|
||
}
|
||
```
|
||
|
||
- [ ] **Vérifier** : `cd server && go build ./...`
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add server/models/models.go server/db/db.go
|
||
git commit -m "feat(server): NetworkInterface + HardwareInfo — migration DB + stockage agents"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 6 — Serveur : API GET /api/agents/{id} + docker-compose iperf3
|
||
|
||
**Files:**
|
||
- Modify: `server/handlers/agents.go`
|
||
- Modify: `server/main.go`
|
||
- Modify: `server/docker-compose.yml`
|
||
|
||
- [ ] **Ajouter dans `server/handlers/agents.go`** le handler single agent :
|
||
|
||
```go
|
||
func AgentDetailHandler(database *db.DB) http.HandlerFunc {
|
||
return func(w http.ResponseWriter, r *http.Request) {
|
||
parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/")
|
||
if len(parts) < 3 { http.Error(w, "invalid path", 400); return }
|
||
agentID := parts[2]
|
||
agents, err := database.GetAgents()
|
||
if err != nil { http.Error(w, err.Error(), 500); return }
|
||
for _, a := range agents {
|
||
if a.ID == agentID {
|
||
a.LastMetrics, _ = database.GetLastMetrics(agentID)
|
||
w.Header().Set("Content-Type", "application/json")
|
||
json.NewEncoder(w).Encode(a)
|
||
return
|
||
}
|
||
}
|
||
http.NotFound(w, r)
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Dans `server/main.go`** — ajouter la route dans le switch `/api/agents/` :
|
||
|
||
```go
|
||
case r.Method == http.MethodGet && !strings.HasSuffix(r.URL.Path, "/"):
|
||
handlers.AgentDetailHandler(database)(w, r)
|
||
```
|
||
|
||
- [ ] **Dans `server/docker-compose.yml`** — ajouter le service iperf3 :
|
||
|
||
```yaml
|
||
iperf3:
|
||
image: ${IPERF3_IMAGE:-public.ecr.aws/docker/library/networkstatic/iperf3:latest}
|
||
pull_policy: if_not_present
|
||
restart: unless-stopped
|
||
command: ["-s"]
|
||
ports:
|
||
- "5201:5201"
|
||
```
|
||
|
||
- [ ] **Vérifier** : `cd server && go build ./...`
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add server/handlers/agents.go server/main.go server/docker-compose.yml
|
||
git commit -m "feat(server): GET /api/agents/{id} + service iperf3 dans compose"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 7 — Dashboard : section réseau dans popup détail
|
||
|
||
**Files:**
|
||
- Modify: `dashboard/js/popups.js`
|
||
- Modify: `dashboard/css/app.css`
|
||
|
||
- [ ] **Ajouter CSS** dans `app.css` pour la section réseau :
|
||
|
||
```css
|
||
.net-table{display:flex;flex-direction:column;gap:4px}
|
||
.net-row{display:grid;grid-template-columns:auto 1fr 80px 120px 60px 90px;
|
||
align-items:center;gap:8px;padding:6px 10px;
|
||
background:var(--bg-3);border-radius:6px;border:1px solid var(--border-1);
|
||
font-family:var(--font-terminal);font-size:10px}
|
||
.net-row:first-child{background:var(--bg-4);font-size:9px;color:var(--ink-4);letter-spacing:.06em}
|
||
.net-val{font-family:var(--font-mono);font-size:11px;color:var(--ink-2)}
|
||
.hw-grid{display:grid;grid-template-columns:1fr 1fr;gap:6px}
|
||
```
|
||
|
||
- [ ] **Dans `popups.js`**, après la section STOCKAGE dans `pop-body`, ajouter les sections réseau et hardware. Construire les variables HTML :
|
||
|
||
```javascript
|
||
const netSection = entry?.agent?.network_info?.length > 0
|
||
? /* tableau des interfaces */ ...
|
||
: '';
|
||
|
||
const hwSection = entry?.agent?.hardware_info
|
||
? /* grille hardware */ ...
|
||
: '';
|
||
```
|
||
|
||
Insérer `${netSection}${hwSection}` avant la section INFORMATIONS.
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add dashboard/js/popups.js dashboard/css/app.css
|
||
git commit -m "feat(dashboard): sections réseau et hardware dans popup détail"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 8 — Dashboard : font-size global
|
||
|
||
**Files:**
|
||
- Modify: `dashboard/js/app.js`
|
||
- Modify: `dashboard/css/app.css`
|
||
|
||
- [ ] **Dans `app.js`**, changer l'application du font-size : appliquer sur `html` (root) au lieu de `body` :
|
||
|
||
```javascript
|
||
if (_serverConfig.font_size) {
|
||
document.documentElement.style.fontSize = _serverConfig.font_size + 'px';
|
||
}
|
||
```
|
||
|
||
- [ ] **Dans `app.css`**, vérifier que les éléments clés utilisent `rem` pour les tailles de police principales. Ajouter la règle de base sur `html` :
|
||
|
||
```css
|
||
html { font-size: 13px; } /* valeur par défaut, écrasée par JS */
|
||
```
|
||
|
||
Les éléments qui utilisent déjà des tailles en `px` absolues seront progressivement mis à l'échelle via ce mécanisme. Ceux qui héritent (`font-size: inherit`) bénéficieront automatiquement.
|
||
|
||
- [ ] **Commit** :
|
||
```bash
|
||
git add dashboard/js/app.js dashboard/css/app.css
|
||
git commit -m "fix(dashboard): font-size global appliqué sur html root"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 9 — Release et déploiement
|
||
|
||
- [ ] **Rebuild agent** : `cargo build --release --manifest-path agent/Cargo.toml`
|
||
- [ ] **Copier binaires** dans `dist/`
|
||
- [ ] **Rebuild Docker** : `cd server && docker compose up -d --build`
|
||
- [ ] **Redéployer l'agent** via `install.sh` sur chaque VM cible
|
||
- [ ] **Push final** : `git push`
|