Lecteur de logs Laravel avec notification par favicon
Application web locale (axum, Leptos 0.8, Tailwind v4, SQLite) qui suit les fichiers storage/logs de projets Laravel et signale les nouvelles entrées par le favicon et le titre de l'onglet. - Ajout de projets par chemin (validation, chemin canonique, doublons) - Découverte récursive des *.log et indexation incrémentale en flux, détection de troncature et de rotation - Curseur de lecture par fichier, polling à intervalle configurable - Vue fichier : pagination, filtres par niveau (niveaux absents grisés, double-clic pour isoler un niveau), recherche texte - Tri des fichiers par nom ou date de modification, projets repliables - Spécification complète dans .spec/specification.md Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
commit
818527b758
20 files changed
+6523
No files matched your search
@@ -0,0 +1,7 @@
|
||||
/target
|
||||
|
||||
# Base SQLite locale (+ fichiers WAL/SHM) et variables d'environnement
|
||||
*.sqlite
|
||||
*.sqlite-shm
|
||||
*.sqlite-wal
|
||||
.env
|
||||
@@ -0,0 +1,17 @@
|
||||
je veux construire une appli web pour lire les logs laravel et notifié de tout nouveau log entrant
|
||||
|
||||
# Objectif fonctionnels :
|
||||
- on peut ajouter un chemin de fichier d'un projet laravel et l'appi remonte tous les fichiers logs du projet
|
||||
- on peut spéficier la durée de rafraichissement de la lecture des logs
|
||||
- le système doit garder en mémoire les dernier log consulté pour notifié par le favicon tout nouveau log
|
||||
|
||||
# Contraintes techniques
|
||||
- Utilisé axum, leptos et tailwindcss
|
||||
- Pour les données une base sqlite
|
||||
|
||||
# Ce que j’attends de toi :
|
||||
- Générer une spécification complète.
|
||||
- Produire des user stories.
|
||||
- Définir des critères d’acceptation précis et testables.
|
||||
- Identifier les cas d’erreur.
|
||||
- Mettre en évidence les invariants importants du système.
|
||||
@@ -0,0 +1,387 @@
|
||||
# Lara Logs Reader — Spécification
|
||||
|
||||
> Document dérivé du brief `.spec/spec.md`.
|
||||
> Statut : brouillon v1 — 2026-10-21.
|
||||
|
||||
---
|
||||
|
||||
## 1. Vue d'ensemble
|
||||
|
||||
Lara Logs Reader est une application web **locale et mono-utilisateur** qui permet à un développeur de :
|
||||
|
||||
1. enregistrer un ou plusieurs projets Laravel par leur chemin sur le disque ;
|
||||
2. voir tous les fichiers de log de chaque projet et en lire les entrées ;
|
||||
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.
|
||||
|
||||
### 1.1 Périmètre
|
||||
|
||||
| Dans le périmètre | Hors périmètre (v1) |
|
||||
|---|---|
|
||||
| Fichiers de log sur le disque local | Logs distants (SSH, S3, Papertrail…) |
|
||||
| Format Monolog par défaut de Laravel (`single`, `daily`, channels custom en fichier) | Formats JSON, syslog, stderr |
|
||||
| Lecture seule des logs | Édition, suppression ou vidage des logs |
|
||||
| Un seul utilisateur, sans authentification | Comptes, rôles, partage |
|
||||
| Notification par favicon et titre d'onglet | E-mail, Slack, notifications natives de l'OS |
|
||||
|
||||
---
|
||||
|
||||
## 2. Glossaire
|
||||
|
||||
| Terme | Définition |
|
||||
|---|---|
|
||||
| **Projet** | Un projet Laravel enregistré, identifié par son chemin racine **canonique** (absolu, symlinks résolus, sans `/` final). |
|
||||
| **Répertoire de logs** | `<racine>/storage/logs`. |
|
||||
| **Fichier de log** | Tout fichier `*.log` situé (récursivement) dans le répertoire de logs. |
|
||||
| **Entrée** | Une écriture de log. Elle commence par une ligne d'en-tête Monolog et contient toutes les lignes suivantes jusqu'à la prochaine ligne d'en-tête (stack trace comprise). |
|
||||
| **Ligne d'en-tête** | Ligne qui correspond à `^\[(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[+-]\d{2}:?\d{2})?)\] (\w+)\.(\w+): ` → horodatage, environnement, niveau. |
|
||||
| **Niveau** | L'un des niveaux PSR-3 : `DEBUG`, `INFO`, `NOTICE`, `WARNING`, `ERROR`, `CRITICAL`, `ALERT`, `EMERGENCY`. |
|
||||
| **Entrée complète** | Une entrée suivie d'une autre ligne d'en-tête, ou, pour la dernière du fichier, terminée par `\n` dans un fichier non modifié depuis 1 s. |
|
||||
| **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. |
|
||||
|
||||
---
|
||||
|
||||
## 3. Architecture
|
||||
|
||||
```
|
||||
┌──────────────── Navigateur ────────────────┐
|
||||
│ Leptos (hydratation WASM) + Tailwind │
|
||||
│ - poll unread_summary toutes les N s │
|
||||
│ - dessine le favicon (canvas) + titre │
|
||||
└──────────────▲─────────────────────────────┘
|
||||
│ server functions Leptos (HTTP)
|
||||
┌──────────────┴──────── Serveur ────────────┐
|
||||
│ axum + leptos_axum (SSR) │
|
||||
│ - Scanner : découverte + lecture │
|
||||
│ incrémentale + parsing │
|
||||
│ - Repository SQLite (sqlx, migrations) │
|
||||
└──────┬───────────────────────────┬─────────┘
|
||||
│ lecture seule │
|
||||
<projet>/storage/logs/*.log data.sqlite
|
||||
```
|
||||
|
||||
- **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.
|
||||
- **Configuration** (variables d'environnement) :
|
||||
- `LLR_DATABASE_URL` — défaut `sqlite://./lara_logs_reader.sqlite?mode=rwc`
|
||||
- `LLR_ADDR` — défaut `127.0.0.1:3000`
|
||||
|
||||
### 3.1 API (server functions)
|
||||
|
||||
Chaque fonction est exposée en `POST /api/<nom>`.
|
||||
|
||||
| Fonction | Entrée | Sortie |
|
||||
|---|---|---|
|
||||
| `add_project` | `path: String`, `name: Option<String>` | `Project` |
|
||||
| `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 }` |
|
||||
| `set_file_sort` | `sort: "name" \| "modified"` | `()` |
|
||||
|
||||
---
|
||||
|
||||
## 4. Modèle de données
|
||||
|
||||
```sql
|
||||
CREATE TABLE projects (
|
||||
id INTEGER PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
root_path TEXT NOT NULL UNIQUE, -- chemin canonique
|
||||
created_at TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE log_files (
|
||||
id INTEGER PRIMARY KEY,
|
||||
project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
|
||||
relative_path TEXT NOT NULL, -- relatif à storage/logs
|
||||
file_identity TEXT, -- inode+device (Unix) / file index (Windows)
|
||||
size INTEGER NOT NULL DEFAULT 0,
|
||||
modified_at INTEGER, -- mtime, secondes Unix (tri)
|
||||
scan_offset INTEGER NOT NULL DEFAULT 0,
|
||||
entries_count INTEGER NOT NULL DEFAULT 0, -- entrées complètes ≤ scan_offset
|
||||
discovered_at TEXT NOT NULL,
|
||||
missing_since TEXT, -- NULL si le fichier existe
|
||||
last_error TEXT,
|
||||
UNIQUE (project_id, relative_path)
|
||||
);
|
||||
|
||||
CREATE TABLE log_entries_index ( -- index léger, pas le contenu
|
||||
log_file_id INTEGER NOT NULL REFERENCES log_files(id) ON DELETE CASCADE,
|
||||
start_offset INTEGER NOT NULL,
|
||||
end_offset INTEGER NOT NULL,
|
||||
logged_at TEXT NOT NULL,
|
||||
level TEXT NOT NULL,
|
||||
PRIMARY KEY (log_file_id, start_offset)
|
||||
);
|
||||
|
||||
CREATE TABLE read_cursors (
|
||||
log_file_id INTEGER PRIMARY KEY REFERENCES log_files(id) ON DELETE CASCADE,
|
||||
read_offset INTEGER NOT NULL DEFAULT 0,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE settings (
|
||||
key TEXT PRIMARY KEY,
|
||||
value TEXT NOT NULL
|
||||
);
|
||||
-- valeurs initiales : ('refresh_interval_seconds', '5'), ('file_sort', 'name')
|
||||
```
|
||||
|
||||
- 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.
|
||||
- `unread(file) = SELECT COUNT(*) FROM log_entries_index WHERE log_file_id = ? AND start_offset >= read_offset`.
|
||||
|
||||
---
|
||||
|
||||
## 5. Règles métier
|
||||
|
||||
### 5.1 Ajout d'un projet
|
||||
|
||||
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, il contient un fichier `artisan` **et** un répertoire `storage/logs` lisible.
|
||||
4. Le nom par défaut est le nom du dernier segment du chemin.
|
||||
5. Les fichiers de log existants sont découverts et indexés. **Leur curseur de lecture est placé à la fin** (`read_offset = scan_offset`) : l'historique n'est pas compté comme non-lu.
|
||||
|
||||
### 5.2 Découverte des fichiers
|
||||
|
||||
- Parcours récursif de `storage/logs`, à chaque scan.
|
||||
- Retenus : fichiers réguliers dont le nom se termine par `.log`. Ignorés : fichiers cachés (`.gitignore`…), répertoires, autres extensions (`.gz`…).
|
||||
- Liens symboliques : suivis uniquement si la cible canonique reste sous `storage/logs`.
|
||||
- Un fichier **apparu après l'ajout du projet** (ex. nouveau `laravel-2026-10-22.log` en mode daily) est créé avec `read_offset = 0` : tout son contenu est non-lu.
|
||||
- Un fichier disparu reçoit `missing_since` ; ses entrées ne comptent plus dans les non-lus ; il réapparaît normalement s'il revient (traité comme une rotation, cf. 5.4).
|
||||
|
||||
### 5.3 Lecture incrémentale et parsing
|
||||
|
||||
- Le fichier est ouvert en **lecture seule**, lu à partir de `scan_offset` par blocs (ex. 64 Kio), sans jamais le charger en entier.
|
||||
- Les octets sont décodés en UTF-8 avec remplacement (`from_utf8_lossy`) ; les offsets restent des offsets d'octets.
|
||||
- Une ligne d'en-tête ouvre une nouvelle entrée. Toute autre ligne est rattachée à l'entrée courante.
|
||||
- Des lignes avant la première ligne d'en-tête du fichier forment une entrée de niveau `UNKNOWN`, horodatée à la date de modification du fichier.
|
||||
- La dernière entrée du fichier n'est indexée que si elle est **complète** : elle se termine par `\n` **et** le fichier n'a pas été modifié depuis au moins 1 s (sinon une stack trace à moitié écrite serait coupée en deux). Sinon `scan_offset` reste à son début et elle sera relue au scan suivant.
|
||||
- Taille maximale d'une entrée affichée : 1 Mio ; au-delà le contenu est tronqué à l'affichage avec la mention « entrée tronquée » (l'index garde les vrais offsets).
|
||||
|
||||
### 5.4 Rotation et troncature
|
||||
|
||||
Au scan, si `taille actuelle < scan_offset` **ou** `file_identity` a changé :
|
||||
|
||||
- l'index des entrées du fichier est purgé ;
|
||||
- `scan_offset = 0`, `read_offset = 0` ;
|
||||
- le fichier est relu depuis le début ; tout son contenu est non-lu.
|
||||
|
||||
### 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 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) ;
|
||||
- serveur injoignable → icône + pastille grise « ! ».
|
||||
- Le titre de l'onglet devient `(N) Lara Logs Reader` quand `N ≥ 1`, `Lara Logs Reader` sinon.
|
||||
- Le favicon change même si l'onglet est en arrière-plan (les timers en arrière-plan peuvent être ralentis par le navigateur jusqu'à 1 fois par minute : comportement accepté).
|
||||
|
||||
### 5.6 Marquage comme lu
|
||||
|
||||
- Ouvrir un fichier affiche ses entrées les plus récentes et appelle `mark_read(file, scan_offset_affiché)`.
|
||||
- Si la vue d'un fichier est ouverte et que de nouvelles entrées arrivent, elles sont ajoutées en haut, surlignées, et marquées lues **seulement si l'onglet est visible** (`document.visibilityState == "visible"`).
|
||||
- `mark_read` ne fait jamais reculer un curseur : `read_offset = max(read_offset, min(up_to_offset, scan_offset))`.
|
||||
- Bouton « Tout marquer comme lu » par projet et global.
|
||||
|
||||
### 5.7 Interface
|
||||
|
||||
- **Barre latérale** : liste des projets, chacun dépliable en liste de fichiers (chemin relatif, 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`).
|
||||
- **Formulaire d'ajout** : champ chemin + nom optionnel, message d'erreur sous le champ.
|
||||
- **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).
|
||||
- **Réglages** : intervalle en secondes (champ numérique, 1–3600).
|
||||
|
||||
---
|
||||
|
||||
## 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.
|
||||
|
||||
### US-01 — Ajouter un projet
|
||||
|
||||
> En tant que développeur, je veux ajouter un projet Laravel en saisissant son chemin, afin de surveiller ses logs.
|
||||
|
||||
- **AC-01.1** Given un répertoire `/tmp/app` avec `artisan` et `storage/logs/laravel.log`, When j'ajoute `/tmp/app`, Then le projet `app` apparaît dans la liste avec le fichier `laravel.log`.
|
||||
- **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.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
|
||||
|
||||
> En tant que développeur, je veux voir tous les fichiers de log du projet, y compris les fichiers journaliers et les channels personnalisés.
|
||||
|
||||
- **AC-02.1** Given `storage/logs` contient `laravel.log`, `laravel-2026-10-20.log`, `jobs/worker.log`, `.gitignore`, `old.log.gz`, When le projet est affiché, Then exactement `laravel.log`, `laravel-2026-10-20.log` et `jobs/worker.log` sont listés.
|
||||
- **AC-02.2** Given un projet enregistré, When un fichier `laravel-2026-10-22.log` est créé avec 2 entrées, Then il apparaît dans la liste avec 2 non-lus en ≤ 2 s.
|
||||
- **AC-02.3** Given un fichier listé, When il est supprimé du disque, Then il est affiché grisé « manquant » en ≤ 2 s et ses non-lus ne comptent plus dans le total.
|
||||
- **AC-02.4** Given `storage/logs/ext.log → /var/log/syslog` (lien hors de `storage/logs`), When le projet est scanné, Then `ext.log` n'est pas listé.
|
||||
|
||||
### US-03 — Consulter un fichier de log
|
||||
|
||||
> En tant que développeur, je veux lire les entrées d'un fichier, des plus récentes aux plus anciennes, avec leur stack trace.
|
||||
|
||||
- **AC-03.1** Given un fichier de 120 entrées, When je l'ouvre, Then les 50 plus récentes s'affichent, la première étant la dernière écrite ; « Charger plus » affiche les 50 suivantes puis les 20 dernières et disparaît.
|
||||
- **AC-03.2** Given une entrée `ERROR` suivie de 30 lignes de stack trace, When elle s'affiche, Then elle compte pour **une** entrée, la première ligne est visible et les 30 lignes sont repliées par défaut.
|
||||
- **AC-03.3** Given une entrée en cours d'écriture (sans `\n` final, ou fichier modifié il y a moins de 1 s), When le fichier est affiché, Then cette entrée n'apparaît pas ; When elle est terminée et le fichier inchangé depuis 1 s, Then elle apparaît au rafraîchissement suivant.
|
||||
- **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
|
||||
|
||||
> En tant que développeur, je veux choisir la fréquence de lecture des logs, pour arbitrer entre réactivité et charge.
|
||||
|
||||
- **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.
|
||||
|
||||
### 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) Lara 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) Lara Logs Reader`.
|
||||
- **AC-05.4** Given des non-lus, When tout est marqué comme lu, Then le favicon redevient normal et le titre `Lara Logs Reader` sans attendre le prochain poll.
|
||||
- **AC-05.5** Given le serveur arrêté, When un poll échoue, Then le favicon affiche la pastille grise « ! » ; When le serveur redémarre, Then au poll suivant le favicon reflète à nouveau le nombre de non-lus.
|
||||
- **AC-05.6** Given `laravel.log` vidé (`> laravel.log`) puis 2 entrées écrites, Then le fichier compte 2 non-lus.
|
||||
|
||||
### US-06 — Marquer comme lu
|
||||
|
||||
> En tant que développeur, je veux que les entrées que j'ai consultées ne soient plus signalées.
|
||||
|
||||
- **AC-06.1** Given `a.log` avec 4 non-lus, When j'ouvre `a.log`, Then son badge passe à 0 et le total diminue de 4.
|
||||
- **AC-06.2** Given `a.log` ouvert et l'onglet visible, When 2 entrées sont écrites, Then elles apparaissent surlignées en haut et le total reste à 0.
|
||||
- **AC-06.3** Given `a.log` ouvert et l'onglet en arrière-plan, When 2 entrées sont écrites, Then le total passe à 2 ; When je reviens sur l'onglet, Then il repasse à 0.
|
||||
- **AC-06.4** Given 2 projets avec des non-lus, When je clique « Tout marquer comme lu » sur le projet A, Then seuls les compteurs de A passent à 0.
|
||||
- **AC-06.5** Given deux onglets ouverts, When je marque lu dans l'onglet 1, Then l'onglet 2 reflète 0 non-lu au poll suivant.
|
||||
|
||||
### US-07 — Supprimer un projet
|
||||
|
||||
> En tant que développeur, je veux retirer un projet que je ne surveille plus.
|
||||
|
||||
- **AC-07.1** Given un projet avec 5 non-lus, When je le supprime et confirme, Then il disparaît de la liste, le total diminue de 5, et aucune ligne liée ne reste dans `log_files`, `log_entries_index`, `read_cursors`.
|
||||
- **AC-07.2** Given un projet supprimé, When je l'ajoute à nouveau, Then l'ajout réussit et les entrées existantes ne sont pas comptées comme non-lues (cf. AC-01.4).
|
||||
- **AC-07.3** When je supprime un projet, Then aucun fichier du projet sur le disque n'est modifié (mtime et contenu identiques).
|
||||
|
||||
### US-08 — Filtrer et rechercher
|
||||
|
||||
> En tant que développeur, je veux isoler les erreurs ou retrouver un message précis.
|
||||
|
||||
- **AC-08.1** Given 10 `INFO` et 3 `ERROR`, When je ne coche que `ERROR`, Then 3 entrées s'affichent.
|
||||
- **AC-08.2** Given une entrée contenant `SQLSTATE[23000]` dans sa stack trace, When je recherche `sqlstate`, Then elle est affichée.
|
||||
- **AC-08.3** Given des filtres actifs, Then les compteurs de non-lus ne sont pas affectés par les filtres.
|
||||
- **AC-08.4** Given `aaa.log` ne contient que des `INFO`, When je l'ouvre, Then seule la case `INFO` est active, les autres sont grisées et désactivées ; When une entrée `CRITICAL` y est écrite, Then la case `CRITICAL` devient active au rafraîchissement suivant.
|
||||
- **AC-08.5** Given tous les niveaux cochés, When je double-clique sur `ERROR`, Then seule la case `ERROR` est cochée et seules les entrées `ERROR` s'affichent ; When je double-clique à nouveau sur `ERROR`, Then tous les niveaux sont recochés. Un double-clic sur un niveau désactivé est sans effet.
|
||||
|
||||
### US-10 — Trier les fichiers
|
||||
|
||||
> En tant que développeur, je veux trier les fichiers d'un projet par nom ou par date de modification, pour trouver vite le log actif.
|
||||
|
||||
- **AC-10.1** Given `aaa.log` (modifié il y a 2 j), `laravel.log` (3 h), `zzz.log` (10 s), When je choisis « Nom », Then l'ordre est `aaa.log`, `laravel.log`, `zzz.log`.
|
||||
- **AC-10.2** Given les mêmes fichiers, When je choisis « Date », Then l'ordre est `zzz.log`, `laravel.log`, `aaa.log` et chaque ligne affiche son ancienneté.
|
||||
- **AC-10.3** Given le tri « Date », When je recharge la page ou redémarre le serveur, Then le tri « Date » est conservé.
|
||||
- **AC-10.4** Given un projet replié, When je change de tri, Then il reste replié.
|
||||
|
||||
### US-09 — Conserver l'état entre deux redémarrages
|
||||
|
||||
> En tant que développeur, je veux retrouver mes projets et mes compteurs après un redémarrage.
|
||||
|
||||
- **AC-09.1** Given 2 projets et 7 non-lus, When je redémarre le serveur, Then les 2 projets et les 7 non-lus sont retrouvés.
|
||||
- **AC-09.2** Given le serveur arrêté, When 3 entrées sont écrites puis le serveur redémarré, Then le total vaut 7 + 3 = 10.
|
||||
- **AC-09.3** Given le serveur arrêté, When `laravel.log` est roté (renommé puis recréé), Then au redémarrage la rotation est détectée et le nouveau fichier est relu depuis le début.
|
||||
|
||||
---
|
||||
|
||||
## 7. Cas d'erreur
|
||||
|
||||
| # | Cas | Détection | Comportement attendu | Message utilisateur |
|
||||
|---|---|---|---|---|
|
||||
| E01 | Chemin vide | Validation client et serveur | Refus | « Veuillez saisir un chemin. » |
|
||||
| E02 | Chemin inexistant | `canonicalize` → `NotFound` | Refus, rien en base | « Le chemin `<p>` n'existe pas. » |
|
||||
| E03 | Chemin vers un fichier | `!is_dir()` | Refus | « `<p>` n'est pas un répertoire. » |
|
||||
| E04 | Pas un projet Laravel | `artisan` absent | Refus | « `<p>` ne semble pas être un projet Laravel (fichier `artisan` introuvable). » |
|
||||
| E05 | `storage/logs` absent | Absence du répertoire | Refus | « Répertoire `storage/logs` introuvable. » |
|
||||
| E06 | Permission refusée à l'ajout | `PermissionDenied` | Refus | « Accès refusé à `<p>`. » |
|
||||
| E07 | Projet déjà enregistré | Contrainte `UNIQUE(root_path)` après canonicalisation | Refus, projet existant mis en évidence | « Ce projet est déjà enregistré. » |
|
||||
| E08 | Aucun fichier `.log` | Découverte vide | Ajout accepté, liste vide | « Aucun fichier de log pour l'instant. » |
|
||||
| E09 | Projet supprimé/déplacé du disque après ajout | Racine introuvable au scan | Projet conservé, marqué en erreur, ses fichiers ne comptent plus ; reprise automatique si le chemin revient | « Projet introuvable sur le disque. » |
|
||||
| E10 | Fichier illisible (permissions changées) | `PermissionDenied` à l'ouverture | `last_error` renseigné, offsets inchangés, les autres fichiers continuent d'être scannés | Icône d'alerte sur le fichier + info-bulle |
|
||||
| E11 | Fichier supprimé entre deux scans | `NotFound` | `missing_since` renseigné (cf. 5.2) | « Fichier manquant » |
|
||||
| E12 | Fichier roté ou tronqué | Taille < `scan_offset` ou identité changée | Reset (cf. 5.4) | — |
|
||||
| E13 | Entrée partielle en fin de fichier | Pas de `\n` final | Non indexée, relue au scan suivant | — |
|
||||
| E14 | Octets non UTF-8 | Décodage | Remplacement par `�` | — |
|
||||
| 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 |
|
||||
| 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. » |
|
||||
| E25 | Scans simultanés (plusieurs onglets) | Mutex par projet | Un seul scan à la fois, résultats partagés ; pas de double indexation | — |
|
||||
|
||||
---
|
||||
|
||||
## 8. Invariants
|
||||
|
||||
Ces propriétés doivent être vraies après toute opération et peuvent être vérifiées par tests (y compris tests de propriétés).
|
||||
|
||||
- **INV-01 Lecture seule** — L'application n'ouvre jamais un fichier de projet en écriture ; elle ne crée, ne renomme, ne supprime ni ne modifie aucun fichier hors de sa propre base.
|
||||
- **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 ; `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 suivi a un chemin canonique sous `<root_path>/storage/logs`.
|
||||
- **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-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.
|
||||
- **INV-15 Favicon fidèle** — Le nombre affiché par le favicon est égal au `total` de la dernière réponse `unread_summary` réussie (ou au résultat de la dernière action `mark_*`), borné à l'affichage à `99+`.
|
||||
|
||||
---
|
||||
|
||||
## 9. Exigences non fonctionnelles
|
||||
|
||||
| Domaine | Exigence |
|
||||
|---|---|
|
||||
| Sécurité | Écoute par défaut sur `127.0.0.1` uniquement. Aucun contenu de log n'est injecté en HTML brut (échappement systématique par Leptos). |
|
||||
| Performance | `unread_summary` < 100 ms avec 10 projets / 50 fichiers sans nouvelle donnée. Indexation initiale d'un fichier de 1 Gio < 30 s, mémoire < 200 Mio. |
|
||||
| Robustesse | L'erreur d'un fichier ou d'un projet n'empêche jamais le scan des autres. |
|
||||
| Portabilité | Linux et macOS en priorité ; Windows : identité de fichier via file index, chemins non sensibles à la casse. |
|
||||
| Accessibilité | Le nombre de non-lus est aussi exposé en texte (titre + badges) et pas seulement par la couleur. |
|
||||
|
||||
---
|
||||
|
||||
## 10. Stratégie de test
|
||||
|
||||
- **Unitaires** : parser (en-têtes valides/invalides, multi-lignes, entrée partielle, UTF-8 invalide, fuseaux horaires, microsecondes), détection de rotation, validation de chemin et d'intervalle, calcul de `mark_read` (non-régression du curseur).
|
||||
- **Propriétés** (`proptest`) : écrire des séquences aléatoires d'entrées en morceaux arbitraires, scanner entre chaque morceau, vérifier INV-02 à INV-05 et INV-13.
|
||||
- **Intégration** : serveur axum sur port aléatoire + SQLite temporaire + projet Laravel factice dans un `tempdir` ; dérouler les AC des US-01 à US-09 via les server functions.
|
||||
- **E2E** (Playwright) : AC-04.2, AC-05.1, AC-05.3, AC-05.4, AC-05.5, AC-06.2, AC-06.3 — lecture de `document.title` et de l'attribut `href` du `<link rel="icon">`.
|
||||
|
||||
---
|
||||
|
||||
## 11. Questions ouvertes
|
||||
|
||||
1. Faut-il une vue agrégée « toutes les nouvelles entrées, tous projets confondus » ?
|
||||
2. Faut-il filtrer les non-lus par niveau (ex. ne notifier que `ERROR` et au-dessus) ?
|
||||
3. Faut-il ajouter les notifications natives du navigateur (Notification API) en plus du favicon ?
|
||||
4. Faut-il purger l'index des fichiers manquants depuis plus de N jours ?
|
||||
5. Faut-il supporter le format JSON de Monolog (`JsonFormatter`) ?
|
||||
Generated
+3415
File diff suppressed because it is too large.
Load diff
+72
@@ -0,0 +1,72 @@
|
||||
[package]
|
||||
name = "lara_logs_reader"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[lib]
|
||||
crate-type = ["cdylib", "rlib"]
|
||||
|
||||
[dependencies]
|
||||
leptos = "0.8"
|
||||
leptos_meta = "0.8"
|
||||
leptos_router = "0.8"
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
|
||||
# Client (WASM)
|
||||
console_error_panic_hook = { version = "0.1", optional = true }
|
||||
wasm-bindgen = { version = "0.2.106", optional = true }
|
||||
web-sys = { version = "0.3", features = ["Document", "VisibilityState"], optional = true }
|
||||
|
||||
# Serveur uniquement
|
||||
axum = { version = "0.8", optional = true }
|
||||
leptos_axum = { version = "0.8", optional = true }
|
||||
tokio = { version = "1", features = ["rt-multi-thread", "macros", "sync", "fs"], optional = true }
|
||||
sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio", "sqlite", "migrate", "macros"], optional = true }
|
||||
regex = { version = "1", optional = true }
|
||||
time = { version = "0.3", features = ["formatting", "macros"], optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile = "3"
|
||||
|
||||
[features]
|
||||
hydrate = [
|
||||
"leptos/hydrate",
|
||||
"dep:console_error_panic_hook",
|
||||
"dep:wasm-bindgen",
|
||||
"dep:web-sys",
|
||||
]
|
||||
ssr = [
|
||||
"dep:axum",
|
||||
"dep:tokio",
|
||||
"dep:leptos_axum",
|
||||
"dep:sqlx",
|
||||
"dep:regex",
|
||||
"dep:time",
|
||||
"leptos/ssr",
|
||||
"leptos_meta/ssr",
|
||||
"leptos_router/ssr",
|
||||
]
|
||||
|
||||
# Profil optimisé en taille pour le bundle WASM en release
|
||||
[profile.wasm-release]
|
||||
inherits = "release"
|
||||
opt-level = 'z'
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
panic = "abort"
|
||||
|
||||
[package.metadata.leptos]
|
||||
output-name = "lara_logs_reader"
|
||||
site-root = "target/site"
|
||||
site-pkg-dir = "pkg"
|
||||
tailwind-input-file = "style/tailwind.css"
|
||||
assets-dir = "public"
|
||||
site-addr = "127.0.0.1:3000"
|
||||
reload-port = 3001
|
||||
browserquery = "defaults"
|
||||
env = "DEV"
|
||||
bin-features = ["ssr"]
|
||||
bin-default-features = false
|
||||
lib-features = ["hydrate"]
|
||||
lib-default-features = false
|
||||
lib-profile-release = "wasm-release"
|
||||
@@ -0,0 +1,39 @@
|
||||
# Lara Logs Reader
|
||||
|
||||
Lecteur local de logs Laravel. Il signale les nouvelles entrées par l'icône et le titre de l'onglet.
|
||||
Spécification : [`.spec/specification.md`](.spec/specification.md).
|
||||
|
||||
Stack : axum, Leptos 0.8 (SSR + hydratation), Tailwind CSS v4, SQLite (sqlx).
|
||||
|
||||
## Lancer
|
||||
|
||||
```sh
|
||||
cargo leptos watch # développement, http://127.0.0.1:3000
|
||||
cargo leptos build --release && ./target/release/lara_logs_reader
|
||||
```
|
||||
|
||||
Variables d'environnement :
|
||||
|
||||
| Variable | Défaut |
|
||||
|---|---|
|
||||
| `LLR_DATABASE_URL` | `sqlite://./lara_logs_reader.sqlite?mode=rwc` |
|
||||
| `LLR_ADDR` | `127.0.0.1:3000` |
|
||||
|
||||
En release, lancer le binaire depuis la racine du dépôt (ou définir `LEPTOS_SITE_ROOT=target/site`).
|
||||
|
||||
## Tests
|
||||
|
||||
```sh
|
||||
cargo test --features ssr
|
||||
```
|
||||
|
||||
## Organisation
|
||||
|
||||
| Fichier | Rôle |
|
||||
|---|---|
|
||||
| `src/model.rs` | Types partagés client/serveur, validation de l'intervalle, favicon SVG |
|
||||
| `src/parser.rs` | Découpage d'un log Monolog en entrées (lecture en flux) |
|
||||
| `src/scanner.rs` | Découverte des fichiers, indexation incrémentale, détection de rotation |
|
||||
| `src/server.rs` | Connexion SQLite, calcul des non-lus |
|
||||
| `src/api.rs` | Server functions (`POST /api/<nom>`) |
|
||||
| `src/app.rs` | Interface Leptos, polling, favicon et titre |
|
||||
@@ -0,0 +1,5 @@
|
||||
fn main() {
|
||||
// `sqlx::migrate!()` embarque les migrations à la compilation : sans cette ligne,
|
||||
// ajouter un nouveau fichier dans `migrations/` ne déclenche pas de recompilation.
|
||||
println!("cargo:rerun-if-changed=migrations");
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
CREATE TABLE projects (
|
||||
id INTEGER PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
root_path TEXT NOT NULL UNIQUE, -- chemin canonique
|
||||
last_error TEXT, -- renseigné si le projet est introuvable sur le disque
|
||||
created_at TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE log_files (
|
||||
id INTEGER PRIMARY KEY,
|
||||
project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
|
||||
relative_path TEXT NOT NULL, -- relatif à storage/logs, séparateur `/`
|
||||
file_identity TEXT, -- device:inode (Unix)
|
||||
size INTEGER NOT NULL DEFAULT 0,
|
||||
scan_offset INTEGER NOT NULL DEFAULT 0,
|
||||
entries_count INTEGER NOT NULL DEFAULT 0,
|
||||
discovered_at TEXT NOT NULL,
|
||||
missing_since TEXT,
|
||||
last_error TEXT,
|
||||
UNIQUE (project_id, relative_path)
|
||||
);
|
||||
|
||||
-- Index léger des entrées : le contenu est relu dans le fichier à partir des offsets.
|
||||
CREATE TABLE log_entries_index (
|
||||
log_file_id INTEGER NOT NULL REFERENCES log_files(id) ON DELETE CASCADE,
|
||||
start_offset INTEGER NOT NULL,
|
||||
end_offset INTEGER NOT NULL,
|
||||
logged_at TEXT NOT NULL,
|
||||
level TEXT NOT NULL,
|
||||
PRIMARY KEY (log_file_id, start_offset)
|
||||
) WITHOUT ROWID;
|
||||
|
||||
CREATE TABLE read_cursors (
|
||||
log_file_id INTEGER PRIMARY KEY REFERENCES log_files(id) ON DELETE CASCADE,
|
||||
read_offset INTEGER NOT NULL DEFAULT 0,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE settings (
|
||||
key TEXT PRIMARY KEY,
|
||||
value TEXT NOT NULL
|
||||
);
|
||||
|
||||
INSERT INTO settings (key, value) VALUES ('refresh_interval_seconds', '5');
|
||||
@@ -0,0 +1,4 @@
|
||||
-- Date de dernière modification du fichier (secondes Unix), pour le tri.
|
||||
ALTER TABLE log_files ADD COLUMN modified_at INTEGER;
|
||||
|
||||
INSERT INTO settings (key, value) VALUES ('file_sort', 'name');
|
||||
@@ -0,0 +1,2 @@
|
||||
-- Niveaux présents dans un fichier et filtre par niveau sans parcourir tout l'index.
|
||||
CREATE INDEX log_entries_level ON log_entries_index (log_file_id, level);
|
||||
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect x="2" y="4" width="24" height="26" rx="4" fill="#18181b"/><rect x="6" y="10" width="16" height="2.5" rx="1" fill="#f87171"/><rect x="6" y="16" width="12" height="2.5" rx="1" fill="#e4e4e7"/><rect x="6" y="22" width="14" height="2.5" rx="1" fill="#e4e4e7"/></svg>
|
||||
|
After Width: | Height: | Size: 329 B |
+264
@@ -0,0 +1,264 @@
|
||||
//! Server functions appelées par l'interface.
|
||||
|
||||
use crate::model::{EntriesPage, FileSort, Settings, Summary};
|
||||
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.
|
||||
#[server(endpoint = "unread_summary")]
|
||||
pub async fn unread_summary() -> Result<Summary, ServerFnError> {
|
||||
let pool = pool()?;
|
||||
scanner()?.scan_all(&pool).await.map_err(internal_error)?;
|
||||
crate::server::load_summary(&pool)
|
||||
.await
|
||||
.map_err(internal_error)
|
||||
}
|
||||
|
||||
#[server(endpoint = "add_project")]
|
||||
pub async fn add_project(path: String, name: String) -> Result<(), ServerFnError> {
|
||||
let root = crate::scanner::validate_project_path(&path).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()),
|
||||
name => name.to_string(),
|
||||
};
|
||||
let pool = pool()?;
|
||||
let inserted: Result<i64, sqlx::Error> = sqlx::query_scalar(
|
||||
"INSERT INTO projects (name, root_path, created_at) VALUES (?, ?, ?) RETURNING id",
|
||||
)
|
||||
.bind(&name)
|
||||
.bind(&root_str)
|
||||
.bind(now())
|
||||
.fetch_one(&pool)
|
||||
.await;
|
||||
let id = match inserted {
|
||||
Ok(id) => id,
|
||||
Err(sqlx::Error::Database(e)) if e.is_unique_violation() => {
|
||||
return Err(ServerFnError::new("Ce projet est déjà enregistré."));
|
||||
}
|
||||
Err(e) => return Err(internal_error(e)),
|
||||
};
|
||||
scanner()?
|
||||
.scan_new_project(&pool, id, &root_str)
|
||||
.await
|
||||
.map_err(internal_error)
|
||||
}
|
||||
|
||||
#[server(endpoint = "remove_project")]
|
||||
pub async fn remove_project(project_id: i64) -> Result<(), ServerFnError> {
|
||||
let result = sqlx::query("DELETE FROM projects WHERE id = ?")
|
||||
.bind(project_id)
|
||||
.execute(&pool()?)
|
||||
.await
|
||||
.map_err(internal_error)?;
|
||||
if result.rows_affected() == 0 {
|
||||
return Err(not_found());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Entrées les plus récentes d'un fichier (du plus récent au plus ancien), filtrées par
|
||||
/// niveau et par texte (insensible à la casse). Un filtre de niveaux vide ne renvoie rien.
|
||||
#[server(input = Json, endpoint = "read_entries")]
|
||||
pub async fn read_entries(
|
||||
file_id: i64,
|
||||
limit: u32,
|
||||
levels: Vec<String>,
|
||||
query: String,
|
||||
) -> Result<EntriesPage, ServerFnError> {
|
||||
use crate::{
|
||||
model::{Entry, MAX_ENTRIES_LIMIT, MAX_ENTRY_BYTES},
|
||||
parser::split_entry,
|
||||
scanner::logs_dir,
|
||||
};
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{Read, Seek, SeekFrom},
|
||||
path::PathBuf,
|
||||
};
|
||||
|
||||
let pool = pool()?;
|
||||
let row: Option<(String, String, String, i64, i64)> = sqlx::query_as(
|
||||
"SELECT p.root_path, p.name, f.relative_path, f.scan_offset, c.read_offset
|
||||
FROM log_files f
|
||||
JOIN projects p ON p.id = f.project_id
|
||||
JOIN read_cursors c ON c.log_file_id = f.id
|
||||
WHERE f.id = ?",
|
||||
)
|
||||
.bind(file_id)
|
||||
.fetch_optional(&pool)
|
||||
.await
|
||||
.map_err(internal_error)?;
|
||||
let Some((root, project_name, relative_path, scan_offset, read_offset)) = row else {
|
||||
return Err(not_found());
|
||||
};
|
||||
let path: PathBuf = logs_dir(root.as_ref()).join(&relative_path);
|
||||
let limit = limit.clamp(1, MAX_ENTRIES_LIMIT) as usize;
|
||||
let query = query.trim().to_lowercase();
|
||||
|
||||
let mut entries = Vec::new();
|
||||
// Sans recherche texte, une seule requête suffit ; sinon on parcourt l'index par lots.
|
||||
let batch_size = if query.is_empty() { limit + 1 } else { 500 };
|
||||
let mut before = i64::MAX;
|
||||
while !levels.is_empty() && entries.len() <= limit {
|
||||
let mut select = sqlx::QueryBuilder::new(
|
||||
"SELECT start_offset, end_offset, logged_at, level FROM log_entries_index WHERE log_file_id = ",
|
||||
);
|
||||
select.push_bind(file_id);
|
||||
select.push(" AND start_offset < ").push_bind(before);
|
||||
select.push(" AND level IN (");
|
||||
let mut list = select.separated(", ");
|
||||
for level in &levels {
|
||||
list.push_bind(level);
|
||||
}
|
||||
select.push(") ORDER BY start_offset DESC LIMIT ");
|
||||
select.push_bind(batch_size as i64);
|
||||
let batch: Vec<(i64, i64, String, String)> = select
|
||||
.build_query_as()
|
||||
.fetch_all(&pool)
|
||||
.await
|
||||
.map_err(internal_error)?;
|
||||
let Some(last) = batch.last() else { break };
|
||||
before = last.0;
|
||||
let fetched = batch.len();
|
||||
|
||||
let file_path = path.clone();
|
||||
let contents = tokio::task::spawn_blocking(move || -> std::io::Result<Vec<_>> {
|
||||
let mut file = File::open(&file_path)?;
|
||||
let mut out = Vec::with_capacity(batch.len());
|
||||
for (start, end, logged_at, level) in batch {
|
||||
let size = (end - start) as u64;
|
||||
let mut buf = Vec::with_capacity(size.min(MAX_ENTRY_BYTES) as usize);
|
||||
file.seek(SeekFrom::Start(start as u64))?;
|
||||
(&mut file).take(MAX_ENTRY_BYTES).read_to_end(&mut buf)?;
|
||||
buf.truncate(size.min(MAX_ENTRY_BYTES) as usize);
|
||||
out.push((
|
||||
start,
|
||||
size,
|
||||
logged_at,
|
||||
level,
|
||||
String::from_utf8_lossy(&buf).to_string(),
|
||||
));
|
||||
}
|
||||
Ok(out)
|
||||
})
|
||||
.await
|
||||
.map_err(internal_error)?
|
||||
.map_err(|e| ServerFnError::new(format!("Impossible de lire le fichier : {e}.")))?;
|
||||
|
||||
for (start, size, logged_at, level, content) in contents {
|
||||
if !query.is_empty() && !content.to_lowercase().contains(&query) {
|
||||
continue;
|
||||
}
|
||||
let (env, message, details) = split_entry(&content);
|
||||
entries.push(Entry {
|
||||
start: start as u64,
|
||||
logged_at,
|
||||
level,
|
||||
env,
|
||||
message,
|
||||
details,
|
||||
size,
|
||||
truncated: size > MAX_ENTRY_BYTES,
|
||||
});
|
||||
if entries.len() > limit {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if fetched < batch_size {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let has_more = entries.len() > limit;
|
||||
entries.truncate(limit);
|
||||
|
||||
let present: Vec<String> =
|
||||
sqlx::query_scalar("SELECT DISTINCT level FROM log_entries_index WHERE log_file_id = ?")
|
||||
.bind(file_id)
|
||||
.fetch_all(&pool)
|
||||
.await
|
||||
.map_err(internal_error)?;
|
||||
|
||||
Ok(EntriesPage {
|
||||
file_id,
|
||||
project_name,
|
||||
relative_path,
|
||||
entries,
|
||||
has_more,
|
||||
scan_offset: scan_offset as u64,
|
||||
read_offset: read_offset as u64,
|
||||
levels: present,
|
||||
})
|
||||
}
|
||||
|
||||
/// Avance le curseur de lecture d'un fichier. Un curseur ne recule jamais et ne dépasse
|
||||
/// jamais la fin de la partie indexée.
|
||||
#[server(endpoint = "mark_read")]
|
||||
pub async fn mark_read(file_id: i64, up_to: u64) -> Result<(), ServerFnError> {
|
||||
let result = sqlx::query(
|
||||
"UPDATE read_cursors
|
||||
SET read_offset = MAX(read_offset, MIN(?, (SELECT scan_offset FROM log_files WHERE id = log_file_id))),
|
||||
updated_at = ?
|
||||
WHERE log_file_id = ?",
|
||||
)
|
||||
.bind(up_to.min(i64::MAX as u64) as i64)
|
||||
.bind(now())
|
||||
.bind(file_id)
|
||||
.execute(&pool()?)
|
||||
.await
|
||||
.map_err(internal_error)?;
|
||||
if result.rows_affected() == 0 {
|
||||
return Err(not_found());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Marque comme lus tous les fichiers d'un projet, ou de tous les projets.
|
||||
#[server(endpoint = "mark_all_read")]
|
||||
pub async fn mark_all_read(project_id: Option<i64>) -> Result<(), ServerFnError> {
|
||||
sqlx::query(
|
||||
"UPDATE read_cursors
|
||||
SET read_offset = (SELECT scan_offset FROM log_files WHERE id = log_file_id),
|
||||
updated_at = ?
|
||||
WHERE log_file_id IN (SELECT id FROM log_files WHERE ?2 IS NULL OR project_id = ?2)",
|
||||
)
|
||||
.bind(now())
|
||||
.bind(project_id)
|
||||
.execute(&pool()?)
|
||||
.await
|
||||
.map_err(internal_error)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[server(endpoint = "get_settings")]
|
||||
pub async fn get_settings() -> Result<Settings, ServerFnError> {
|
||||
crate::server::load_settings(&pool()?)
|
||||
.await
|
||||
.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)
|
||||
}
|
||||
|
||||
/// Ordre des fichiers dans la barre latérale, conservé entre deux sessions.
|
||||
#[server(input = Json, endpoint = "set_file_sort")]
|
||||
pub async fn set_file_sort(sort: FileSort) -> Result<(), ServerFnError> {
|
||||
crate::server::set_setting(&pool()?, "file_sort", sort.as_str())
|
||||
.await
|
||||
.map_err(internal_error)
|
||||
}
|
||||
+818
@@ -0,0 +1,818 @@
|
||||
use crate::{
|
||||
api::{
|
||||
AddProject, MarkAllRead, MarkRead, RemoveProject, SetFileSort, SetRefreshInterval,
|
||||
get_settings, read_entries, unread_summary,
|
||||
},
|
||||
model::{
|
||||
DEFAULT_INTERVAL, EntriesPage, Entry, FaviconState, FileSort, LEVELS, PAGE_SIZE,
|
||||
ProjectSummary, Settings, Summary, UNKNOWN_LEVEL, favicon_data_url, human_size, page_title,
|
||||
relative_age, sort_files,
|
||||
},
|
||||
};
|
||||
use leptos::{html, prelude::*};
|
||||
use leptos_meta::{MetaTags, Stylesheet, Title, provide_meta_context};
|
||||
use leptos_router::{
|
||||
SsrMode,
|
||||
components::{A, Route, Router, Routes},
|
||||
hooks::use_params_map,
|
||||
path,
|
||||
};
|
||||
use std::{collections::HashSet, time::Duration};
|
||||
|
||||
pub fn shell(options: LeptosOptions) -> impl IntoView {
|
||||
view! {
|
||||
<!DOCTYPE html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="utf-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1" />
|
||||
<link id="favicon" rel="icon" href="/favicon.svg" type="image/svg+xml" />
|
||||
<AutoReload options=options.clone() />
|
||||
<HydrationScripts options />
|
||||
<MetaTags />
|
||||
</head>
|
||||
<body class="bg-zinc-50 text-zinc-900 antialiased dark:bg-zinc-950 dark:text-zinc-100">
|
||||
<App />
|
||||
</body>
|
||||
</html>
|
||||
}
|
||||
}
|
||||
|
||||
/// État partagé par toute l'interface : le compteur de rafraîchissement et le résumé des
|
||||
/// non-lus qui en dépend. Incrémenter `refresh` relance le scan côté serveur.
|
||||
#[derive(Clone, Copy)]
|
||||
struct Live {
|
||||
refresh: RwSignal<u64>,
|
||||
summary: Resource<Result<Summary, ServerFnError>>,
|
||||
/// Dernier résumé reçu avec succès, affiché quand le serveur est injoignable.
|
||||
last_ok: RwSignal<Option<Summary>>,
|
||||
}
|
||||
|
||||
impl Live {
|
||||
fn bump(&self) {
|
||||
self.refresh.update(|n| *n += 1);
|
||||
}
|
||||
|
||||
/// Résumé à afficher : le plus récent, ou le dernier connu si le serveur ne répond plus.
|
||||
fn current(&self) -> Option<Summary> {
|
||||
match self.summary.get() {
|
||||
Some(Ok(summary)) => Some(summary),
|
||||
_ => self.last_ok.get(),
|
||||
}
|
||||
}
|
||||
|
||||
fn offline(&self) -> bool {
|
||||
matches!(self.summary.get(), Some(Err(_)))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct SettingsCtx {
|
||||
settings: Resource<Result<Settings, ServerFnError>>,
|
||||
save: ServerAction<SetRefreshInterval>,
|
||||
}
|
||||
|
||||
/// Extrait le message lisible d'une erreur de server function.
|
||||
fn error_message(error: &ServerFnError) -> String {
|
||||
match error {
|
||||
ServerFnError::ServerError(message) => message.clone(),
|
||||
_ => "Impossible de joindre le serveur.".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Vrai si l'onglet est affiché (toujours vrai côté serveur).
|
||||
fn page_visible() -> bool {
|
||||
#[cfg(feature = "hydrate")]
|
||||
{
|
||||
document().visibility_state() == web_sys::VisibilityState::Visible
|
||||
}
|
||||
#[cfg(not(feature = "hydrate"))]
|
||||
{
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[component]
|
||||
pub fn App() -> impl IntoView {
|
||||
provide_meta_context();
|
||||
|
||||
let refresh = RwSignal::new(0u64);
|
||||
let summary = Resource::new(move || refresh.get(), |_| unread_summary());
|
||||
let live = Live {
|
||||
refresh,
|
||||
summary,
|
||||
last_ok: RwSignal::new(None),
|
||||
};
|
||||
provide_context(live);
|
||||
|
||||
let save = ServerAction::<SetRefreshInterval>::new();
|
||||
let settings = Resource::new(move || save.version().get(), |_| get_settings());
|
||||
provide_context(SettingsCtx { settings, save });
|
||||
|
||||
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.
|
||||
Effect::new(move |previous: Option<Option<IntervalHandle>>| {
|
||||
if let Some(Some(handle)) = previous {
|
||||
handle.clear();
|
||||
}
|
||||
let seconds = interval();
|
||||
set_interval_with_handle(move || live.bump(), Duration::from_secs(seconds.into())).ok()
|
||||
});
|
||||
|
||||
// Retour sur l'onglet : rafraîchit tout de suite (et marque lu le fichier ouvert).
|
||||
Effect::new(move |_| {
|
||||
let _ = window_event_listener(leptos::ev::focus, move |_| live.bump());
|
||||
});
|
||||
|
||||
Effect::new(move |_| {
|
||||
if let Some(Ok(summary)) = summary.get() {
|
||||
live.last_ok.set(Some(summary));
|
||||
}
|
||||
});
|
||||
|
||||
// Favicon : pastille rouge avec le nombre de non-lus, grise si le serveur est injoignable.
|
||||
Effect::new(move |_| {
|
||||
let state = match summary.get() {
|
||||
Some(Ok(s)) if s.total > 0 => FaviconState::Unread(s.total),
|
||||
Some(Err(_)) => FaviconState::Offline,
|
||||
_ => FaviconState::Idle,
|
||||
};
|
||||
if let Ok(Some(link)) = document().query_selector("link#favicon") {
|
||||
let _ = link.set_attribute("href", &favicon_data_url(state));
|
||||
}
|
||||
});
|
||||
|
||||
let total = move || live.current().map(|s| s.total).unwrap_or(0);
|
||||
|
||||
view! {
|
||||
<Stylesheet id="leptos" href="/pkg/lara_logs_reader.css" />
|
||||
// Routes en `SsrMode::Async` : le serveur attend le résumé avant d'envoyer `<head>`,
|
||||
// le titre contient donc déjà le nombre de non-lus.
|
||||
<Transition>
|
||||
{move || view! { <Title text=page_title(total()) /> }}
|
||||
</Transition>
|
||||
<Router>
|
||||
<div class="flex h-screen">
|
||||
<Sidebar />
|
||||
<main class="flex-1 overflow-y-auto">
|
||||
<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>
|
||||
</Router>
|
||||
}
|
||||
}
|
||||
|
||||
const INPUT: &str = "w-full rounded-md border border-zinc-700 bg-zinc-800 px-2 py-1.5 text-sm text-zinc-100 placeholder:text-zinc-500 focus:border-red-400 focus:outline-none";
|
||||
const BUTTON: &str = "rounded-md bg-red-500 px-3 py-1.5 text-sm font-medium text-white hover:bg-red-600 disabled:opacity-50";
|
||||
const SMALL_BUTTON: &str =
|
||||
"rounded px-1.5 py-0.5 text-xs text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100";
|
||||
|
||||
#[component]
|
||||
fn Sidebar() -> impl IntoView {
|
||||
let live = expect_context::<Live>();
|
||||
let add = ServerAction::<AddProject>::new();
|
||||
let remove = ServerAction::<RemoveProject>::new();
|
||||
let mark_all = ServerAction::<MarkAllRead>::new();
|
||||
let form = NodeRef::<html::Form>::new();
|
||||
// Projets repliés par l'utilisateur. La liste est reconstruite à chaque rafraîchissement :
|
||||
// sans cet état, chaque projet se redéplierait.
|
||||
let collapsed = RwSignal::new(HashSet::<i64>::new());
|
||||
|
||||
// Ordre des fichiers : le choix fait ici s'applique tout de suite, sans attendre que
|
||||
// les réglages soient relus ; sinon, celui enregistré en base.
|
||||
let SettingsCtx { settings, .. } = expect_context::<SettingsCtx>();
|
||||
let save_sort = ServerAction::<SetFileSort>::new();
|
||||
let chosen_sort = RwSignal::new(None::<FileSort>);
|
||||
let sort = move || {
|
||||
chosen_sort.get().unwrap_or_else(|| {
|
||||
settings
|
||||
.get()
|
||||
.and_then(Result::ok)
|
||||
.map(|s| s.file_sort)
|
||||
.unwrap_or_default()
|
||||
})
|
||||
};
|
||||
let sort_button = move |value: FileSort, label: &'static str| {
|
||||
view! {
|
||||
<button
|
||||
class=move || {
|
||||
if sort() == value {
|
||||
"rounded px-1.5 py-0.5 text-xs bg-zinc-700 text-white"
|
||||
} else {
|
||||
SMALL_BUTTON
|
||||
}
|
||||
}
|
||||
aria-pressed=move || (sort() == value).to_string()
|
||||
on:click=move |_| {
|
||||
chosen_sort.set(Some(value));
|
||||
save_sort.dispatch(SetFileSort { sort: value });
|
||||
}
|
||||
>
|
||||
{label}
|
||||
</button>
|
||||
}
|
||||
};
|
||||
|
||||
Effect::watch(
|
||||
move || {
|
||||
(
|
||||
add.version().get(),
|
||||
remove.version().get(),
|
||||
mark_all.version().get(),
|
||||
)
|
||||
},
|
||||
move |_, _, _| live.bump(),
|
||||
false,
|
||||
);
|
||||
// Vide le formulaire quand l'ajout a réussi (`ActionForm` ne le fait pas).
|
||||
Effect::new(move |_| {
|
||||
if matches!(add.value().get(), Some(Ok(())))
|
||||
&& let Some(form) = form.get()
|
||||
{
|
||||
form.reset();
|
||||
}
|
||||
});
|
||||
|
||||
let total = move || live.current().map(|s| s.total).unwrap_or(0);
|
||||
|
||||
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">
|
||||
<A href="/" attr:class="text-lg font-semibold">
|
||||
"Lara Logs Reader"
|
||||
</A>
|
||||
<A href="/settings" attr:class=SMALL_BUTTON attr:title="Réglages">
|
||||
"Réglages"
|
||||
</A>
|
||||
</header>
|
||||
|
||||
<ActionForm action=add node_ref=form attr:class="flex flex-col gap-2">
|
||||
<input
|
||||
name="path"
|
||||
required
|
||||
placeholder="/chemin/vers/projet-laravel"
|
||||
aria-label="Chemin du projet"
|
||||
class=INPUT
|
||||
/>
|
||||
<input
|
||||
name="name"
|
||||
placeholder="Nom (optionnel)"
|
||||
aria-label="Nom du projet"
|
||||
class=INPUT
|
||||
/>
|
||||
<button type="submit" class=BUTTON disabled=move || add.pending().get()>
|
||||
"Ajouter le projet"
|
||||
</button>
|
||||
{move || {
|
||||
add.value()
|
||||
.get()
|
||||
.and_then(Result::err)
|
||||
.map(|e| view! { <p class="text-sm text-red-400">{error_message(&e)}</p> })
|
||||
}}
|
||||
</ActionForm>
|
||||
|
||||
{move || {
|
||||
remove
|
||||
.value()
|
||||
.get()
|
||||
.and_then(Result::err)
|
||||
.map(|e| view! { <p class="text-sm text-red-400">{error_message(&e)}</p> })
|
||||
}}
|
||||
|
||||
<Transition fallback=|| view! { <p class="text-sm text-zinc-400">"Chargement…"</p> }>
|
||||
<Show when=move || live.offline()>
|
||||
<p class="rounded-md bg-zinc-700 px-2 py-1 text-sm">"Serveur injoignable."</p>
|
||||
</Show>
|
||||
<div class="flex items-center justify-between border-t border-zinc-800 pt-3 text-sm">
|
||||
<span>
|
||||
{move || match total() {
|
||||
0 => "Aucun nouveau log".to_string(),
|
||||
1 => "1 nouveau log".to_string(),
|
||||
n => format!("{n} nouveaux logs"),
|
||||
}}
|
||||
</span>
|
||||
<Show when=move || { total() > 0 }>
|
||||
<button
|
||||
class=SMALL_BUTTON
|
||||
on:click=move |_| {
|
||||
mark_all.dispatch(MarkAllRead { project_id: None });
|
||||
}
|
||||
>
|
||||
"Tout marquer lu"
|
||||
</button>
|
||||
</Show>
|
||||
</div>
|
||||
<div class="flex items-center gap-1 text-xs text-zinc-400">
|
||||
"Trier les fichiers :" {sort_button(FileSort::Name, "Nom")}
|
||||
{sort_button(FileSort::Modified, "Date")}
|
||||
</div>
|
||||
{move || {
|
||||
let sort = sort();
|
||||
live.current()
|
||||
.map(|summary| {
|
||||
if summary.projects.is_empty() {
|
||||
view! {
|
||||
<p class="text-sm text-zinc-400">"Aucun projet pour l'instant."</p>
|
||||
}
|
||||
.into_any()
|
||||
} else {
|
||||
let now = summary.now;
|
||||
summary
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|project| {
|
||||
view! { <ProjectItem project remove mark_all collapsed sort now /> }
|
||||
})
|
||||
.collect_view()
|
||||
.into_any()
|
||||
}
|
||||
})
|
||||
}}
|
||||
</Transition>
|
||||
</aside>
|
||||
}
|
||||
}
|
||||
|
||||
#[component]
|
||||
fn UnreadBadge(count: u64) -> impl IntoView {
|
||||
(count > 0).then(|| {
|
||||
view! {
|
||||
<span class="rounded-full bg-red-500 px-1.5 text-xs font-semibold text-white">
|
||||
{count}
|
||||
</span>
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[component]
|
||||
fn ProjectItem(
|
||||
project: ProjectSummary,
|
||||
remove: ServerAction<RemoveProject>,
|
||||
mark_all: ServerAction<MarkAllRead>,
|
||||
collapsed: RwSignal<HashSet<i64>>,
|
||||
sort: FileSort,
|
||||
/// Heure du serveur, pour l'ancienneté des fichiers.
|
||||
now: i64,
|
||||
) -> impl IntoView {
|
||||
let id = project.id;
|
||||
// Lu sans suivi : replier un projet ne doit pas reconstruire la liste.
|
||||
let open = !collapsed.read_untracked().contains(&id);
|
||||
let on_toggle = move |ev: leptos::ev::Event| {
|
||||
let is_open = event_target::<leptos::web_sys::Element>(&ev).has_attribute("open");
|
||||
collapsed.update_untracked(|set| {
|
||||
if is_open {
|
||||
set.remove(&id);
|
||||
} else {
|
||||
set.insert(id);
|
||||
}
|
||||
});
|
||||
};
|
||||
let name = project.name.clone();
|
||||
let confirm_remove = move |_| {
|
||||
let message =
|
||||
format!("Retirer le projet « {name} » ? Les fichiers de log ne sont pas modifiés.");
|
||||
if window().confirm_with_message(&message).unwrap_or(false) {
|
||||
remove.dispatch(RemoveProject { project_id: id });
|
||||
}
|
||||
};
|
||||
let mut files = project.files;
|
||||
sort_files(&mut files, sort);
|
||||
let empty = files.is_empty();
|
||||
|
||||
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()>
|
||||
{project.name.clone()}
|
||||
</span>
|
||||
<UnreadBadge count=project.unread />
|
||||
<Show when=move || { project.unread > 0 }>
|
||||
<button
|
||||
class=SMALL_BUTTON
|
||||
title="Tout marquer comme lu"
|
||||
on:click=move |ev| {
|
||||
ev.prevent_default();
|
||||
mark_all.dispatch(MarkAllRead { project_id: Some(id) });
|
||||
}
|
||||
>
|
||||
"✓"
|
||||
</button>
|
||||
</Show>
|
||||
<button
|
||||
class=SMALL_BUTTON
|
||||
title="Retirer le projet"
|
||||
on:click=move |ev| {
|
||||
ev.prevent_default();
|
||||
confirm_remove(ev);
|
||||
}
|
||||
>
|
||||
"✕"
|
||||
</button>
|
||||
</summary>
|
||||
{project.error.map(|e| view! { <p class="px-1 text-xs text-red-400">{e}</p> })}
|
||||
{empty.then(|| view! { <p class="px-3 py-1 text-xs text-zinc-500">"Aucun fichier de log pour l'instant."</p> })}
|
||||
<ul class="mt-1 flex flex-col">
|
||||
{files
|
||||
.into_iter()
|
||||
.map(|file| {
|
||||
let age = file.modified.map(|m| relative_age(now - m));
|
||||
let tooltip = match &age {
|
||||
Some(age) => {
|
||||
format!("{} — {} — modifié {age}", file.relative_path, human_size(file.size))
|
||||
}
|
||||
None => format!("{} — {}", file.relative_path, human_size(file.size)),
|
||||
};
|
||||
// Trié par date, l'ancienneté est plus utile que la taille.
|
||||
let detail = match (sort, age) {
|
||||
(FileSort::Modified, Some(age)) => age,
|
||||
_ => human_size(file.size),
|
||||
};
|
||||
let label_class = if file.missing {
|
||||
"flex-1 truncate line-through text-zinc-500"
|
||||
} else {
|
||||
"flex-1 truncate"
|
||||
};
|
||||
view! {
|
||||
<li>
|
||||
<A
|
||||
href=format!("/files/{}", file.id)
|
||||
attr:class="flex items-center gap-2 rounded py-1 pl-4 pr-1 text-sm text-zinc-300 hover:bg-zinc-800 aria-[current=page]:bg-zinc-800 aria-[current=page]:text-white"
|
||||
>
|
||||
<span class=label_class title=tooltip>
|
||||
{file.relative_path.clone()}
|
||||
</span>
|
||||
{file.missing.then(|| view! { <span class="text-xs text-zinc-500">"manquant"</span> })}
|
||||
{file
|
||||
.error
|
||||
.clone()
|
||||
.map(|e| view! { <span class="text-xs text-amber-400" title=e>"⚠"</span> })}
|
||||
<span class="shrink-0 text-xs text-zinc-500">{detail}</span>
|
||||
<UnreadBadge count=file.unread />
|
||||
</A>
|
||||
</li>
|
||||
}
|
||||
})
|
||||
.collect_view()}
|
||||
</ul>
|
||||
</details>
|
||||
}
|
||||
}
|
||||
|
||||
#[component]
|
||||
fn HomePage() -> impl IntoView {
|
||||
view! {
|
||||
<div class="mx-auto max-w-xl p-10 text-zinc-600 dark:text-zinc-400">
|
||||
<h1 class="mb-4 text-2xl font-semibold text-zinc-900 dark:text-zinc-100">
|
||||
"Lara Logs Reader"
|
||||
</h1>
|
||||
<p class="mb-2">
|
||||
"Ajoutez un projet Laravel avec son chemin dans la barre latérale : tous les fichiers de "
|
||||
<code>"storage/logs"</code> " sont suivis."
|
||||
</p>
|
||||
<p>
|
||||
"Les nouveaux logs sont signalés par l'icône de l'onglet, même quand il est en arrière-plan. Choisissez un fichier pour les lire."
|
||||
</p>
|
||||
</div>
|
||||
}
|
||||
}
|
||||
|
||||
fn all_levels() -> Vec<String> {
|
||||
LEVELS
|
||||
.iter()
|
||||
.chain([&UNKNOWN_LEVEL])
|
||||
.map(|l| l.to_string())
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[component]
|
||||
fn FileView() -> impl IntoView {
|
||||
let live = expect_context::<Live>();
|
||||
let params = use_params_map();
|
||||
let file_id = Memo::new(move |_| params.read().get("id").and_then(|s| s.parse::<i64>().ok()));
|
||||
|
||||
let pages = RwSignal::new(1u32);
|
||||
let levels = RwSignal::new(all_levels());
|
||||
let query = RwSignal::new(String::new());
|
||||
// Curseur de lecture à l'ouverture du fichier : les entrées au-delà sont surlignées.
|
||||
let highlight_from = RwSignal::new(None::<(i64, u64)>);
|
||||
// Niveaux présents dans le fichier affiché. Tenu à part de la ressource : la barre de
|
||||
// filtres reste en place (et la recherche garde le focus) pendant les rafraîchissements.
|
||||
let present_levels = RwSignal::new(None::<(i64, Vec<String>)>);
|
||||
|
||||
Effect::watch(
|
||||
move || file_id.get(),
|
||||
move |_, _, _| {
|
||||
pages.set(1);
|
||||
levels.set(all_levels());
|
||||
query.set(String::new());
|
||||
},
|
||||
false,
|
||||
);
|
||||
|
||||
let entries = Resource::new(
|
||||
move || {
|
||||
(
|
||||
file_id.get(),
|
||||
pages.get(),
|
||||
levels.get(),
|
||||
query.get(),
|
||||
live.refresh.get(),
|
||||
)
|
||||
},
|
||||
|(id, pages, levels, query, _)| async move {
|
||||
match id {
|
||||
Some(id) => read_entries(id, pages * PAGE_SIZE, levels, query).await,
|
||||
None => Err(ServerFnError::new("Fichier introuvable.")),
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
// Consulter un fichier le marque comme lu, si l'onglet est visible.
|
||||
let mark = ServerAction::<MarkRead>::new();
|
||||
Effect::watch(
|
||||
move || mark.version().get(),
|
||||
move |_, _, _| live.bump(),
|
||||
false,
|
||||
);
|
||||
Effect::new(move |_| {
|
||||
if let Some(Ok(page)) = entries.get() {
|
||||
present_levels.set(Some((page.file_id, page.levels.clone())));
|
||||
if highlight_from.get_untracked().map(|(id, _)| id) != Some(page.file_id) {
|
||||
highlight_from.set(Some((page.file_id, page.read_offset)));
|
||||
}
|
||||
if page.scan_offset > page.read_offset && page_visible() {
|
||||
mark.dispatch(MarkRead {
|
||||
file_id: page.file_id,
|
||||
up_to: page.scan_offset,
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let toggle_level = move |level: &'static str| {
|
||||
levels.update(|selected| {
|
||||
if let Some(i) = selected.iter().position(|l| l == level) {
|
||||
selected.remove(i);
|
||||
} else {
|
||||
selected.push(level.to_string());
|
||||
}
|
||||
});
|
||||
pages.set(1);
|
||||
};
|
||||
// Double-clic : n'afficher que ce niveau ; s'il est déjà le seul, tout réafficher.
|
||||
// Les deux clics qui précèdent le double-clic ont coché puis décoché la case : sans effet.
|
||||
let solo_level = move |level: &'static str| {
|
||||
levels.update(|selected| {
|
||||
*selected = if selected.len() == 1 && selected[0] == level {
|
||||
all_levels()
|
||||
} else {
|
||||
vec![level.to_string()]
|
||||
};
|
||||
});
|
||||
pages.set(1);
|
||||
};
|
||||
|
||||
view! {
|
||||
<div class="flex flex-col gap-4 p-6">
|
||||
<div class="flex flex-wrap items-center gap-3 text-sm">
|
||||
{LEVELS
|
||||
.iter()
|
||||
.chain([&UNKNOWN_LEVEL])
|
||||
.map(|level| {
|
||||
let level: &'static str = level;
|
||||
// Disponible tant que le fichier courant n'est pas encore chargé.
|
||||
let available = move || {
|
||||
present_levels
|
||||
.read()
|
||||
.as_ref()
|
||||
.filter(|(id, _)| Some(*id) == file_id.get())
|
||||
.is_none_or(|(_, present)| present.iter().any(|l| l == level))
|
||||
};
|
||||
view! {
|
||||
<label
|
||||
class=move || {
|
||||
if available() {
|
||||
"flex cursor-pointer select-none items-center gap-1"
|
||||
} else {
|
||||
"flex cursor-not-allowed items-center gap-1 opacity-40 grayscale"
|
||||
}
|
||||
}
|
||||
title=move || {
|
||||
if available() {
|
||||
"Double-cliquer pour n'afficher que ce niveau"
|
||||
} else {
|
||||
"Aucune entrée de ce niveau dans ce fichier"
|
||||
}
|
||||
}
|
||||
on:dblclick=move |_| {
|
||||
if available() {
|
||||
solo_level(level);
|
||||
}
|
||||
}
|
||||
>
|
||||
<input
|
||||
type="checkbox"
|
||||
disabled=move || !available()
|
||||
prop:checked=move || levels.read().iter().any(|l| l == level)
|
||||
on:change=move |_| toggle_level(level)
|
||||
/>
|
||||
<span class=level_badge(level)>{level}</span>
|
||||
</label>
|
||||
}
|
||||
})
|
||||
.collect_view()}
|
||||
<input
|
||||
type="search"
|
||||
placeholder="Rechercher…"
|
||||
aria-label="Rechercher dans les entrées"
|
||||
class="ml-auto w-64 rounded-md border border-zinc-300 bg-white px-2 py-1 dark:border-zinc-700 dark:bg-zinc-900"
|
||||
prop:value=move || query.get()
|
||||
on:change=move |ev| {
|
||||
query.set(event_target_value(&ev));
|
||||
pages.set(1);
|
||||
}
|
||||
/>
|
||||
</div>
|
||||
|
||||
<Transition fallback=|| view! { <p>"Chargement…"</p> }>
|
||||
{move || {
|
||||
entries
|
||||
.get()
|
||||
.map(|result| match result {
|
||||
Err(e) => {
|
||||
view! { <p class="text-red-600">{error_message(&e)}</p> }.into_any()
|
||||
}
|
||||
Ok(page) => {
|
||||
let highlight = highlight_from
|
||||
.get()
|
||||
.filter(|(id, _)| *id == page.file_id)
|
||||
.map(|(_, offset)| offset);
|
||||
view! { <EntriesList page highlight pages /> }.into_any()
|
||||
}
|
||||
})
|
||||
}}
|
||||
</Transition>
|
||||
</div>
|
||||
}
|
||||
}
|
||||
|
||||
#[component]
|
||||
fn EntriesList(page: EntriesPage, highlight: Option<u64>, pages: RwSignal<u32>) -> impl IntoView {
|
||||
let empty = page.entries.is_empty();
|
||||
view! {
|
||||
<h1 class="text-lg font-semibold">
|
||||
{page.project_name} <span class="text-zinc-400">" / "</span> {page.relative_path}
|
||||
</h1>
|
||||
{empty.then(|| view! { <p class="text-zinc-500">"Aucune entrée."</p> })}
|
||||
<ul class="flex flex-col gap-2">
|
||||
{page
|
||||
.entries
|
||||
.into_iter()
|
||||
.map(|entry| {
|
||||
let new = highlight.is_some_and(|offset| entry.start >= offset);
|
||||
view! { <EntryRow entry new /> }
|
||||
})
|
||||
.collect_view()}
|
||||
</ul>
|
||||
{page
|
||||
.has_more
|
||||
.then(|| {
|
||||
view! {
|
||||
<button
|
||||
class="self-center rounded-md border border-zinc-300 px-4 py-1.5 text-sm hover:bg-zinc-100 dark:border-zinc-700 dark:hover:bg-zinc-800"
|
||||
on:click=move |_| pages.update(|p| *p += 1)
|
||||
>
|
||||
"Charger plus"
|
||||
</button>
|
||||
}
|
||||
})}
|
||||
}
|
||||
}
|
||||
|
||||
fn level_badge(level: &str) -> &'static str {
|
||||
match level {
|
||||
"DEBUG" => "rounded px-1.5 text-xs font-semibold bg-zinc-200 text-zinc-700",
|
||||
"INFO" => "rounded px-1.5 text-xs font-semibold bg-sky-100 text-sky-800",
|
||||
"NOTICE" => "rounded px-1.5 text-xs font-semibold bg-teal-100 text-teal-800",
|
||||
"WARNING" => "rounded px-1.5 text-xs font-semibold bg-amber-100 text-amber-800",
|
||||
"ERROR" => "rounded px-1.5 text-xs font-semibold bg-red-100 text-red-800",
|
||||
"CRITICAL" | "ALERT" | "EMERGENCY" => {
|
||||
"rounded px-1.5 text-xs font-semibold bg-red-700 text-white"
|
||||
}
|
||||
_ => "rounded px-1.5 text-xs font-semibold bg-zinc-100 text-zinc-500",
|
||||
}
|
||||
}
|
||||
|
||||
#[component]
|
||||
fn EntryRow(entry: Entry, new: bool) -> impl IntoView {
|
||||
let class = if new {
|
||||
"rounded-md border border-amber-300 bg-amber-50 p-3 dark:border-amber-700 dark:bg-amber-950"
|
||||
} else {
|
||||
"rounded-md border border-zinc-200 bg-white p-3 dark:border-zinc-800 dark:bg-zinc-900"
|
||||
};
|
||||
let message_class = "font-mono text-sm whitespace-pre-wrap break-all";
|
||||
let body = if entry.details.is_empty() {
|
||||
view! { <p class=message_class>{entry.message}</p> }.into_any()
|
||||
} else {
|
||||
view! {
|
||||
<details>
|
||||
<summary class=format!("cursor-pointer {message_class}")>{entry.message}</summary>
|
||||
<pre class="mt-2 overflow-x-auto text-xs text-zinc-600 dark:text-zinc-400">{entry.details}</pre>
|
||||
</details>
|
||||
}
|
||||
.into_any()
|
||||
};
|
||||
view! {
|
||||
<li class=class>
|
||||
<div class="mb-1 flex items-center gap-2">
|
||||
<span class="font-mono text-xs text-zinc-500">{entry.logged_at}</span>
|
||||
<span class=level_badge(&entry.level)>{entry.level.clone()}</span>
|
||||
<span class="text-xs text-zinc-500">{entry.env}</span>
|
||||
{new.then(|| view! { <span class="text-xs font-semibold text-amber-600">"nouveau"</span> })}
|
||||
</div>
|
||||
{body}
|
||||
{entry
|
||||
.truncated
|
||||
.then(|| {
|
||||
view! {
|
||||
<p class="mt-1 text-xs text-amber-700">
|
||||
{format!("Entrée tronquée ({}).", human_size(entry.size))}
|
||||
</p>
|
||||
}
|
||||
})}
|
||||
</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>
|
||||
}
|
||||
}
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
pub mod api;
|
||||
pub mod app;
|
||||
pub mod model;
|
||||
#[cfg(feature = "ssr")]
|
||||
pub mod parser;
|
||||
#[cfg(feature = "ssr")]
|
||||
pub mod scanner;
|
||||
#[cfg(feature = "ssr")]
|
||||
pub mod server;
|
||||
|
||||
#[cfg(feature = "hydrate")]
|
||||
#[wasm_bindgen::prelude::wasm_bindgen]
|
||||
pub fn hydrate() {
|
||||
use crate::app::*;
|
||||
console_error_panic_hook::set_once();
|
||||
leptos::mount::hydrate_body(App);
|
||||
}
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
#[cfg(feature = "ssr")]
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
use axum::Router;
|
||||
use lara_logs_reader::{
|
||||
app::{App, shell},
|
||||
scanner::Scanner,
|
||||
server,
|
||||
};
|
||||
use leptos::{logging::log, prelude::*};
|
||||
use leptos_axum::{LeptosRoutes, generate_route_list};
|
||||
use std::{net::SocketAddr, process::exit, sync::Arc};
|
||||
|
||||
let database_url = std::env::var("LLR_DATABASE_URL")
|
||||
.unwrap_or_else(|_| "sqlite://./lara_logs_reader.sqlite?mode=rwc".into());
|
||||
let pool = match server::connect_db(&database_url).await {
|
||||
Ok(pool) => pool,
|
||||
Err(e) => {
|
||||
eprintln!("Impossible d'ouvrir la base de données `{database_url}` : {e}");
|
||||
exit(1);
|
||||
}
|
||||
};
|
||||
let scanner = Arc::new(Scanner::default());
|
||||
|
||||
let conf = get_configuration(None).unwrap();
|
||||
let mut leptos_options = conf.leptos_options;
|
||||
if let Ok(addr) = std::env::var("LLR_ADDR") {
|
||||
match addr.parse::<SocketAddr>() {
|
||||
Ok(addr) => leptos_options.site_addr = addr,
|
||||
Err(e) => {
|
||||
eprintln!("LLR_ADDR invalide `{addr}` : {e}");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
let addr = leptos_options.site_addr;
|
||||
|
||||
let routes = generate_route_list(App);
|
||||
let app = Router::new()
|
||||
.leptos_routes_with_context(
|
||||
&leptos_options,
|
||||
routes,
|
||||
{
|
||||
let pool = pool.clone();
|
||||
let scanner = scanner.clone();
|
||||
move || {
|
||||
provide_context(pool.clone());
|
||||
provide_context(scanner.clone());
|
||||
}
|
||||
},
|
||||
{
|
||||
let leptos_options = leptos_options.clone();
|
||||
move || shell(leptos_options.clone())
|
||||
},
|
||||
)
|
||||
.fallback(leptos_axum::file_and_error_handler(shell))
|
||||
.with_state(leptos_options);
|
||||
|
||||
let listener = match tokio::net::TcpListener::bind(&addr).await {
|
||||
Ok(listener) => listener,
|
||||
Err(e) => {
|
||||
eprintln!("Impossible d'écouter sur `{addr}` : {e}");
|
||||
exit(1);
|
||||
}
|
||||
};
|
||||
log!("listening on http://{}", &addr);
|
||||
axum::serve(listener, app.into_make_service())
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "ssr"))]
|
||||
pub fn main() {
|
||||
// Pas de `main` côté client : voir `hydrate()` dans lib.rs.
|
||||
}
|
||||
+313
@@ -0,0 +1,313 @@
|
||||
//! Types partagés entre le serveur et le client, et règles pures (sans E/S).
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
pub const MIN_INTERVAL: u32 = 1;
|
||||
pub const MAX_INTERVAL: u32 = 3600;
|
||||
pub const DEFAULT_INTERVAL: 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`.
|
||||
pub const MAX_ENTRIES_LIMIT: u32 = 2000;
|
||||
/// Au-delà, le contenu d'une entrée est tronqué à l'affichage.
|
||||
pub const MAX_ENTRY_BYTES: u64 = 1024 * 1024;
|
||||
|
||||
/// Niveaux PSR-3, plus `UNKNOWN` pour le texte qui précède la première ligne d'en-tête.
|
||||
pub const LEVELS: [&str; 8] = [
|
||||
"DEBUG",
|
||||
"INFO",
|
||||
"NOTICE",
|
||||
"WARNING",
|
||||
"ERROR",
|
||||
"CRITICAL",
|
||||
"ALERT",
|
||||
"EMERGENCY",
|
||||
];
|
||||
pub const UNKNOWN_LEVEL: &str = "UNKNOWN";
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct Summary {
|
||||
pub total: u64,
|
||||
/// Heure du serveur (secondes Unix), pour afficher l'ancienneté des fichiers.
|
||||
pub now: i64,
|
||||
pub projects: Vec<ProjectSummary>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct ProjectSummary {
|
||||
pub id: i64,
|
||||
pub name: String,
|
||||
pub root_path: String,
|
||||
pub error: Option<String>,
|
||||
pub unread: u64,
|
||||
pub files: Vec<FileSummary>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct FileSummary {
|
||||
pub id: i64,
|
||||
pub relative_path: String,
|
||||
pub size: u64,
|
||||
/// Date de dernière modification (secondes Unix).
|
||||
pub modified: Option<i64>,
|
||||
pub missing: bool,
|
||||
pub error: Option<String>,
|
||||
pub unread: u64,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct EntriesPage {
|
||||
pub file_id: i64,
|
||||
pub project_name: String,
|
||||
pub relative_path: String,
|
||||
pub entries: Vec<Entry>,
|
||||
pub has_more: bool,
|
||||
/// Fin de la dernière entrée complète indexée.
|
||||
pub scan_offset: u64,
|
||||
/// Curseur de lecture au moment de l'appel.
|
||||
pub read_offset: u64,
|
||||
/// Niveaux présents dans le fichier, indépendamment des filtres.
|
||||
pub levels: Vec<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct Entry {
|
||||
pub start: u64,
|
||||
pub logged_at: String,
|
||||
pub level: String,
|
||||
pub env: String,
|
||||
/// Première ligne, sans l'en-tête `[date] env.LEVEL: `.
|
||||
pub message: String,
|
||||
/// Lignes suivantes (stack trace…).
|
||||
pub details: String,
|
||||
/// Taille réelle de l'entrée en octets.
|
||||
pub size: u64,
|
||||
pub truncated: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct Settings {
|
||||
pub refresh_interval_seconds: u32,
|
||||
pub file_sort: FileSort,
|
||||
}
|
||||
|
||||
/// Ordre des fichiers dans la liste d'un projet.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum FileSort {
|
||||
/// Par chemin, ordre alphabétique.
|
||||
#[default]
|
||||
Name,
|
||||
/// Le plus récemment modifié en premier.
|
||||
Modified,
|
||||
}
|
||||
|
||||
impl FileSort {
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
FileSort::Name => "name",
|
||||
FileSort::Modified => "modified",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(value: &str) -> Option<Self> {
|
||||
match value {
|
||||
"name" => Some(FileSort::Name),
|
||||
"modified" => Some(FileSort::Modified),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Trie les fichiers d'un projet. À date égale (ou inconnue), l'ordre alphabétique départage ;
|
||||
/// les fichiers sans date viennent en dernier.
|
||||
pub fn sort_files(files: &mut [FileSummary], sort: FileSort) {
|
||||
match sort {
|
||||
FileSort::Name => files.sort_by(|a, b| a.relative_path.cmp(&b.relative_path)),
|
||||
FileSort::Modified => files.sort_by(|a, b| {
|
||||
b.modified
|
||||
.cmp(&a.modified)
|
||||
.then_with(|| a.relative_path.cmp(&b.relative_path))
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
/// Ancienneté lisible : « à l'instant », « il y a 5 min », « il y a 3 h », « il y a 2 j ».
|
||||
pub fn relative_age(seconds: i64) -> String {
|
||||
match seconds.max(0) {
|
||||
s if s < 60 => "à l'instant".to_string(),
|
||||
s if s < 3600 => format!("il y a {} min", s / 60),
|
||||
s if s < 86_400 => format!("il y a {} h", s / 3600),
|
||||
s => format!("il y a {} j", s / 86_400),
|
||||
}
|
||||
}
|
||||
|
||||
/// Valide l'intervalle saisi par l'utilisateur.
|
||||
pub fn parse_interval(input: &str) -> Result<u32, String> {
|
||||
input
|
||||
.trim()
|
||||
.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."
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// État affiché par le favicon.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum FaviconState {
|
||||
Idle,
|
||||
Unread(u64),
|
||||
Offline,
|
||||
}
|
||||
|
||||
/// Favicon SVG correspondant à l'état, sous forme d'URL `data:`.
|
||||
pub fn favicon_data_url(state: FaviconState) -> String {
|
||||
let badge = match state {
|
||||
FaviconState::Idle | FaviconState::Unread(0) => String::new(),
|
||||
FaviconState::Unread(n) => {
|
||||
let label = if n > 99 {
|
||||
"99+".to_string()
|
||||
} else {
|
||||
n.to_string()
|
||||
};
|
||||
let font = match label.len() {
|
||||
1 => 18,
|
||||
2 => 15,
|
||||
_ => 11,
|
||||
};
|
||||
format!(
|
||||
"<circle cx='21' cy='11' r='11' fill='#dc2626'/>\
|
||||
<text x='21' y='11' dy='.35em' text-anchor='middle' font-family='Arial,sans-serif' \
|
||||
font-weight='bold' font-size='{font}' fill='#fff'>{label}</text>"
|
||||
)
|
||||
}
|
||||
FaviconState::Offline => "<circle cx='21' cy='11' r='11' fill='#71717a'/>\
|
||||
<text x='21' y='11' dy='.35em' text-anchor='middle' font-family='Arial,sans-serif' \
|
||||
font-weight='bold' font-size='18' fill='#fff'>!</text>"
|
||||
.to_string(),
|
||||
};
|
||||
let svg = format!(
|
||||
"<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'>\
|
||||
<rect x='2' y='4' width='24' height='26' rx='4' fill='#18181b'/>\
|
||||
<rect x='6' y='10' width='16' height='2.5' rx='1' fill='#f87171'/>\
|
||||
<rect x='6' y='16' width='12' height='2.5' rx='1' fill='#e4e4e7'/>\
|
||||
<rect x='6' y='22' width='14' height='2.5' rx='1' fill='#e4e4e7'/>\
|
||||
{badge}</svg>"
|
||||
);
|
||||
let mut url = String::from("data:image/svg+xml,");
|
||||
for c in svg.chars() {
|
||||
match c {
|
||||
'#' => url.push_str("%23"),
|
||||
'<' => url.push_str("%3C"),
|
||||
'>' => url.push_str("%3E"),
|
||||
'%' => url.push_str("%25"),
|
||||
_ => url.push(c),
|
||||
}
|
||||
}
|
||||
url
|
||||
}
|
||||
|
||||
/// Titre de l'onglet selon le nombre de non-lus.
|
||||
pub fn page_title(unread: u64) -> String {
|
||||
if unread == 0 {
|
||||
"Lara Logs Reader".to_string()
|
||||
} else {
|
||||
format!("({unread}) Lara Logs Reader")
|
||||
}
|
||||
}
|
||||
|
||||
/// Taille lisible (o, Kio, Mio, Gio).
|
||||
pub fn human_size(bytes: u64) -> String {
|
||||
const UNITS: [&str; 4] = ["o", "Kio", "Mio", "Gio"];
|
||||
let mut size = bytes as f64;
|
||||
let mut unit = 0;
|
||||
while size >= 1024.0 && unit < UNITS.len() - 1 {
|
||||
size /= 1024.0;
|
||||
unit += 1;
|
||||
}
|
||||
if unit == 0 {
|
||||
format!("{bytes} o")
|
||||
} else {
|
||||
format!("{size:.1} {}", UNITS[unit])
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
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é");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn favicon_badge_label() {
|
||||
let decode = |s: String| s.replace("%3C", "<").replace("%3E", ">");
|
||||
assert!(!decode(favicon_data_url(FaviconState::Idle)).contains("<text"));
|
||||
assert!(!decode(favicon_data_url(FaviconState::Unread(0))).contains("<text"));
|
||||
assert!(decode(favicon_data_url(FaviconState::Unread(3))).contains(">3</text>"));
|
||||
assert!(decode(favicon_data_url(FaviconState::Unread(150))).contains(">99+</text>"));
|
||||
assert!(decode(favicon_data_url(FaviconState::Offline)).contains(">!</text>"));
|
||||
assert!(!favicon_data_url(FaviconState::Unread(3)).contains('#'));
|
||||
}
|
||||
|
||||
fn file(name: &str, modified: Option<i64>) -> FileSummary {
|
||||
FileSummary {
|
||||
id: 0,
|
||||
relative_path: name.to_string(),
|
||||
size: 0,
|
||||
modified,
|
||||
missing: false,
|
||||
error: None,
|
||||
unread: 0,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn file_sorting() {
|
||||
let mut files = vec![
|
||||
file("b.log", Some(100)),
|
||||
file("a.log", Some(50)),
|
||||
file("z.log", None),
|
||||
file("c.log", Some(100)),
|
||||
];
|
||||
sort_files(&mut files, FileSort::Modified);
|
||||
let names: Vec<_> = files.iter().map(|f| f.relative_path.as_str()).collect();
|
||||
assert_eq!(names, ["b.log", "c.log", "a.log", "z.log"]);
|
||||
sort_files(&mut files, FileSort::Name);
|
||||
let names: Vec<_> = files.iter().map(|f| f.relative_path.as_str()).collect();
|
||||
assert_eq!(names, ["a.log", "b.log", "c.log", "z.log"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sort_round_trip() {
|
||||
for sort in [FileSort::Name, FileSort::Modified] {
|
||||
assert_eq!(FileSort::parse(sort.as_str()), Some(sort));
|
||||
}
|
||||
assert_eq!(FileSort::parse("size"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ages() {
|
||||
assert_eq!(relative_age(-3), "à l'instant");
|
||||
assert_eq!(relative_age(59), "à l'instant");
|
||||
assert_eq!(relative_age(300), "il y a 5 min");
|
||||
assert_eq!(relative_age(3 * 3600), "il y a 3 h");
|
||||
assert_eq!(relative_age(2 * 86_400 + 5), "il y a 2 j");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn title() {
|
||||
assert_eq!(page_title(0), "Lara Logs Reader");
|
||||
assert_eq!(page_title(150), "(150) Lara Logs Reader");
|
||||
}
|
||||
}
|
||||
+251
@@ -0,0 +1,251 @@
|
||||
//! Découpage d'un fichier de log Laravel (format Monolog par défaut) en entrées.
|
||||
|
||||
use crate::model::UNKNOWN_LEVEL;
|
||||
use regex::Regex;
|
||||
use std::{io::BufRead, sync::LazyLock};
|
||||
|
||||
static HEADER: LazyLock<Regex> = LazyLock::new(|| {
|
||||
Regex::new(
|
||||
r"^\[(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)\] (\S+?)\.([A-Za-z]+): ?",
|
||||
)
|
||||
.unwrap()
|
||||
});
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct Header<'a> {
|
||||
pub logged_at: &'a str,
|
||||
pub env: &'a str,
|
||||
pub level: String,
|
||||
/// Le texte qui suit l'en-tête sur la même ligne.
|
||||
pub message: &'a str,
|
||||
}
|
||||
|
||||
/// Reconnaît une ligne d'en-tête `[YYYY-MM-DD HH:MM:SS] env.LEVEL: message`.
|
||||
pub fn parse_header(line: &str) -> Option<Header<'_>> {
|
||||
let caps = HEADER.captures(line)?;
|
||||
Some(Header {
|
||||
logged_at: caps.get(1).unwrap().as_str(),
|
||||
env: caps.get(2).unwrap().as_str(),
|
||||
level: caps.get(3).unwrap().as_str().to_ascii_uppercase(),
|
||||
message: &line[caps.get(0).unwrap().end()..],
|
||||
})
|
||||
}
|
||||
|
||||
/// Une entrée repérée dans le fichier, sans son contenu.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct IndexedEntry {
|
||||
pub start: u64,
|
||||
pub end: u64,
|
||||
pub logged_at: String,
|
||||
pub level: String,
|
||||
}
|
||||
|
||||
/// Résultat de l'indexation d'une portion de fichier.
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct Indexed {
|
||||
pub entries: Vec<IndexedEntry>,
|
||||
/// Fin de la dernière entrée complète : le prochain scan reprendra ici.
|
||||
pub offset: u64,
|
||||
}
|
||||
|
||||
/// Indexe les entrées complètes lues depuis `reader`, positionné à l'octet `start` du fichier.
|
||||
///
|
||||
/// Le fichier est lu ligne par ligne, sans être chargé en mémoire. Une entrée est complète
|
||||
/// quand une ligne d'en-tête la suit. La dernière entrée du fichier ne l'est que si elle se
|
||||
/// termine par `\n` **et** que le fichier est `settled` (non modifié depuis un court instant) :
|
||||
/// sinon on pourrait lire une stack trace à moitié écrite. Une entrée incomplète n'est pas
|
||||
/// indexée : `offset` s'arrête à son début pour qu'elle soit relue au scan suivant.
|
||||
/// `fallback_ts` horodate le texte qui ne commence pas par une ligne d'en-tête.
|
||||
pub fn index_entries(
|
||||
mut reader: impl BufRead,
|
||||
start: u64,
|
||||
fallback_ts: &str,
|
||||
settled: bool,
|
||||
) -> std::io::Result<Indexed> {
|
||||
let mut entries = Vec::new();
|
||||
let mut current: Option<IndexedEntry> = None;
|
||||
let mut pos = start;
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
buf.clear();
|
||||
let n = reader.read_until(b'\n', &mut buf)? as u64;
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
if buf.last() != Some(&b'\n') {
|
||||
// Ligne partielle en fin de fichier. Si elle commence par `[`, c'est
|
||||
// vraisemblablement une nouvelle entrée : la précédente est donc complète.
|
||||
// Sinon, c'est la suite de l'entrée courante, qui n'est pas encore finie.
|
||||
if buf.first() != Some(&b'[')
|
||||
&& let Some(cur) = current.take()
|
||||
{
|
||||
pos = cur.start;
|
||||
}
|
||||
break;
|
||||
}
|
||||
let line = String::from_utf8_lossy(&buf);
|
||||
if let Some(header) = parse_header(&line) {
|
||||
if let Some(mut cur) = current.take() {
|
||||
cur.end = pos;
|
||||
entries.push(cur);
|
||||
}
|
||||
current = Some(IndexedEntry {
|
||||
start: pos,
|
||||
end: 0,
|
||||
logged_at: header.logged_at.to_string(),
|
||||
level: header.level,
|
||||
});
|
||||
} else if current.is_none() {
|
||||
current = Some(IndexedEntry {
|
||||
start: pos,
|
||||
end: 0,
|
||||
logged_at: fallback_ts.to_string(),
|
||||
level: UNKNOWN_LEVEL.to_string(),
|
||||
});
|
||||
}
|
||||
pos += n;
|
||||
}
|
||||
if let Some(mut cur) = current {
|
||||
if settled {
|
||||
cur.end = pos;
|
||||
entries.push(cur);
|
||||
} else {
|
||||
pos = cur.start;
|
||||
}
|
||||
}
|
||||
Ok(Indexed {
|
||||
entries,
|
||||
offset: pos,
|
||||
})
|
||||
}
|
||||
|
||||
/// Découpe le texte d'une entrée en (env, message, détails).
|
||||
pub fn split_entry(content: &str) -> (String, String, String) {
|
||||
let content = content.trim_end_matches(['\n', '\r']);
|
||||
let (first, rest) = content.split_once('\n').unwrap_or((content, ""));
|
||||
let first = first.trim_end_matches('\r');
|
||||
match parse_header(first) {
|
||||
Some(h) => (h.env.to_string(), h.message.to_string(), rest.to_string()),
|
||||
None => (String::new(), first.to_string(), rest.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn index(s: &str) -> Indexed {
|
||||
index_entries(s.as_bytes(), 0, "2026-01-01 00:00:00", true).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn header_variants() {
|
||||
let h = parse_header("[2026-10-21 10:00:00] local.ERROR: boom\n").unwrap();
|
||||
assert_eq!(h.logged_at, "2026-10-21 10:00:00");
|
||||
assert_eq!(h.env, "local");
|
||||
assert_eq!(h.level, "ERROR");
|
||||
assert_eq!(h.message, "boom\n");
|
||||
assert!(parse_header("[2026-10-21T10:00:00.123456+02:00] production.info: x").is_some());
|
||||
assert!(parse_header("[2026-10-21 10:00:00] local.INFO:").is_some());
|
||||
assert!(parse_header("#0 /app/vendor/foo.php(12): bar()").is_none());
|
||||
assert!(parse_header("[2026-10-21] local.INFO: x").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multiline_entries() {
|
||||
let log = "[2026-10-21 10:00:00] local.ERROR: boom\n#0 a\n#1 b\n[2026-10-21 10:00:01] local.INFO: ok\n";
|
||||
let r = index(log);
|
||||
assert_eq!(r.entries.len(), 2);
|
||||
assert_eq!(r.entries[0].start, 0);
|
||||
assert_eq!(r.entries[0].end, r.entries[1].start);
|
||||
assert_eq!(r.entries[1].level, "INFO");
|
||||
assert_eq!(r.entries[1].end, log.len() as u64);
|
||||
assert_eq!(r.offset, log.len() as u64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_header_line_is_not_indexed() {
|
||||
let done = "[2026-10-21 10:00:00] local.INFO: a\n";
|
||||
let r = index(&format!("{done}[2026-10-21 10:00:01] local.INFO: b"));
|
||||
assert_eq!(r.entries.len(), 1);
|
||||
assert_eq!(r.offset, done.len() as u64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_continuation_keeps_entry_open() {
|
||||
let first = "[2026-10-21 10:00:00] local.INFO: a\n";
|
||||
let r = index(&format!(
|
||||
"{first}[2026-10-21 10:00:01] local.ERROR: b\n#0 trace"
|
||||
));
|
||||
assert_eq!(r.entries.len(), 1);
|
||||
assert_eq!(r.offset, first.len() as u64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn last_entry_waits_until_settled() {
|
||||
let first = "[2026-10-21 10:00:00] local.INFO: a\n";
|
||||
let log = format!("{first}[2026-10-21 10:00:01] local.ERROR: b\n#0 trace\n");
|
||||
let r = index_entries(log.as_bytes(), 0, "x", false).unwrap();
|
||||
assert_eq!(r.entries.len(), 1);
|
||||
assert_eq!(r.offset, first.len() as u64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_before_first_header_is_unknown() {
|
||||
let r = index("garbage\n[2026-10-21 10:00:00] local.INFO: a\n");
|
||||
assert_eq!(r.entries.len(), 2);
|
||||
assert_eq!(r.entries[0].level, UNKNOWN_LEVEL);
|
||||
assert_eq!(r.entries[0].logged_at, "2026-01-01 00:00:00");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_utf8_is_tolerated() {
|
||||
let mut bytes = b"[2026-10-21 10:00:00] local.INFO: caf".to_vec();
|
||||
bytes.extend_from_slice(&[0xff, 0xfe, b'\n']);
|
||||
let r = index_entries(&bytes[..], 0, "x", true).unwrap();
|
||||
assert_eq!(r.entries.len(), 1);
|
||||
assert_eq!(r.offset, bytes.len() as u64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incremental_from_offset() {
|
||||
let a = "[2026-10-21 10:00:00] local.INFO: a\n";
|
||||
let b = "[2026-10-21 10:00:01] local.INFO: b\n";
|
||||
let r = index_entries(b.as_bytes(), a.len() as u64, "x", true).unwrap();
|
||||
assert_eq!(r.entries[0].start, a.len() as u64);
|
||||
assert_eq!(r.offset, (a.len() + b.len()) as u64);
|
||||
}
|
||||
|
||||
/// Quel que soit le découpage des écritures, l'indexation incrémentale aboutit au même
|
||||
/// résultat que l'indexation d'un seul coup (pas de doublon ni d'entrée coupée).
|
||||
#[test]
|
||||
fn chunked_writes_match_full_index() {
|
||||
let log = "[2026-10-21 10:00:00] local.ERROR: boom\n#0 a\n#1 b\n\
|
||||
[2026-10-21 10:00:01] local.INFO: ok\n\
|
||||
[2026-10-21 10:00:02] local.WARNING: w\nmore\n";
|
||||
let full = index(log);
|
||||
for step in 1..log.len() {
|
||||
let mut offset = 0u64;
|
||||
let mut entries = Vec::new();
|
||||
let mut written = 0;
|
||||
while written < log.len() {
|
||||
written = (written + step).min(log.len());
|
||||
let visible = &log.as_bytes()[offset as usize..written];
|
||||
let settled = written == log.len();
|
||||
let r = index_entries(visible, offset, "x", settled).unwrap();
|
||||
entries.extend(r.entries);
|
||||
offset = r.offset;
|
||||
}
|
||||
assert_eq!(entries, full.entries, "découpage par {step} octets");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn split() {
|
||||
let (env, msg, details) =
|
||||
split_entry("[2026-10-21 10:00:00] local.ERROR: boom\n#0 a\n#1 b\n");
|
||||
assert_eq!(env, "local");
|
||||
assert_eq!(msg, "boom");
|
||||
assert_eq!(details, "#0 a\n#1 b");
|
||||
}
|
||||
}
|
||||
+612
@@ -0,0 +1,612 @@
|
||||
//! Découverte des fichiers de log d'un projet et indexation incrémentale de leurs entrées.
|
||||
|
||||
use crate::{
|
||||
parser::{self, Indexed},
|
||||
server::{format_ts, now},
|
||||
};
|
||||
use sqlx::{QueryBuilder, SqlitePool};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fs::{self, File, Metadata},
|
||||
io::{BufReader, ErrorKind, Read, Seek, SeekFrom},
|
||||
path::{Path, PathBuf},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
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);
|
||||
|
||||
pub fn logs_dir(root: &Path) -> PathBuf {
|
||||
root.join("storage").join("logs")
|
||||
}
|
||||
|
||||
/// Valide le chemin saisi pour un nouveau projet et renvoie sa forme canonique.
|
||||
pub fn validate_project_path(input: &str) -> Result<PathBuf, String> {
|
||||
let input = input.trim();
|
||||
if input.is_empty() {
|
||||
return Err("Veuillez saisir un chemin.".into());
|
||||
}
|
||||
let expanded = match input.strip_prefix('~') {
|
||||
Some(rest) if rest.is_empty() || rest.starts_with('/') => {
|
||||
format!("{}{rest}", std::env::var("HOME").unwrap_or_default())
|
||||
}
|
||||
_ => input.to_string(),
|
||||
};
|
||||
let path = Path::new(&expanded)
|
||||
.canonicalize()
|
||||
.map_err(|e| match e.kind() {
|
||||
ErrorKind::NotFound => format!("Le chemin « {input} » n'existe pas."),
|
||||
ErrorKind::PermissionDenied => format!("Accès refusé à « {input} »."),
|
||||
_ => format!("Le chemin « {input} » est inaccessible : {e}."),
|
||||
})?;
|
||||
if !path.is_dir() {
|
||||
return Err(format!("« {input} » n'est pas un répertoire."));
|
||||
}
|
||||
if !path.join("artisan").is_file() {
|
||||
return Err(format!(
|
||||
"« {input} » ne semble pas être un projet Laravel (fichier artisan introuvable)."
|
||||
));
|
||||
}
|
||||
let logs = logs_dir(&path);
|
||||
if !logs.is_dir() {
|
||||
return Err(format!(
|
||||
"Répertoire storage/logs introuvable dans « {input} »."
|
||||
));
|
||||
}
|
||||
if let Err(e) = fs::read_dir(&logs) {
|
||||
return Err(match e.kind() {
|
||||
ErrorKind::PermissionDenied => format!("Accès refusé à « {} ».", logs.display()),
|
||||
_ => format!("« {} » est illisible : {e}.", logs.display()),
|
||||
});
|
||||
}
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
/// Fichiers `*.log` sous `dir` (récursivement), avec leur chemin relatif (séparateur `/`).
|
||||
///
|
||||
/// Les fichiers et dossiers cachés sont ignorés. Un lien symbolique n'est retenu que s'il
|
||||
/// pointe vers un fichier situé lui aussi sous `dir` ; les liens vers des dossiers ne sont
|
||||
/// pas suivis (pas de boucle possible).
|
||||
pub fn discover(dir: &Path) -> std::io::Result<Vec<(String, PathBuf)>> {
|
||||
let base = dir.canonicalize()?;
|
||||
let mut found = Vec::new();
|
||||
let mut stack = vec![base.clone()];
|
||||
while let Some(current) = stack.pop() {
|
||||
let entries = match fs::read_dir(¤t) {
|
||||
Ok(entries) => entries,
|
||||
Err(e) if current == base => return Err(e),
|
||||
Err(_) => continue,
|
||||
};
|
||||
for entry in entries.flatten() {
|
||||
let name = entry.file_name();
|
||||
let name = name.to_string_lossy();
|
||||
if name.starts_with('.') {
|
||||
continue;
|
||||
}
|
||||
let path = entry.path();
|
||||
let Ok(file_type) = entry.file_type() else {
|
||||
continue;
|
||||
};
|
||||
if file_type.is_dir() {
|
||||
stack.push(path);
|
||||
continue;
|
||||
}
|
||||
let is_file = if file_type.is_symlink() {
|
||||
path.canonicalize()
|
||||
.is_ok_and(|target| target.starts_with(&base) && target.is_file())
|
||||
} else {
|
||||
file_type.is_file()
|
||||
};
|
||||
if is_file && name.ends_with(".log") {
|
||||
let relative = path
|
||||
.strip_prefix(&base)
|
||||
.unwrap_or(&path)
|
||||
.components()
|
||||
.map(|c| c.as_os_str().to_string_lossy())
|
||||
.collect::<Vec<_>>()
|
||||
.join("/");
|
||||
found.push((relative, path));
|
||||
}
|
||||
}
|
||||
}
|
||||
found.sort();
|
||||
Ok(found)
|
||||
}
|
||||
|
||||
/// Identité physique d'un fichier, pour détecter qu'il a été remplacé (rotation).
|
||||
fn identity(meta: &Metadata) -> Option<String> {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::MetadataExt;
|
||||
Some(format!("{}:{}", meta.dev(), meta.ino()))
|
||||
}
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
let _ = meta;
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Ce que la base sait d'un fichier avant le scan.
|
||||
#[derive(Clone, Debug)]
|
||||
struct Known {
|
||||
id: i64,
|
||||
identity: Option<String>,
|
||||
scan_offset: u64,
|
||||
missing: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum Outcome {
|
||||
Missing,
|
||||
Error(String),
|
||||
Scanned {
|
||||
size: u64,
|
||||
modified: Option<i64>,
|
||||
identity: Option<String>,
|
||||
/// Le fichier a été tronqué, remplacé ou recréé : on repart de zéro.
|
||||
reset: bool,
|
||||
indexed: Indexed,
|
||||
},
|
||||
}
|
||||
|
||||
/// Lit la partie nouvelle d'un fichier (E/S bloquantes).
|
||||
fn scan_file(path: &Path, known: &Known) -> Outcome {
|
||||
let meta = match fs::metadata(path) {
|
||||
Ok(meta) => meta,
|
||||
Err(e) if e.kind() == ErrorKind::NotFound => return Outcome::Missing,
|
||||
Err(e) => return Outcome::Error(e.to_string()),
|
||||
};
|
||||
let size = meta.len();
|
||||
let modified = meta.modified().ok();
|
||||
let modified_unix = modified
|
||||
.and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok())
|
||||
.map(|d| d.as_secs() as i64);
|
||||
let ident = identity(&meta);
|
||||
let reset = known.missing
|
||||
|| size < known.scan_offset
|
||||
|| (known.identity.is_some() && ident != known.identity);
|
||||
let from = if reset { 0 } else { known.scan_offset };
|
||||
if from == size {
|
||||
return Outcome::Scanned {
|
||||
size,
|
||||
modified: modified_unix,
|
||||
identity: ident,
|
||||
reset,
|
||||
indexed: Indexed {
|
||||
entries: Vec::new(),
|
||||
offset: from,
|
||||
},
|
||||
};
|
||||
}
|
||||
let settled = modified
|
||||
.and_then(|m| m.elapsed().ok())
|
||||
.is_none_or(|elapsed| elapsed >= SETTLE_DELAY);
|
||||
let fallback_ts = modified.map(|m| format_ts(m.into())).unwrap_or_else(now);
|
||||
let read = || -> std::io::Result<Indexed> {
|
||||
let mut file = File::open(path)?;
|
||||
file.seek(SeekFrom::Start(from))?;
|
||||
// Borné à la taille observée : ce qui est écrit pendant la lecture attendra le prochain scan.
|
||||
let reader = BufReader::with_capacity(64 * 1024, file.take(size - from));
|
||||
parser::index_entries(reader, from, &fallback_ts, settled)
|
||||
};
|
||||
match read() {
|
||||
Ok(indexed) => Outcome::Scanned {
|
||||
size,
|
||||
modified: modified_unix,
|
||||
identity: ident,
|
||||
reset,
|
||||
indexed,
|
||||
},
|
||||
Err(e) if e.kind() == ErrorKind::NotFound => Outcome::Missing,
|
||||
Err(e) => Outcome::Error(e.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Enregistre le résultat d'un scan, en une transaction pour un fichier donné.
|
||||
async fn apply(pool: &SqlitePool, file_id: i64, outcome: Outcome) -> sqlx::Result<()> {
|
||||
match outcome {
|
||||
Outcome::Missing => {
|
||||
sqlx::query(
|
||||
"UPDATE log_files SET missing_since = COALESCE(missing_since, ?) WHERE id = ?",
|
||||
)
|
||||
.bind(now())
|
||||
.bind(file_id)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
}
|
||||
Outcome::Error(message) => {
|
||||
sqlx::query("UPDATE log_files SET last_error = ? WHERE id = ?")
|
||||
.bind(message)
|
||||
.bind(file_id)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
}
|
||||
Outcome::Scanned {
|
||||
size,
|
||||
modified,
|
||||
identity,
|
||||
reset,
|
||||
indexed,
|
||||
} => {
|
||||
let mut tx = pool.begin().await?;
|
||||
if reset {
|
||||
sqlx::query("DELETE FROM log_entries_index WHERE log_file_id = ?")
|
||||
.bind(file_id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"UPDATE read_cursors SET read_offset = 0, updated_at = ? WHERE log_file_id = ?",
|
||||
)
|
||||
.bind(now())
|
||||
.bind(file_id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
}
|
||||
for chunk in indexed.entries.chunks(1000) {
|
||||
let mut insert = QueryBuilder::new(
|
||||
"INSERT INTO log_entries_index (log_file_id, start_offset, end_offset, logged_at, level) ",
|
||||
);
|
||||
insert.push_values(chunk, |mut row, entry| {
|
||||
row.push_bind(file_id)
|
||||
.push_bind(entry.start as i64)
|
||||
.push_bind(entry.end as i64)
|
||||
.push_bind(&entry.logged_at)
|
||||
.push_bind(&entry.level);
|
||||
});
|
||||
insert.build().execute(&mut *tx).await?;
|
||||
}
|
||||
sqlx::query(
|
||||
"UPDATE log_files
|
||||
SET size = ?, modified_at = ?, file_identity = ?, scan_offset = ?,
|
||||
entries_count = CASE WHEN ? THEN 0 ELSE entries_count END + ?,
|
||||
missing_since = NULL, last_error = NULL
|
||||
WHERE id = ?",
|
||||
)
|
||||
.bind(size as i64)
|
||||
.bind(modified)
|
||||
.bind(identity)
|
||||
.bind(indexed.offset as i64)
|
||||
.bind(reset)
|
||||
.bind(indexed.entries.len() as i64)
|
||||
.bind(file_id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Découvre et indexe les fichiers d'un projet.
|
||||
///
|
||||
/// Avec `mark_existing_read`, les curseurs sont placés en fin de fichier : utilisé à l'ajout
|
||||
/// du projet, pour que l'historique ne soit pas compté comme non-lu.
|
||||
async fn scan_project(
|
||||
pool: &SqlitePool,
|
||||
project_id: i64,
|
||||
root: &str,
|
||||
mark_existing_read: bool,
|
||||
) -> sqlx::Result<()> {
|
||||
let root = PathBuf::from(root);
|
||||
let logs = logs_dir(&root);
|
||||
let discovered = tokio::task::spawn_blocking(move || {
|
||||
if !root.is_dir() || !logs.is_dir() {
|
||||
return Err("Projet introuvable sur le disque.".to_string());
|
||||
}
|
||||
discover(&logs).map_err(|e| format!("storage/logs illisible : {e}."))
|
||||
})
|
||||
.await
|
||||
.unwrap_or_else(|e| Err(e.to_string()));
|
||||
|
||||
let discovered = match discovered {
|
||||
Ok(files) => {
|
||||
sqlx::query("UPDATE projects SET last_error = NULL WHERE id = ?")
|
||||
.bind(project_id)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
files
|
||||
}
|
||||
Err(message) => {
|
||||
sqlx::query("UPDATE projects SET last_error = ? WHERE id = ?")
|
||||
.bind(message)
|
||||
.bind(project_id)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
return Ok(());
|
||||
}
|
||||
};
|
||||
|
||||
let rows: Vec<(i64, String, Option<String>, i64, bool)> = sqlx::query_as(
|
||||
"SELECT id, relative_path, file_identity, scan_offset, missing_since IS NOT NULL
|
||||
FROM log_files WHERE project_id = ?",
|
||||
)
|
||||
.bind(project_id)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
let mut known: HashMap<String, Known> = rows
|
||||
.into_iter()
|
||||
.map(|(id, rel, identity, offset, missing)| {
|
||||
(
|
||||
rel,
|
||||
Known {
|
||||
id,
|
||||
identity,
|
||||
scan_offset: offset as u64,
|
||||
missing,
|
||||
},
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
|
||||
for (relative, path) in discovered {
|
||||
let state = match known.remove(&relative) {
|
||||
Some(state) => state,
|
||||
None => {
|
||||
// Nouveau fichier : tout son contenu est non-lu (curseur à 0).
|
||||
let ts = now();
|
||||
let id: i64 = sqlx::query_scalar(
|
||||
"INSERT INTO log_files (project_id, relative_path, discovered_at)
|
||||
VALUES (?, ?, ?) RETURNING id",
|
||||
)
|
||||
.bind(project_id)
|
||||
.bind(&relative)
|
||||
.bind(&ts)
|
||||
.fetch_one(pool)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"INSERT INTO read_cursors (log_file_id, read_offset, updated_at) VALUES (?, 0, ?)",
|
||||
)
|
||||
.bind(id)
|
||||
.bind(&ts)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Known {
|
||||
id,
|
||||
identity: None,
|
||||
scan_offset: 0,
|
||||
missing: false,
|
||||
}
|
||||
}
|
||||
};
|
||||
let file_id = state.id;
|
||||
let outcome = tokio::task::spawn_blocking(move || scan_file(&path, &state))
|
||||
.await
|
||||
.unwrap_or_else(|e| Outcome::Error(e.to_string()));
|
||||
apply(pool, file_id, outcome).await?;
|
||||
}
|
||||
|
||||
// Fichiers connus qui n'ont pas été retrouvés.
|
||||
for state in known.into_values() {
|
||||
apply(pool, state.id, Outcome::Missing).await?;
|
||||
}
|
||||
|
||||
if mark_existing_read {
|
||||
sqlx::query(
|
||||
"UPDATE read_cursors
|
||||
SET read_offset = (SELECT scan_offset FROM log_files WHERE id = log_file_id),
|
||||
updated_at = ?
|
||||
WHERE log_file_id IN (SELECT id FROM log_files WHERE project_id = ?)",
|
||||
)
|
||||
.bind(now())
|
||||
.bind(project_id)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Sérialise les scans : un seul à la fois, quel que soit le nombre d'onglets ouverts.
|
||||
#[derive(Default)]
|
||||
pub struct Scanner {
|
||||
last_full_scan: Mutex<Option<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, String)> = sqlx::query_as("SELECT id, root_path FROM projects")
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
for (id, root) in projects {
|
||||
scan_project(pool, id, &root, false).await?;
|
||||
}
|
||||
*last = Some(Instant::now());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Premier scan d'un projet qui vient d'être ajouté.
|
||||
pub async fn scan_new_project(
|
||||
&self,
|
||||
pool: &SqlitePool,
|
||||
project_id: i64,
|
||||
root: &str,
|
||||
) -> sqlx::Result<()> {
|
||||
let _guard = self.last_full_scan.lock().await;
|
||||
scan_project(pool, project_id, root, true).await
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::io::Write;
|
||||
|
||||
fn laravel_project() -> tempfile::TempDir {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
fs::write(dir.path().join("artisan"), "").unwrap();
|
||||
fs::create_dir_all(logs_dir(dir.path())).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validation_errors() {
|
||||
let project = laravel_project();
|
||||
assert!(validate_project_path(" ").is_err());
|
||||
assert!(
|
||||
validate_project_path("/nope/does/not/exist")
|
||||
.unwrap_err()
|
||||
.contains("n'existe pas")
|
||||
);
|
||||
let file = project.path().join("artisan");
|
||||
assert!(
|
||||
validate_project_path(file.to_str().unwrap())
|
||||
.unwrap_err()
|
||||
.contains("n'est pas un répertoire")
|
||||
);
|
||||
let plain = tempfile::tempdir().unwrap();
|
||||
assert!(
|
||||
validate_project_path(plain.path().to_str().unwrap())
|
||||
.unwrap_err()
|
||||
.contains("artisan")
|
||||
);
|
||||
fs::write(plain.path().join("artisan"), "").unwrap();
|
||||
assert!(
|
||||
validate_project_path(plain.path().to_str().unwrap())
|
||||
.unwrap_err()
|
||||
.contains("storage/logs")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validation_canonicalizes() {
|
||||
let project = laravel_project();
|
||||
let canonical = project.path().canonicalize().unwrap();
|
||||
let with_slash = format!("{}/", project.path().display());
|
||||
assert_eq!(validate_project_path(&with_slash).unwrap(), canonical);
|
||||
let dotted = format!("{}/storage/..", project.path().display());
|
||||
assert_eq!(validate_project_path(&dotted).unwrap(), canonical);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn discovery_rules() {
|
||||
let project = laravel_project();
|
||||
let logs = logs_dir(project.path());
|
||||
for name in [
|
||||
"laravel.log",
|
||||
"laravel-2026-10-20.log",
|
||||
".hidden.log",
|
||||
"old.log.gz",
|
||||
".gitignore",
|
||||
] {
|
||||
fs::write(logs.join(name), "").unwrap();
|
||||
}
|
||||
fs::create_dir(logs.join("jobs")).unwrap();
|
||||
fs::write(logs.join("jobs/worker.log"), "").unwrap();
|
||||
let outside = tempfile::NamedTempFile::new().unwrap();
|
||||
std::os::unix::fs::symlink(outside.path(), logs.join("ext.log")).unwrap();
|
||||
std::os::unix::fs::symlink(logs.join("laravel.log"), logs.join("alias.log")).unwrap();
|
||||
|
||||
let names: Vec<String> = discover(&logs)
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.map(|(r, _)| r)
|
||||
.collect();
|
||||
assert_eq!(
|
||||
names,
|
||||
[
|
||||
"alias.log",
|
||||
"jobs/worker.log",
|
||||
"laravel-2026-10-20.log",
|
||||
"laravel.log"
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
/// Recule la date de modification : la dernière entrée est alors jugée complète.
|
||||
fn settle(path: &Path) {
|
||||
File::options()
|
||||
.write(true)
|
||||
.open(path)
|
||||
.unwrap()
|
||||
.set_modified(std::time::SystemTime::now() - Duration::from_secs(10))
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn known(offset: u64, identity: Option<String>) -> Known {
|
||||
Known {
|
||||
id: 1,
|
||||
identity,
|
||||
scan_offset: offset,
|
||||
missing: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn scanned(outcome: Outcome) -> (u64, Option<String>, bool, Indexed) {
|
||||
match outcome {
|
||||
Outcome::Scanned {
|
||||
size,
|
||||
identity,
|
||||
reset,
|
||||
indexed,
|
||||
..
|
||||
} => (size, identity, reset, indexed),
|
||||
other => panic!("scan inattendu : {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn truncation_and_rotation_reset() {
|
||||
let project = laravel_project();
|
||||
let path = logs_dir(project.path()).join("laravel.log");
|
||||
let line = "[2026-10-21 10:00:00] local.INFO: a\n";
|
||||
fs::write(&path, line.repeat(3)).unwrap();
|
||||
settle(&path);
|
||||
let (_, ident, reset, indexed) = scanned(scan_file(&path, &known(0, None)));
|
||||
assert!(!reset);
|
||||
assert_eq!(indexed.entries.len(), 3);
|
||||
|
||||
// Tronqué puis réécrit plus court.
|
||||
fs::write(&path, line).unwrap();
|
||||
settle(&path);
|
||||
let (_, _, reset, indexed) = scanned(scan_file(
|
||||
&path,
|
||||
&known(3 * line.len() as u64, ident.clone()),
|
||||
));
|
||||
assert!(reset);
|
||||
assert_eq!(indexed.entries.len(), 1);
|
||||
|
||||
// Remplacé par un autre fichier plus long (rotation).
|
||||
fs::rename(&path, path.with_extension("old")).unwrap();
|
||||
let mut f = File::create(&path).unwrap();
|
||||
f.write_all(line.repeat(5).as_bytes()).unwrap();
|
||||
drop(f);
|
||||
settle(&path);
|
||||
let (_, _, reset, indexed) = scanned(scan_file(&path, &known(line.len() as u64, ident)));
|
||||
if cfg!(unix) {
|
||||
assert!(reset);
|
||||
assert_eq!(indexed.entries.len(), 5);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn last_entry_waits_for_settle() {
|
||||
let project = laravel_project();
|
||||
let path = logs_dir(project.path()).join("laravel.log");
|
||||
fs::write(&path, "[2026-10-21 10:00:00] local.INFO: a\n").unwrap();
|
||||
let (_, _, _, indexed) = scanned(scan_file(&path, &known(0, None)));
|
||||
assert!(indexed.entries.is_empty());
|
||||
assert_eq!(indexed.offset, 0);
|
||||
settle(&path);
|
||||
let (_, _, _, indexed) = scanned(scan_file(&path, &known(0, None)));
|
||||
assert_eq!(indexed.entries.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_file() {
|
||||
let project = laravel_project();
|
||||
let path = logs_dir(project.path()).join("gone.log");
|
||||
assert!(matches!(
|
||||
scan_file(&path, &known(0, None)),
|
||||
Outcome::Missing
|
||||
));
|
||||
}
|
||||
}
|
||||
+176
@@ -0,0 +1,176 @@
|
||||
//! Code exécuté uniquement côté serveur : base de données et accès au contexte.
|
||||
|
||||
use crate::{
|
||||
model::{DEFAULT_INTERVAL, FileSort, FileSummary, ProjectSummary, Settings, Summary},
|
||||
scanner::Scanner,
|
||||
};
|
||||
use leptos::prelude::*;
|
||||
use sqlx::{
|
||||
SqlitePool,
|
||||
sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePoolOptions},
|
||||
};
|
||||
use std::{error::Error, fmt::Display, str::FromStr, sync::Arc, time::Duration};
|
||||
|
||||
/// Ouvre le pool SQLite (en créant le fichier au besoin), vérifie son intégrité
|
||||
/// et applique les migrations.
|
||||
pub async fn connect_db(url: &str) -> Result<SqlitePool, Box<dyn Error>> {
|
||||
let options = SqliteConnectOptions::from_str(url)?
|
||||
.create_if_missing(true)
|
||||
.foreign_keys(true)
|
||||
.journal_mode(SqliteJournalMode::Wal)
|
||||
.busy_timeout(Duration::from_secs(5));
|
||||
let pool = SqlitePoolOptions::new()
|
||||
.max_connections(5)
|
||||
.connect_with(options)
|
||||
.await?;
|
||||
let check: String = sqlx::query_scalar("PRAGMA quick_check")
|
||||
.fetch_one(&pool)
|
||||
.await?;
|
||||
if check != "ok" {
|
||||
return Err(format!("base corrompue : {check}").into());
|
||||
}
|
||||
sqlx::migrate!().run(&pool).await?;
|
||||
Ok(pool)
|
||||
}
|
||||
|
||||
/// Récupère le pool fourni en contexte par `main`.
|
||||
pub fn pool() -> Result<SqlitePool, ServerFnError> {
|
||||
use_context::<SqlitePool>().ok_or_else(|| internal_error("SqlitePool absent du contexte"))
|
||||
}
|
||||
|
||||
/// Récupère le scanner fourni en contexte par `main`.
|
||||
pub fn scanner() -> Result<Arc<Scanner>, ServerFnError> {
|
||||
use_context::<Arc<Scanner>>().ok_or_else(|| internal_error("Scanner absent du contexte"))
|
||||
}
|
||||
|
||||
/// Journalise l'erreur réelle et renvoie au client un message générique.
|
||||
pub fn internal_error(error: impl Display) -> ServerFnError {
|
||||
leptos::logging::error!("erreur interne : {error}");
|
||||
ServerFnError::new("Une erreur interne est survenue.")
|
||||
}
|
||||
|
||||
/// Erreur renvoyée quand un projet ou un fichier demandé n'existe plus.
|
||||
pub fn not_found() -> ServerFnError {
|
||||
ServerFnError::new("Élément introuvable, la liste a été rafraîchie.")
|
||||
}
|
||||
|
||||
/// Horodatage courant, au format stocké en base.
|
||||
pub fn now() -> String {
|
||||
format_ts(time::OffsetDateTime::now_utc())
|
||||
}
|
||||
|
||||
pub fn format_ts(ts: time::OffsetDateTime) -> String {
|
||||
use time::macros::format_description;
|
||||
ts.format(format_description!(
|
||||
"[year]-[month]-[day] [hour]:[minute]:[second]"
|
||||
))
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
async fn setting(pool: &SqlitePool, key: &str) -> sqlx::Result<Option<String>> {
|
||||
sqlx::query_scalar("SELECT value FROM settings WHERE key = ?")
|
||||
.bind(key)
|
||||
.fetch_optional(pool)
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn set_setting(pool: &SqlitePool, key: &str, value: &str) -> sqlx::Result<()> {
|
||||
sqlx::query(
|
||||
"INSERT INTO settings (key, value) VALUES (?, ?)
|
||||
ON CONFLICT (key) DO UPDATE SET value = excluded.value",
|
||||
)
|
||||
.bind(key)
|
||||
.bind(value)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
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();
|
||||
Ok(Settings {
|
||||
refresh_interval_seconds,
|
||||
file_sort,
|
||||
})
|
||||
}
|
||||
|
||||
/// (id, project_id, relative_path, size, modifié le, manquant, erreur, non-lus)
|
||||
type FileRow = (
|
||||
i64,
|
||||
i64,
|
||||
String,
|
||||
i64,
|
||||
Option<i64>,
|
||||
bool,
|
||||
Option<String>,
|
||||
i64,
|
||||
);
|
||||
|
||||
/// Projets, fichiers et compteurs de non-lus.
|
||||
///
|
||||
/// Un fichier manquant ou un projet introuvable sur le disque ne compte aucun non-lu.
|
||||
pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
|
||||
let projects: Vec<(i64, String, String, Option<String>)> = sqlx::query_as(
|
||||
"SELECT id, name, root_path, last_error FROM projects ORDER BY name COLLATE NOCASE, id",
|
||||
)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
let files: Vec<FileRow> = sqlx::query_as(
|
||||
"SELECT f.id, f.project_id, f.relative_path, f.size, f.modified_at,
|
||||
f.missing_since IS NOT NULL,
|
||||
f.last_error,
|
||||
(SELECT COUNT(*) FROM log_entries_index e
|
||||
WHERE e.log_file_id = f.id AND e.start_offset >= c.read_offset)
|
||||
FROM log_files f
|
||||
JOIN read_cursors c ON c.log_file_id = f.id
|
||||
ORDER BY f.relative_path",
|
||||
)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
|
||||
let mut summary = Summary {
|
||||
total: 0,
|
||||
now: time::OffsetDateTime::now_utc().unix_timestamp(),
|
||||
projects: Vec::with_capacity(projects.len()),
|
||||
};
|
||||
for (id, name, root_path, error) in projects {
|
||||
let project_ok = error.is_none();
|
||||
let files: Vec<FileSummary> = files
|
||||
.iter()
|
||||
.filter(|f| f.1 == id)
|
||||
.map(
|
||||
|(fid, _, rel, size, modified, missing, ferr, unread)| FileSummary {
|
||||
id: *fid,
|
||||
relative_path: rel.clone(),
|
||||
size: *size as u64,
|
||||
modified: *modified,
|
||||
missing: *missing,
|
||||
error: ferr.clone(),
|
||||
unread: if project_ok && !*missing {
|
||||
*unread as u64
|
||||
} else {
|
||||
0
|
||||
},
|
||||
},
|
||||
)
|
||||
.collect();
|
||||
let unread = files.iter().map(|f| f.unread).sum();
|
||||
summary.total += unread;
|
||||
summary.projects.push(ProjectSummary {
|
||||
id,
|
||||
name,
|
||||
root_path,
|
||||
error,
|
||||
unread,
|
||||
files,
|
||||
});
|
||||
}
|
||||
Ok(summary)
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
@import "tailwindcss";
|
||||
|
||||
/* Les vues Leptos vivent dans le dossier `src`. */
|
||||
@source "../src";
|
||||
Reference in new issue
Block a user