Rafraîchissement par projet, nom obligatoire et fichiers anciens masqués

- Chaque projet choisit sa fréquence de relecture (jamais, 5 s … 1 h) ; le
  serveur ne relit que les projets dus, le fichier affiché est toujours à
  jour. Le réglage global et sa page disparaissent (migration de l'ancien
  intervalle vers chaque projet).
- Le nom du projet est obligatoire, proposé d'après le chemin.
- Les fichiers non modifiés depuis N jours peuvent être masqués ; ils ne
  comptent plus dans les non-lus et réapparaissent dès qu'ils changent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Romulus21andClaude Opus 5.5 committed 2026-10-21 13:24:11 +02:00
1 parent 86c8f1bb49
commit e44e0fd162
9 files changed
+474 -206

No files matched your search

+41 -27
View File
@@ -12,7 +12,7 @@ Logs Reader est une application web **locale et mono-utilisateur** qui permet à
1. enregistrer un ou plusieurs projets (Laravel, Symfony, Node… : n'importe quel dossier) par leur chemin sur le disque et leurs dossiers de logs ;
2. voir tous les fichiers de log de chaque projet et en lire les entrées, y compris les logs Apache du vhost du projet ;
3. être prévenu, via le **favicon** et le titre de l'onglet, de toute nouvelle entrée apparue depuis sa dernière consultation ;
4. choisir l'intervalle de rafraîchissement.
4. choisir, pour chaque projet, la fréquence de relecture de ses logs.
### 1.1 Périmètre
@@ -42,7 +42,7 @@ Logs Reader est une application web **locale et mono-utilisateur** qui permet à
| **Offset de scan** | Position (en octets) jusqu'à laquelle le fichier a été lu et découpé en entrées complètes. |
| **Curseur de lecture** | Position (en octets) de fin de la dernière entrée **consultée** par l'utilisateur, une par fichier. |
| **Non-lu** | Une entrée complète qui commence à un offset ≥ curseur de lecture. |
| **Intervalle** | Délai en secondes entre deux rafraîchissements côté client. |
| **Intervalle** | Délai entre deux relectures automatiques des logs d'un projet, choisi par projet : jamais, 5 s, 15 s, 30 s, 1 min, 5 min, 15 min, 30 min ou 1 h. |
| **Vhost** | Fichier de configuration Apache rattaché à un projet (au plus un), identifié par son chemin canonique. |
| **Log Apache** | Fichier déclaré par une directive `ErrorLog` (log d'erreurs) ou `CustomLog`/`TransferLog` (log d'accès) du vhost. |
@@ -69,7 +69,7 @@ Logs Reader est une application web **locale et mono-utilisateur** qui permet à
- **Build** : `cargo-leptos` (features `ssr` / `hydrate`), Tailwind CSS intégré via la config `tailwind-input-file` de cargo-leptos.
- **Persistance** : SQLite via `sqlx`, migrations embarquées (`sqlx::migrate!`) appliquées au démarrage, `PRAGMA foreign_keys = ON`, mode WAL.
- **Scan** : déclenché par chaque appel `unread_summary` (donc au rythme du polling). Les scans concurrents d'un même projet sont sérialisés (mutex par projet) ; un appel qui arrive pendant un scan attend son résultat au lieu d'en relancer un.
- **Scan** : déclenché par chaque appel `unread_summary` (donc au rythme du polling) pour les projets dont l'intervalle est écoulé (cf. 5.5), et par `read_entries` pour le projet du fichier affiché. Les scans concurrents d'un même projet sont sérialisés (mutex par projet) ; un appel qui arrive pendant un scan attend son résultat au lieu d'en relancer un.
- **Configuration** (variables d'environnement) :
- `LOGS_READER_DATABASE_URL` — défaut `sqlite://./logs_reader.sqlite?mode=rwc`
- `LOGS_READER_ADDR` — défaut `127.0.0.1:3000`
@@ -80,15 +80,15 @@ Chaque fonction est exposée en `POST /api/<nom>`.
| Fonction | Entrée | Sortie |
|---|---|---|
| `add_project` | `path`, `name`, `log_dirs` (un par ligne), `vhost` (vides = défaut / aucun) | `()` |
| `update_project` | `project_id`, `path`, `name`, `log_dirs`, `vhost` (vhost vide = retirer) | `()` |
| `add_project` | `path`, `name`, `refresh_seconds`, `hide_after_days` (vide = aucun), `log_dirs` (un par ligne), `vhost` (vides = défaut / aucun) | `()` |
| `update_project` | `project_id`, `path`, `name`, `refresh_seconds`, `hide_after_days`, `log_dirs`, `vhost` (vhost vide = retirer) | `()` |
| `suggest_log_dirs` | `path` | `Vec<String>` (cf. 5.1) |
| `remove_project` | `project_id` | `()` |
| `read_entries` | `file_id`, `limit` (≤ 2000), `levels: Vec<String>`, `query: String` | `EntriesPage { entries, has_more, scan_offset, read_offset, levels }` |
| `mark_read` | `file_id`, `up_to` | `()` |
| `mark_all_read` | `project_id: Option<_>` | `()` |
| `unread_summary` | — | `Summary { total, projects[{…, unread, files[{…, unread}]}] }` |
| `get_settings` / `set_refresh_interval` | `seconds: String` | `Settings { refresh_interval_seconds, file_sort }` |
| `get_settings` | — | `Settings { file_sort, paused }` |
| `set_paused` | `paused: bool` | `()` |
| `set_file_sort` | `sort: "name" \| "modified"` | `()` |
@@ -105,6 +105,8 @@ CREATE TABLE projects (
vhost_path TEXT, -- vhost Apache, chemin canonique
vhost_error TEXT, -- vhost illisible
log_dirs TEXT NOT NULL DEFAULT 'storage/logs', -- dossiers de logs, un par ligne
refresh_seconds INTEGER NOT NULL DEFAULT 5, -- 0 (jamais), 5, 15, 30, 60, 300, 900, 1800, 3600
hide_after_days INTEGER, -- masque les fichiers plus anciens ; NULL = aucun
created_at TEXT NOT NULL
);
@@ -144,7 +146,7 @@ CREATE TABLE settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
-- valeurs initiales : ('refresh_interval_seconds', '5'), ('file_sort', 'name')
-- valeurs : ('file_sort', 'name' | 'modified'), ('paused', '0' | '1')
```
- Le **contenu** des entrées n'est pas stocké : il est relu dans le fichier à partir de `start_offset`/`end_offset`. L'index permet compteurs, filtres par niveau et pagination sans tout relire.
@@ -159,7 +161,7 @@ CREATE TABLE settings (
1. Le chemin saisi est nettoyé (trim) ; `~` en tête est remplacé par `$HOME`.
2. Il est canonicalisé (`std::fs::canonicalize`).
3. Il est valide si c'est un répertoire (aucun fichier particulier n'est exigé).
4. Le nom par défaut est le nom du dernier segment du chemin.
4. Le nom est obligatoire (« Veuillez saisir un nom. ») ; la fenêtre propose le dernier segment du chemin tant que l'utilisateur ne l'a pas saisi lui-même.
5. **Dossiers de logs** : un par ligne (ou séparés par des virgules), relatifs à la racine ; espaces, `./` en tête et `/` final retirés, doublons ignorés. Chacun doit être un sous-dossier (ni `.`, ni `..`, ni chemin absolu) existant et lisible.
6. **Proposition** : quand le chemin est saisi (et tant que l'utilisateur n'a pas modifié le champ), la fenêtre propose les dossiers existants parmi : `storage/logs` si `artisan` existe (Laravel), `var/log` si `bin/console` existe (Symfony), puis `storage/logs`, `var/log`, `var/logs`, `logs`, `log`.
7. Un vhost Apache peut être indiqué (optionnel, cf. 5.8). Il faut au moins un dossier de logs ou un vhost. Si un champ est invalide, rien n'est enregistré.
@@ -167,7 +169,7 @@ CREATE TABLE settings (
### 5.1 bis Modification d'un projet
- Le nom, le chemin, les dossiers de logs et le vhost se modifient avec les mêmes règles qu'à l'ajout (nom vide → dernier segment du chemin ; vhost vide → aucun vhost).
- Le nom, le chemin, les dossiers de logs et le vhost se modifient avec les mêmes règles qu'à l'ajout (nom obligatoire ; vhost vide → aucun vhost).
- Un nouveau chemin déjà enregistré par un autre projet est refusé (« Ce projet est déjà enregistré. »).
- Changer de chemin supprime les fichiers suivis de l'ancien chemin ; ceux du nouveau sont indexés avec leur curseur en fin de fichier. Retirer un dossier de logs supprime ses fichiers. Les fichiers qui deviennent suivis (nouveau chemin, nouveau dossier, nouveau vhost) ne comptent pas leur historique en non-lu ; les autres gardent leurs curseurs.
- La modification et le scan qui suit se font sous le verrou du scanner.
@@ -202,8 +204,10 @@ Au scan, si `taille actuelle < scan_offset` **ou** `file_identity` a changé :
### 5.5 Rafraîchissement et notification
- Le client appelle `unread_summary` au chargement de la page puis toutes les `refresh_interval_seconds` secondes.
- Le nouvel intervalle s'applique dès l'enregistrement, sans recharger la page (le timer est recréé).
- Le client appelle `unread_summary` au chargement de la page puis toutes les 5 s (le plus court des intervalles).
- Le serveur ne relit que les projets dont l'intervalle est écoulé (marge de 1 s, pour qu'un poll un peu en avance ne fasse pas attendre un cycle de plus) ; les autres gardent leurs compteurs. Un projet réglé sur « jamais » n'est jamais relu ainsi. L'heure de la dernière relecture de chaque projet est tenue en mémoire : au démarrage du serveur, tous les projets (sauf « jamais ») sont relus au premier poll.
- **Fichier affiché** : `read_entries` relit d'abord le projet du fichier, quel que soit son intervalle. Le fichier ouvert est donc à jour à chaque poll, y compris pour un projet « jamais ».
- Un nouvel intervalle s'applique dès l'enregistrement du projet, sans recharger la page.
- Le favicon est un SVG 32×32 généré côté client (URL `data:`) :
- `total = 0` → icône normale ;
- `total ≥ 1` → icône + pastille rouge avec le nombre (`99+` au-delà de 99) ;
@@ -223,11 +227,12 @@ Au scan, si `taille actuelle < scan_offset` **ou** `file_identity` a changé :
- **Barre latérale** : liste des projets, chacun dépliable en liste de fichiers (chemin relatif à la racine, ou au dossier de logs s'il n'y en a qu'un ; taille ; badge de non-lus). Fichiers manquants grisés. Un projet replié le reste aux rafraîchissements.
- **Tri des fichiers** : par nom (alphabétique, défaut) ou par date de dernière modification (le plus récent en premier, sans date en dernier, nom en départage). Trié par date, l'ancienneté (« il y a 3 h ») remplace la taille. Le choix s'applique à tous les projets et est enregistré dans `settings` (`file_sort`).
- **Fenêtre de projet** (modale, `<dialog>` natif) : ouverte par « + Ajouter un projet » ou par le bouton ✎ d'un projet (pré-remplie). Champs : chemin du projet, nom (optionnel), dossiers de logs (zone de texte, un par ligne, proposés d'après le chemin, cf. 5.1), vhost Apache (optionnel). En modification, un bouton « Retirer ce projet » en bas à gauche le supprime après confirmation (c'est le seul moyen de retirer un projet). Message d'erreur dans la fenêtre ; elle se ferme quand l'enregistrement ou le retrait réussit, par « Annuler », Échap ou un clic sur le fond.
- **Fenêtre de projet** (modale, `<dialog>` natif) : ouverte par « + Ajouter un projet » ou par le bouton ✎ d'un projet (pré-remplie). Champs : chemin du projet, nom (obligatoire, proposé d'après le chemin), dossiers de logs (zone de texte, un par ligne, proposés d'après le chemin, cf. 5.1), vhost Apache (optionnel). En modification, un bouton « Retirer ce projet » en bas à gauche le supprime après confirmation (c'est le seul moyen de retirer un projet). Message d'erreur dans la fenêtre ; elle se ferme quand l'enregistrement ou le retrait réussit, par « Annuler », Échap ou un clic sur le fond.
- **Vue fichier** : entrées triées du plus récent au plus ancien, 50 par page, bouton « Charger plus ». Chaque entrée : date, niveau (badge coloré), environnement, première ligne ; le reste (stack trace) est repliable. Filtres par niveau (cases à cocher ; les niveaux absents du fichier sont grisés et désactivés, et se réactivent dès qu'une entrée de ce niveau apparaît) et recherche texte (insensible à la casse, sur le contenu complet de l'entrée).
- **Bouton marche/arrêt de la lecture** : à gauche du titre. Lecture active : un engrenage qui tourne lentement (6 s par tour, immobile si l'utilisateur a demandé moins d'animations). Lecture arrêtée : un bouton rouge avec l'icône « power ». L'arrêt supprime le polling et le rafraîchissement au retour sur l'onglet ; « · lecture arrêtée » s'affiche en rouge à côté du compteur. L'état est enregistré dans `settings` (`paused`). À la reprise, un rafraîchissement part immédiatement. Les actions de l'utilisateur (ouvrir un fichier, marquer comme lu, charger la page) rafraîchissent toujours.
- **Logs Apache** : les logs Apache sont listés sous le titre « Apache », après les logs du projet, par nom de fichier suivi de leur rôle (« erreurs » ou « accès »), le chemin complet en info-bulle.
- **Réglages** : intervalle en secondes (champ numérique, 1–3600).
- **Fichiers anciens** : champ numérique « Masquer les fichiers non modifiés depuis (jours) » dans la fenêtre de projet, vide par défaut (aucun fichier masqué), sinon un entier ≥ 1 (« Le nombre de jours doit être un entier positif. »). Un fichier est masqué si sa dernière modification remonte à plus de N × 24 h ; un fichier sans date reste affiché. Les fichiers masqués ne sont ni listés ni comptés dans les non-lus, mais restent scannés : une nouvelle entrée change leur date et les fait réapparaître. Sous le projet, « N fichiers anciens masqués » les signale ; le message « Aucun fichier de log pour l'instant. » n'apparaît pas si des fichiers sont masqués.
- **Rafraîchissement** : liste déroulante dans la fenêtre de projet (« Jamais », « 5 s » … « 1 h », 5 s par défaut). Un projet réglé sur « jamais » porte un ⏸ dans la liste ; l'info-bulle de son nom rappelle l'intervalle. Il n'y a plus de page de réglages.
### 5.8 Logs Apache du vhost
@@ -245,7 +250,7 @@ Au scan, si `taille actuelle < scan_offset` **ou** `file_identity` a changé :
## 6. User stories et critères d'acceptation
Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter au fichier une ligne `[2026-10-21 10:00:00] local.ERROR: message\n`. Tous les délais s'entendent avec un intervalle de 1 s sauf mention contraire.
Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter au fichier une ligne `[2026-10-21 10:00:00] local.ERROR: message\n`. Tous les délais s'entendent avec un projet rafraîchi toutes les 5 s sauf mention contraire.
### US-01 — Ajouter un projet
@@ -257,7 +262,7 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
- **AC-01.2** Given le même répertoire, When j'ajoute `/tmp/app/` puis `/tmp/../tmp/app`, Then la 2ᵉ et la 3ᵉ tentative sont refusées avec « Ce projet est déjà enregistré ».
- **AC-01.3** Given un lien `/tmp/link → /tmp/app` et `/tmp/app` déjà enregistré, When j'ajoute `/tmp/link`, Then l'ajout est refusé (même chemin canonique).
- **AC-01.4** Given `laravel.log` contient 10 entrées, When j'ajoute le projet, Then le compteur de non-lus du projet vaut 0.
- **AC-01.5** Given un nom saisi « Mon API », When j'ajoute le projet, Then il s'affiche sous le nom « Mon API ».
- **AC-01.5** Given le chemin `/tmp/app` saisi, Then le nom proposé est « app » ; When je le remplace par « Mon API » et j'ajoute le projet, Then il s'affiche sous le nom « Mon API ». When le nom est vide, Then l'ajout est refusé avec « Veuillez saisir un nom. ».
- **AC-01.6** Given `~/code/app` valide, When je saisis `~/code/app`, Then le projet est enregistré avec le chemin absolu.
### US-02 — Lister tous les fichiers de log d'un projet
@@ -279,20 +284,29 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
- **AC-03.4** Given un fichier contenant des octets non UTF-8, When il est affiché, Then les entrées s'affichent avec le caractère `�` à la place des octets invalides, sans erreur.
- **AC-03.5** Given un fichier de 1 Gio, When je l'ouvre, Then la première page s'affiche en < 2 s après l'indexation initiale et la mémoire du serveur reste < 200 Mio.
### US-04 — Configurer l'intervalle de rafraîchissement
### US-14 — Masquer les fichiers anciens
> En tant que développeur, je veux choisir la fréquence de lecture des logs, pour arbitrer entre réactivité et charge.
> En tant que développeur, je veux ne pas voir les vieux logs journaliers d'un projet, pour trouver vite ceux qui vivent encore.
- **AC-04.1** Given une première installation, When j'ouvre les réglages, Then l'intervalle vaut 5 s.
- **AC-04.2** Given l'intervalle à 5 s, When je saisis 30 et j'enregistre, Then le client n'appelle plus `unread_summary` qu'une fois toutes les 30 s (± 1 s), sans rechargement de page.
- **AC-04.3** When je saisis `0`, `3601`, `-5`, `abc` ou une valeur vide, Then l'enregistrement est refusé avec « L'intervalle doit être un entier entre 1 et 3600 secondes » et la valeur précédente est conservée.
- **AC-04.4** Given l'intervalle à 30 s, When je redémarre le serveur, Then l'intervalle vaut toujours 30 s.
- **AC-14.1** Given `laravel-2026-09-01.log` modifié il y a 50 j et `laravel.log` modifié il y a 1 h, When je règle « 30 » jours, Then seul `laravel.log` est listé, suivi de « 1 fichier ancien masqué ».
- **AC-14.2** Given le réglage à 30 j et 2 non-lus dans un fichier masqué, Then le total ne les compte pas ; When une entrée y est écrite, Then le fichier réapparaît avec 3 non-lus.
- **AC-14.3** When je vide le champ, Then tous les fichiers sont à nouveau listés. When je saisis `0`, Then l'enregistrement est refusé avec « Le nombre de jours doit être un entier positif. ».
### US-04 — Choisir le rafraîchissement d'un projet
> En tant que développeur, je veux régler la fréquence de relecture de chaque projet, pour suivre de près le projet sur lequel je travaille sans relire en permanence les autres.
- **AC-04.1** Given un nouveau projet, When j'ouvre la fenêtre d'ajout, Then le rafraîchissement vaut « 5 s » et la liste propose Jamais, 5 s, 15 s, 30 s, 1 min, 5 min, 15 min, 30 min, 1 h.
- **AC-04.2** Given un projet A à 5 s et un projet B à 1 min, When une entrée est écrite dans chacun, Then A la signale en ≤ 6 s et B en ≤ 61 s.
- **AC-04.3** Given un projet réglé sur « Jamais », When des entrées sont écrites, Then ses compteurs ne changent pas et un ⏸ est affiché à côté de son nom ; When j'ouvre un de ses fichiers, Then les nouvelles entrées s'affichent.
- **AC-04.4** When une valeur hors de la liste est envoyée à `add_project` ou `update_project`, Then l'enregistrement est refusé avec « Intervalle de rafraîchissement invalide. ».
- **AC-04.5** Given un projet à 15 min, When je redémarre le serveur, Then il est toujours à 15 min. Les projets existants avant cette version prennent l'ancien intervalle global, arrondi au choix supérieur.
### US-05 — Être notifié des nouvelles entrées par le favicon
> En tant que développeur, je veux voir dans l'onglet du navigateur s'il y a de nouveaux logs, sans avoir à regarder l'application.
- **AC-05.1** Given 0 non-lu, When 3 entrées sont écrites dans un fichier suivi, Then en ≤ intervalle + 1 s le favicon porte une pastille « 3 » et le titre est `(3) Logs Reader`.
- **AC-05.1** Given 0 non-lu, When 3 entrées sont écrites dans un fichier suivi, Then en ≤ 6 s le favicon porte une pastille « 3 » et le titre est `(3) Logs Reader`.
- **AC-05.2** Given 2 non-lus dans `a.log` et 1 dans `b.log` (même projet ou non), Then la pastille affiche « 3 ».
- **AC-05.3** Given 150 non-lus, Then la pastille affiche « 99+ » et le titre `(150) Logs Reader`.
- **AC-05.4** Given des non-lus, When tout est marqué comme lu, Then le favicon redevient normal et le titre `Logs Reader` sans attendre le prochain poll.
@@ -340,7 +354,7 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
> En tant que développeur, je veux arrêter temporairement la lecture des logs, par exemple pendant une session de debug bruyante.
- **AC-11.1** Given la lecture active (engrenage qui tourne), When je clique dessus, Then le bouton devient rouge, le favicon affiche la pastille rouge « pause », « · lecture arrêtée » est affiché, et aucun appel `unread_summary` n'est fait pendant 3 intervalles, même si des entrées sont écrites.
- **AC-11.1** Given la lecture active (engrenage qui tourne), When je clique dessus, Then le bouton devient rouge, le favicon affiche la pastille rouge « pause », « · lecture arrêtée » est affiché, et aucun appel `unread_summary` n'est fait pendant 15 s, même si des entrées sont écrites.
- **AC-11.2** Given la lecture arrêtée, When je recharge la page, Then le bouton est toujours rouge, le favicon toujours en pause, et aucun polling ne reprend.
- **AC-11.3** Given la lecture arrêtée et 1 entrée écrite entre-temps, When je clique sur le bouton rouge, Then l'engrenage réapparaît et le compteur et le favicon sont mis à jour en moins de 1 s.
@@ -395,13 +409,13 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
| E15 | Texte sans ligne d'en-tête valide | Regex | Entrée `UNKNOWN` (cf. 5.3) | — |
| E16 | Fichier très volumineux | — | Lecture par blocs ; jamais de chargement complet | — |
| E17 | Entrée gigantesque (> 1 Mio) | Taille `end - start` | Affichage tronqué | « Entrée tronquée (X Mio). » |
| E18 | Intervalle invalide | Validation client et serveur | Refus, ancienne valeur conservée | cf. AC-04.3 |
| E18 | Intervalle invalide | Validation serveur (choix de la liste) | Refus, ancienne valeur conservée | cf. AC-04.4 |
| E19 | `log_file_id` / `project_id` inconnu | Requête vide | Erreur 404 de la server function | « Élément introuvable, la liste a été rafraîchie. » |
| E20 | Base SQLite inaccessible au démarrage | Échec de connexion/migration | Arrêt du processus, code de sortie ≠ 0 | Log console explicite avec le chemin |
| E21 | Base verrouillée en cours d'exécution | `SQLITE_BUSY` | `busy_timeout` de 5 s, puis erreur renvoyée au client ; aucun état partiel (transaction) | « Base de données occupée, nouvel essai au prochain rafraîchissement. » |
| E22 | Base corrompue | `PRAGMA quick_check` au démarrage | Arrêt du processus | Log console explicite |
| E23 | Port déjà utilisé | `bind` échoue | Arrêt, code de sortie ≠ 0 | « L'adresse `<addr>` est déjà utilisée. » |
| E24 | Serveur injoignable côté client | Échec réseau du poll | Favicon gris « ! », bandeau discret ; on continue de poller au même intervalle | « Serveur injoignable. » |
| E24 | Serveur injoignable côté client | Échec réseau du poll | Favicon gris « ! », bandeau discret ; on continue de poller toutes les 5 s | « Serveur injoignable. » |
| E25 | Scans simultanés (plusieurs onglets) | Mutex par projet | Un seul scan à la fois, résultats partagés ; pas de double indexation | — |
| E26 | Vhost inexistant, illisible ou sans directive de log | Validation serveur | Refus, vhost précédent conservé | « Le fichier « p » n'existe pas. », « Accès refusé à « p ». », « Aucune directive ErrorLog ni CustomLog dans « p ». » |
| E27 | Vhost supprimé ou illisible après configuration | Lecture au scan | `vhost_error` renseigné, fichiers Apache connus conservés en l'état | Message sous le titre « Apache » |
@@ -417,13 +431,13 @@ Ces propriétés doivent être vraies après toute opération et peuvent être v
- **INV-02 Ordre des offsets** — Pour tout fichier présent : `0 ≤ read_offset ≤ scan_offset ≤ size`.
- **INV-03 Index cohérent** — Les entrées indexées d'un fichier sont disjointes, contiguës et triées : pour deux entrées consécutives `e1, e2`, `e1.end_offset = e2.start_offset` ; la dernière se termine à `scan_offset` ; `entries_count` = nombre de lignes d'index.
- **INV-04 Aucune entrée partielle ni doublon** — Chaque entrée complète du fichier est indexée exactement une fois ; aucune entrée incomplète n'est indexée.
- **INV-05 Calcul des non-lus** — `unread(f)` = nombre d'entrées indexées de `f` avec `start_offset ≥ read_offset` ; `unread(f) ≥ 0` ; `unread(f) = 0` si `f` est manquant ou est un log d'accès Apache ; `total = Σ unread(f)` sur les fichiers présents des projets accessibles.
- **INV-05 Calcul des non-lus** — `unread(f)` = nombre d'entrées indexées de `f` avec `start_offset ≥ read_offset` ; `unread(f) ≥ 0` ; `unread(f) = 0` si `f` est manquant, masqué (trop ancien) ou est un log d'accès ; `total = Σ unread(f)` sur les fichiers présents des projets accessibles.
- **INV-06 Le curseur n'avance que par l'utilisateur** — Un scan ne fait jamais avancer `read_offset` ; seuls `mark_read`, `mark_all_read` et l'ajout initial d'un projet (5.1) le font avancer. Seule une rotation (5.4) le fait reculer (à 0).
- **INV-07 Monotonie hors rotation** — En l'absence de rotation, `scan_offset` et `read_offset` sont croissants dans le temps.
- **INV-08 Confinement** — Tout fichier du projet suivi a un chemin canonique sous l'un de ses dossiers de logs ; tout log Apache suivi est déclaré par le vhost du projet.
- **INV-09 Unicité** — Un chemin canonique correspond à au plus un projet ; un couple (projet, chemin relatif) à au plus un fichier.
- **INV-10 Cascade** — Après suppression d'un projet, aucune ligne de `log_files`, `log_entries_index` ou `read_cursors` ne le référence.
- **INV-11 Bornes de l'intervalle** — `refresh_interval_seconds` stocké est toujours un entier dans `[1, 3600]`.
- **INV-11 Intervalle valide** — `refresh_seconds` d'un projet est toujours l'un de 0, 5, 15, 30, 60, 300, 900, 1800, 3600.
- **INV-12 Persistance** — Sans changement des fichiers sur le disque, un redémarrage ne change aucun compteur de non-lus.
- **INV-13 Idempotence du scan** — Deux scans successifs sans modification des fichiers produisent le même état en base.
- **INV-14 Atomicité** — Le scan d'un fichier (mise à jour de l'index + `scan_offset`) est fait dans une seule transaction : un crash au milieu laisse l'état précédent.
+1 -1
View File
@@ -35,7 +35,7 @@ cargo test --features ssr
| Fichier | Rôle |
|---|---|
| `src/model.rs` | Types partagés client/serveur, validation de l'intervalle, favicon SVG |
| `src/model.rs` | Types partagés client/serveur, choix de rafraîchissement, favicon SVG |
| `src/parser.rs` | Détection du format et découpage d'un log en entrées (lecture en flux) |
| `src/apache.rs` | Lecture du vhost Apache, format des logs d'erreurs et d'accès |
| `src/scanner.rs` | Découverte des fichiers (dossiers de logs et vhost), indexation incrémentale, détection de rotation |
+20
View File
@@ -0,0 +1,20 @@
-- Rafraîchissement propre à chaque projet (secondes, 0 = jamais), qui remplace le réglage global.
ALTER TABLE projects ADD COLUMN refresh_seconds INTEGER NOT NULL DEFAULT 5;
-- Les projets existants prennent l'ancien intervalle global, arrondi au choix supérieur.
UPDATE projects
SET refresh_seconds = (
SELECT CASE
WHEN CAST(value AS INTEGER) <= 5 THEN 5
WHEN CAST(value AS INTEGER) <= 15 THEN 15
WHEN CAST(value AS INTEGER) <= 30 THEN 30
WHEN CAST(value AS INTEGER) <= 60 THEN 60
WHEN CAST(value AS INTEGER) <= 300 THEN 300
WHEN CAST(value AS INTEGER) <= 900 THEN 900
WHEN CAST(value AS INTEGER) <= 1800 THEN 1800
ELSE 3600
END
FROM settings WHERE key = 'refresh_interval_seconds')
WHERE EXISTS (SELECT 1 FROM settings WHERE key = 'refresh_interval_seconds');
DELETE FROM settings WHERE key = 'refresh_interval_seconds';
+3
View File
@@ -0,0 +1,3 @@
-- Fichiers masqués d'un projet : ceux dont la dernière modification remonte à plus de ce
-- nombre de jours (NULL = aucun fichier masqué).
ALTER TABLE projects ADD COLUMN hide_after_days INTEGER;
+50 -25
View File
@@ -6,37 +6,39 @@ use leptos::{prelude::*, server_fn::codec::Json};
#[cfg(feature = "ssr")]
use crate::server::{internal_error, not_found, now, pool, scanner};
/// Rafraîchit l'index de tous les projets puis renvoie les compteurs de non-lus.
/// Appelée à chaque cycle de polling.
/// Rafraîchit l'index des projets dont l'intervalle est écoulé, puis renvoie les compteurs
/// de non-lus. Appelée à chaque cycle de polling.
#[server(endpoint = "unread_summary")]
pub async fn unread_summary() -> Result<Summary, ServerFnError> {
let pool = pool()?;
scanner()?.scan_all(&pool).await.map_err(internal_error)?;
scanner()?.scan_due(&pool).await.map_err(internal_error)?;
crate::server::load_summary(&pool)
.await
.map_err(internal_error)
}
/// Valide les champs du formulaire d'un projet. Sans nom, le projet prend celui du dernier
/// dossier du chemin ; un vhost vide n'en est pas un. Il faut au moins un dossier de logs ou
/// un vhost.
/// Valide les champs du formulaire d'un projet. Le nom est obligatoire ; un vhost vide n'en
/// est pas un. Il faut au moins un dossier de logs ou un vhost.
#[cfg(feature = "ssr")]
fn project_fields(
path: &str,
name: &str,
refresh_seconds: u32,
hide_after_days: &str,
log_dirs: &str,
vhost: &str,
) -> Result<crate::scanner::ProjectConfig, ServerFnError> {
let refresh_seconds =
crate::model::validate_refresh(refresh_seconds).map_err(ServerFnError::new)?;
let hide_after_days =
crate::model::parse_hide_days(hide_after_days).map_err(ServerFnError::new)?;
use crate::scanner::{validate_log_dirs, validate_project_path};
let root = validate_project_path(path).map_err(ServerFnError::new)?;
let log_dirs = crate::model::parse_log_dirs(log_dirs);
validate_log_dirs(&root, &log_dirs).map_err(ServerFnError::new)?;
let root_str = root.to_string_lossy().to_string();
let name = match name.trim() {
"" => root
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| root_str.clone()),
"" => return Err(ServerFnError::new("Veuillez saisir un nom.")),
name => name.to_string(),
};
let vhost = match vhost.trim() {
@@ -56,6 +58,8 @@ fn project_fields(
Ok(crate::scanner::ProjectConfig {
name,
root: root_str,
refresh_seconds,
hide_after_days,
log_dirs,
vhost,
})
@@ -85,27 +89,45 @@ fn save_error(error: sqlx::Error) -> ServerFnError {
pub async fn add_project(
path: String,
name: String,
refresh_seconds: u32,
hide_after_days: String,
log_dirs: String,
vhost: String,
) -> Result<(), ServerFnError> {
let project = project_fields(&path, &name, &log_dirs, &vhost)?;
let project = project_fields(
&path,
&name,
refresh_seconds,
&hide_after_days,
&log_dirs,
&vhost,
)?;
scanner()?
.add_project(&pool()?, &project)
.await
.map_err(save_error)
}
/// Modifie le nom, le chemin, les dossiers de logs ou le vhost d'un projet. Un vhost vide
/// Modifie le nom, le chemin, le rafraîchissement, les dossiers de logs ou le vhost d'un projet. Un vhost vide
/// le retire.
#[server(endpoint = "update_project")]
pub async fn update_project(
project_id: i64,
path: String,
name: String,
refresh_seconds: u32,
hide_after_days: String,
log_dirs: String,
vhost: String,
) -> Result<(), ServerFnError> {
let project = project_fields(&path, &name, &log_dirs, &vhost)?;
let project = project_fields(
&path,
&name,
refresh_seconds,
&hide_after_days,
&log_dirs,
&vhost,
)?;
let found = scanner()?
.update_project(&pool()?, project_id, &project)
.await
@@ -151,6 +173,21 @@ pub async fn read_entries(
};
let pool = pool()?;
// Le fichier affiché est toujours à jour, quel que soit l'intervalle de son projet.
let project_id: Option<i64> =
sqlx::query_scalar("SELECT project_id FROM log_files WHERE id = ?")
.bind(file_id)
.fetch_optional(&pool)
.await
.map_err(internal_error)?;
let Some(project_id) = project_id else {
return Err(not_found());
};
scanner()?
.scan_now(&pool, project_id)
.await
.map_err(internal_error)?;
/// (racine, nom du projet, chemin, origine, format, offset de scan, curseur de lecture)
type FileRow = (String, String, String, String, Option<String>, i64, i64);
let row: Option<FileRow> = sqlx::query_as(
@@ -320,18 +357,6 @@ pub async fn get_settings() -> Result<Settings, ServerFnError> {
.map_err(internal_error)
}
#[server(endpoint = "set_refresh_interval")]
pub async fn set_refresh_interval(seconds: String) -> Result<Settings, ServerFnError> {
let seconds = crate::model::parse_interval(&seconds).map_err(ServerFnError::new)?;
let pool = pool()?;
crate::server::set_setting(&pool, "refresh_interval_seconds", &seconds.to_string())
.await
.map_err(internal_error)?;
crate::server::load_settings(&pool)
.await
.map_err(internal_error)
}
/// Arrête ou reprend la lecture automatique des logs, conservé entre deux sessions.
#[server(endpoint = "set_paused")]
pub async fn set_paused(paused: bool) -> Result<(), ServerFnError> {
+132 -97
View File
@@ -1,13 +1,12 @@
use crate::{
api::{
AddProject, MarkAllRead, MarkRead, RemoveProject, SetFileSort, SetPaused,
SetRefreshInterval, UpdateProject, get_settings, read_entries, suggest_log_dirs,
unread_summary,
AddProject, MarkAllRead, MarkRead, RemoveProject, SetFileSort, SetPaused, UpdateProject,
get_settings, read_entries, suggest_log_dirs, unread_summary,
},
model::{
DEFAULT_INTERVAL, EntriesPage, Entry, FaviconState, FileSort, FileSummary, LEVELS, LogKind,
PAGE_SIZE, ProjectSummary, Settings, Summary, UNKNOWN_LEVEL, favicon_data_url, human_size,
page_title, relative_age, sort_files,
DEFAULT_REFRESH, EntriesPage, Entry, FaviconState, FileSort, FileSummary, LEVELS, LogKind,
PAGE_SIZE, POLL_SECONDS, ProjectSummary, REFRESH_CHOICES, Settings, Summary, UNKNOWN_LEVEL,
favicon_data_url, human_size, page_title, refresh_label, relative_age, sort_files,
},
};
use leptos::{html, prelude::*};
@@ -70,7 +69,6 @@ impl Live {
#[derive(Clone, Copy)]
struct SettingsCtx {
settings: Resource<Result<Settings, ServerFnError>>,
save: ServerAction<SetRefreshInterval>,
}
/// Interrupteur de lecture automatique des logs.
@@ -131,9 +129,8 @@ pub fn App() -> impl IntoView {
};
provide_context(live);
let save = ServerAction::<SetRefreshInterval>::new();
let settings = Resource::new(move || save.version().get(), |_| get_settings());
provide_context(SettingsCtx { settings, save });
let settings = Resource::new(|| (), |_| get_settings());
provide_context(SettingsCtx { settings });
let pause = Pause {
chosen: RwSignal::new(None),
@@ -142,15 +139,8 @@ pub fn App() -> impl IntoView {
};
provide_context(pause);
let interval = move || {
settings
.get()
.and_then(Result::ok)
.map(|s| s.refresh_interval_seconds)
.unwrap_or(DEFAULT_INTERVAL)
};
// Polling : le timer est recréé à chaque changement d'intervalle, et supprimé en pause.
// Polling à la période la plus courte : le serveur ne relit que les projets dont
// l'intervalle est écoulé. Le timer est supprimé en pause.
Effect::new(move |previous: Option<Option<IntervalHandle>>| {
if let Some(Some(handle)) = previous {
handle.clear();
@@ -158,8 +148,11 @@ pub fn App() -> impl IntoView {
if pause.get() {
return None;
}
let seconds = interval();
set_interval_with_handle(move || live.bump(), Duration::from_secs(seconds.into())).ok()
set_interval_with_handle(
move || live.bump(),
Duration::from_secs(POLL_SECONDS.into()),
)
.ok()
});
// À la reprise, rafraîchit tout de suite sans attendre la fin du premier intervalle.
@@ -218,7 +211,6 @@ pub fn App() -> impl IntoView {
<Routes fallback=|| view! { <p class="p-8">"Page introuvable."</p> }>
<Route path=path!("/") view=HomePage ssr=SsrMode::Async />
<Route path=path!("/files/:id") view=FileView ssr=SsrMode::Async />
<Route path=path!("/settings") view=SettingsPage ssr=SsrMode::Async />
</Routes>
</main>
</div>
@@ -297,8 +289,7 @@ fn Sidebar() -> impl IntoView {
view! {
<aside class="flex w-80 shrink-0 flex-col gap-4 overflow-y-auto bg-zinc-900 p-4 text-zinc-100">
<header class="flex items-center justify-between">
<div class="flex items-center gap-2">
<header class="flex items-center gap-2">
// Sous un `Transition` : l'état vient des réglages, chargés par le serveur.
<Transition>
<PauseSwitch />
@@ -306,16 +297,12 @@ fn Sidebar() -> impl IntoView {
<A href="/" attr:class="text-lg font-semibold">
"Logs Reader"
</A>
</div>
<A href="/settings" attr:class=SMALL_BUTTON attr:title="Réglages">
"Réglages"
</A>
</header>
<button
type="button"
class=BUTTON
on:click=move |_| editing.set(Some(ProjectForm::default()))
on:click=move |_| editing.set(Some(ProjectForm::new()))
>
"+ Ajouter un projet"
</button>
@@ -388,23 +375,44 @@ fn Sidebar() -> impl IntoView {
}
/// Contenu de la fenêtre de projet : vide pour un ajout, pré-rempli pour une modification.
#[derive(Clone, Debug, Default, PartialEq)]
#[derive(Clone, Debug, PartialEq)]
struct ProjectForm {
/// `None` pour un nouveau projet.
id: Option<i64>,
name: String,
path: String,
/// Secondes, 0 = jamais.
refresh_seconds: u32,
/// Nombre de jours, vide pour ne masquer aucun fichier.
hide_after_days: String,
/// Un dossier par ligne.
log_dirs: String,
vhost: String,
}
impl ProjectForm {
fn new() -> Self {
ProjectForm {
id: None,
name: String::new(),
path: String::new(),
refresh_seconds: DEFAULT_REFRESH,
hide_after_days: String::new(),
log_dirs: String::new(),
vhost: String::new(),
}
}
fn edit(project: &ProjectSummary) -> Self {
ProjectForm {
id: Some(project.id),
name: project.name.clone(),
path: project.root_path.clone(),
refresh_seconds: project.refresh_seconds,
hide_after_days: project
.hide_after_days
.map(|d| d.to_string())
.unwrap_or_default(),
log_dirs: project.log_dirs.join("\n"),
vhost: project.vhost_path.clone().unwrap_or_default(),
}
@@ -584,11 +592,19 @@ fn ProjectFields(
// modifiés lui-même (ceux d'un projet existant sont conservés).
let log_dirs = RwSignal::new(form.log_dirs);
let dirs_touched = RwSignal::new(!is_new);
// Nom proposé d'après le dernier dossier du chemin, tant qu'il n'a pas été saisi.
let name = RwSignal::new(form.name);
let name_touched = RwSignal::new(!is_new);
let suggest = move |ev: leptos::ev::Event| {
let path = event_target_value(&ev);
if !name_touched.get_untracked()
&& let Some(last) = path.trim().trim_end_matches('/').rsplit('/').next()
{
name.set(last.to_string());
}
if dirs_touched.get_untracked() {
return;
}
let path = event_target_value(&ev);
leptos::task::spawn_local(async move {
if let Ok(dirs) = suggest_log_dirs(path).await
&& !dirs_touched.get_untracked()
@@ -622,8 +638,54 @@ fn ProjectFields(
})}
</label>
<label class="flex flex-col gap-1 text-sm">
"Nom (optionnel)"
<input name="name" value=form.name placeholder="Dernier dossier du chemin" class=INPUT />
"Nom"
<input
name="name"
required
placeholder="Mon projet"
class=INPUT
prop:value=move || name.get()
on:input=move |ev| {
name_touched.set(true);
name.set(event_target_value(&ev));
}
/>
</label>
<label class="flex flex-col gap-1 text-sm">
"Rafraîchissement"
<select name="refresh_seconds" class=INPUT>
{REFRESH_CHOICES
.iter()
.map(|(seconds, label)| {
view! {
<option
value=seconds.to_string()
selected=*seconds == form.refresh_seconds
>
{*label}
</option>
}
})
.collect_view()}
</select>
<span class="text-xs text-zinc-400">
"Fréquence de relecture des logs. « Jamais » : ils ne sont relus qu'à l'affichage d'un de ses fichiers."
</span>
</label>
<label class="flex flex-col gap-1 text-sm">
"Masquer les fichiers non modifiés depuis (jours)"
<input
name="hide_after_days"
type="number"
min="1"
step="1"
value=form.hide_after_days
placeholder="Aucun fichier masqué"
class=INPUT
/>
<span class="text-xs text-zinc-400">
"Les fichiers masqués ne comptent pas dans les nouveaux logs ; ils réapparaissent dès qu'ils sont modifiés."
</span>
</label>
<label class="flex flex-col gap-1 text-sm">
"Dossiers de logs"
@@ -769,7 +831,13 @@ fn ProjectItem(
.partition(|f| f.kind != LogKind::Project);
sort_files(&mut files, sort);
sort_files(&mut apache, sort);
let empty = files.is_empty();
// Sans fichier à afficher, mais pas parce qu'ils sont tous masqués.
let empty = files.is_empty() && apache.is_empty() && project.hidden_files == 0;
let hidden_files = project.hidden_files;
let hidden_title = project
.hide_after_days
.map(|d| format!("Non modifiés depuis plus de {d} j (réglable avec ✎)"))
.unwrap_or_default();
// Avec un seul dossier de logs, les fichiers sont désignés par leur chemin dans ce dossier.
let prefix = match project.log_dirs.as_slice() {
[dir] => Some(format!("{dir}/")),
@@ -779,9 +847,27 @@ fn ProjectItem(
view! {
<details open=open on:toggle=on_toggle class="group">
<summary class="flex cursor-pointer items-center gap-2 rounded px-1 py-1 hover:bg-zinc-800">
<span class="flex-1 truncate font-medium" title=project.root_path.clone()>
<span
class="flex-1 truncate font-medium"
title=format!(
"{} — rafraîchissement : {}",
project.root_path,
refresh_label(project.refresh_seconds).to_lowercase(),
)
>
{project.name.clone()}
</span>
{(project.refresh_seconds == 0)
.then(|| {
view! {
<span
class="text-xs text-zinc-500"
title="Pas de rafraîchissement automatique"
>
"⏸"
</span>
}
})}
<UnreadBadge count=project.unread />
<Show when=move || { project.unread > 0 }>
<button
@@ -829,6 +915,17 @@ fn ProjectItem(
.map(|file| view! { <FileRow file sort now prefix=None /> })
.collect_view()}
</ul>
{(hidden_files > 0)
.then(|| {
view! {
<p class="px-4 py-1 text-xs text-zinc-500" title=hidden_title>
{match hidden_files {
1 => "1 fichier ancien masqué".to_string(),
n => format!("{n} fichiers anciens masqués"),
}}
</p>
}
})}
</details>
}
}
@@ -1196,65 +1293,3 @@ fn EntryRow(entry: Entry, new: bool) -> impl IntoView {
</li>
}
}
#[component]
fn SettingsPage() -> impl IntoView {
let SettingsCtx { settings, save } = expect_context::<SettingsCtx>();
view! {
<div class="mx-auto max-w-md p-10">
<h1 class="mb-6 text-2xl font-semibold">"Réglages"</h1>
<Transition fallback=|| view! { <p>"Chargement…"</p> }>
{move || {
settings
.get()
.map(|result| {
let current = result
.map(|s| s.refresh_interval_seconds)
.unwrap_or(DEFAULT_INTERVAL);
view! {
<ActionForm action=save attr:class="flex flex-col gap-3">
<label class="flex flex-col gap-1 text-sm">
"Intervalle de rafraîchissement (secondes, 1 à 3600)"
<input
name="seconds"
inputmode="numeric"
value=current.to_string()
class="rounded-md border border-zinc-300 bg-white px-2 py-1.5 dark:border-zinc-700 dark:bg-zinc-900"
/>
</label>
<button
type="submit"
class=BUTTON
disabled=move || save.pending().get()
>
"Enregistrer"
</button>
</ActionForm>
}
})
}}
</Transition>
{move || {
save.value()
.get()
.map(|result| match result {
Ok(s) => {
view! {
<p class="mt-3 text-sm text-green-700">
{format!(
"Enregistré : rafraîchissement toutes les {} s.",
s.refresh_interval_seconds,
)}
</p>
}
.into_any()
}
Err(e) => {
view! { <p class="mt-3 text-sm text-red-600">{error_message(&e)}</p> }
.into_any()
}
})
}}
</div>
}
}
+81 -19
View File
@@ -2,9 +2,22 @@
use serde::{Deserialize, Serialize};
pub const MIN_INTERVAL: u32 = 1;
pub const MAX_INTERVAL: u32 = 3600;
pub const DEFAULT_INTERVAL: u32 = 5;
/// Choix de rafraîchissement d'un projet (secondes, libellé) ; 0 = jamais.
pub const REFRESH_CHOICES: [(u32, &str); 9] = [
(0, "Jamais"),
(5, "5 s"),
(15, "15 s"),
(30, "30 s"),
(60, "1 min"),
(300, "5 min"),
(900, "15 min"),
(1800, "30 min"),
(3600, "1 h"),
];
pub const DEFAULT_REFRESH: u32 = 5;
/// Période du polling côté client : le plus petit choix non nul. Le serveur ne relit que les
/// projets dont l'intervalle est écoulé.
pub const POLL_SECONDS: u32 = 5;
/// Nombre d'entrées chargées par page dans la vue d'un fichier.
pub const PAGE_SIZE: u32 = 50;
/// Nombre maximal d'entrées renvoyées par un appel à `read_entries`.
@@ -38,6 +51,12 @@ pub struct ProjectSummary {
pub id: i64,
pub name: String,
pub root_path: String,
/// Intervalle de rafraîchissement (secondes), 0 = jamais.
pub refresh_seconds: u32,
/// Les fichiers non modifiés depuis plus de ce nombre de jours sont masqués.
pub hide_after_days: Option<u32>,
/// Nombre de fichiers masqués (absents de `files`).
pub hidden_files: u32,
/// Dossiers de logs, relatifs à la racine.
pub log_dirs: Vec<String>,
pub error: Option<String>,
@@ -191,7 +210,6 @@ pub struct Entry {
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct Settings {
pub refresh_interval_seconds: u32,
pub file_sort: FileSort,
/// Lecture automatique des logs arrêtée par l'utilisateur.
pub paused: bool,
@@ -248,18 +266,44 @@ pub fn relative_age(seconds: i64) -> String {
}
}
/// Valide l'intervalle saisi par l'utilisateur.
pub fn parse_interval(input: &str) -> Result<u32, String> {
input
.trim()
/// Vérifie que l'intervalle de rafraîchissement est l'un des choix proposés.
pub fn validate_refresh(seconds: u32) -> Result<u32, String> {
REFRESH_CHOICES
.iter()
.any(|(s, _)| *s == seconds)
.then_some(seconds)
.ok_or_else(|| "Intervalle de rafraîchissement invalide.".to_string())
}
/// Nombre de jours saisi pour masquer les fichiers anciens : vide pour n'en masquer aucun.
pub fn parse_hide_days(input: &str) -> Result<Option<u32>, String> {
match input.trim() {
"" => Ok(None),
days => days
.parse::<u32>()
.ok()
.filter(|s| (MIN_INTERVAL..=MAX_INTERVAL).contains(s))
.ok_or_else(|| {
format!(
"L'intervalle doit être un entier entre {MIN_INTERVAL} et {MAX_INTERVAL} secondes."
)
})
.filter(|d| *d > 0)
.map(Some)
.ok_or_else(|| "Le nombre de jours doit être un entier positif.".to_string()),
}
}
/// Vrai si un fichier modifié à `modified` (secondes Unix) est masqué à l'heure `now` :
/// sa dernière modification remonte à plus de `days` jours. Sans date, il reste affiché.
pub fn is_hidden(modified: Option<i64>, now: i64, days: Option<u32>) -> bool {
match (modified, days) {
(Some(modified), Some(days)) => now - modified > i64::from(days) * 86_400,
_ => false,
}
}
/// Libellé d'un intervalle de rafraîchissement (« 5 min », « Jamais »).
pub fn refresh_label(seconds: u32) -> String {
REFRESH_CHOICES
.iter()
.find(|(s, _)| *s == seconds)
.map(|(_, label)| label.to_string())
.unwrap_or_else(|| format!("{seconds} s"))
}
/// État affiché par le favicon.
@@ -353,12 +397,30 @@ mod tests {
use super::*;
#[test]
fn interval_bounds() {
assert_eq!(parse_interval("5"), Ok(5));
assert_eq!(parse_interval(" 3600 "), Ok(3600));
for bad in ["0", "3601", "-5", "abc", "", "1.5"] {
assert!(parse_interval(bad).is_err(), "{bad:?} devrait être refusé");
fn hide_old_files() {
assert_eq!(parse_hide_days(" "), Ok(None));
assert_eq!(parse_hide_days(" 30 "), Ok(Some(30)));
for bad in ["0", "-1", "1.5", "abc"] {
assert!(parse_hide_days(bad).is_err(), "{bad:?} devrait être refusé");
}
let day = 86_400;
assert!(!is_hidden(Some(0), 2 * day, None));
assert!(!is_hidden(None, 100 * day, Some(1)));
assert!(!is_hidden(Some(0), 2 * day, Some(2)));
assert!(is_hidden(Some(0), 2 * day + 1, Some(2)));
}
#[test]
fn refresh_choices() {
for ok in [0, 5, 15, 30, 60, 300, 900, 1800, 3600] {
assert_eq!(validate_refresh(ok), Ok(ok));
}
for bad in [1, 10, 3601] {
assert!(validate_refresh(bad).is_err(), "{bad} devrait être refusé");
}
assert_eq!(refresh_label(0), "Jamais");
assert_eq!(refresh_label(900), "15 min");
assert_eq!(POLL_SECONDS, REFRESH_CHOICES[1].0);
}
#[test]
+115 -21
View File
@@ -8,7 +8,7 @@ use crate::{
};
use sqlx::{QueryBuilder, SqlitePool};
use std::{
collections::HashMap,
collections::{HashMap, HashSet},
fs::{self, File, Metadata},
io::{BufReader, ErrorKind, Read, Seek, SeekFrom},
path::{Component, Path, PathBuf},
@@ -18,8 +18,9 @@ use tokio::sync::Mutex;
/// Délai sans modification au-delà duquel la dernière entrée d'un fichier est jugée complète.
pub const SETTLE_DELAY: Duration = Duration::from_secs(1);
/// Deux scans complets rapprochés de moins de ce délai n'en font qu'un (plusieurs onglets).
const MIN_SCAN_GAP: Duration = Duration::from_millis(500);
/// Marge sur l'intervalle d'un projet : un polling un peu en avance (timers du navigateur,
/// plusieurs onglets) ne le fait pas attendre un cycle de plus.
const DUE_MARGIN: Duration = Duration::from_secs(1);
/// Chemin sur le disque d'un fichier suivi : relatif à la racine pour un fichier du projet,
/// tel qu'enregistré (absolu) pour un log Apache.
@@ -595,26 +596,44 @@ async fn scan_project(pool: &SqlitePool, project_id: i64, mark_read: MarkRead) -
Ok(())
}
/// Sérialise les scans : un seul à la fois, quel que soit le nombre d'onglets ouverts.
/// Sérialise les scans (un seul à la fois, quel que soit le nombre d'onglets ouverts) et
/// retient quand chaque projet a été relu.
#[derive(Default)]
pub struct Scanner {
last_full_scan: Mutex<Option<Instant>>,
last_scans: Mutex<HashMap<i64, Instant>>,
}
impl Scanner {
/// Scanne tous les projets, sauf si un scan complet vient de se terminer.
pub async fn scan_all(&self, pool: &SqlitePool) -> sqlx::Result<()> {
let mut last = self.last_full_scan.lock().await;
if last.is_some_and(|t| t.elapsed() < MIN_SCAN_GAP) {
return Ok(());
}
let projects: Vec<i64> = sqlx::query_scalar("SELECT id FROM projects")
/// Relit les projets dont l'intervalle de rafraîchissement est écoulé. Un projet réglé sur
/// « jamais » n'est pas relu ici.
pub async fn scan_due(&self, pool: &SqlitePool) -> sqlx::Result<()> {
let mut last = self.last_scans.lock().await;
let projects: Vec<(i64, i64)> =
sqlx::query_as("SELECT id, refresh_seconds FROM projects WHERE refresh_seconds > 0")
.fetch_all(pool)
.await?;
for id in projects {
scan_project(pool, id, MarkRead::None).await?;
let ids: HashSet<i64> = projects.iter().map(|(id, _)| *id).collect();
last.retain(|id, _| ids.contains(id));
for (id, refresh) in projects {
let interval = Duration::from_secs(refresh as u64);
if last
.get(&id)
.is_some_and(|t| t.elapsed() + DUE_MARGIN < interval)
{
continue;
}
*last = Some(Instant::now());
scan_project(pool, id, MarkRead::None).await?;
last.insert(id, Instant::now());
}
Ok(())
}
/// Relit un projet tout de suite, quel que soit son intervalle : quand un de ses fichiers
/// est affiché.
pub async fn scan_now(&self, pool: &SqlitePool, project_id: i64) -> sqlx::Result<()> {
let mut last = self.last_scans.lock().await;
scan_project(pool, project_id, MarkRead::None).await?;
last.insert(project_id, Instant::now());
Ok(())
}
@@ -628,19 +647,24 @@ impl Scanner {
pool: &SqlitePool,
project: &ProjectConfig,
) -> sqlx::Result<()> {
let _guard = self.last_full_scan.lock().await;
let mut last = self.last_scans.lock().await;
let id: i64 = sqlx::query_scalar(
"INSERT INTO projects (name, root_path, log_dirs, vhost_path, created_at)
VALUES (?, ?, ?, ?, ?) RETURNING id",
"INSERT INTO projects
(name, root_path, refresh_seconds, hide_after_days, log_dirs, vhost_path, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id",
)
.bind(&project.name)
.bind(&project.root)
.bind(project.refresh_seconds)
.bind(project.hide_after_days)
.bind(project.log_dirs.join("\n"))
.bind(&project.vhost)
.bind(now())
.fetch_one(pool)
.await?;
scan_project(pool, id, MarkRead::All).await
scan_project(pool, id, MarkRead::All).await?;
last.insert(id, Instant::now());
Ok(())
}
/// Modifie un projet puis le scanne. Les fichiers qui deviennent suivis ne sont pas
@@ -652,7 +676,7 @@ impl Scanner {
project_id: i64,
project: &ProjectConfig,
) -> sqlx::Result<bool> {
let _guard = self.last_full_scan.lock().await;
let mut last = self.last_scans.lock().await;
let mut tx = pool.begin().await?;
let old_root: Option<String> =
sqlx::query_scalar("SELECT root_path FROM projects WHERE id = ?")
@@ -664,11 +688,14 @@ impl Scanner {
};
sqlx::query(
"UPDATE projects
SET name = ?, root_path = ?, log_dirs = ?, vhost_path = ?, vhost_error = NULL
SET name = ?, root_path = ?, refresh_seconds = ?, hide_after_days = ?,
log_dirs = ?, vhost_path = ?, vhost_error = NULL
WHERE id = ?",
)
.bind(&project.name)
.bind(&project.root)
.bind(project.refresh_seconds)
.bind(project.hide_after_days)
.bind(project.log_dirs.join("\n"))
.bind(&project.vhost)
.bind(project_id)
@@ -683,6 +710,7 @@ impl Scanner {
}
tx.commit().await?;
scan_project(pool, project_id, MarkRead::New).await?;
last.insert(project_id, Instant::now());
Ok(true)
}
}
@@ -693,6 +721,10 @@ pub struct ProjectConfig {
pub name: String,
/// Chemin canonique.
pub root: String,
/// Secondes, 0 = jamais.
pub refresh_seconds: u32,
/// Fichiers non modifiés depuis plus de ce nombre de jours masqués.
pub hide_after_days: Option<u32>,
/// Relatifs à la racine.
pub log_dirs: Vec<String>,
/// Chemin canonique du vhost Apache.
@@ -923,6 +955,8 @@ mod tests {
ProjectConfig {
name: "p".into(),
root: root.to_string_lossy().to_string(),
refresh_seconds: 5,
hide_after_days: None,
log_dirs: dirs.iter().map(|d| d.to_string()).collect(),
vhost: vhost.map(|v| v.to_string_lossy().to_string()),
}
@@ -1047,6 +1081,66 @@ mod tests {
assert!(!scanner.update_project(&pool, id + 1, &moved).await.unwrap());
}
/// Seuls les projets dont l'intervalle est écoulé sont relus ; « jamais » ne l'est que
/// sur demande (fichier affiché).
#[tokio::test]
async fn refresh_per_project() {
let fast = laravel_project();
let never = laravel_project();
let dir = tempfile::tempdir().unwrap();
let pool = crate::server::connect_db(&format!(
"sqlite://{}",
dir.path().join("t.sqlite").display()
))
.await
.unwrap();
let scanner = Scanner::default();
let mut never_config = config(never.path(), &["storage/logs"], None);
never_config.refresh_seconds = 0;
scanner
.add_project(&pool, &config(fast.path(), &["storage/logs"], None))
.await
.unwrap();
scanner.add_project(&pool, &never_config).await.unwrap();
let line = "[2026-10-21 10:00:00] local.ERROR: x\n";
for project in [&fast, &never] {
let path = logs_dir(project.path()).join("laravel.log");
fs::write(&path, line).unwrap();
settle(&path);
}
let unread = || async {
let s = crate::server::load_summary(&pool).await.unwrap();
let mut counts: Vec<_> = s
.projects
.iter()
.map(|p| (p.refresh_seconds, p.unread))
.collect();
counts.sort();
counts
};
// Les deux viennent d'être scannés à l'ajout : rien n'est dû.
scanner.scan_due(&pool).await.unwrap();
assert_eq!(unread().await, [(0, 0), (5, 0)]);
// Intervalle écoulé pour le projet à 5 s ; « jamais » attend.
scanner
.last_scans
.lock()
.await
.values_mut()
.for_each(|t| *t -= Duration::from_secs(5));
scanner.scan_due(&pool).await.unwrap();
assert_eq!(unread().await, [(0, 0), (5, 1)]);
let never_id: i64 = sqlx::query_scalar("SELECT id FROM projects WHERE refresh_seconds = 0")
.fetch_one(&pool)
.await
.unwrap();
scanner.scan_now(&pool, never_id).await.unwrap();
assert_eq!(unread().await, [(0, 1), (5, 1)]);
}
#[test]
fn missing_file() {
let project = laravel_project();
+31 -16
View File
@@ -2,8 +2,8 @@
use crate::{
model::{
DEFAULT_INTERVAL, FileSort, FileSummary, LogFormat, LogKind, ProjectSummary, Settings,
Summary, parse_log_dirs,
FileSort, FileSummary, LogFormat, LogKind, ProjectSummary, Settings, Summary, is_hidden,
parse_log_dirs,
},
scanner::Scanner,
};
@@ -90,20 +90,12 @@ pub async fn set_setting(pool: &SqlitePool, key: &str, value: &str) -> sqlx::Res
}
pub async fn load_settings(pool: &SqlitePool) -> sqlx::Result<Settings> {
let refresh_interval_seconds = setting(pool, "refresh_interval_seconds")
.await?
.and_then(|v| v.parse().ok())
.unwrap_or(DEFAULT_INTERVAL);
let file_sort = setting(pool, "file_sort")
.await?
.and_then(|v| FileSort::parse(&v))
.unwrap_or_default();
let paused = setting(pool, "paused").await?.as_deref() == Some("1");
Ok(Settings {
refresh_interval_seconds,
file_sort,
paused,
})
Ok(Settings { file_sort, paused })
}
/// (id, project_id, relative_path, kind, format, size, modifié le, manquant, erreur, non-lus)
@@ -123,19 +115,23 @@ type FileRow = (
/// Projets, fichiers et compteurs de non-lus.
///
/// Un fichier manquant ou un projet introuvable sur le disque ne compte aucun non-lu, ni un
/// log d'accès (cf. [`LogFormat::notifies`]).
/// log d'accès (cf. [`LogFormat::notifies`]). Les fichiers masqués (trop anciens, cf.
/// [`is_hidden`]) ne sont ni listés ni comptés.
pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
type ProjectRow = (
i64,
String,
String,
i64,
Option<i64>,
String,
Option<String>,
Option<String>,
Option<String>,
);
let projects: Vec<ProjectRow> = sqlx::query_as(
"SELECT id, name, root_path, log_dirs, last_error, vhost_path, vhost_error
"SELECT id, name, root_path, refresh_seconds, hide_after_days, log_dirs, last_error,
vhost_path, vhost_error
FROM projects ORDER BY name COLLATE NOCASE, id",
)
.fetch_all(pool)
@@ -153,16 +149,32 @@ pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
.fetch_all(pool)
.await?;
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let mut summary = Summary {
total: 0,
now: time::OffsetDateTime::now_utc().unix_timestamp(),
now,
projects: Vec::with_capacity(projects.len()),
};
for (id, name, root_path, log_dirs, error, vhost_path, vhost_error) in projects {
for (
id,
name,
root_path,
refresh_seconds,
hide_after_days,
log_dirs,
error,
vhost_path,
vhost_error,
) in projects
{
let project_ok = error.is_none();
let files: Vec<FileSummary> = files
let hide_after_days = hide_after_days.map(|d| d as u32);
let (hidden, visible): (Vec<&FileRow>, Vec<&FileRow>) = files
.iter()
.filter(|f| f.1 == id)
.partition(|f| is_hidden(f.6, now, hide_after_days));
let files: Vec<FileSummary> = visible
.into_iter()
.map(
|(fid, _, rel, kind, format, size, modified, missing, ferr, unread)| {
let kind = LogKind::parse(kind).unwrap_or_default();
@@ -190,6 +202,9 @@ pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
id,
name,
root_path,
refresh_seconds: refresh_seconds as u32,
hide_after_days,
hidden_files: hidden.len() as u32,
log_dirs: parse_log_dirs(&log_dirs),
error,
vhost_path,