Auteur SHA1 Message Date

2026-10-18

Théo GastineletClaude Sonnet 5.5 6b89a9d815 Tests hors ligne du quota avec journal du relais
Journal absent, vide, illisible, lignes invalides, hier/aujourd hui, bornes,
plafond atteint par le total ou par les 24 h. Les tests desactivent le journal
reel par defaut (MC_JOURNAL_RELAIS vide dans tests/aide.py).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-18 21:06:36 +02:00
Théo GastineletClaude Sonnet 5.5 f0dea50fa5 Quota : compter les appels GWS passes par le relais SSH
MC_JOURNAL_RELAIS (defaut ~/gws-relais/journal/appels.log, vide = desactive).
Le quota additionne les lignes du journal sur le jour de Paris et sur les 24 h
glissantes. Journal absent ou illisible : 0 appel et une ligne de journal.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-18 21:06:35 +02:00

2026-10-17

Théo GastineletClaude Haiku 5.5 778825198e Securite deploiement : copie sans liens vers MC_SERVI, script Caddy hors du home, listes en NUL
- publier.copier_vers_servi : copie les seuls fichiers ordinaires de public/data vers MC_SERVI ; lien refuse
  dans la source, lien remplace (jamais suivi) dans la destination ; ecriture temporaire O_EXCL|O_NOFOLLOW puis
  os.replace. Caddy ne sert que /data depuis ce dossier.
- Unite : MC_PUBLIC dans ~/meteo-collecte/public, MC_SERVI=/srv/weather.gastinel.me.
- deployer-vps.sh : ne copie plus le script Caddy dans ~ ; il le depose dans ~/meteo-collecte/deploy et affiche
  son sha256 pour une installation root:root 755 dans /usr/local/sbin. Sauvegardes : noms passes en NUL sur
  stdin, pas de commande construite a partir des noms.
- appliquer-caddy-meteo.sh : refuse si /srv/weather.gastinel.me est un lien.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-17 16:45:09 +02:00
Théo GastineletClaude Haiku 5.5 21f7fca8b6 README : procedure de deploiement (corrige le nom du rapport)
Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-17 15:15:49 +02:00
Théo GastineletClaude Haiku 5.5 fdcca5bccc Deploiement VPS : unites utilisateur, script deployer-vps.sh, Caddy weather.gastinel.me
- deploiement/ : unites reelles (EnvironmentFile=%h/.config/meteo-collecte/env, MC_PUBLIC=/srv/weather.gastinel.me,
  MC_DIRECT_COMPAT a cote de direct.json, pas dessus). Minuteur inchange (hh:x4, hh:x9), non active.
- deploy/deployer-vps.sh : copie sans ecraser var/, sauvegardes .avant-deploiement-1017, env cree vide (600),
  --config et --publier de controle sans appel reseau ; --activer seulement si conditions reunies.
- deploy/appliquer-caddy-meteo.sh : bloc weather.gastinel.me (/data/* lecture seule, CORS), sauvegarde
  Caddyfile.avant-meteo-1017, validate, reload, retour arriere.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-10-17 15:15:40 +02:00
13 fichiers modifiés avec 1014 ajouts et 558 suppressions

Aucun fichier ne correspond à votre recherche

+82 -75
Voir le fichier
@@ -1,75 +1,82 @@
# meteo-collecte
Collecteur du site météo public (weather.gastinel.me). Python 3, bibliothèque standard seulement
(aucune dépendance à installer ; `pytest` est facultatif pour lancer les tests).
Conception : `Gastinel-Projets/site-meteo-architecture-2026-10-15.md`.
Ce dépôt ne touche ni `weather-collector` ni `weather-db`.
## Ce que fait un tick
Lancé toutes les 5 min (hh:x4 et hh:x9) par le minuteur systemd :
1. **ROMMA** (`romma.py`) : au plus une requête `type=live&global=1` toutes les 10 min, toutes stations d'un coup.
2. **Infoclimat** (`infoclimat.py`) : passage principal à hh:x4 seulement si une station est due (rythme
mesuré dans la base), rattrapage ciblé à hh:x9, requêtes groupées par lots de 25, fenêtre d'un jour.
Plafonds : 1000 requêtes/jour pour le site (jour de Paris **et** 24 h glissantes) et quota commun
`~/gws-collecte/quota.json` (4999). Alerte à 80 % (envoi ntfy désactivé par défaut).
3. **Stockage** (`stockage.py`) : SQLite `var/mesures.sqlite`, une ligne par (source, station, instant UTC),
14 jours glissants. Les sources ne sont jamais mélangées.
4. **Publication** (`publier.py`) : fichiers statiques écrits de façon atomique sous `<public>/data/` :
`stations.json`, `station/<source>-<id>.json` (48 h), `etat.json`.
Toute erreur réseau ou de statut pose une pause de 15 min sur la source concernée ; l'autre source et la
publication continuent. Un verrou empêche deux ticks simultanés.
## Configuration (variables d'environnement)
| Variable | Rôle | Défaut |
|---|---|---|
| `MC_BASE` | dossier d'état (var/, base, journal) | `~/meteo-collecte` |
| `MC_PUBLIC` | racine servie par le serveur web | `$MC_BASE/public` |
| `MC_QUOTA_COMMUN` | compteur commun Infoclimat | `~/gws-collecte/quota.json` |
| `MC_STATIONS` | liste des stations Infoclimat | `config/stations.json` |
| `MC_PLAFOND_SITE` / `MC_PLAFOND_COMMUN` | plafonds Infoclimat | 1000 / 4999 |
| `MC_LOT_MAX` | stations par requête | 25 |
| `MC_COMPTE_PAR_STATION` | compter une requête par station | 0 |
| `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 |
| `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide |
| `MC_DIRECT_COMPAT` | écrire aussi l'ancien `direct.json` | vide |
### Secrets
Uniquement par variables d'environnement, lues au moment de l'appel, jamais écrites ni affichées :
* `MC_JETON_INFOCLIMAT` : jeton Infoclimat (lié à l'IP du VPS) ;
* `MC_CLE_ROMMA` : clé API ROMMA.
Sans la variable, la source ne fait aucun appel (`sans_jeton` / `sans_cle`). Tout message de journal passe
par `scrub` (masque `token=`, `apikey=` et la valeur, en clair ou encodée).
## Commandes
```sh
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente »
```
## Tests (hors ligne)
```sh
python -m pytest -q # ou : python -m unittest discover -s . -p "test_*.py"
python -m pytest -q -s tests/test_hors_ligne.py # affiche les compteurs de requêtes simulés
```
`tests/__init__.py` coupe le réseau (DNS et connexions hors boucle locale lèvent une erreur) : aucun test ne
peut joindre une API. Les réponses viennent de `tests/fixtures/` ou de petits serveurs simulés ; les secrets
sont des valeurs fictives passées dans un environnement en mémoire. `tests/test_hors_ligne.py` simule
plusieurs jours de ticks (fonctionnement normal, plafond, panne longue, sans secrets, purge, heure d'hiver).
## Déploiement
`deploiement/meteo-collecte.service` et `.timer` sont des **exemples non installés** (unité utilisateur).
Points à vérifier avant installation par Théo : voir les commentaires `[À VÉRIFIER]` en tête du service
(emplacement du code, linger, arrêt de `meteo-direct.timer` pour ne pas compter deux fois le quota).
# meteo-collecte
Collecteur du site météo public (weather.gastinel.me). Python 3, bibliothèque standard seulement
(aucune dépendance à installer ; `pytest` est facultatif pour lancer les tests).
Conception : `Gastinel-Projets/site-meteo-architecture-2026-10-15.md`.
Ce dépôt ne touche ni `weather-collector` ni `weather-db`.
## Ce que fait un tick
Lancé toutes les 5 min (hh:x4 et hh:x9) par le minuteur systemd :
1. **ROMMA** (`romma.py`) : au plus une requête `type=live&global=1` toutes les 10 min, toutes stations d'un coup.
2. **Infoclimat** (`infoclimat.py`) : passage principal à hh:x4 seulement si une station est due (rythme
mesuré dans la base), rattrapage ciblé à hh:x9, requêtes groupées par lots de 25, fenêtre d'un jour.
Plafonds : 1000 requêtes/jour pour le site (jour de Paris **et** 24 h glissantes) et quota commun
`~/gws-collecte/quota.json` (4999). Alerte à 80 % (envoi ntfy désactivé par défaut).
3. **Stockage** (`stockage.py`) : SQLite `var/mesures.sqlite`, une ligne par (source, station, instant UTC),
14 jours glissants. Les sources ne sont jamais mélangées.
4. **Publication** (`publier.py`) : fichiers statiques écrits de façon atomique sous `<public>/data/` :
`stations.json`, `station/<source>-<id>.json` (48 h), `etat.json`.
Toute erreur réseau ou de statut pose une pause de 15 min sur la source concernée ; l'autre source et la
publication continuent. Un verrou empêche deux ticks simultanés.
## Configuration (variables d'environnement)
| Variable | Rôle | Défaut |
|---|---|---|
| `MC_BASE` | dossier d'état (var/, base, journal) | `~/meteo-collecte` |
| `MC_PUBLIC` | racine servie par le serveur web | `$MC_BASE/public` |
| `MC_QUOTA_COMMUN` | compteur commun Infoclimat | `~/gws-collecte/quota.json` |
| `MC_STATIONS` | liste des stations Infoclimat | `config/stations.json` |
| `MC_PLAFOND_SITE` / `MC_PLAFOND_COMMUN` | plafonds Infoclimat | 1000 / 4999 |
| `MC_LOT_MAX` | stations par requête | 25 |
| `MC_COMPTE_PAR_STATION` | compter une requête par station | 0 |
| `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 |
| `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide |
| `MC_DIRECT_COMPAT` | écrire aussi l'ancien `direct.json` | vide |
| `MC_JOURNAL_RELAIS` | journal des appels GWS via le relais SSH, ajoutés au quota (vide = désactivé) | `~/gws-relais/journal/appels.log` |
| `MC_SERVI` | après publication, copie des seuls fichiers ordinaires de `public/data/` vers ce dossier (lu par Caddy) ; liens refusés | vide |
### Secrets
Uniquement par variables d'environnement, lues au moment de l'appel, jamais écrites ni affichées :
* `MC_JETON_INFOCLIMAT` : jeton Infoclimat (lié à l'IP du VPS) ;
* `MC_CLE_ROMMA` : clé API ROMMA.
Sans la variable, la source ne fait aucun appel (`sans_jeton` / `sans_cle`). Tout message de journal passe
par `scrub` (masque `token=`, `apikey=` et la valeur, en clair ou encodée).
## Commandes
```sh
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente »
```
## Tests (hors ligne)
```sh
python -m pytest -q # ou : python -m unittest discover -s . -p "test_*.py"
python -m pytest -q -s tests/test_hors_ligne.py # affiche les compteurs de requêtes simulés
```
`tests/__init__.py` coupe le réseau (DNS et connexions hors boucle locale lèvent une erreur) : aucun test ne
peut joindre une API. Les réponses viennent de `tests/fixtures/` ou de petits serveurs simulés ; les secrets
sont des valeurs fictives passées dans un environnement en mémoire. `tests/test_hors_ligne.py` simule
plusieurs jours de ticks (fonctionnement normal, plafond, panne longue, sans secrets, purge, heure d'hiver).
## Déploiement (VPS, non activé)
`bash deploy/deployer-vps.sh` (depuis le PC ou le VPS) copie le code dans `~/meteo-collecte`, installe les unités
utilisateur `deploiement/meteo-collecte.service` et `.timer` **sans les activer**, crée `~/.config/meteo-collecte/env`
vide (600) et lance un `--config` et un `--publier` de contrôle. `--activer` active le minuteur, seulement si
linger est actif, `/srv/weather.gastinel.me` est accessible en écriture et `meteo-direct.timer` est arrêté.
Les secrets ne sont jamais saisis par script : Théo les met dans le fichier env avec un éditeur.
Caddy (`weather.gastinel.me`, `/data/*` en lecture seule) : `deploy/appliquer-caddy-meteo.sh`, à lancer par Théo avec sudo.
Procédure complète : `NOTES
apport-deploiement-meteo-collecte-20261017.md`.
+32 -33
Voir le fichier
@@ -1,33 +1,32 @@
# EXEMPLE — non installé. Unité « utilisateur » proposée pour le VPS (à relire par Théo avant toute installation).
#
# Installation possible (par Théo, PAS faite ici) :
# mkdir -p ~/.config/systemd/user
# cp deploiement/meteo-collecte.service deploiement/meteo-collecte.timer ~/.config/systemd/user/
# systemctl --user daemon-reload && systemctl --user enable --now meteo-collecte.timer
# (pour tourner sans session ouverte : « loginctl enable-linger <utilisateur> », qui peut demander sudo)
# [À VÉRIFIER] : emplacement réel du code sur le VPS, chemin de python3, linger déjà actif ou non,
# arrêt de meteo-direct.timer avant activation (sinon deux collecteurs comptent le même quota).
[Unit]
Description=meteo-collecte : un tick (ROMMA, Infoclimat, publication des fichiers statiques)
After=network-online.target
Wants=network-online.target
[Service]
Type=oneshot
WorkingDirectory=%h/meteo-collecte/code
# Secrets : variables d'environnement seulement (MC_JETON_INFOCLIMAT, MC_CLE_ROMMA), dans un fichier
# créé à la main par Théo, droits 600, hors du dépôt. Format : une ligne NOM=valeur par secret.
# Le « - » rend le fichier facultatif : sans lui, aucun appel n'est fait (la publication continue).
EnvironmentFile=-%h/meteo-collecte/.secrets/env
Environment=MC_BASE=%h/meteo-collecte
Environment=MC_QUOTA_COMMUN=%h/gws-collecte/quota.json
# Alerte ntfy : désactivée tant que Théo ne l'a pas décidé.
Environment=MC_ALERTE_ACTIVE=0
ExecStart=/usr/bin/python3 -m meteo_collecte.ordonnanceur
TimeoutStartSec=4min
Nice=10
# Durcissement léger compatible avec une unité utilisateur
NoNewPrivileges=yes
PrivateTmp=yes
UMask=0022
# Unité UTILISATEUR (systemd --user) pour le VPS. Installée par deploy/deployer-vps.sh (sans activation).
# Un tick par déclenchement du minuteur meteo-collecte.timer (hh:x4 et hh:x9).
#
# Secrets : uniquement dans %h/.config/meteo-collecte/env (droits 600, créé vide par le script ;
# rempli à la main par Théo, nom=valeur, jamais dans ce fichier ni dans le dépôt).
# Sans valeur, aucun appel n'est fait (sans_jeton / sans_cle) et la publication continue.
[Unit]
Description=meteo-collecte : un tick (ROMMA, Infoclimat, publication des fichiers statiques)
After=network-online.target
Wants=network-online.target
[Service]
Type=oneshot
WorkingDirectory=%h/meteo-collecte
EnvironmentFile=%h/.config/meteo-collecte/env
Environment=MC_BASE=%h/meteo-collecte
# Publication dans le dossier du collecteur, puis copie des seuls fichiers ordinaires vers MC_SERVI (lu par Caddy,
# qui ne sert que /data). Aucun lien symbolique n'est copié (publier.copier_vers_servi).
Environment=MC_PUBLIC=%h/meteo-collecte/public
Environment=MC_SERVI=/srv/weather.gastinel.me
Environment=MC_QUOTA_COMMUN=%h/gws-collecte/quota.json
# Ancien format direct.json, écrit à côté (PAS à la place de ~/meteo-direct/direct.json, lu par cornafserver).
Environment=MC_DIRECT_COMPAT=%h/meteo-collecte/direct-compat.json
# Alerte ntfy : désactivée tant que Théo ne l'a pas décidé.
Environment=MC_ALERTE_ACTIVE=0
ExecStart=/usr/bin/python3 -m meteo_collecte.ordonnanceur
TimeoutStartSec=4min
Nice=10
NoNewPrivileges=yes
PrivateTmp=yes
UMask=0022
+1 -1
Voir le fichier
@@ -1,4 +1,4 @@
# EXEMPLE — non installé. Tick toutes les 5 min à hh:x4 et hh:x9 :
# Minuteur utilisateur : tick toutes les 5 min à hh:x4 et hh:x9 (installé par deploy/deployer-vps.sh, NON activé).
# hh:x4 = passage principal Infoclimat (+ ROMMA si 10 min écoulées), hh:x9 = rattrapage ciblé.
[Unit]
+53
Voir le fichier
@@ -0,0 +1,53 @@
#!/bin/bash
# Caddy pour weather.gastinel.me : sert en LECTURE SEULE /data/* depuis /srv/weather.gastinel.me (JSON publiés
# par meteo-collecte), avec CORS pour le site LAN. Tout le reste : 404.
# Ajoute un bloc en fin de /etc/caddy/Caddyfile. Sauvegarde -> validation -> rechargement ; retour arrière si échec.
# Installation (root:root 755, après vérification du sha256 affiché par deployer-vps.sh) :
# sudo install -o root -g root -m 755 appliquer-caddy-meteo.sh /usr/local/sbin/appliquer-caddy-meteo.sh
# Usage : sudo /usr/local/sbin/appliquer-caddy-meteo.sh
set -euo pipefail
[ "$(id -u)" = 0 ] || { echo "A lancer avec sudo"; exit 1; }
CF=/etc/caddy/Caddyfile
BAK="$CF.avant-meteo-1017"
DOSSIER=/srv/weather.gastinel.me
PROPRIO=${SUDO_USER:-debian}
[ -e "$BAK" ] && { echo "Refus : $BAK existe deja (sauvegarde precedente conservee)."; exit 1; }
grep -q "weather.gastinel.me" "$CF" && { echo "Refus : weather.gastinel.me est deja dans le Caddyfile."; exit 1; }
# Dossier servi : copie de fichiers ordinaires faite par le collecteur (MC_SERVI, publier.copier_vers_servi) ;
# il n'est jamais le dossier de publication. Les liens symboliques y sont refusés (ni ce script ni Caddy ne les suivent).
[ -L "$DOSSIER" ] && { echo "Refus : $DOSSIER est un lien symbolique."; exit 1; }
install -d -m 755 -o "$PROPRIO" -g "$PROPRIO" "$DOSSIER"
echo "Dossier : $DOSSIER (proprietaire $PROPRIO)"
cp -a "$CF" "$BAK"
echo "Sauvegarde : $BAK"
cat >> "$CF" <<'CADDY'
# meteo-collecte (weather.gastinel.me) : donnees publiees, lecture seule.
weather.gastinel.me {
import /etc/caddy/securite.caddy
handle /data/* {
header Access-Control-Allow-Origin "*"
header Cache-Control "no-cache"
root * /srv/weather.gastinel.me
file_server
}
handle {
respond "Pas encore en ligne." 404
}
}
CADDY
if caddy validate --config "$CF" --adapter caddyfile && systemctl reload caddy; then
echo "OK : Caddy recharge."
if sudo -u caddy test -r "$DOSSIER" ; then echo "Caddy peut lire $DOSSIER."; else echo "ATTENTION : Caddy ne peut pas lire $DOSSIER."; fi
else
echo "ECHEC : restauration de $BAK"
cp -a "$BAK" "$CF"
systemctl reload caddy || true
exit 1
fi
+115
Voir le fichier
@@ -0,0 +1,115 @@
#!/usr/bin/env bash
# Déploiement de meteo-collecte sur le VPS cornafsuisse (utilisateur debian). Aucun appel API, aucun secret lu ni affiché.
#
# bash deploy/deployer-vps.sh copie le code, installe les unités (NON activées), --config et --publier de contrôle
# bash deploy/deployer-vps.sh --activer active meteo-collecte.timer, seulement si toutes les conditions sont réunies
#
# Lancé depuis le PC (ssh cornafsuisse) ou sur le VPS lui-même (détecté par le nom d'hôte).
# Sans sudo. Tout fichier existant remplacé est sauvegardé en <nom>.avant-deploiement-1017 (jamais écrasé).
# Les noms de fichiers ne sont jamais interpolés dans une commande distante : la liste passe en données NUL.
set -euo pipefail
HOTE_VPS=${HOTE_VPS:-cornafsuisse}
NOM_VPS=ov-edfba0
HORODATAGE=1017
ICI=$(cd "$(dirname "$0")/.." && pwd)
ACTIVER=0
[ "${1:-}" = "--activer" ] && ACTIVER=1
if [ "$(hostname)" = "$NOM_VPS" ]; then
vps() { bash -c "$1"; }
else
vps() { ssh -o BatchMode=yes -o ConnectTimeout=20 "$HOTE_VPS" "$1"; }
fi
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' EXIT
cd "$ICI"
if [ -n "$(git status --porcelain -- meteo_collecte config deploiement deploy)" ]; then
echo "ATTENTION : modifications non commitées ; le VPS recevra l'arbre de travail tel quel."
fi
echo "== 1. Liste des fichiers de code (séparateur NUL)"
find meteo_collecte config -type f ! -path '*/__pycache__/*' ! -name '*.pyc' -print0 | sort -z > "$TMP/liste0"
tr -cd '\0' < "$TMP/liste0" | wc -c
echo "== 2. Sauvegardes de ce qui sera remplacé (.avant-deploiement-$HORODATAGE)"
# Le script distant est fixe (guillemets simples) ; les noms arrivent sur stdin, séparés par NUL.
vps 'C="$HOME/meteo-collecte"; U="$HOME/.config/systemd/user"; H=1017
bak() { if [ -e "$1" ] && [ ! -e "$1.avant-deploiement-'"$HORODATAGE"'" ]; then cp -p -- "$1" "$1.avant-deploiement-'"$HORODATAGE"'"; echo "sauvegarde : $1"; fi; }
while IFS= read -r -d "" f; do bak "$C/$f"; done
bak "$U/meteo-collecte.service"; bak "$U/meteo-collecte.timer"; echo "sauvegardes terminees"' < "$TMP/liste0"
echo "== 3. Copie du code dans ~/meteo-collecte (var/ et public/ ne sont jamais touchés)"
vps 'mkdir -p "$HOME/meteo-collecte"'
tar -C "$ICI" -cf - --exclude='__pycache__' --exclude='*.pyc' meteo_collecte config \
| vps 'tar -C "$HOME/meteo-collecte" -xf -'
echo "== 4. Unités systemd utilisateur (installées, non activées)"
vps 'mkdir -p "$HOME/.config/systemd/user" && cat > "$HOME/.config/systemd/user/meteo-collecte.service"' \
< "$ICI/deploiement/meteo-collecte.service"
vps 'cat > "$HOME/.config/systemd/user/meteo-collecte.timer"' < "$ICI/deploiement/meteo-collecte.timer"
vps 'systemctl --user daemon-reload'
echo "== 5. Fichier de secrets : créé VIDE s'il n'existe pas (contenu jamais affiché)"
vps 'mkdir -p -m 700 "$HOME/.config/meteo-collecte"
E="$HOME/.config/meteo-collecte/env"
if [ ! -e "$E" ]; then (umask 077 && : > "$E"); echo "env cree (vide)"; else echo "env deja present"; fi
chmod 600 "$E"; echo "droits : $(stat -c %a "$E") taille : $(stat -c %s "$E") octets"'
echo "== 6. Script Caddy : copié dans deploy/ (dossier du collecteur, PAS dans ~), à installer en root par Théo"
vps 'mkdir -p "$HOME/meteo-collecte/deploy"'
vps 'cat > "$HOME/meteo-collecte/deploy/appliquer-caddy-meteo.sh"' < "$ICI/deploy/appliquer-caddy-meteo.sh"
SHA=$(sha256sum "$ICI/deploy/appliquer-caddy-meteo.sh" | cut -d' ' -f1)
echo "sha256 attendu : $SHA"
echo "Théo, sur le VPS, vérifier puis installer en root (la commande refuse si le hash diffère) :"
echo " cd ~/meteo-collecte/deploy && echo \"$SHA appliquer-caddy-meteo.sh\" | sha256sum -c - && \\"
echo " sudo install -o root -g root -m 755 appliquer-caddy-meteo.sh /usr/local/sbin/appliquer-caddy-meteo.sh"
echo " sudo /usr/local/sbin/appliquer-caddy-meteo.sh"
echo "== 7. Contrôle --config (noms de variables et « définie / absente » seulement)"
vps 'systemd-run --user --wait --pipe --quiet \
-p WorkingDirectory="$HOME/meteo-collecte" \
-p EnvironmentFile="$HOME/.config/meteo-collecte/env" \
-p Environment=MC_BASE="$HOME/meteo-collecte" \
-p Environment=MC_PUBLIC="$HOME/meteo-collecte/public" \
-p Environment=MC_SERVI= \
-p Environment=MC_DIRECT_COMPAT="$HOME/meteo-collecte/direct-compat.json" \
/usr/bin/python3 -m meteo_collecte.ordonnanceur --config' \
|| echo "ATTENTION : --config non obtenu (systemd-run --user indisponible ?)"
echo "== 8. Contrôle --publier (aucun appel réseau ; écrit dans ~/meteo-collecte/public ; MC_SERVI vide, donc"
echo " rien dans /srv ; MC_DIRECT_COMPAT vide, donc ~/meteo-direct/direct.json n'est jamais touché)"
vps 'cd "$HOME/meteo-collecte" && env -i HOME="$HOME" PATH="$PATH" MC_BASE="$HOME/meteo-collecte" \
MC_PUBLIC="$HOME/meteo-collecte/public" MC_SERVI= MC_DIRECT_COMPAT= /usr/bin/python3 -m meteo_collecte.ordonnanceur --publier \
&& ls -l "$HOME/meteo-collecte/public/data"'
if [ "$ACTIVER" = 0 ]; then
echo
echo "Minuteur NON active. Étapes suivantes : voir rapport-deploiement-meteo-collecte-20261017.md (dossier NOTES)."
echo "Activation, une fois le jeton saisi, le script Caddy installé et linger actif : bash deploy/deployer-vps.sh --activer"
exit 0
fi
echo "== 9. Activation (conditions vérifiées sur le VPS avant)"
vps 'bash -s' <<'DISTANT'
set -eu
ok=1
if [ "$(loginctl show-user "$USER" -p Linger --value 2>/dev/null)" != "yes" ]; then
echo "REFUS : linger desactive. Sans lui le minuteur s'arrete a la fin de la session SSH."
echo " Theo, sur le VPS : sudo loginctl enable-linger debian"; ok=0
fi
if [ ! -d /srv/weather.gastinel.me ] || [ -L /srv/weather.gastinel.me ] || [ ! -w /srv/weather.gastinel.me ]; then
echo "REFUS : /srv/weather.gastinel.me absent, lien, ou non accessible en ecriture."
echo " Theo, sur le VPS : sudo /usr/local/sbin/appliquer-caddy-meteo.sh (voir l'etape 6)"; ok=0
fi
if systemctl is-active --quiet meteo-direct.timer; then
echo "REFUS : meteo-direct.timer est actif (deux collecteurs compteraient le meme quota)."
echo " Theo, sur le VPS : sudo systemctl stop meteo-direct.timer (puis decider de sa desactivation)"; ok=0
fi
[ "$ok" = 1 ] || exit 1
systemctl --user daemon-reload
systemctl --user enable --now meteo-collecte.timer
systemctl --user list-timers meteo-collecte.timer --no-pager
DISTANT
+251 -241
Voir le fichier
@@ -1,241 +1,251 @@
"""Outils communs : configuration, heure de Paris, JSON atomique, journal, verrou, masquage des secrets.
Aucun chemin, nom de serveur ni secret n'est écrit en dur : tout vient de variables d'environnement
(voir `Config.depuis_env`) avec des valeurs par défaut relatives au dossier personnel.
"""
import datetime as dt
import json
import os
import re
import urllib.parse
from dataclasses import dataclass, field
from pathlib import Path
try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows
import fcntl
except ImportError: # pragma: no cover
fcntl = None
UTC = dt.timezone.utc
# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
@dataclass
class Config:
base: Path # état, journal, base SQLite
public: Path # racine servie par Caddy (on écrit dans public/data/)
quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct
stations: Path # liste des stations Infoclimat suivies (JSON)
plafond_commun: int = 4999 # même plafond que le collecteur (décision du 29/09)
plafond_site: int = 1000 # plafond propre au site (décision du 16/10)
seuil_alerte: float = 0.80
alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé
ntfy_url: str = ""
compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4)
lot_max: int = 25
garder_jours: int = 14
fiche_heures: int = 48
romma_actif: bool = True
infoclimat_actif: bool = True
direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN)
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
var_cle_romma: str = "MC_CLE_ROMMA"
env: object = field(default=None, repr=False)
def secret(self, nom_variable):
"""Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide."""
e = os.environ if self.env is None else self.env
v = (e.get(nom_variable) or "").strip()
if not v:
raise LookupError("variable %s absente ou vide" % nom_variable)
return v
@classmethod
def depuis_env(cls, env=None):
e = os.environ if env is None else env
home = Path.home()
base = Path(e.get("MC_BASE") or home / "meteo-collecte")
def chemin(nom, defaut):
return Path(e[nom]) if e.get(nom) else defaut
def oui(nom, defaut):
v = e.get(nom)
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
return cls(
base=base,
public=chemin("MC_PUBLIC", base / "public"),
quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"),
stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"),
plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)),
plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)),
alerte_active=oui("MC_ALERTE_ACTIVE", False),
ntfy_url=e.get("MC_NTFY_URL", ""),
compte_par_station=oui("MC_COMPTE_PAR_STATION", False),
lot_max=int(e.get("MC_LOT_MAX", 25)),
romma_actif=oui("MC_ROMMA_ACTIF", True),
infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True),
direct_compat=chemin("MC_DIRECT_COMPAT", None),
env=env,
)
# ---------------------------------------------------------------------------
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
# ---------------------------------------------------------------------------
def _dernier_dimanche(annee, mois):
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
def decalage_paris(utc):
"""Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST)."""
a = utc.year
debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC)
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC)
return dt.timedelta(hours=2 if debut <= utc < fin else 1)
def vers_paris(utc):
return (utc + decalage_paris(utc)).replace(tzinfo=None)
def paris_vers_utc(local, maintenant=None):
"""Heure locale de Paris (naïve) -> instant UTC.
None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus
récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
"""
possibles = []
for h in (2, 1):
c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC)
if (c + decalage_paris(c)).replace(tzinfo=None) == local:
possibles.append(c)
if not possibles:
return None
if len(possibles) == 1 or maintenant is None:
return possibles[0]
passes = [c for c in possibles if c <= maintenant]
return max(passes) if passes else min(possibles)
def jour_paris(utc):
return str(vers_paris(utc).date())
def fmt_utc(t):
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
def lire_utc(s):
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
def iso(t):
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
# ---------------------------------------------------------------------------
# Fichiers
# ---------------------------------------------------------------------------
def lire_json(p, defaut):
try:
return json.loads(Path(p).read_text(encoding="utf-8"))
except (OSError, ValueError):
return defaut
def ecrire_json(p, d, compact=True):
"""Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
p = Path(p)
p.parent.mkdir(parents=True, exist_ok=True)
tmp = p.with_name(p.name + ".tmp-%d" % os.getpid())
texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None,
indent=None if compact else 1)
tmp.write_text(texte, encoding="utf-8")
os.replace(tmp, p)
def scrub(texte, *secrets):
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
for s in secrets:
if s:
texte = texte.replace(s, "***")
enc = urllib.parse.quote(s, safe="")
if enc != s:
texte = texte.replace(enc, "***")
return texte
class Journal:
"""Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.secrets = []
def masquer(self, *secrets):
self.secrets.extend(s for s in secrets if s)
def __call__(self, msg, maintenant=None):
t = maintenant or dt.datetime.now(UTC)
self.fichier.parent.mkdir(parents=True, exist_ok=True)
with open(self.fichier, "a", encoding="utf-8") as f:
f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n")
class Verrou:
"""Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.f = None
def __enter__(self):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.f = open(self.fichier, "w")
if fcntl is not None:
try:
fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError:
self.f.close()
self.f = None
return False
return True
def __exit__(self, *a):
if self.f:
self.f.close()
class Pause:
"""Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
def __init__(self, fichier, duree_s=15 * 60):
self.fichier = Path(fichier)
self.duree_s = duree_s
def active(self, maintenant):
try:
return float(self.fichier.read_text()) > maintenant.timestamp()
except (OSError, ValueError):
return False
def jusqua(self):
try:
return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC)
except (OSError, ValueError):
return None
def poser(self, maintenant):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.fichier.write_text(str(maintenant.timestamp() + self.duree_s))
"""Outils communs : configuration, heure de Paris, JSON atomique, journal, verrou, masquage des secrets.
Aucun chemin, nom de serveur ni secret n'est écrit en dur : tout vient de variables d'environnement
(voir `Config.depuis_env`) avec des valeurs par défaut relatives au dossier personnel.
"""
import datetime as dt
import json
import os
import re
import urllib.parse
from dataclasses import dataclass, field
from pathlib import Path
try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows
import fcntl
except ImportError: # pragma: no cover
fcntl = None
UTC = dt.timezone.utc
# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
@dataclass
class Config:
base: Path # état, journal, base SQLite
public: Path # racine servie par Caddy (on écrit dans public/data/)
quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct
stations: Path # liste des stations Infoclimat suivies (JSON)
plafond_commun: int = 4999 # même plafond que le collecteur (décision du 29/09)
plafond_site: int = 1000 # plafond propre au site (décision du 16/10)
seuil_alerte: float = 0.80
alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé
ntfy_url: str = ""
compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4)
lot_max: int = 25
garder_jours: int = 14
fiche_heures: int = 48
romma_actif: bool = True
infoclimat_actif: bool = True
direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN)
servi: Path = None # si défini : copie des seuls fichiers réguliers de public/data/ (voir publier.py)
journal_relais: Path = None # journal des appels GWS via le relais SSH (None = désactivé)
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
var_cle_romma: str = "MC_CLE_ROMMA"
env: object = field(default=None, repr=False)
def secret(self, nom_variable):
"""Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide."""
e = os.environ if self.env is None else self.env
v = (e.get(nom_variable) or "").strip()
if not v:
raise LookupError("variable %s absente ou vide" % nom_variable)
return v
@classmethod
def depuis_env(cls, env=None):
e = os.environ if env is None else env
home = Path.home()
base = Path(e.get("MC_BASE") or home / "meteo-collecte")
def chemin(nom, defaut):
return Path(e[nom]) if e.get(nom) else defaut
def oui(nom, defaut):
v = e.get(nom)
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
# Variable présente mais vide = désactivé ; absente = défaut.
if "MC_JOURNAL_RELAIS" in e:
journal_relais = Path(e["MC_JOURNAL_RELAIS"]) if (e["MC_JOURNAL_RELAIS"] or "").strip() else None
else:
journal_relais = home / "gws-relais" / "journal" / "appels.log"
return cls(
base=base,
public=chemin("MC_PUBLIC", base / "public"),
quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"),
stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"),
plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)),
plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)),
alerte_active=oui("MC_ALERTE_ACTIVE", False),
ntfy_url=e.get("MC_NTFY_URL", ""),
compte_par_station=oui("MC_COMPTE_PAR_STATION", False),
lot_max=int(e.get("MC_LOT_MAX", 25)),
romma_actif=oui("MC_ROMMA_ACTIF", True),
infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True),
direct_compat=chemin("MC_DIRECT_COMPAT", None),
servi=chemin("MC_SERVI", None),
journal_relais=journal_relais,
env=env,
)
# ---------------------------------------------------------------------------
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
# ---------------------------------------------------------------------------
def _dernier_dimanche(annee, mois):
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
def decalage_paris(utc):
"""Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST)."""
a = utc.year
debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC)
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC)
return dt.timedelta(hours=2 if debut <= utc < fin else 1)
def vers_paris(utc):
return (utc + decalage_paris(utc)).replace(tzinfo=None)
def paris_vers_utc(local, maintenant=None):
"""Heure locale de Paris (naïve) -> instant UTC.
None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus
récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
"""
possibles = []
for h in (2, 1):
c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC)
if (c + decalage_paris(c)).replace(tzinfo=None) == local:
possibles.append(c)
if not possibles:
return None
if len(possibles) == 1 or maintenant is None:
return possibles[0]
passes = [c for c in possibles if c <= maintenant]
return max(passes) if passes else min(possibles)
def jour_paris(utc):
return str(vers_paris(utc).date())
def fmt_utc(t):
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
def lire_utc(s):
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
def iso(t):
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
# ---------------------------------------------------------------------------
# Fichiers
# ---------------------------------------------------------------------------
def lire_json(p, defaut):
try:
return json.loads(Path(p).read_text(encoding="utf-8"))
except (OSError, ValueError):
return defaut
def ecrire_json(p, d, compact=True):
"""Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
p = Path(p)
p.parent.mkdir(parents=True, exist_ok=True)
tmp = p.with_name(p.name + ".tmp-%d" % os.getpid())
texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None,
indent=None if compact else 1)
tmp.write_text(texte, encoding="utf-8")
os.replace(tmp, p)
def scrub(texte, *secrets):
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
for s in secrets:
if s:
texte = texte.replace(s, "***")
enc = urllib.parse.quote(s, safe="")
if enc != s:
texte = texte.replace(enc, "***")
return texte
class Journal:
"""Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.secrets = []
def masquer(self, *secrets):
self.secrets.extend(s for s in secrets if s)
def __call__(self, msg, maintenant=None):
t = maintenant or dt.datetime.now(UTC)
self.fichier.parent.mkdir(parents=True, exist_ok=True)
with open(self.fichier, "a", encoding="utf-8") as f:
f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n")
class Verrou:
"""Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
def __init__(self, fichier):
self.fichier = Path(fichier)
self.f = None
def __enter__(self):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.f = open(self.fichier, "w")
if fcntl is not None:
try:
fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError:
self.f.close()
self.f = None
return False
return True
def __exit__(self, *a):
if self.f:
self.f.close()
class Pause:
"""Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
def __init__(self, fichier, duree_s=15 * 60):
self.fichier = Path(fichier)
self.duree_s = duree_s
def active(self, maintenant):
try:
return float(self.fichier.read_text()) > maintenant.timestamp()
except (OSError, ValueError):
return False
def jusqua(self):
try:
return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC)
except (OSError, ValueError):
return None
def poser(self, maintenant):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.fichier.write_text(str(maintenant.timestamp() + self.duree_s))
+61 -4
Voir le fichier
@@ -8,7 +8,7 @@
6. Cache serveur : les visiteurs lisent les fichiers publiés, jamais l'API.
Garde-fous : verrou (ordonnanceur), statut vérifié même en HTTP 200, pause 15 min sur toute erreur,
quota commun ~/gws-collecte/quota.json (plafond 4999, jour de Paris) + plafond propre au site (1000/jour,
quota commun ~/gws-collecte/quota.json + journal du relais GWS (MC_JOURNAL_RELAIS) (plafond 4999, jour de Paris et 24 h) + plafond propre au site (1000/jour,
compté sur le jour de Paris ET sur 24 h glissantes), alerte à 80 % (envoi réel désactivé par défaut).
Le jeton est lu au moment de l'appel, n'est jamais écrit, et est masqué dans tout message.
"""
@@ -44,6 +44,9 @@ class ErreurInfoclimat(Exception):
# Quota
# ---------------------------------------------------------------------------
LECTURE_JOURNAL_MAX = 4_000_000 # octets lus en fin de journal du relais (le journal est en ajout seul)
class Quota:
"""Deux compteurs : le commun (même format que direct.py et le collecteur GWS) et celui du site."""
@@ -51,6 +54,7 @@ class Quota:
self.cfg = cfg
self.journal = journal
self.fichier_site = cfg.base / "var" / "quota_site.json"
self._deja_signales = set()
self.envoyer_alerte = envoyer_alerte or (lambda texte: envoyer_ntfy(cfg, texte))
def _commun(self, maintenant):
@@ -69,15 +73,68 @@ class Quota:
s["horodatages"] = [t for t in s.get("horodatages", []) if t > limite]
return s
def _relais(self, maintenant):
"""(appels du jour de Paris, appels des 24 h glissantes) du journal du relais SSH de GWS.
Lignes `<secondes UTC> <id appareil> <couleur> <nom base64>` ; seules les secondes comptent. Ligne
invalide ou dans le futur (> 60 s) ignorée. Journal désactivé, absent ou illisible : (0, 0) et une ligne
de journal (une seule fois par message et par instance, pour ne pas inonder le journal).
"""
chemin = self.cfg.journal_relais
if not chemin:
return 0, 0
try:
with open(chemin, "rb") as f:
f.seek(0, 2)
taille = f.tell()
f.seek(max(0, taille - LECTURE_JOURNAL_MAX))
brut = f.read(LECTURE_JOURNAL_MAX)
except FileNotFoundError:
self._signaler("journal du relais absent (%s) : 0 appel compté" % chemin, maintenant)
return 0, 0
except Exception as e: # illisible : jamais de plantage
self._signaler("journal du relais illisible (%s) : 0 appel compté" % str(e)[:200], maintenant)
return 0, 0
now = maintenant.timestamp()
jour = jour_paris(maintenant)
n_jour = n_24h = 0
for ligne in brut.decode("utf-8", "replace").splitlines():
champs = ligne.split()
if len(champs) < 2:
continue
try:
ts = int(champs[0])
if ts <= 0 or ts > now + 60:
continue
dans_jour = jour_paris(dt.datetime.fromtimestamp(ts, UTC)) == jour
except (ValueError, OverflowError, OSError):
continue
n_jour += dans_jour
n_24h += ts > now - 86400
return n_jour, n_24h
def _signaler(self, msg, maintenant):
if msg not in self._deja_signales:
self._deja_signales.add(msg)
try:
self.journal(msg, maintenant)
except Exception:
pass
def etat(self, maintenant):
c, s = self._commun(maintenant), self._site(maintenant)
return {"commun_jour": c["requetes"], "plafond_commun": self.cfg.plafond_commun,
rj, r24 = self._relais(maintenant)
return {"commun_jour": c["requetes"], "relais_jour": rj, "relais_24h": r24,
"total_jour": c["requetes"] + rj, "plafond_commun": self.cfg.plafond_commun,
"site_jour": s["requetes"], "site_24h": len(s["horodatages"]), "plafond_site": self.cfg.plafond_site}
def peut(self, n, maintenant):
e = self.etat(maintenant)
return (e["commun_jour"] + n <= self.cfg.plafond_commun and e["site_jour"] + n <= self.cfg.plafond_site
and e["site_24h"] + n <= self.cfg.plafond_site)
# Jour de Paris : compteur commun + relais. 24 h glissantes : le commun n'est pas horodaté, on prend donc
# les appels horodatés connus (site + relais), sous-estimation possible des autres appels du collecteur.
return (e["total_jour"] + n <= self.cfg.plafond_commun
and e["site_24h"] + e["relais_24h"] + n <= self.cfg.plafond_commun
and e["site_jour"] + n <= self.cfg.plafond_site and e["site_24h"] + n <= self.cfg.plafond_site)
def noter(self, n, maintenant):
c = self._commun(maintenant)
+76 -74
Voir le fichier
@@ -1,74 +1,76 @@
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
Chaque source décide seule si elle appelle :
* ROMMA : au plus une requête global=1 toutes les 10 min ;
* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9.
Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche
ni l'autre source ni la publication.
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
"""
import datetime as dt
import sys
from . import infoclimat, publier, romma
from .commun import UTC, Config, Journal, Verrou, lire_json
from .stockage import Stockage
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
appels=True):
maintenant = maintenant or dt.datetime.now(UTC)
var = cfg.base / "var"
journal = Journal(var / "collecte.log")
with Verrou(var / ".collecte.lock") as obtenu:
if not obtenu:
return {"action": "verrou"} # un tick précédent tourne encore
stockage = Stockage(var / "mesures.sqlite")
resumes = {}
try:
if appels and cfg.romma_actif:
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
if appels and cfg.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
stockage.purger(maintenant, cfg.garder_jours)
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
finally:
stockage.fermer()
return resumes
def _sans_planter(journal, maintenant, nom, f):
try:
return f()
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
return {"source": nom, "action": "erreur_interne"}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
cfg = Config.depuis_env()
if "--config" in argv:
for k, v in vars(cfg).items():
if k == "env":
continue # l'environnement contient les secrets : jamais affiché
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
try:
cfg.secret(nom)
print("%-20s définie (valeur masquée)" % nom)
except LookupError:
print("%-20s absente" % nom)
return 0
tick(cfg, appels="--publier" not in argv)
return 0
if __name__ == "__main__":
sys.exit(main())
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
Chaque source décide seule si elle appelle :
* ROMMA : au plus une requête global=1 toutes les 10 min ;
* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9.
Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche
ni l'autre source ni la publication.
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
"""
import datetime as dt
import sys
from . import infoclimat, publier, romma
from .commun import UTC, Config, Journal, Verrou, lire_json
from .stockage import Stockage
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
appels=True):
maintenant = maintenant or dt.datetime.now(UTC)
var = cfg.base / "var"
journal = Journal(var / "collecte.log")
with Verrou(var / ".collecte.lock") as obtenu:
if not obtenu:
return {"action": "verrou"} # un tick précédent tourne encore
stockage = Stockage(var / "mesures.sqlite")
resumes = {}
try:
if appels and cfg.romma_actif:
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
if appels and cfg.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
stockage.purger(maintenant, cfg.garder_jours)
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
if cfg.servi:
resumes["servies"] = publier.copier_vers_servi(cfg.public, cfg.servi)
finally:
stockage.fermer()
return resumes
def _sans_planter(journal, maintenant, nom, f):
try:
return f()
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
return {"source": nom, "action": "erreur_interne"}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
cfg = Config.depuis_env()
if "--config" in argv:
for k, v in vars(cfg).items():
if k == "env":
continue # l'environnement contient les secrets : jamais affiché
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
try:
cfg.secret(nom)
print("%-20s définie (valeur masquée)" % nom)
except LookupError:
print("%-20s absente" % nom)
return 0
tick(cfg, appels="--publier" not in argv)
return 0
if __name__ == "__main__":
sys.exit(main())
+140 -96
Voir le fichier
@@ -1,96 +1,140 @@
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
* data/stations.json : index de toutes les stations avec leur dernière mesure ;
* data/station/<source>-<id>.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ;
* data/etat.json : heure de mise à jour par source, sources en pause.
Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage
(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers.
Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API.
"""
import datetime as dt
import re
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
from .stockage import CHAMPS
ATTRIBUTIONS = {
"infoclimat": "Données Infoclimat",
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
"interprétation.",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
}
def nom_fichier(source, station_id):
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
def _releve(r):
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
def _fiche(st):
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
def publier(cfg, stockage, maintenant, resumes=None):
data = cfg.public / "data"
index = []
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
for st in stockage.stations():
fiche = _fiche(st)
der = stockage.derniere(st["source"], st["station_id"])
if der:
fiche["derniere"] = _releve(der)
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
else:
fiche["derniere"], fiche["age_min"] = None, None
index.append(fiche)
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
ecrire_json(data / "station" / (fiche["id"] + ".json"),
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
if cfg.direct_compat:
publier_direct_compat(cfg, stockage, maintenant)
return len(index)
def etat(cfg, maintenant, resumes):
from .commun import Pause, lire_json
sources = {}
for src in ("infoclimat", "romma"):
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
succes = e.get("dernier_succes_utc")
sources[src] = {
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
"en_pause": p.active(maintenant),
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
"dernier_passage": (resumes.get(src) or {}).get("action"),
}
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
def publier_direct_compat(cfg, stockage, maintenant):
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
depuis = maintenant - dt.timedelta(hours=48)
stations, meta = {}, {}
for st in stockage.stations():
if st["source"] != "infoclimat":
continue
rel = []
for r in stockage.serie("infoclimat", st["station_id"], depuis):
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
x["pluie_cumul_0h"] = r.get("pluie_cumul")
rel.append(x)
stations[st["station_id"]] = {"nom": st["nom"], "releves": rel}
meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"],
"licence": st["licence"] or ""}
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations})
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
* data/stations.json : index de toutes les stations avec leur dernière mesure ;
* data/station/<source>-<id>.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ;
* data/etat.json : heure de mise à jour par source, sources en pause.
Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage
(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers.
Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API.
"""
import datetime as dt
import os
import re
import stat
from pathlib import Path
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
from .stockage import CHAMPS
ATTRIBUTIONS = {
"infoclimat": "Données Infoclimat",
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
"interprétation.",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
}
def nom_fichier(source, station_id):
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
def _releve(r):
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
def _fiche(st):
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
def publier(cfg, stockage, maintenant, resumes=None):
data = cfg.public / "data"
index = []
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
for st in stockage.stations():
fiche = _fiche(st)
der = stockage.derniere(st["source"], st["station_id"])
if der:
fiche["derniere"] = _releve(der)
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
else:
fiche["derniere"], fiche["age_min"] = None, None
index.append(fiche)
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
ecrire_json(data / "station" / (fiche["id"] + ".json"),
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
if cfg.direct_compat:
publier_direct_compat(cfg, stockage, maintenant)
return len(index)
def etat(cfg, maintenant, resumes):
from .commun import Pause, lire_json
sources = {}
for src in ("infoclimat", "romma"):
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
succes = e.get("dernier_succes_utc")
sources[src] = {
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
"en_pause": p.active(maintenant),
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
"dernier_passage": (resumes.get(src) or {}).get("action"),
}
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
def publier_direct_compat(cfg, stockage, maintenant):
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
depuis = maintenant - dt.timedelta(hours=48)
stations, meta = {}, {}
for st in stockage.stations():
if st["source"] != "infoclimat":
continue
rel = []
for r in stockage.serie("infoclimat", st["station_id"], depuis):
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
x["pluie_cumul_0h"] = r.get("pluie_cumul")
rel.append(x)
stations[st["station_id"]] = {"nom": st["nom"], "releves": rel}
meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"],
"licence": st["licence"] or ""}
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations})
def copier_vers_servi(src, dst):
"""Copie data/ de `src` vers `dst` (dossier lu par Caddy, lecture seule côté serveur).
Seuls les fichiers ordinaires sont copiés : tout lien symbolique dans la source fait échouer la copie
(ValueError, rien de copié pour ce fichier). Dans la destination, un lien est remplacé, jamais suivi :
écriture dans un fichier temporaire créé avec O_EXCL|O_NOFOLLOW, puis os.replace (atomique).
Renvoie le nombre de fichiers copiés."""
src, dst = Path(src), Path(dst)
racine = src / "data"
dst.mkdir(parents=True, exist_ok=True)
n = 0
for f in sorted(racine.rglob("*")):
st = os.lstat(f)
if stat.S_ISLNK(st.st_mode):
raise ValueError("lien symbolique refusé dans la source : %s" % f.name)
if not stat.S_ISREG(st.st_mode):
continue
rel = f.relative_to(src)
cible_dir = dst
for morceau in rel.parts[:-1]:
cible_dir = cible_dir / morceau
if cible_dir.is_symlink():
raise ValueError("lien symbolique refusé dans la destination : %s" % cible_dir.name)
cible_dir.mkdir(exist_ok=True)
cible = cible_dir / rel.parts[-1]
tmp = cible_dir / (rel.parts[-1] + ".tmp")
if tmp.is_symlink() or tmp.exists():
tmp.unlink() # supprime l'entrée (un lien n'est jamais suivi)
fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o644)
try:
with os.fdopen(fd, "wb") as out, open(f, "rb") as entree:
out.write(entree.read())
except BaseException:
if tmp.exists() or tmp.is_symlink():
tmp.unlink()
raise
os.replace(str(tmp), str(cible)) # remplace aussi un lien existant, sans le suivre
n += 1
return n
+1
Voir le fichier
@@ -17,6 +17,7 @@ def config(dossier, **kw):
d = Path(dossier)
# Environnement simulé (dictionnaire) : les valeurs fictives ne sont jamais écrites sur disque.
env = {"MC_BASE": str(d), "MC_QUOTA_COMMUN": str(d / "quota.json"),
"MC_JOURNAL_RELAIS": "",
"MC_JETON_INFOCLIMAT": JETON_FICTIF, "MC_CLE_ROMMA": CLE_FICTIVE}
cfg = Config.depuis_env(env)
for k, v in kw.items():
+35 -34
Voir le fichier
@@ -1,34 +1,35 @@
"""Contrôles statiques des fichiers systemd d'exemple (pas de systemd sous Windows : rien n'est installé)."""
import datetime as dt
import re
import unittest
from pathlib import Path
from meteo_collecte.infoclimat import type_passage
from tests.aide import t
DOSSIER = Path(__file__).resolve().parent.parent / "deploiement"
class TestUnites(unittest.TestCase):
def test_minuteur_aligne_sur_les_passages(self):
texte = (DOSSIER / "meteo-collecte.timer").read_text(encoding="utf-8")
m = re.search(r"^OnCalendar=\*:(\d\d)/(\d+)$", texte, re.M)
self.assertIsNotNone(m)
depart, pas = int(m.group(1)), int(m.group(2))
minutes = list(range(depart, 60, pas))
self.assertEqual(minutes, [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59])
genres = [type_passage(t(12, 0) + dt.timedelta(minutes=x)) for x in minutes]
self.assertEqual(genres, ["principal", "rattrapage"] * 6)
def test_service_sans_secret_ni_sudo(self):
texte = (DOSSIER / "meteo-collecte.service").read_text(encoding="utf-8")
actif = [l for l in texte.splitlines() if l and not l.startswith("#")]
self.assertTrue(any(l.startswith("ExecStart=") and "meteo_collecte.ordonnanceur" in l for l in actif))
for l in actif:
self.assertNotRegex(l, r"(?i)MC_JETON_INFOCLIMAT=|MC_CLE_ROMMA=|token=|apikey=|sudo")
self.assertIn("EnvironmentFile=-", texte)
if __name__ == "__main__":
unittest.main()
"""Contrôles statiques des fichiers systemd d'exemple (pas de systemd sous Windows : rien n'est installé)."""
import datetime as dt
import re
import unittest
from pathlib import Path
from meteo_collecte.infoclimat import type_passage
from tests.aide import t
DOSSIER = Path(__file__).resolve().parent.parent / "deploiement"
class TestUnites(unittest.TestCase):
def test_minuteur_aligne_sur_les_passages(self):
texte = (DOSSIER / "meteo-collecte.timer").read_text(encoding="utf-8")
m = re.search(r"^OnCalendar=\*:(\d\d)/(\d+)$", texte, re.M)
self.assertIsNotNone(m)
depart, pas = int(m.group(1)), int(m.group(2))
minutes = list(range(depart, 60, pas))
self.assertEqual(minutes, [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59])
genres = [type_passage(t(12, 0) + dt.timedelta(minutes=x)) for x in minutes]
self.assertEqual(genres, ["principal", "rattrapage"] * 6)
def test_service_sans_secret_ni_sudo(self):
texte = (DOSSIER / "meteo-collecte.service").read_text(encoding="utf-8")
actif = [l for l in texte.splitlines() if l and not l.startswith("#")]
self.assertTrue(any(l.startswith("ExecStart=") and "meteo_collecte.ordonnanceur" in l for l in actif))
for l in actif:
self.assertNotRegex(l, r"(?i)MC_JETON_INFOCLIMAT=|MC_CLE_ROMMA=|token=|apikey=|sudo")
self.assertIn("EnvironmentFile=%h/.config/meteo-collecte/env", texte)
self.assertNotIn("EnvironmentFile=-", texte)
if __name__ == "__main__":
unittest.main()
+120
Voir le fichier
@@ -0,0 +1,120 @@
"""Quota : appels GWS via le relais SSH (journal `~/gws-relais/journal/appels.log`). Hors ligne, fichiers temporaires."""
import tempfile
import unittest
from pathlib import Path
from meteo_collecte import infoclimat as ic
from meteo_collecte.commun import Config, ecrire_json
from tests.aide import config, t
MAINTENANT = t(12, 0, jour=18) # 18/10/2026 12:00 UTC = 14:00 Paris (CEST)
MINUIT_PARIS = t(22, 0, jour=17) # 18/10 00:00 Paris
NOM = "TWFjIGRlIFRoZW8="
def ligne(ts, ident="a1b2c3d4e5f60718", couleur=3):
return "%d %s %d %s" % (int(ts.timestamp()), ident, couleur, NOM)
class TestQuotaRelais(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.cfg, self.journal = config(self.tmp.name)
self.fichier = Path(self.tmp.name) / "appels.log"
self.cfg.journal_relais = self.fichier
def tearDown(self):
self.tmp.cleanup()
def ecrire(self, *lignes):
self.fichier.write_text("\n".join(lignes) + "\n", encoding="utf-8")
def texte_journal(self):
f = self.cfg.base / "var" / "journal.log"
return f.read_text(encoding="utf-8") if f.exists() else ""
def etat(self):
return ic.Quota(self.cfg, self.journal).etat(MAINTENANT)
def test_defaut_et_desactivation_de_la_config(self):
d = Config.depuis_env({"MC_BASE": self.tmp.name})
self.assertEqual(d.journal_relais, Path.home() / "gws-relais" / "journal" / "appels.log")
self.assertIsNone(Config.depuis_env({"MC_BASE": self.tmp.name, "MC_JOURNAL_RELAIS": ""}).journal_relais)
self.assertEqual(Config.depuis_env({"MC_JOURNAL_RELAIS": "/x/y.log"}).journal_relais, Path("/x/y.log"))
def test_journal_absent(self):
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"], e["total_jour"]), (0, 0, 0))
self.assertIn("absent", self.texte_journal())
def test_desactive_aucune_lecture_ni_message(self):
self.ecrire(ligne(t(11, 0, jour=18)))
self.cfg.journal_relais = None
self.assertEqual(self.etat()["relais_jour"], 0)
self.assertEqual(self.texte_journal(), "")
def test_journal_vide(self):
self.fichier.write_text("", encoding="utf-8")
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 0))
def test_journal_illisible(self):
self.cfg.journal_relais = Path(self.tmp.name) # un dossier : l'ouverture échoue
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 0))
self.assertIn("illisible", self.texte_journal())
def test_lignes_invalides_ignorees(self):
self.ecrire("", "n'importe quoi", "abc def 1 x", "-5 id 1 x", "99999999999999999999 id 1 x",
"1.5e9 id 1 x", "seul", ligne(t(11, 0, jour=18)))
self.fichier.write_bytes(self.fichier.read_bytes() + b"\xff\xfe\x00 garbage\n")
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (1, 1))
def test_hier_et_aujourd_hui(self):
self.ecrire(ligne(t(10, 0, jour=16)), # 2 jours avant : hors jour, hors 24 h
ligne(t(21, 59, jour=17)), # 17/10 23:59 Paris : hier, dans les 24 h
ligne(MINUIT_PARIS), # 18/10 00:00 Paris : aujourd'hui
ligne(t(11, 59, jour=18), ident="admin", couleur=0),
ligne(t(12, 5, jour=18))) # futur (> 60 s) : ignoré
e = self.etat()
self.assertEqual(e["relais_jour"], 2)
self.assertEqual(e["relais_24h"], 3)
def test_borne_24h(self):
self.ecrire(ligne(t(12, 0, jour=17)), # exactement 24 h avant : exclu
ligne(t(12, 1, jour=17)))
self.assertEqual(self.etat()["relais_24h"], 1)
def test_total_additionne_le_compteur_commun(self):
ecrire_json(self.cfg.quota_commun, {"date": "2026-10-18", "requetes": 100}, compact=False)
self.ecrire(*[ligne(t(11, 0, jour=18))] * 40)
e = self.etat()
self.assertEqual((e["commun_jour"], e["relais_jour"], e["total_jour"]), (100, 40, 140))
def test_plafond_atteint_par_le_total(self):
ecrire_json(self.cfg.quota_commun, {"date": "2026-10-18", "requetes": 4000}, compact=False)
q = ic.Quota(self.cfg, self.journal)
self.assertTrue(q.peut(1, MAINTENANT)) # sans relais : 4001 <= 4999
self.ecrire(*[ligne(t(11, 0, jour=18))] * 998)
self.assertTrue(q.peut(1, MAINTENANT)) # 4000 + 998 + 1 = 4999 : pile au plafond
self.assertFalse(q.peut(2, MAINTENANT))
self.ecrire(*[ligne(t(11, 0, jour=18))] * 999)
self.assertFalse(q.peut(1, MAINTENANT))
def test_plafond_atteint_par_les_24h_glissantes_seules(self):
# Le relais a fait 4999 appels hier soir (jour précédent) : le compteur du jour est à 0, mais 24 h pleines.
self.ecrire(*[ligne(t(21, 0, jour=17))] * 4999)
e = self.etat()
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 4999))
self.assertFalse(ic.Quota(self.cfg, self.journal).peut(1, MAINTENANT))
def test_message_signale_une_seule_fois(self):
q = ic.Quota(self.cfg, self.journal)
q.etat(MAINTENANT)
q.etat(MAINTENANT)
self.assertEqual(self.texte_journal().count("absent"), 1)
if __name__ == "__main__":
unittest.main()
+47
Voir le fichier
@@ -0,0 +1,47 @@
"""Copie vers le dossier servi : fichiers ordinaires seulement, aucun lien suivi."""
import os
import tempfile
import unittest
from pathlib import Path
from meteo_collecte.publier import copier_vers_servi
class TestCopieServi(unittest.TestCase):
def setUp(self):
self.tmp = Path(tempfile.mkdtemp())
self.src = self.tmp / "public"
self.dst = self.tmp / "servi"
(self.src / "data" / "station").mkdir(parents=True)
(self.src / "data" / "stations.json").write_text('{"ok": 1}', encoding="utf-8")
(self.src / "data" / "station" / "x.json").write_text("{}", encoding="utf-8")
self.secret = self.tmp / "hors_site.txt"
self.secret.write_text("NE DOIT PAS SORTIR", encoding="utf-8")
def test_copie_fichiers_reguliers(self):
self.assertEqual(copier_vers_servi(self.src, self.dst), 2)
self.assertEqual((self.dst / "data" / "stations.json").read_text(encoding="utf-8"), '{"ok": 1}')
self.assertFalse(any(p.name.endswith(".tmp") for p in self.dst.rglob("*")))
def test_lien_dans_la_source_refuse(self):
try:
os.symlink(self.secret, self.src / "data" / "lien.json")
except (OSError, NotImplementedError):
self.skipTest("liens symboliques non disponibles ici")
with self.assertRaises(ValueError):
copier_vers_servi(self.src, self.dst)
self.assertFalse((self.dst / "data" / "lien.json").exists())
def test_lien_dans_la_destination_remplace_sans_suivre(self):
self.dst.joinpath("data").mkdir(parents=True)
try:
os.symlink(self.secret, self.dst / "data" / "stations.json")
except (OSError, NotImplementedError):
self.skipTest("liens symboliques non disponibles ici")
copier_vers_servi(self.src, self.dst)
self.assertFalse((self.dst / "data" / "stations.json").is_symlink())
self.assertEqual(self.secret.read_text(encoding="utf-8"), "NE DOIT PAS SORTIR")
if __name__ == "__main__":
unittest.main()