Comparer les révisions
5
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
6b89a9d815 | |||
|
|
f0dea50fa5 | |||
| ||||
|
|
778825198e | |||
|
|
21f7fca8b6 | |||
|
|
fdcca5bccc | |||
Aucun fichier ne correspond à votre recherche
+82
-75
@@ -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`.
|
||||
@@ -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
|
||||
+251
-241
@@ -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))
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
@@ -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():
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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