Comparer les révisions
7
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
de74617447 | |||
|
|
fb235a2c85 | |||
|
|
b8fd17d0e6 | |||
|
|
feb78ba2ab | |||
| ||||
|
|
778825198e | |||
|
|
21f7fca8b6 | |||
|
|
fdcca5bccc | |||
Aucun fichier ne correspond à votre recherche
+97
-75
@@ -1,75 +1,97 @@
|
|||||||
# meteo-collecte
|
# meteo-collecte
|
||||||
|
|
||||||
Collecteur du site météo public (weather.gastinel.me). Python 3, bibliothèque standard seulement
|
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).
|
(aucune dépendance à installer ; `pytest` est facultatif pour lancer les tests).
|
||||||
|
|
||||||
Conception : `Gastinel-Projets/site-meteo-architecture-2026-10-15.md`.
|
Conception : `Gastinel-Projets/site-meteo-architecture-2026-10-15.md`.
|
||||||
Ce dépôt ne touche ni `weather-collector` ni `weather-db`.
|
Ce dépôt ne touche ni `weather-collector` ni `weather-db`.
|
||||||
|
|
||||||
## Ce que fait un tick
|
## Ce que fait un tick
|
||||||
|
|
||||||
Lancé toutes les 5 min (hh:x4 et hh:x9) par le minuteur systemd :
|
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.
|
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
|
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.
|
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
|
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).
|
`~/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),
|
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.
|
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/` :
|
4. **Publication** (`publier.py`) : fichiers statiques écrits de façon atomique sous `<public>/data/` :
|
||||||
`stations.json`, `station/<source>-<id>.json` (48 h), `etat.json`.
|
`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
|
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.
|
publication continuent. Un verrou empêche deux ticks simultanés.
|
||||||
|
|
||||||
## Configuration (variables d'environnement)
|
## Configuration (variables d'environnement)
|
||||||
|
|
||||||
| Variable | Rôle | Défaut |
|
| Variable | Rôle | Défaut |
|
||||||
|---|---|---|
|
|---|---|---|
|
||||||
| `MC_BASE` | dossier d'état (var/, base, journal) | `~/meteo-collecte` |
|
| `MC_BASE` | dossier d'état (var/, base, journal) | `~/meteo-collecte` |
|
||||||
| `MC_PUBLIC` | racine servie par le serveur web | `$MC_BASE/public` |
|
| `MC_PUBLIC` | racine servie par le serveur web | `$MC_BASE/public` |
|
||||||
| `MC_QUOTA_COMMUN` | compteur commun Infoclimat | `~/gws-collecte/quota.json` |
|
| `MC_QUOTA_COMMUN` | compteur commun Infoclimat | `~/gws-collecte/quota.json` |
|
||||||
| `MC_STATIONS` | liste des stations Infoclimat | `config/stations.json` |
|
| `MC_STATIONS` | liste des stations Infoclimat | `config/stations.json` |
|
||||||
| `MC_PLAFOND_SITE` / `MC_PLAFOND_COMMUN` | plafonds Infoclimat | 1000 / 4999 |
|
| `MC_PLAFOND_SITE` / `MC_PLAFOND_COMMUN` | plafonds Infoclimat | 1000 / 4999 |
|
||||||
| `MC_LOT_MAX` | stations par requête | 25 |
|
| `MC_LOT_MAX` | stations par requête | 25 |
|
||||||
| `MC_COMPTE_PAR_STATION` | compter une requête par station | 0 |
|
| `MC_COMPTE_PAR_STATION` | compter une requête par station | 0 |
|
||||||
| `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 |
|
| `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 |
|
||||||
| `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide |
|
| `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide |
|
||||||
| `MC_DIRECT_COMPAT` | écrire aussi l'ancien `direct.json` | 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
|
|
||||||
|
### Secrets
|
||||||
Uniquement par variables d'environnement, lues au moment de l'appel, jamais écrites ni affichées :
|
|
||||||
|
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.
|
* `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).
|
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
|
|
||||||
|
## WeatherLink v2 (nos stations, opt-in)
|
||||||
```sh
|
|
||||||
python3 -m meteo_collecte.ordonnanceur # un tick
|
Lecture de **nos** stations Davis (Allières, Bruyères, Méaudre, Gêve : à vérifier) par l'API WeatherLink v2,
|
||||||
python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau
|
`weatherlink.py`. Désactivée par défaut. Totalement séparée de ROMMA, Infoclimat et Météo-France : autres clés,
|
||||||
python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente »
|
aucun accès à `quota.json`, état propre (`var/etat_weatherlink.json`, `var/pause_weatherlink_<compte>.txt`).
|
||||||
```
|
Chaque mesure garde la source `weatherlink` (jamais fusionnée avec Infoclimat/ROMMA, même station physique).
|
||||||
|
|
||||||
## Tests (hors ligne)
|
* `MC_WEATHERLINK_ACTIF=1` pour activer ; comptes décrits dans `config/weatherlink.json` (`MC_WEATHERLINK_COMPTES`) :
|
||||||
|
un compte = une clé API, avec les **noms** de ses deux variables (`MC_WL_ALLIERES_CLE`/`_SECRET`,
|
||||||
```sh
|
`MC_WL_BRUYERES_CLE`/`_SECRET`). Sans les variables d'un compte : aucun appel (`sans_cle`).
|
||||||
python -m pytest -q # ou : python -m unittest discover -s . -p "test_*.py"
|
* Une requête `GET /current/{station_id}` par station (pas de requête groupée), au plus toutes les 10 min
|
||||||
python -m pytest -q -s tests/test_hors_ligne.py # affiche les compteurs de requêtes simulés
|
(`MC_WL_INTERVALLE_S`, minimum 300), 0,5 s entre deux appels, plafond propre `MC_WL_MAX_HEURE` (120/h/compte,
|
||||||
```
|
dur 900 ; l'API donne 1000/h et 10/s par clé). Erreur : pause 15 min ; 429 : 1 h ; 401/403 : 6 h ; le compte s'arrête.
|
||||||
|
* Secret en en-tête `X-Api-Secret`, clé en `api-key=` (masquée dans les journaux). `station_id` null = ignorée.
|
||||||
`tests/__init__.py` coupe le réseau (DNS et connexions hors boucle locale lèvent une erreur) : aucun test ne
|
* À vérifier sur une vraie réponse : noms de champs et unités de `/current` (supposées impériales), code de limite.
|
||||||
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
|
## Commandes
|
||||||
plusieurs jours de ticks (fonctionnement normal, plafond, panne longue, sans secrets, purge, heure d'hiver).
|
|
||||||
|
```sh
|
||||||
## Déploiement
|
python3 -m meteo_collecte.ordonnanceur # un tick
|
||||||
|
python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau
|
||||||
`deploiement/meteo-collecte.service` et `.timer` sont des **exemples non installés** (unité utilisateur).
|
python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente »
|
||||||
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).
|
|
||||||
|
## 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`.
|
||||||
@@ -0,0 +1,21 @@
|
|||||||
|
{
|
||||||
|
"_note": "Comptes WeatherLink v2 (nos stations). Ce fichier ne contient JAMAIS de valeur secrète : seulement les NOMS des variables d'environnement qui portent la clé et le secret. Une clé API par compte. Fonction désactivée par défaut (MC_WEATHERLINK_ACTIF=1 pour l'activer). station_id null = à fournir par Théo : la station est ignorée tant qu'il manque.",
|
||||||
|
"comptes": {
|
||||||
|
"allieres": {
|
||||||
|
"var_cle": "MC_WL_ALLIERES_CLE",
|
||||||
|
"var_secret": "MC_WL_ALLIERES_SECRET",
|
||||||
|
"stations": {
|
||||||
|
"ALLIERES": {"station_id": null, "nom": "Lans-en-Vercors – Les Allières", "altitude": 1449, "a_verifier": "station_id WeatherLink à fournir par Théo"}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"bruyeres-meaudre": {
|
||||||
|
"var_cle": "MC_WL_BRUYERES_CLE",
|
||||||
|
"var_secret": "MC_WL_BRUYERES_SECRET",
|
||||||
|
"stations": {
|
||||||
|
"BRUYERES": {"station_id": "41723", "nom": "Lans-en-Vercors – Les Bruyères", "altitude": 990},
|
||||||
|
"MEAUDRE": {"station_id": "208771", "nom": "Méaudre", "altitude": 976},
|
||||||
|
"GEVE": {"station_id": "211934", "nom": "Autrans – Gêve nordique", "altitude": 1353, "a_verifier": "même compte/clé que Bruyères et Méaudre ? Box débranchée sur place (journal 29/09)"}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -1,33 +1,32 @@
|
|||||||
# EXEMPLE — non installé. Unité « utilisateur » proposée pour le VPS (à relire par Théo avant toute installation).
|
# 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).
|
||||||
# Installation possible (par Théo, PAS faite ici) :
|
#
|
||||||
# mkdir -p ~/.config/systemd/user
|
# Secrets : uniquement dans %h/.config/meteo-collecte/env (droits 600, créé vide par le script ;
|
||||||
# cp deploiement/meteo-collecte.service deploiement/meteo-collecte.timer ~/.config/systemd/user/
|
# rempli à la main par Théo, nom=valeur, jamais dans ce fichier ni dans le dépôt).
|
||||||
# systemctl --user daemon-reload && systemctl --user enable --now meteo-collecte.timer
|
# Sans valeur, aucun appel n'est fait (sans_jeton / sans_cle) et la publication continue.
|
||||||
# (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,
|
[Unit]
|
||||||
# arrêt de meteo-direct.timer avant activation (sinon deux collecteurs comptent le même quota).
|
Description=meteo-collecte : un tick (ROMMA, Infoclimat, publication des fichiers statiques)
|
||||||
|
After=network-online.target
|
||||||
[Unit]
|
Wants=network-online.target
|
||||||
Description=meteo-collecte : un tick (ROMMA, Infoclimat, publication des fichiers statiques)
|
|
||||||
After=network-online.target
|
[Service]
|
||||||
Wants=network-online.target
|
Type=oneshot
|
||||||
|
WorkingDirectory=%h/meteo-collecte
|
||||||
[Service]
|
EnvironmentFile=%h/.config/meteo-collecte/env
|
||||||
Type=oneshot
|
Environment=MC_BASE=%h/meteo-collecte
|
||||||
WorkingDirectory=%h/meteo-collecte/code
|
# Publication dans le dossier du collecteur, puis copie des seuls fichiers ordinaires vers MC_SERVI (lu par Caddy,
|
||||||
# Secrets : variables d'environnement seulement (MC_JETON_INFOCLIMAT, MC_CLE_ROMMA), dans un fichier
|
# qui ne sert que /data). Aucun lien symbolique n'est copié (publier.copier_vers_servi).
|
||||||
# créé à la main par Théo, droits 600, hors du dépôt. Format : une ligne NOM=valeur par secret.
|
Environment=MC_PUBLIC=%h/meteo-collecte/public
|
||||||
# Le « - » rend le fichier facultatif : sans lui, aucun appel n'est fait (la publication continue).
|
Environment=MC_SERVI=/srv/weather.gastinel.me
|
||||||
EnvironmentFile=-%h/meteo-collecte/.secrets/env
|
Environment=MC_QUOTA_COMMUN=%h/gws-collecte/quota.json
|
||||||
Environment=MC_BASE=%h/meteo-collecte
|
# Ancien format direct.json, écrit à côté (PAS à la place de ~/meteo-direct/direct.json, lu par cornafserver).
|
||||||
Environment=MC_QUOTA_COMMUN=%h/gws-collecte/quota.json
|
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é.
|
# Alerte ntfy : désactivée tant que Théo ne l'a pas décidé.
|
||||||
Environment=MC_ALERTE_ACTIVE=0
|
Environment=MC_ALERTE_ACTIVE=0
|
||||||
ExecStart=/usr/bin/python3 -m meteo_collecte.ordonnanceur
|
ExecStart=/usr/bin/python3 -m meteo_collecte.ordonnanceur
|
||||||
TimeoutStartSec=4min
|
TimeoutStartSec=4min
|
||||||
Nice=10
|
Nice=10
|
||||||
# Durcissement léger compatible avec une unité utilisateur
|
NoNewPrivileges=yes
|
||||||
NoNewPrivileges=yes
|
PrivateTmp=yes
|
||||||
PrivateTmp=yes
|
UMask=0022
|
||||||
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é.
|
# hh:x4 = passage principal Infoclimat (+ ROMMA si 10 min écoulées), hh:x9 = rattrapage ciblé.
|
||||||
|
|
||||||
[Unit]
|
[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
|
||||||
+252
-241
@@ -1,241 +1,252 @@
|
|||||||
"""Outils communs : configuration, heure de Paris, JSON atomique, journal, verrou, masquage des secrets.
|
"""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
|
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.
|
(voir `Config.depuis_env`) avec des valeurs par défaut relatives au dossier personnel.
|
||||||
"""
|
"""
|
||||||
import datetime as dt
|
import datetime as dt
|
||||||
import json
|
import json
|
||||||
import os
|
import os
|
||||||
import re
|
import re
|
||||||
import urllib.parse
|
import urllib.parse
|
||||||
from dataclasses import dataclass, field
|
from dataclasses import dataclass, field
|
||||||
from pathlib import Path
|
from pathlib import Path
|
||||||
|
|
||||||
try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows
|
try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows
|
||||||
import fcntl
|
import fcntl
|
||||||
except ImportError: # pragma: no cover
|
except ImportError: # pragma: no cover
|
||||||
fcntl = None
|
fcntl = None
|
||||||
|
|
||||||
UTC = dt.timezone.utc
|
UTC = dt.timezone.utc
|
||||||
|
|
||||||
|
|
||||||
# ---------------------------------------------------------------------------
|
# ---------------------------------------------------------------------------
|
||||||
# Configuration
|
# Configuration
|
||||||
# ---------------------------------------------------------------------------
|
# ---------------------------------------------------------------------------
|
||||||
|
|
||||||
@dataclass
|
@dataclass
|
||||||
class Config:
|
class Config:
|
||||||
base: Path # état, journal, base SQLite
|
base: Path # état, journal, base SQLite
|
||||||
public: Path # racine servie par Caddy (on écrit dans public/data/)
|
public: Path # racine servie par Caddy (on écrit dans public/data/)
|
||||||
quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct
|
quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct
|
||||||
stations: Path # liste des stations Infoclimat suivies (JSON)
|
stations: Path # liste des stations Infoclimat suivies (JSON)
|
||||||
plafond_commun: int = 4999 # même plafond que le collecteur (décision du 29/09)
|
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)
|
plafond_site: int = 1000 # plafond propre au site (décision du 16/10)
|
||||||
seuil_alerte: float = 0.80
|
seuil_alerte: float = 0.80
|
||||||
alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé
|
alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé
|
||||||
ntfy_url: str = ""
|
ntfy_url: str = ""
|
||||||
compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4)
|
compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4)
|
||||||
lot_max: int = 25
|
lot_max: int = 25
|
||||||
garder_jours: int = 14
|
garder_jours: int = 14
|
||||||
fiche_heures: int = 48
|
fiche_heures: int = 48
|
||||||
romma_actif: bool = True
|
romma_actif: bool = True
|
||||||
infoclimat_actif: bool = True
|
infoclimat_actif: bool = True
|
||||||
direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN)
|
# WeatherLink v2 (nos stations) : opt-in, désactivé par défaut. Source entièrement séparée des quotas des autres.
|
||||||
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
|
weatherlink_actif: bool = False
|
||||||
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
|
weatherlink_comptes: Path = None # JSON des comptes (noms de variables seulement, jamais de valeurs)
|
||||||
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
|
wl_intervalle_s: int = 600 # une lecture par station au plus toutes les 10 min (minimum 300)
|
||||||
var_cle_romma: str = "MC_CLE_ROMMA"
|
wl_max_heure: int = 120 # requêtes/heure/compte (plafond dur 900 ; l'API donne 1000/h et 10/s par clé)
|
||||||
env: object = field(default=None, repr=False)
|
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)
|
||||||
def secret(self, nom_variable):
|
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
|
||||||
"""Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide."""
|
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
|
||||||
e = os.environ if self.env is None else self.env
|
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
|
||||||
v = (e.get(nom_variable) or "").strip()
|
var_cle_romma: str = "MC_CLE_ROMMA"
|
||||||
if not v:
|
env: object = field(default=None, repr=False)
|
||||||
raise LookupError("variable %s absente ou vide" % nom_variable)
|
|
||||||
return v
|
def secret(self, nom_variable):
|
||||||
|
"""Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide."""
|
||||||
@classmethod
|
e = os.environ if self.env is None else self.env
|
||||||
def depuis_env(cls, env=None):
|
v = (e.get(nom_variable) or "").strip()
|
||||||
e = os.environ if env is None else env
|
if not v:
|
||||||
home = Path.home()
|
raise LookupError("variable %s absente ou vide" % nom_variable)
|
||||||
base = Path(e.get("MC_BASE") or home / "meteo-collecte")
|
return v
|
||||||
|
|
||||||
def chemin(nom, defaut):
|
@classmethod
|
||||||
return Path(e[nom]) if e.get(nom) else defaut
|
def depuis_env(cls, env=None):
|
||||||
|
e = os.environ if env is None else env
|
||||||
def oui(nom, defaut):
|
home = Path.home()
|
||||||
v = e.get(nom)
|
base = Path(e.get("MC_BASE") or home / "meteo-collecte")
|
||||||
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
|
|
||||||
|
def chemin(nom, defaut):
|
||||||
return cls(
|
return Path(e[nom]) if e.get(nom) else defaut
|
||||||
base=base,
|
|
||||||
public=chemin("MC_PUBLIC", base / "public"),
|
def oui(nom, defaut):
|
||||||
quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"),
|
v = e.get(nom)
|
||||||
stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"),
|
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
|
||||||
plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)),
|
|
||||||
plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)),
|
return cls(
|
||||||
alerte_active=oui("MC_ALERTE_ACTIVE", False),
|
base=base,
|
||||||
ntfy_url=e.get("MC_NTFY_URL", ""),
|
public=chemin("MC_PUBLIC", base / "public"),
|
||||||
compte_par_station=oui("MC_COMPTE_PAR_STATION", False),
|
quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"),
|
||||||
lot_max=int(e.get("MC_LOT_MAX", 25)),
|
stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"),
|
||||||
romma_actif=oui("MC_ROMMA_ACTIF", True),
|
plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)),
|
||||||
infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True),
|
plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)),
|
||||||
direct_compat=chemin("MC_DIRECT_COMPAT", None),
|
alerte_active=oui("MC_ALERTE_ACTIVE", False),
|
||||||
env=env,
|
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),
|
||||||
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
|
weatherlink_actif=oui("MC_WEATHERLINK_ACTIF", False),
|
||||||
# ---------------------------------------------------------------------------
|
weatherlink_comptes=chemin("MC_WEATHERLINK_COMPTES", Path(__file__).resolve().parent.parent / "config" / "weatherlink.json"),
|
||||||
|
wl_intervalle_s=max(300, int(e.get("MC_WL_INTERVALLE_S", 600))),
|
||||||
def _dernier_dimanche(annee, mois):
|
wl_max_heure=min(900, int(e.get("MC_WL_MAX_HEURE", 120))),
|
||||||
d = dt.date(annee, mois, 31)
|
direct_compat=chemin("MC_DIRECT_COMPAT", None),
|
||||||
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
|
servi=chemin("MC_SERVI", None),
|
||||||
|
env=env,
|
||||||
|
)
|
||||||
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)
|
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
|
||||||
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC)
|
# ---------------------------------------------------------------------------
|
||||||
return dt.timedelta(hours=2 if debut <= utc < fin else 1)
|
|
||||||
|
def _dernier_dimanche(annee, mois):
|
||||||
|
d = dt.date(annee, mois, 31)
|
||||||
def vers_paris(utc):
|
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
|
||||||
return (utc + decalage_paris(utc)).replace(tzinfo=None)
|
|
||||||
|
|
||||||
|
def decalage_paris(utc):
|
||||||
def paris_vers_utc(local, maintenant=None):
|
"""Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST)."""
|
||||||
"""Heure locale de Paris (naïve) -> instant UTC.
|
a = utc.year
|
||||||
|
debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC)
|
||||||
None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus
|
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC)
|
||||||
récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
|
return dt.timedelta(hours=2 if debut <= utc < fin else 1)
|
||||||
"""
|
|
||||||
possibles = []
|
|
||||||
for h in (2, 1):
|
def vers_paris(utc):
|
||||||
c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC)
|
return (utc + decalage_paris(utc)).replace(tzinfo=None)
|
||||||
if (c + decalage_paris(c)).replace(tzinfo=None) == local:
|
|
||||||
possibles.append(c)
|
|
||||||
if not possibles:
|
def paris_vers_utc(local, maintenant=None):
|
||||||
return None
|
"""Heure locale de Paris (naïve) -> instant UTC.
|
||||||
if len(possibles) == 1 or maintenant is None:
|
|
||||||
return possibles[0]
|
None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus
|
||||||
passes = [c for c in possibles if c <= maintenant]
|
récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
|
||||||
return max(passes) if passes else min(possibles)
|
"""
|
||||||
|
possibles = []
|
||||||
|
for h in (2, 1):
|
||||||
def jour_paris(utc):
|
c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC)
|
||||||
return str(vers_paris(utc).date())
|
if (c + decalage_paris(c)).replace(tzinfo=None) == local:
|
||||||
|
possibles.append(c)
|
||||||
|
if not possibles:
|
||||||
def fmt_utc(t):
|
return None
|
||||||
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
|
if len(possibles) == 1 or maintenant is None:
|
||||||
|
return possibles[0]
|
||||||
|
passes = [c for c in possibles if c <= maintenant]
|
||||||
def lire_utc(s):
|
return max(passes) if passes else min(possibles)
|
||||||
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
|
|
||||||
|
|
||||||
|
def jour_paris(utc):
|
||||||
def iso(t):
|
return str(vers_paris(utc).date())
|
||||||
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
||||||
|
|
||||||
|
def fmt_utc(t):
|
||||||
# ---------------------------------------------------------------------------
|
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
|
||||||
# Fichiers
|
|
||||||
# ---------------------------------------------------------------------------
|
|
||||||
|
def lire_utc(s):
|
||||||
def lire_json(p, defaut):
|
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
|
||||||
try:
|
|
||||||
return json.loads(Path(p).read_text(encoding="utf-8"))
|
|
||||||
except (OSError, ValueError):
|
def iso(t):
|
||||||
return defaut
|
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
|
||||||
|
|
||||||
|
|
||||||
def ecrire_json(p, d, compact=True):
|
# ---------------------------------------------------------------------------
|
||||||
"""Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
|
# Fichiers
|
||||||
p = Path(p)
|
# ---------------------------------------------------------------------------
|
||||||
p.parent.mkdir(parents=True, exist_ok=True)
|
|
||||||
tmp = p.with_name(p.name + ".tmp-%d" % os.getpid())
|
def lire_json(p, defaut):
|
||||||
texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None,
|
try:
|
||||||
indent=None if compact else 1)
|
return json.loads(Path(p).read_text(encoding="utf-8"))
|
||||||
tmp.write_text(texte, encoding="utf-8")
|
except (OSError, ValueError):
|
||||||
os.replace(tmp, p)
|
return defaut
|
||||||
|
|
||||||
|
|
||||||
def scrub(texte, *secrets):
|
def ecrire_json(p, d, compact=True):
|
||||||
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
|
"""Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
|
||||||
texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
|
p = Path(p)
|
||||||
for s in secrets:
|
p.parent.mkdir(parents=True, exist_ok=True)
|
||||||
if s:
|
tmp = p.with_name(p.name + ".tmp-%d" % os.getpid())
|
||||||
texte = texte.replace(s, "***")
|
texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None,
|
||||||
enc = urllib.parse.quote(s, safe="")
|
indent=None if compact else 1)
|
||||||
if enc != s:
|
tmp.write_text(texte, encoding="utf-8")
|
||||||
texte = texte.replace(enc, "***")
|
os.replace(tmp, p)
|
||||||
return texte
|
|
||||||
|
|
||||||
|
def scrub(texte, *secrets):
|
||||||
class Journal:
|
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
|
||||||
"""Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
|
texte = re.sub(r"(?i)\b(token|apikey|api-key)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
|
||||||
|
for s in secrets:
|
||||||
def __init__(self, fichier):
|
if s:
|
||||||
self.fichier = Path(fichier)
|
texte = texte.replace(s, "***")
|
||||||
self.secrets = []
|
enc = urllib.parse.quote(s, safe="")
|
||||||
|
if enc != s:
|
||||||
def masquer(self, *secrets):
|
texte = texte.replace(enc, "***")
|
||||||
self.secrets.extend(s for s in secrets if s)
|
return texte
|
||||||
|
|
||||||
def __call__(self, msg, maintenant=None):
|
|
||||||
t = maintenant or dt.datetime.now(UTC)
|
class Journal:
|
||||||
self.fichier.parent.mkdir(parents=True, exist_ok=True)
|
"""Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
|
||||||
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")
|
def __init__(self, fichier):
|
||||||
|
self.fichier = Path(fichier)
|
||||||
|
self.secrets = []
|
||||||
class Verrou:
|
|
||||||
"""Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
|
def masquer(self, *secrets):
|
||||||
|
self.secrets.extend(s for s in secrets if s)
|
||||||
def __init__(self, fichier):
|
|
||||||
self.fichier = Path(fichier)
|
def __call__(self, msg, maintenant=None):
|
||||||
self.f = None
|
t = maintenant or dt.datetime.now(UTC)
|
||||||
|
self.fichier.parent.mkdir(parents=True, exist_ok=True)
|
||||||
def __enter__(self):
|
with open(self.fichier, "a", encoding="utf-8") as f:
|
||||||
self.fichier.parent.mkdir(parents=True, exist_ok=True)
|
f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n")
|
||||||
self.f = open(self.fichier, "w")
|
|
||||||
if fcntl is not None:
|
|
||||||
try:
|
class Verrou:
|
||||||
fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
"""Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
|
||||||
except OSError:
|
|
||||||
self.f.close()
|
def __init__(self, fichier):
|
||||||
self.f = None
|
self.fichier = Path(fichier)
|
||||||
return False
|
self.f = None
|
||||||
return True
|
|
||||||
|
def __enter__(self):
|
||||||
def __exit__(self, *a):
|
self.fichier.parent.mkdir(parents=True, exist_ok=True)
|
||||||
if self.f:
|
self.f = open(self.fichier, "w")
|
||||||
self.f.close()
|
if fcntl is not None:
|
||||||
|
try:
|
||||||
|
fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||||
class Pause:
|
except OSError:
|
||||||
"""Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
|
self.f.close()
|
||||||
|
self.f = None
|
||||||
def __init__(self, fichier, duree_s=15 * 60):
|
return False
|
||||||
self.fichier = Path(fichier)
|
return True
|
||||||
self.duree_s = duree_s
|
|
||||||
|
def __exit__(self, *a):
|
||||||
def active(self, maintenant):
|
if self.f:
|
||||||
try:
|
self.f.close()
|
||||||
return float(self.fichier.read_text()) > maintenant.timestamp()
|
|
||||||
except (OSError, ValueError):
|
|
||||||
return False
|
class Pause:
|
||||||
|
"""Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
|
||||||
def jusqua(self):
|
|
||||||
try:
|
def __init__(self, fichier, duree_s=15 * 60):
|
||||||
return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC)
|
self.fichier = Path(fichier)
|
||||||
except (OSError, ValueError):
|
self.duree_s = duree_s
|
||||||
return None
|
|
||||||
|
def active(self, maintenant):
|
||||||
def poser(self, maintenant):
|
try:
|
||||||
self.fichier.parent.mkdir(parents=True, exist_ok=True)
|
return float(self.fichier.read_text()) > maintenant.timestamp()
|
||||||
self.fichier.write_text(str(maintenant.timestamp() + self.duree_s))
|
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))
|
||||||
@@ -1,74 +1,87 @@
|
|||||||
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
|
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
|
||||||
|
|
||||||
Chaque source décide seule si elle appelle :
|
Chaque source décide seule si elle appelle :
|
||||||
* ROMMA : au plus une requête global=1 toutes les 10 min ;
|
* 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.
|
* 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
|
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.
|
ni l'autre source ni la publication.
|
||||||
|
|
||||||
python3 -m meteo_collecte.ordonnanceur # un tick
|
python3 -m meteo_collecte.ordonnanceur # un tick
|
||||||
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
|
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
|
||||||
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
|
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
|
||||||
"""
|
"""
|
||||||
import datetime as dt
|
import datetime as dt
|
||||||
import sys
|
import sys
|
||||||
|
|
||||||
from . import infoclimat, publier, romma
|
from . import infoclimat, publier, romma, weatherlink
|
||||||
from .commun import UTC, Config, Journal, Verrou, lire_json
|
from .commun import UTC, Config, Journal, Verrou, lire_json
|
||||||
from .stockage import Stockage
|
from .stockage import Stockage
|
||||||
|
|
||||||
|
|
||||||
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
|
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
|
||||||
appels=True):
|
appels=True, fetch_weatherlink=weatherlink.telecharger, dormir_weatherlink=None):
|
||||||
maintenant = maintenant or dt.datetime.now(UTC)
|
maintenant = maintenant or dt.datetime.now(UTC)
|
||||||
var = cfg.base / "var"
|
var = cfg.base / "var"
|
||||||
journal = Journal(var / "collecte.log")
|
journal = Journal(var / "collecte.log")
|
||||||
with Verrou(var / ".collecte.lock") as obtenu:
|
with Verrou(var / ".collecte.lock") as obtenu:
|
||||||
if not obtenu:
|
if not obtenu:
|
||||||
return {"action": "verrou"} # un tick précédent tourne encore
|
return {"action": "verrou"} # un tick précédent tourne encore
|
||||||
stockage = Stockage(var / "mesures.sqlite")
|
stockage = Stockage(var / "mesures.sqlite")
|
||||||
resumes = {}
|
resumes = {}
|
||||||
try:
|
try:
|
||||||
if appels and cfg.romma_actif:
|
if appels and cfg.romma_actif:
|
||||||
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
|
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
|
||||||
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
|
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
|
||||||
if appels and cfg.infoclimat_actif:
|
if appels and cfg.weatherlink_actif: # opt-in ; quota et état entièrement séparés
|
||||||
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
|
resumes["weatherlink"] = _sans_planter(journal, maintenant, "weatherlink", lambda: weatherlink.passer(
|
||||||
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
|
cfg, stockage, journal, maintenant, fetch_weatherlink, dormir_weatherlink))
|
||||||
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
|
if appels and cfg.infoclimat_actif:
|
||||||
stockage.purger(maintenant, cfg.garder_jours)
|
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
|
||||||
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
|
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
|
||||||
finally:
|
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
|
||||||
stockage.fermer()
|
stockage.purger(maintenant, cfg.garder_jours)
|
||||||
return resumes
|
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
|
||||||
|
if cfg.servi:
|
||||||
|
resumes["servies"] = publier.copier_vers_servi(cfg.public, cfg.servi)
|
||||||
def _sans_planter(journal, maintenant, nom, f):
|
finally:
|
||||||
try:
|
stockage.fermer()
|
||||||
return f()
|
return resumes
|
||||||
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 _sans_planter(journal, maintenant, nom, f):
|
||||||
|
try:
|
||||||
|
return f()
|
||||||
def main(argv=None):
|
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
|
||||||
argv = sys.argv[1:] if argv is None else argv
|
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
|
||||||
cfg = Config.depuis_env()
|
return {"source": nom, "action": "erreur_interne"}
|
||||||
if "--config" in argv:
|
|
||||||
for k, v in vars(cfg).items():
|
|
||||||
if k == "env":
|
def main(argv=None):
|
||||||
continue # l'environnement contient les secrets : jamais affiché
|
argv = sys.argv[1:] if argv is None else argv
|
||||||
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
|
cfg = Config.depuis_env()
|
||||||
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
|
if "--config" in argv:
|
||||||
try:
|
for k, v in vars(cfg).items():
|
||||||
cfg.secret(nom)
|
if k == "env":
|
||||||
print("%-20s définie (valeur masquée)" % nom)
|
continue # l'environnement contient les secrets : jamais affiché
|
||||||
except LookupError:
|
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
|
||||||
print("%-20s absente" % nom)
|
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
|
||||||
return 0
|
try:
|
||||||
tick(cfg, appels="--publier" not in argv)
|
cfg.secret(nom)
|
||||||
return 0
|
print("%-20s définie (valeur masquée)" % nom)
|
||||||
|
except LookupError:
|
||||||
|
print("%-20s absente" % nom)
|
||||||
if __name__ == "__main__":
|
if cfg.weatherlink_actif:
|
||||||
sys.exit(main())
|
for compte, d in lire_json(cfg.weatherlink_comptes, {}).get("comptes", {}).items():
|
||||||
|
for nom in (d.get("var_cle"), d.get("var_secret")):
|
||||||
|
try:
|
||||||
|
cfg.secret(nom)
|
||||||
|
print("%-28s définie (valeur masquée) [compte %s]" % (nom, compte))
|
||||||
|
except LookupError:
|
||||||
|
print("%-28s absente [compte %s]" % (nom, compte))
|
||||||
|
return 0
|
||||||
|
tick(cfg, appels="--publier" not in argv)
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
+152
-96
@@ -1,96 +1,152 @@
|
|||||||
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
|
"""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/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/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.
|
* 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
|
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.
|
(« 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.
|
Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API.
|
||||||
"""
|
"""
|
||||||
import datetime as dt
|
import datetime as dt
|
||||||
import re
|
import os
|
||||||
|
import re
|
||||||
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
|
import stat
|
||||||
from .stockage import CHAMPS
|
from pathlib import Path
|
||||||
|
|
||||||
ATTRIBUTIONS = {
|
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
|
||||||
"infoclimat": "Données Infoclimat",
|
from .stockage import CHAMPS
|
||||||
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
|
|
||||||
"interprétation.",
|
ATTRIBUTIONS = {
|
||||||
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
|
"infoclimat": "Données Infoclimat",
|
||||||
}
|
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
|
||||||
|
"interprétation.",
|
||||||
|
"weatherlink": "Station Gastinel (Davis), données WeatherLink de la station",
|
||||||
def nom_fichier(source, station_id):
|
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
|
||||||
"""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 nom_fichier(source, station_id):
|
||||||
def _releve(r):
|
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
|
||||||
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
|
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
|
||||||
|
|
||||||
|
|
||||||
def _fiche(st):
|
def _releve(r):
|
||||||
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
|
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
|
||||||
"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 _fiche(st):
|
||||||
|
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
|
||||||
def publier(cfg, stockage, maintenant, resumes=None):
|
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
|
||||||
data = cfg.public / "data"
|
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
|
||||||
index = []
|
|
||||||
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
|
|
||||||
for st in stockage.stations():
|
def publier(cfg, stockage, maintenant, resumes=None):
|
||||||
fiche = _fiche(st)
|
data = cfg.public / "data"
|
||||||
der = stockage.derniere(st["source"], st["station_id"])
|
index = []
|
||||||
if der:
|
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
|
||||||
fiche["derniere"] = _releve(der)
|
for st in stockage.stations():
|
||||||
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
|
fiche = _fiche(st)
|
||||||
else:
|
der = stockage.derniere(st["source"], st["station_id"])
|
||||||
fiche["derniere"], fiche["age_min"] = None, None
|
if der:
|
||||||
index.append(fiche)
|
fiche["derniere"] = _releve(der)
|
||||||
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
|
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
|
||||||
ecrire_json(data / "station" / (fiche["id"] + ".json"),
|
else:
|
||||||
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
|
fiche["derniere"], fiche["age_min"] = None, None
|
||||||
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
|
index.append(fiche)
|
||||||
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
|
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
|
||||||
if cfg.direct_compat:
|
ecrire_json(data / "station" / (fiche["id"] + ".json"),
|
||||||
publier_direct_compat(cfg, stockage, maintenant)
|
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
|
||||||
return len(index)
|
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:
|
||||||
def etat(cfg, maintenant, resumes):
|
publier_direct_compat(cfg, stockage, maintenant)
|
||||||
from .commun import Pause, lire_json
|
return len(index)
|
||||||
sources = {}
|
|
||||||
for src in ("infoclimat", "romma"):
|
|
||||||
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
|
def etat(cfg, maintenant, resumes):
|
||||||
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
|
from .commun import Pause, lire_json
|
||||||
succes = e.get("dernier_succes_utc")
|
sources = {}
|
||||||
sources[src] = {
|
for src in ("infoclimat", "romma"):
|
||||||
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
|
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
|
||||||
"en_pause": p.active(maintenant),
|
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
|
||||||
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
|
succes = e.get("dernier_succes_utc")
|
||||||
"dernier_passage": (resumes.get(src) or {}).get("action"),
|
sources[src] = {
|
||||||
}
|
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
|
||||||
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
|
"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"),
|
||||||
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é."""
|
if cfg.weatherlink_actif:
|
||||||
depuis = maintenant - dt.timedelta(hours=48)
|
e = lire_json(cfg.base / "var" / "etat_weatherlink.json", {})
|
||||||
stations, meta = {}, {}
|
succes = [c.get("dernier_succes_utc") for c in e.get("comptes", {}).values() if c.get("dernier_succes_utc")]
|
||||||
for st in stockage.stations():
|
pauses = [Pause(p, 0) for p in sorted((cfg.base / "var").glob("pause_weatherlink_*.txt"))]
|
||||||
if st["source"] != "infoclimat":
|
actives = [p for p in pauses if p.active(maintenant)]
|
||||||
continue
|
sources["weatherlink"] = {
|
||||||
rel = []
|
"dernier_succes_utc": iso(lire_utc(max(succes))) if succes else None,
|
||||||
for r in stockage.serie("infoclimat", st["station_id"], depuis):
|
"en_pause": bool(actives),
|
||||||
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
|
"pause_jusqua_utc": iso(max(p.jusqua() for p in actives)) if actives else None,
|
||||||
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
|
"dernier_passage": ((resumes.get("weatherlink") or {}).get("action")),
|
||||||
x["pluie_cumul_0h"] = r.get("pluie_cumul")
|
}
|
||||||
rel.append(x)
|
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
|
||||||
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 ""}
|
def publier_direct_compat(cfg, stockage, maintenant):
|
||||||
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
|
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
|
||||||
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations})
|
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
|
||||||
@@ -0,0 +1,222 @@
|
|||||||
|
"""Source WeatherLink v2 (Davis) : NOS stations (Allières, Bruyères, Méaudre, Gêve ?), lues à part.
|
||||||
|
|
||||||
|
Entièrement séparée de ROMMA, Infoclimat et Météo-France : autres clés, autre API, autre compteur. Elle ne
|
||||||
|
touche jamais `quota.json` (Infoclimat) ni l'état de ROMMA. Opt-in : `MC_WEATHERLINK_ACTIF=1` ET, pour chaque
|
||||||
|
compte, ses deux variables d'environnement (clé, secret) ; sans elles, aucun appel (`sans_cle`).
|
||||||
|
|
||||||
|
Documentation officielle (https://weatherlink.github.io/v2-api/, lue le 19/10/2026) :
|
||||||
|
* base `https://api.weatherlink.com/v2` ; clé en paramètre `api-key`, secret en en-tête `X-Api-Secret` (jamais en URL) ;
|
||||||
|
* `GET /current/{station-id}` (entier ou UUID) ; une requête par station (pas de requête groupée) ;
|
||||||
|
* limites par défaut : 1000 appels/heure et 10 appels/seconde, par clé ;
|
||||||
|
* réponse : `station_id`, `generated_at`, `sensors[]` ({lsid, sensor_type, data_structure_type, data[{ts, ...}]}).
|
||||||
|
À VÉRIFIER (non lisible dans la doc récupérée, noms repris de la connaissance de l'API, à confirmer sur une vraie
|
||||||
|
réponse) : les noms exacts des champs de chaque capteur, leurs unités (supposées impériales : °F, mph, inHg, in),
|
||||||
|
et le code HTTP au dépassement de limite (429 supposé).
|
||||||
|
|
||||||
|
Chaque donnée garde sa source (« weatherlink ») ; elle n'est jamais fusionnée avec celle d'une autre source, même
|
||||||
|
pour la même station physique (ex. Bruyères publiée aussi par Infoclimat sous 000T0).
|
||||||
|
"""
|
||||||
|
import datetime as dt
|
||||||
|
import json
|
||||||
|
import urllib.error
|
||||||
|
import urllib.parse
|
||||||
|
import urllib.request
|
||||||
|
|
||||||
|
from .commun import UTC, Pause, ecrire_json, fmt_utc, lire_json, scrub
|
||||||
|
|
||||||
|
SOURCE = "weatherlink"
|
||||||
|
URL_BASE = "https://api.weatherlink.com/v2"
|
||||||
|
UA = "weather.gastinel.me/0.1 (meteo-collecte)"
|
||||||
|
AVANCE_TOLEREE_S = 15 * 60
|
||||||
|
ECART_APPELS_S = 0.5 # >= 0,5 s entre deux appels : très en dessous de 10/s
|
||||||
|
PAUSE_ERREUR_S = 15 * 60
|
||||||
|
PAUSE_LIMITE_S = 60 * 60 # limite de débit atteinte : une heure
|
||||||
|
PAUSE_REFUS_S = 6 * 3600 # clé refusée (401/403) : inutile d'insister
|
||||||
|
|
||||||
|
|
||||||
|
class ErreurWeatherLink(Exception):
|
||||||
|
def __init__(self, message, http=None):
|
||||||
|
super().__init__(message)
|
||||||
|
self.http = http
|
||||||
|
|
||||||
|
|
||||||
|
# Champs de /current (À VÉRIFIER). Pour chaque champ publié : noms candidats par ordre de préférence, avec leur
|
||||||
|
# conversion vers nos unités (°C, %, hPa, km/h, degrés, mm, W/m²).
|
||||||
|
def _f2c(x): return (x - 32.0) * 5.0 / 9.0
|
||||||
|
def _mph(x): return x * 1.609344
|
||||||
|
def _inhg(x): return x * 33.8639
|
||||||
|
def _inch(x): return x * 25.4
|
||||||
|
def _id(x): return x
|
||||||
|
|
||||||
|
|
||||||
|
CHAMPS_WL = {
|
||||||
|
"temperature": (("temp", _f2c), ("temp_out", _f2c)),
|
||||||
|
"humidite": (("hum", _id), ("hum_out", _id)),
|
||||||
|
"point_de_rosee": (("dew_point", _f2c),),
|
||||||
|
"pression": (("bar_sea_level", _inhg), ("bar", _inhg)),
|
||||||
|
"vent_moyen": (("wind_speed_avg_last_10_min", _mph), ("wind_speed_last", _mph), ("wind_speed", _mph)),
|
||||||
|
"vent_rafales": (("wind_speed_hi_last_10_min", _mph), ("wind_gust_10_min", _mph)),
|
||||||
|
"vent_direction": (("wind_dir_scalar_avg_last_10_min", _id), ("wind_dir_last", _id), ("wind_dir", _id)),
|
||||||
|
"pluie_1h": (("rainfall_last_60_min_in", _inch),),
|
||||||
|
"pluie_cumul": (("rainfall_daily_in", _inch), ("rain_day_in", _inch)),
|
||||||
|
"rayonnement": (("solar_rad", _id),),
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def construire_url(station_id, cle):
|
||||||
|
"""Seule la clé (non secrète seule) est en URL ; le secret part en en-tête."""
|
||||||
|
return "%s/current/%s?api-key=%s" % (URL_BASE, urllib.parse.quote(str(station_id), safe=""),
|
||||||
|
urllib.parse.quote(cle, safe=""))
|
||||||
|
|
||||||
|
|
||||||
|
def _nombre(v):
|
||||||
|
if isinstance(v, bool) or v is None:
|
||||||
|
return None
|
||||||
|
if isinstance(v, (int, float)):
|
||||||
|
return float(v)
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
def lire_reponse(corps, cle, secret, maintenant):
|
||||||
|
"""-> {dh_utc, mesure, capteurs, avertissements}. Lève ErreurWeatherLink si la réponse est inutilisable."""
|
||||||
|
if isinstance(corps, bytes):
|
||||||
|
corps = corps.decode("utf-8", errors="replace")
|
||||||
|
try:
|
||||||
|
rep = json.loads(corps.strip().lstrip(""))
|
||||||
|
except ValueError:
|
||||||
|
raise ErreurWeatherLink("ce n'est pas du JSON (début : « %s »)" % scrub(corps, cle, secret)[:100])
|
||||||
|
if not isinstance(rep, dict):
|
||||||
|
raise ErreurWeatherLink("un objet JSON était attendu")
|
||||||
|
if rep.get("code") not in (None, 200) and "sensors" not in rep: # corps d'erreur de l'API (forme à vérifier)
|
||||||
|
raise ErreurWeatherLink("erreur API : %s" % scrub(rep.get("message") or rep.get("code"), cle, secret)[:200])
|
||||||
|
capteurs = rep.get("sensors")
|
||||||
|
if not isinstance(capteurs, list):
|
||||||
|
raise ErreurWeatherLink("pas de liste « sensors » dans la réponse")
|
||||||
|
|
||||||
|
avert, brut, ts_champ = [], {}, {}
|
||||||
|
for cap in capteurs:
|
||||||
|
data = cap.get("data") if isinstance(cap, dict) else None
|
||||||
|
if not isinstance(data, list) or not data or not isinstance(data[0], dict):
|
||||||
|
continue # capteur muet (0 enregistrement : normal)
|
||||||
|
rec = data[0]
|
||||||
|
ts = rec.get("ts")
|
||||||
|
for k, v in rec.items():
|
||||||
|
n = _nombre(v)
|
||||||
|
if n is not None and k != "ts" and k not in brut: # 1er capteur qui fournit le champ gagne
|
||||||
|
brut[k], ts_champ[k] = n, ts
|
||||||
|
mesure, ts_temp = {}, None
|
||||||
|
for champ, candidats in CHAMPS_WL.items():
|
||||||
|
for nom, conv in candidats:
|
||||||
|
if nom in brut:
|
||||||
|
mesure[champ] = conv(brut[nom])
|
||||||
|
if champ == "temperature":
|
||||||
|
ts_temp = ts_champ[nom]
|
||||||
|
break
|
||||||
|
if "vent_direction" in mesure:
|
||||||
|
mesure["vent_direction"] %= 360
|
||||||
|
if mesure.get("temperature") is None:
|
||||||
|
raise ErreurWeatherLink("pas de température dans la réponse (capteur absent ou champ inconnu)")
|
||||||
|
ts = ts_temp if isinstance(ts_temp, (int, float)) else None
|
||||||
|
if ts is None:
|
||||||
|
raise ErreurWeatherLink("horodatage (ts) absent")
|
||||||
|
dh = dt.datetime.fromtimestamp(int(ts), UTC)
|
||||||
|
if (dh - maintenant).total_seconds() > AVANCE_TOLEREE_S:
|
||||||
|
raise ErreurWeatherLink("mesure datée dans le futur, ignorée")
|
||||||
|
return {"dh_utc": fmt_utc(dh), "mesure": mesure, "champs_bruts": sorted(brut), "avertissements": avert}
|
||||||
|
|
||||||
|
|
||||||
|
def telecharger(url, secret):
|
||||||
|
req = urllib.request.Request(url, headers={"User-Agent": UA, "X-Api-Secret": secret})
|
||||||
|
return urllib.request.urlopen(req, timeout=30).read()
|
||||||
|
|
||||||
|
|
||||||
|
def _http_vers_erreur(e, cle, secret):
|
||||||
|
msg = scrub("HTTP %s" % e.code, cle, secret)
|
||||||
|
return ErreurWeatherLink(msg, http=e.code)
|
||||||
|
|
||||||
|
|
||||||
|
def _nom_sur(nom):
|
||||||
|
return "".join(c if c.isalnum() or c in "_-" else "_" for c in nom)
|
||||||
|
|
||||||
|
|
||||||
|
def passer(cfg, stockage, journal, maintenant, fetch=telecharger, dormir=None):
|
||||||
|
"""Un tick WeatherLink. Résumé par compte. `dormir(s)` injectable (tests)."""
|
||||||
|
import time
|
||||||
|
dormir = dormir or time.sleep
|
||||||
|
resume = {"source": SOURCE, "action": "rien", "requetes": 0, "comptes": {}}
|
||||||
|
if not cfg.weatherlink_actif:
|
||||||
|
resume["action"] = "desactive" # opt-in
|
||||||
|
return resume
|
||||||
|
config = lire_json(cfg.weatherlink_comptes, {}).get("comptes", {})
|
||||||
|
var = cfg.base / "var"
|
||||||
|
fichier_etat = var / "etat_weatherlink.json"
|
||||||
|
etat = lire_json(fichier_etat, {"comptes": {}})
|
||||||
|
etat.setdefault("comptes", {})
|
||||||
|
premier = True
|
||||||
|
for compte, desc in config.items():
|
||||||
|
r = resume["comptes"][compte] = {"action": "rien", "requetes": 0, "nouvelles": 0}
|
||||||
|
pause = Pause(var / ("pause_weatherlink_%s.txt" % _nom_sur(compte)), PAUSE_ERREUR_S)
|
||||||
|
if pause.active(maintenant):
|
||||||
|
r.update(action="pause", jusqua=fmt_utc(pause.jusqua()))
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
cle = cfg.secret(desc.get("var_cle", ""))
|
||||||
|
secret = cfg.secret(desc.get("var_secret", ""))
|
||||||
|
except LookupError:
|
||||||
|
r["action"] = "sans_cle" # opt-in : sans clé ni secret, aucun appel
|
||||||
|
continue
|
||||||
|
journal.masquer(cle, secret)
|
||||||
|
e = etat["comptes"].setdefault(compte, {"stations": {}, "appels": []})
|
||||||
|
# fenêtre glissante d'une heure : plafond propre, bien en dessous de 1000/h
|
||||||
|
limite = maintenant.timestamp() - 3600
|
||||||
|
e["appels"] = [x for x in e.get("appels", []) if x > limite]
|
||||||
|
for cle_st, st in desc.get("stations", {}).items():
|
||||||
|
sid = st.get("station_id")
|
||||||
|
if not sid:
|
||||||
|
r.setdefault("ignorees", []).append(cle_st) # station_id à fournir
|
||||||
|
continue
|
||||||
|
sid = str(sid)
|
||||||
|
dernier = e["stations"].get(sid)
|
||||||
|
if dernier and maintenant.timestamp() - dernier < cfg.wl_intervalle_s - 30:
|
||||||
|
continue # cache : déjà lue il y a moins d'un intervalle
|
||||||
|
if len(e["appels"]) >= cfg.wl_max_heure:
|
||||||
|
r["action"] = "plafond_heure"
|
||||||
|
journal("WeatherLink %s : plafond de %d requêtes/heure atteint" % (compte, cfg.wl_max_heure), maintenant)
|
||||||
|
break
|
||||||
|
if not premier:
|
||||||
|
dormir(ECART_APPELS_S)
|
||||||
|
premier = False
|
||||||
|
e["appels"].append(maintenant.timestamp())
|
||||||
|
e["stations"][sid] = maintenant.timestamp()
|
||||||
|
ecrire_json(fichier_etat, etat, compact=False) # noté AVANT l'appel
|
||||||
|
r["requetes"] += 1
|
||||||
|
resume["requetes"] += 1
|
||||||
|
try:
|
||||||
|
try:
|
||||||
|
corps = fetch(construire_url(sid, cle), secret)
|
||||||
|
except urllib.error.HTTPError as ex:
|
||||||
|
raise _http_vers_erreur(ex, cle, secret)
|
||||||
|
lu = lire_reponse(corps, cle, secret, maintenant)
|
||||||
|
except Exception as ex:
|
||||||
|
code = getattr(ex, "http", None)
|
||||||
|
duree = PAUSE_LIMITE_S if code == 429 else PAUSE_REFUS_S if code in (401, 403) else PAUSE_ERREUR_S
|
||||||
|
Pause(pause.fichier, duree).poser(maintenant)
|
||||||
|
msg = scrub(str(ex), cle, secret)[:200]
|
||||||
|
journal("ERREUR WeatherLink %s station %s : %s ; pause %d min" % (compte, sid, msg, duree // 60), maintenant)
|
||||||
|
r.update(action="erreur", erreur=msg)
|
||||||
|
break # le compte s'arrête ; les autres comptes continuent
|
||||||
|
stockage.maj_station(SOURCE, sid, nom=st.get("nom"), lat=st.get("lat"), lon=st.get("lon"),
|
||||||
|
altitude=st.get("altitude"), licence="Station Gastinel (Davis, via WeatherLink)",
|
||||||
|
extra=json.dumps({"compte": compte, "a_verifier": st.get("a_verifier")}, ensure_ascii=False))
|
||||||
|
r["nouvelles"] += stockage.ajouter(SOURCE, sid, [dict(lu["mesure"], dh_utc=lu["dh_utc"])], maintenant)
|
||||||
|
e["dernier_succes_utc"] = fmt_utc(maintenant)
|
||||||
|
r["action"] = "appel"
|
||||||
|
etat["comptes"][compte] = e
|
||||||
|
ecrire_json(fichier_etat, etat, compact=False)
|
||||||
|
if any(c["requetes"] for c in resume["comptes"].values()):
|
||||||
|
resume["action"] = "appel"
|
||||||
|
journal("ok WeatherLink : %s" % ", ".join("%s %d req/%d nouv." % (k, v["requetes"], v["nouvelles"])
|
||||||
|
for k, v in resume["comptes"].items() if v["requetes"]), maintenant)
|
||||||
|
if any(c["action"] == "erreur" for c in resume["comptes"].values()):
|
||||||
|
resume["action"] = "erreur"
|
||||||
|
return resume
|
||||||
@@ -0,0 +1,8 @@
|
|||||||
|
{"station_id": 41723, "generated_at": 1792410960, "sensors": [
|
||||||
|
{"lsid": 1001, "sensor_type": 504, "data_structure_type": 15, "data": [{"ts": 1792410900, "battery": 1}]},
|
||||||
|
{"lsid": 1002, "sensor_type": 45, "data_structure_type": 10, "data": [{"ts": 1792410900, "tx_id": 1,
|
||||||
|
"temp": 50.0, "hum": 80.0, "dew_point": 41.0, "wind_speed_avg_last_10_min": 10.0, "wind_speed_hi_last_10_min": 20.0,
|
||||||
|
"wind_dir_scalar_avg_last_10_min": 370, "rainfall_daily_in": 0.5, "rainfall_last_60_min_in": 0.1, "solar_rad": 300}]},
|
||||||
|
{"lsid": 1003, "sensor_type": 242, "data_structure_type": 12, "data": [{"ts": 1792410840, "bar_sea_level": 30.0, "bar_trend": 0.02}]},
|
||||||
|
{"lsid": 1004, "sensor_type": 243, "data_structure_type": 12, "data": []}
|
||||||
|
]}
|
||||||
@@ -0,0 +1,4 @@
|
|||||||
|
{"station_id": 208771, "generated_at": 1792410960, "sensors": [
|
||||||
|
{"lsid": 2001, "sensor_type": 43, "data_structure_type": 2, "data": [{"ts": 1792410900, "temp_out": 32.0, "hum_out": 90,
|
||||||
|
"wind_speed": 5.0, "wind_dir": 90, "bar": 29.5, "rain_day_in": 0.0}]}
|
||||||
|
]}
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
{"code": 401, "message": "Unauthorized: api-key FAKEKEY123 is not valid"}
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
{"station_id": 41723, "generated_at": 1792410960, "sensors": [{"lsid": 1, "sensor_type": 242, "data_structure_type": 12, "data": [{"ts": 1792410900, "bar_sea_level": 30.0}]}]}
|
||||||
@@ -1,34 +1,35 @@
|
|||||||
"""Contrôles statiques des fichiers systemd d'exemple (pas de systemd sous Windows : rien n'est installé)."""
|
"""Contrôles statiques des fichiers systemd d'exemple (pas de systemd sous Windows : rien n'est installé)."""
|
||||||
import datetime as dt
|
import datetime as dt
|
||||||
import re
|
import re
|
||||||
import unittest
|
import unittest
|
||||||
from pathlib import Path
|
from pathlib import Path
|
||||||
|
|
||||||
from meteo_collecte.infoclimat import type_passage
|
from meteo_collecte.infoclimat import type_passage
|
||||||
from tests.aide import t
|
from tests.aide import t
|
||||||
|
|
||||||
DOSSIER = Path(__file__).resolve().parent.parent / "deploiement"
|
DOSSIER = Path(__file__).resolve().parent.parent / "deploiement"
|
||||||
|
|
||||||
|
|
||||||
class TestUnites(unittest.TestCase):
|
class TestUnites(unittest.TestCase):
|
||||||
def test_minuteur_aligne_sur_les_passages(self):
|
def test_minuteur_aligne_sur_les_passages(self):
|
||||||
texte = (DOSSIER / "meteo-collecte.timer").read_text(encoding="utf-8")
|
texte = (DOSSIER / "meteo-collecte.timer").read_text(encoding="utf-8")
|
||||||
m = re.search(r"^OnCalendar=\*:(\d\d)/(\d+)$", texte, re.M)
|
m = re.search(r"^OnCalendar=\*:(\d\d)/(\d+)$", texte, re.M)
|
||||||
self.assertIsNotNone(m)
|
self.assertIsNotNone(m)
|
||||||
depart, pas = int(m.group(1)), int(m.group(2))
|
depart, pas = int(m.group(1)), int(m.group(2))
|
||||||
minutes = list(range(depart, 60, pas))
|
minutes = list(range(depart, 60, pas))
|
||||||
self.assertEqual(minutes, [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59])
|
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]
|
genres = [type_passage(t(12, 0) + dt.timedelta(minutes=x)) for x in minutes]
|
||||||
self.assertEqual(genres, ["principal", "rattrapage"] * 6)
|
self.assertEqual(genres, ["principal", "rattrapage"] * 6)
|
||||||
|
|
||||||
def test_service_sans_secret_ni_sudo(self):
|
def test_service_sans_secret_ni_sudo(self):
|
||||||
texte = (DOSSIER / "meteo-collecte.service").read_text(encoding="utf-8")
|
texte = (DOSSIER / "meteo-collecte.service").read_text(encoding="utf-8")
|
||||||
actif = [l for l in texte.splitlines() if l and not l.startswith("#")]
|
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))
|
self.assertTrue(any(l.startswith("ExecStart=") and "meteo_collecte.ordonnanceur" in l for l in actif))
|
||||||
for l in actif:
|
for l in actif:
|
||||||
self.assertNotRegex(l, r"(?i)MC_JETON_INFOCLIMAT=|MC_CLE_ROMMA=|token=|apikey=|sudo")
|
self.assertNotRegex(l, r"(?i)MC_JETON_INFOCLIMAT=|MC_CLE_ROMMA=|token=|apikey=|sudo")
|
||||||
self.assertIn("EnvironmentFile=-", texte)
|
self.assertIn("EnvironmentFile=%h/.config/meteo-collecte/env", texte)
|
||||||
|
self.assertNotIn("EnvironmentFile=-", texte)
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
unittest.main()
|
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()
|
||||||
@@ -0,0 +1,195 @@
|
|||||||
|
import json
|
||||||
|
import tempfile
|
||||||
|
import unittest
|
||||||
|
import urllib.error
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
from meteo_collecte import ordonnanceur, publier, weatherlink
|
||||||
|
from meteo_collecte.commun import Config, lire_json, scrub
|
||||||
|
from meteo_collecte.stockage import Stockage
|
||||||
|
from tests.aide import FauxReseau, config, fixture, t
|
||||||
|
|
||||||
|
CLE_A, SEC_A = "CLEALLIERES-FICTIVE", "SECRETALLIERES-FICTIF"
|
||||||
|
CLE_B, SEC_B = "CLEBRUYERES-FICTIVE", "SECRETBRUYERES-FICTIF"
|
||||||
|
APPEL = t(12, 0, jour=19) # ts des fixtures = 11:55 UTC le 19/10/2026
|
||||||
|
|
||||||
|
COMPTES = {"comptes": {
|
||||||
|
"allieres": {"var_cle": "MC_WL_ALLIERES_CLE", "var_secret": "MC_WL_ALLIERES_SECRET",
|
||||||
|
"stations": {"ALL": {"station_id": None, "nom": "Allières"}}},
|
||||||
|
"bruyeres-meaudre": {"var_cle": "MC_WL_BRUYERES_CLE", "var_secret": "MC_WL_BRUYERES_SECRET",
|
||||||
|
"stations": {"B": {"station_id": "41723", "nom": "Bruyères", "altitude": 990},
|
||||||
|
"M": {"station_id": "208771", "nom": "Méaudre"}}}}}
|
||||||
|
|
||||||
|
|
||||||
|
def pas_de_dormir(s):
|
||||||
|
pass
|
||||||
|
|
||||||
|
|
||||||
|
class Base(unittest.TestCase):
|
||||||
|
def setUp(self):
|
||||||
|
self.tmp = tempfile.TemporaryDirectory()
|
||||||
|
self.cfg, self.journal = config(self.tmp.name, weatherlink_actif=True)
|
||||||
|
self.cfg.weatherlink_comptes = Path(self.tmp.name) / "comptes.json"
|
||||||
|
self.cfg.weatherlink_comptes.write_text(json.dumps(COMPTES), encoding="utf-8")
|
||||||
|
self.cfg.env.update({"MC_WL_BRUYERES_CLE": CLE_B, "MC_WL_BRUYERES_SECRET": SEC_B})
|
||||||
|
self.s = Stockage(Path(self.tmp.name) / "m.sqlite")
|
||||||
|
|
||||||
|
def tearDown(self):
|
||||||
|
self.s.fermer()
|
||||||
|
self.tmp.cleanup()
|
||||||
|
|
||||||
|
def passer(self, fetch, quand=APPEL):
|
||||||
|
return weatherlink.passer(self.cfg, self.s, self.journal, quand, fetch, pas_de_dormir)
|
||||||
|
|
||||||
|
|
||||||
|
class TestLecture(unittest.TestCase):
|
||||||
|
def test_conversions_iss(self):
|
||||||
|
r = weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", APPEL)
|
||||||
|
m = r["mesure"]
|
||||||
|
self.assertEqual(r["dh_utc"], "2026-10-19 11:55:00")
|
||||||
|
self.assertAlmostEqual(m["temperature"], 10.0)
|
||||||
|
self.assertAlmostEqual(m["point_de_rosee"], 5.0)
|
||||||
|
self.assertEqual(m["humidite"], 80.0)
|
||||||
|
self.assertAlmostEqual(m["vent_moyen"], 16.09344)
|
||||||
|
self.assertAlmostEqual(m["vent_rafales"], 32.18688)
|
||||||
|
self.assertEqual(m["vent_direction"], 10.0) # 370 -> 10
|
||||||
|
self.assertAlmostEqual(m["pluie_cumul"], 12.7)
|
||||||
|
self.assertAlmostEqual(m["pluie_1h"], 2.54)
|
||||||
|
self.assertAlmostEqual(m["pression"], 1015.917, places=2) # capteur barométrique distinct, même station
|
||||||
|
self.assertEqual(m["rayonnement"], 300.0)
|
||||||
|
|
||||||
|
def test_vantage_pro2_noms_anciens(self):
|
||||||
|
m = weatherlink.lire_reponse(fixture("weatherlink_current_vp2.json"), "K", "S", APPEL)["mesure"]
|
||||||
|
self.assertAlmostEqual(m["temperature"], 0.0)
|
||||||
|
self.assertEqual((m["humidite"], m["vent_direction"]), (90.0, 90.0))
|
||||||
|
self.assertAlmostEqual(m["vent_moyen"], 8.04672)
|
||||||
|
self.assertEqual(m["pluie_cumul"], 0.0) # 0 reste 0, pas None
|
||||||
|
|
||||||
|
def test_reponses_inutilisables(self):
|
||||||
|
for corps in (fixture("weatherlink_sans_temperature.json"), b"<html>", b"[]", b'{"a":1}',
|
||||||
|
fixture("weatherlink_erreur.json")):
|
||||||
|
with self.assertRaises(weatherlink.ErreurWeatherLink):
|
||||||
|
weatherlink.lire_reponse(corps, "FAKEKEY123", "S", APPEL)
|
||||||
|
with self.assertRaises(weatherlink.ErreurWeatherLink) as c:
|
||||||
|
weatherlink.lire_reponse(fixture("weatherlink_erreur.json"), "FAKEKEY123", "S", APPEL)
|
||||||
|
self.assertNotIn("FAKEKEY123", str(c.exception))
|
||||||
|
|
||||||
|
def test_futur_refuse(self):
|
||||||
|
with self.assertRaises(weatherlink.ErreurWeatherLink):
|
||||||
|
weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", t(11, 0, jour=19))
|
||||||
|
|
||||||
|
def test_url_cle_seule_secret_en_entete(self):
|
||||||
|
u = weatherlink.construire_url("41723", "AB/C")
|
||||||
|
self.assertEqual(u, "https://api.weatherlink.com/v2/current/41723?api-key=AB%2FC")
|
||||||
|
self.assertNotIn("***", scrub(u)[:10])
|
||||||
|
self.assertIn("api-key=***", scrub(u))
|
||||||
|
|
||||||
|
|
||||||
|
class TestPassage(Base):
|
||||||
|
def test_desactive_par_defaut(self):
|
||||||
|
self.assertFalse(Config.depuis_env({}).weatherlink_actif)
|
||||||
|
self.cfg.weatherlink_actif = False
|
||||||
|
res = FauxReseau(fixture("weatherlink_current_iss.json"))
|
||||||
|
self.assertEqual(self.passer(res)["action"], "desactive")
|
||||||
|
self.assertEqual(res.urls, [])
|
||||||
|
|
||||||
|
def test_source_distincte_et_pas_de_station_sans_id(self):
|
||||||
|
class Rec:
|
||||||
|
def __init__(s): s.appels = []
|
||||||
|
def __call__(s, url, secret):
|
||||||
|
s.appels.append((url, secret))
|
||||||
|
return fixture("weatherlink_current_iss.json" if "41723" in url else "weatherlink_current_vp2.json")
|
||||||
|
rec = Rec()
|
||||||
|
r = self.passer(rec)
|
||||||
|
self.assertEqual(r["requetes"], 2)
|
||||||
|
self.assertEqual(r["comptes"]["allieres"]["action"], "sans_cle") # pas de clé : aucun appel
|
||||||
|
self.assertEqual({s for _, s in rec.appels}, {SEC_B}) # secret en en-tête, jamais en URL
|
||||||
|
self.assertTrue(all(SEC_B not in u and "api-key=" + CLE_B in u for u, _ in rec.appels))
|
||||||
|
self.assertEqual(self.s.compter("weatherlink"), 2)
|
||||||
|
self.assertEqual(self.s.compter("infoclimat") + self.s.compter("romma"), 0)
|
||||||
|
self.assertAlmostEqual(self.s.derniere("weatherlink", "41723")["temperature"], 10.0)
|
||||||
|
st = {x["station_id"]: x for x in self.s.stations()}
|
||||||
|
self.assertEqual(st["41723"]["source"], "weatherlink")
|
||||||
|
self.assertIn("bruyeres-meaudre", st["41723"]["extra"])
|
||||||
|
|
||||||
|
def test_station_id_manquant_ignoree(self):
|
||||||
|
self.cfg.env.update({"MC_WL_ALLIERES_CLE": CLE_A, "MC_WL_ALLIERES_SECRET": SEC_A})
|
||||||
|
res = FauxReseau(fixture("weatherlink_current_iss.json"))
|
||||||
|
r = self.passer(lambda u, s: res(u))
|
||||||
|
self.assertEqual(r["comptes"]["allieres"]["ignorees"], ["ALL"])
|
||||||
|
self.assertEqual(r["comptes"]["allieres"]["requetes"], 0)
|
||||||
|
|
||||||
|
def test_cache_dix_minutes(self):
|
||||||
|
res = FauxReseau(fixture("weatherlink_current_iss.json"))
|
||||||
|
f = lambda u, s: res(u)
|
||||||
|
self.passer(f)
|
||||||
|
self.assertEqual(len(res.urls), 2)
|
||||||
|
self.assertEqual(self.passer(f, t(12, 5, jour=19))["requetes"], 0) # moins de 10 min : cache
|
||||||
|
self.assertEqual(len(res.urls), 2)
|
||||||
|
self.passer(f, t(12, 11, jour=19))
|
||||||
|
self.assertEqual(len(res.urls), 4)
|
||||||
|
|
||||||
|
def test_plafond_horaire_propre(self):
|
||||||
|
self.cfg.wl_max_heure = 1
|
||||||
|
res = FauxReseau(fixture("weatherlink_current_iss.json"))
|
||||||
|
r = self.passer(lambda u, s: res(u))
|
||||||
|
self.assertEqual(len(res.urls), 1)
|
||||||
|
self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "plafond_heure")
|
||||||
|
|
||||||
|
def test_erreur_http_pause_et_secrets_masques(self):
|
||||||
|
def f(url, secret):
|
||||||
|
raise urllib.error.HTTPError(url, 429, "Too Many Requests " + SEC_B, {}, None)
|
||||||
|
r = self.passer(f)
|
||||||
|
self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "erreur")
|
||||||
|
self.assertEqual(r["requetes"], 1) # le compte s'arrête net
|
||||||
|
texte = (self.cfg.base / "var" / "journal.log").read_text(encoding="utf-8")
|
||||||
|
for secret in (CLE_B, SEC_B):
|
||||||
|
self.assertNotIn(secret, texte)
|
||||||
|
self.assertNotIn(secret, json.dumps(r))
|
||||||
|
res = FauxReseau(fixture("weatherlink_current_iss.json"))
|
||||||
|
r2 = self.passer(lambda u, s: res(u), t(12, 30, jour=19)) # 429 : pause 1 h
|
||||||
|
self.assertEqual(r2["comptes"]["bruyeres-meaudre"]["action"], "pause")
|
||||||
|
self.assertEqual(res.urls, [])
|
||||||
|
self.assertEqual(self.passer(lambda u, s: res(u), t(13, 1, jour=19))["requetes"], 2)
|
||||||
|
|
||||||
|
def test_ne_touche_pas_le_quota_infoclimat(self):
|
||||||
|
res = FauxReseau(fixture("weatherlink_current_iss.json"))
|
||||||
|
self.passer(lambda u, s: res(u))
|
||||||
|
self.assertFalse(self.cfg.quota_commun.exists())
|
||||||
|
self.assertFalse((self.cfg.base / "var" / "etat_romma.json").exists())
|
||||||
|
|
||||||
|
|
||||||
|
class TestIntegration(Base):
|
||||||
|
def test_tick_et_publication(self):
|
||||||
|
self.cfg.env.update({"MC_ROMMA_ACTIF": "0"})
|
||||||
|
self.cfg.romma_actif = self.cfg.infoclimat_actif = False
|
||||||
|
res = FauxReseau(fixture("weatherlink_current_iss.json"))
|
||||||
|
ordonnanceur.tick(self.cfg, APPEL, fetch_weatherlink=lambda u, s: res(u), dormir_weatherlink=pas_de_dormir)
|
||||||
|
data = self.cfg.public / "data"
|
||||||
|
idx = lire_json(data / "stations.json", {})
|
||||||
|
par = {x["id"]: x for x in idx["stations"]}
|
||||||
|
self.assertEqual(set(par), {"weatherlink-41723", "weatherlink-208771"})
|
||||||
|
self.assertEqual(par["weatherlink-41723"]["source"], "weatherlink")
|
||||||
|
self.assertIn("Station Gastinel", par["weatherlink-41723"]["attribution"])
|
||||||
|
self.assertIn("weatherlink", lire_json(data / "etat.json", {})["sources"])
|
||||||
|
for p in data.rglob("*.json"):
|
||||||
|
texte = p.read_text(encoding="utf-8")
|
||||||
|
for secret in (CLE_B, SEC_B, "api-key"):
|
||||||
|
self.assertNotIn(secret, texte)
|
||||||
|
|
||||||
|
def test_tick_desactive_ne_publie_pas_la_source(self):
|
||||||
|
self.cfg.weatherlink_actif = False
|
||||||
|
self.cfg.romma_actif = self.cfg.infoclimat_actif = False
|
||||||
|
ordonnanceur.tick(self.cfg, APPEL)
|
||||||
|
self.assertNotIn("weatherlink", lire_json(self.cfg.public / "data" / "etat.json", {})["sources"])
|
||||||
|
|
||||||
|
def test_fichier_de_comptes_du_depot_sans_valeur_secrete(self):
|
||||||
|
brut = (Path(__file__).resolve().parent.parent / "config" / "weatherlink.json").read_text(encoding="utf-8")
|
||||||
|
comptes = json.loads(brut)["comptes"]
|
||||||
|
for c in comptes.values():
|
||||||
|
self.assertTrue(c["var_cle"].startswith("MC_WL_") and c["var_secret"].startswith("MC_WL_"))
|
||||||
|
self.assertEqual(len({c["var_cle"] for c in comptes.values()}), len(comptes)) # une clé par compte
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
Référencer dans un nouveau ticket
Bloquer un utilisateur