Comparer les révisions
3
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
778825198e | |||
|
|
21f7fca8b6 | |||
|
|
fdcca5bccc | |||
Aucun fichier ne correspond à votre recherche
+81
-75
@@ -1,75 +1,81 @@
|
||||
# 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_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`.
|
||||
@@ -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,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]
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
+243
-241
@@ -1,241 +1,243 @@
|
||||
"""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)
|
||||
# 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),
|
||||
servi=chemin("MC_SERVI", 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))
|
||||
@@ -2,7 +2,6 @@
|
||||
|
||||
1. Requêtes groupées : toutes les stations dues dans une seule requête (`stations[]=` répété), lots de 25.
|
||||
2. Rythme par station *mesuré* dans la base (pas réel 10/15/20 min) ; due à dernière + pas + délai de publication.
|
||||
2bis. `frequence_min` (dashboard) : due après max(frequence_min, rythme mesuré) ; absent = comportement d'avant.
|
||||
3. Un passage principal toutes les 10 min (hh:x4), seulement si au moins une station est due.
|
||||
4. Rattrapage ciblé (hh:x9) : seulement les stations ponctuelles manquées au passage principal.
|
||||
5. Fenêtre courte : start=end=aujourd'hui UTC ; la veille seulement au premier passage après minuit UTC.
|
||||
@@ -30,7 +29,6 @@ PAS_DEFAUT_S = 600
|
||||
PAS_MIN_S, PAS_MAX_S = 600, 3600
|
||||
RETARD_PONCTUEL_S = 9 * 60 # [À VÉRIFIER] seuil « habituellement ponctuelle » (médiane réception - mesure)
|
||||
ECART_MIN_PRINCIPAL_S = 8 * 60
|
||||
FREQ_MIN_MIN, FREQ_MIN_MAX = 5, 1440 # bornes de frequence_min, comme la validation du dashboard meteo-lan
|
||||
|
||||
# Champs Infoclimat -> colonnes du stockage (pluie_cumul_0h : cumul depuis 0 h, [À VÉRIFIER] UTC ou Paris)
|
||||
CORRESPONDANCE = {"temperature": "temperature", "humidite": "humidite", "point_de_rosee": "point_de_rosee",
|
||||
@@ -129,43 +127,19 @@ def mesurer_rythme(instants):
|
||||
return pas, retard
|
||||
|
||||
|
||||
def frequences_configurees(stations_cfg, journal=None, maintenant=None):
|
||||
"""Fréquence réglée dans le dashboard (`frequence_min`, entier 5 à 1440) -> {station: secondes}.
|
||||
Champ absent : station ignorée ici (comportement inchangé). Valeur invalide : ignorée, une ligne de journal."""
|
||||
out = {}
|
||||
for sid, info in stations_cfg.items():
|
||||
if not isinstance(info, dict) or "frequence_min" not in info:
|
||||
continue
|
||||
f = info["frequence_min"]
|
||||
if isinstance(f, bool) or not isinstance(f, int) or not (FREQ_MIN_MIN <= f <= FREQ_MIN_MAX):
|
||||
if journal:
|
||||
journal("frequence_min invalide pour %s (%r : entier %d à %d attendu), ignorée"
|
||||
% (str(sid)[:40], str(f)[:40], FREQ_MIN_MIN, FREQ_MIN_MAX), maintenant)
|
||||
continue
|
||||
out[sid] = f * 60
|
||||
return out
|
||||
|
||||
|
||||
def rythmes(stockage, ids, frequences=None):
|
||||
def rythmes(stockage, ids):
|
||||
r = {}
|
||||
for sid in ids:
|
||||
inst = stockage.instants(SOURCE, sid, 30)
|
||||
pas, retard = mesurer_rythme(inst)
|
||||
r[sid] = {"derniere": lire_utc(inst[-1][0]) if inst else None, "pas_s": pas, "retard_s": retard}
|
||||
if frequences and sid in frequences:
|
||||
r[sid]["frequence_s"] = frequences[sid]
|
||||
return r
|
||||
|
||||
|
||||
def pas_effectif_s(r):
|
||||
"""Pas mesuré, relevé à la fréquence réglée si elle est plus lente (jamais plus vite que la station)."""
|
||||
return max(r["pas_s"], r.get("frequence_s") or 0)
|
||||
|
||||
|
||||
def est_due(r, maintenant):
|
||||
if r["derniere"] is None:
|
||||
return True
|
||||
return maintenant >= r["derniere"] + dt.timedelta(seconds=pas_effectif_s(r) + DELAI_PUBLICATION_S)
|
||||
return maintenant >= r["derniere"] + dt.timedelta(seconds=r["pas_s"] + DELAI_PUBLICATION_S)
|
||||
|
||||
|
||||
def est_ponctuelle(r):
|
||||
@@ -256,7 +230,7 @@ def passer(cfg, stockage, journal, maintenant, stations_cfg, fetch=telecharger,
|
||||
|
||||
for sid, info in stations_cfg.items():
|
||||
stockage.maj_station(SOURCE, sid, nom=info.get("nom"), licence=info.get("licence"), lien=info.get("lien"))
|
||||
r = rythmes(stockage, list(stations_cfg), frequences_configurees(stations_cfg, journal, maintenant))
|
||||
r = rythmes(stockage, list(stations_cfg))
|
||||
genre, cibles = planifier(etat, r, maintenant)
|
||||
resume["type"] = genre
|
||||
if not cibles:
|
||||
|
||||
@@ -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
@@ -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,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()
|
||||
@@ -1,162 +0,0 @@
|
||||
"""frequence_min (réglée dans le dashboard meteo-lan) : due après max(frequence_min, rythme mesuré). Hors ligne."""
|
||||
import datetime as dt
|
||||
import json
|
||||
import tempfile
|
||||
import unittest
|
||||
import urllib.parse
|
||||
from pathlib import Path
|
||||
|
||||
from meteo_collecte import infoclimat as ic
|
||||
from meteo_collecte.commun import UTC
|
||||
from meteo_collecte.stockage import Stockage
|
||||
from tests.aide import config, t
|
||||
|
||||
|
||||
def r(derniere, pas_s=600, **kw):
|
||||
return dict({"derniere": derniere, "pas_s": pas_s, "retard_s": 120}, **kw)
|
||||
|
||||
|
||||
class TestValidation(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory()
|
||||
self.cfg, self.journal = config(self.tmp.name)
|
||||
|
||||
def tearDown(self):
|
||||
self.tmp.cleanup()
|
||||
|
||||
def lire_journal(self):
|
||||
return self.journal.fichier.read_text(encoding="utf-8") if self.journal.fichier.exists() else ""
|
||||
|
||||
def test_valeurs_valides(self):
|
||||
f = ic.frequences_configurees({"a": {"frequence_min": 5}, "b": {"frequence_min": 60},
|
||||
"c": {"frequence_min": 1440}}, self.journal, t(12, 4))
|
||||
self.assertEqual(f, {"a": 300, "b": 3600, "c": 86400})
|
||||
self.assertEqual(self.lire_journal(), "")
|
||||
|
||||
def test_champ_absent_ignore_sans_journal(self):
|
||||
self.assertEqual(ic.frequences_configurees({"a": {"nom": "x"}}, self.journal, t(12, 4)), {})
|
||||
self.assertEqual(self.lire_journal(), "")
|
||||
|
||||
def test_valeurs_invalides_ignorees_avec_une_ligne_chacune(self):
|
||||
mauvaises = [4, 1441, 0, -10, 30.5, "30", None, True, [30]]
|
||||
stations = {"s%d" % i: {"frequence_min": v} for i, v in enumerate(mauvaises)}
|
||||
self.assertEqual(ic.frequences_configurees(stations, self.journal, t(12, 4)), {})
|
||||
lignes = self.lire_journal().strip().splitlines()
|
||||
self.assertEqual(len(lignes), len(mauvaises))
|
||||
self.assertTrue(all("frequence_min invalide" in x for x in lignes))
|
||||
|
||||
def test_entree_non_dictionnaire_ne_plante_pas(self):
|
||||
self.assertEqual(ic.frequences_configurees({"a": "texte", "b": None}, self.journal, t(12, 4)), {})
|
||||
|
||||
|
||||
class TestDue(unittest.TestCase):
|
||||
def test_sans_champ_comportement_inchange(self):
|
||||
d = t(12, 0)
|
||||
self.assertFalse(ic.est_due(r(d), t(12, 11)))
|
||||
self.assertTrue(ic.est_due(r(d), t(12, 12)))
|
||||
|
||||
def test_frequence_plus_lente_que_la_station(self):
|
||||
d = t(12, 0)
|
||||
st = r(d, 600, frequence_s=1800)
|
||||
self.assertFalse(ic.est_due(st, t(12, 31)))
|
||||
self.assertTrue(ic.est_due(st, t(12, 32))) # 30 min + 2 min de publication
|
||||
|
||||
def test_jamais_plus_souvent_que_la_station(self):
|
||||
d = t(12, 0)
|
||||
st = r(d, 1800, frequence_s=300) # station lente (30 min), réglage 5 min
|
||||
self.assertEqual(ic.pas_effectif_s(st), 1800)
|
||||
self.assertFalse(ic.est_due(st, t(12, 20)))
|
||||
self.assertTrue(ic.est_due(st, t(12, 32)))
|
||||
|
||||
def test_jamais_vue_toujours_due(self):
|
||||
self.assertTrue(ic.est_due(r(None, 600, frequence_s=3600), t(12, 4)))
|
||||
|
||||
def test_planifier_exclut_la_station_non_due(self):
|
||||
rs = {"lente": r(t(12, 0), 600, frequence_s=3600), "libre": r(t(12, 0), 600)}
|
||||
genre, cibles = ic.planifier({}, rs, t(12, 14))
|
||||
self.assertEqual((genre, cibles), ("principal", ["libre"]))
|
||||
|
||||
|
||||
class FauxServeur:
|
||||
"""Stations qui publient toutes les `pas` minutes avec 2 min de retard ; compte les requêtes et stations."""
|
||||
|
||||
def __init__(self, pas=10):
|
||||
self.pas, self.maintenant = pas, None
|
||||
self.requetes, self.stations_demandees = 0, 0
|
||||
|
||||
def __call__(self, url):
|
||||
q = urllib.parse.parse_qs(urllib.parse.urlparse(url).query)
|
||||
ids = q["stations[]"]
|
||||
self.requetes += 1
|
||||
self.stations_demandees += len(ids)
|
||||
debut = dt.datetime.strptime(q["start"][0], "%Y-%m-%d").replace(tzinfo=UTC)
|
||||
limite = self.maintenant - dt.timedelta(minutes=2)
|
||||
horaire, m = {}, debut
|
||||
while m <= limite:
|
||||
if m.minute % self.pas == 0:
|
||||
for s in ids:
|
||||
horaire.setdefault(s, []).append({"dh_utc": m.strftime("%Y-%m-%d %H:%M:%S"), "temperature": "7.0"})
|
||||
m += dt.timedelta(minutes=1)
|
||||
return json.dumps({"status": "OK", "errors": [], "stations": [], "hourly": horaire}).encode()
|
||||
|
||||
|
||||
def simuler_24h(frequence_min, nb_stations=3, pas_station=10, debut=None):
|
||||
"""Tick toutes les 5 min (hh:x4 et hh:x9) pendant 24 h, avec la vraie `passer`. -> (requêtes, stations demandées)."""
|
||||
debut = debut or dt.datetime(2026, 10, 16, 0, 4, tzinfo=UTC)
|
||||
stations = {}
|
||||
for i in range(nb_stations):
|
||||
stations["S%d" % i] = {"nom": "s", "licence": "CC BY"}
|
||||
if frequence_min is not None:
|
||||
stations["S%d" % i]["frequence_min"] = frequence_min
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
cfg, journal = config(tmp)
|
||||
st = Stockage(Path(tmp) / "m.sqlite")
|
||||
srv = FauxServeur(pas_station)
|
||||
try:
|
||||
for k in range(24 * 12):
|
||||
srv.maintenant = debut + dt.timedelta(minutes=5 * k)
|
||||
ic.passer(cfg, st, journal, srv.maintenant, stations, fetch=srv)
|
||||
finally:
|
||||
st.fermer()
|
||||
return srv.requetes, srv.stations_demandees
|
||||
|
||||
|
||||
class TestSimulation24h(unittest.TestCase):
|
||||
resultats = {}
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
for f in (None, 10, 30, 60):
|
||||
cls.resultats[f] = simuler_24h(f)
|
||||
base = cls.resultats[None][0]
|
||||
print("\n[simulation 24 h, 3 stations qui publient toutes les 10 min, 288 ticks de 5 min]")
|
||||
for f, (req, sta) in cls.resultats.items():
|
||||
print(" frequence_min=%-5s -> %3d requêtes, %3d demandes de station%s" % (
|
||||
f if f else "absent", req, sta,
|
||||
"" if f is None else " (gain %d requêtes, %.0f %%)" % (base - req, 100 * (base - req) / base)))
|
||||
|
||||
def test_sans_champ_identique_au_comportement_actuel(self):
|
||||
self.assertEqual(self.resultats[None][0], 144) # même valeur que test_ordonnanceur (144/24 h)
|
||||
|
||||
def test_10_min_egale_la_station(self):
|
||||
self.assertEqual(self.resultats[10], self.resultats[None])
|
||||
|
||||
def test_30_et_60_min_reduisent_les_requetes(self):
|
||||
self.assertLess(self.resultats[30][0], self.resultats[10][0])
|
||||
self.assertLess(self.resultats[60][0], self.resultats[30][0])
|
||||
|
||||
def test_ordre_de_grandeur(self):
|
||||
# ~1 requête par période + le premier passage ; marge pour le démarrage et les dérives de 5 min
|
||||
self.assertTrue(24 * 60 // 30 <= self.resultats[30][0] <= 24 * 60 // 30 + 3)
|
||||
self.assertTrue(24 * 60 // 60 <= self.resultats[60][0] <= 24 * 60 // 60 + 3)
|
||||
|
||||
def test_frequence_5_ne_depasse_pas_le_rythme_de_la_station(self):
|
||||
self.assertEqual(simuler_24h(5)[0], self.resultats[None][0])
|
||||
|
||||
def test_station_lente_30_min_avec_reglage_10(self):
|
||||
lent = simuler_24h(10, pas_station=30)[0]
|
||||
self.assertEqual(lent, simuler_24h(None, pas_station=30)[0])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -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()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur