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