Auteur SHA1 Message Date

2026-10-17

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

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

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

Aucun fichier ne correspond à votre recherche

+81 -75
Voir le fichier
@@ -1,75 +1,81 @@
# 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
## Commandes
```sh
python3 -m meteo_collecte.ordonnanceur # un tick ```sh
python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente » python3 -m meteo_collecte.ordonnanceur --publier # republie depuis la base, sans aucun appel réseau
``` python3 -m meteo_collecte.ordonnanceur --config # configuration ; secrets : « définie » ou « absente »
```
## Tests (hors ligne)
## Tests (hors ligne)
```sh
python -m pytest -q # ou : python -m unittest discover -s . -p "test_*.py" ```sh
python -m pytest -q -s tests/test_hors_ligne.py # affiche les compteurs de requêtes simulés 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 `tests/__init__.py` coupe le réseau (DNS et connexions hors boucle locale lèvent une erreur) : aucun test ne
sont des valeurs fictives passées dans un environnement en mémoire. `tests/test_hors_ligne.py` simule peut joindre une API. Les réponses viennent de `tests/fixtures/` ou de petits serveurs simulés ; les secrets
plusieurs jours de ticks (fonctionnement normal, plafond, panne longue, sans secrets, purge, heure d'hiver). 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
## Déploiement (VPS, non activé)
`deploiement/meteo-collecte.service` et `.timer` sont des **exemples non installés** (unité utilisateur).
Points à vérifier avant installation par Théo : voir les commentaires `[À VÉRIFIER]` en tête du service `bash deploy/deployer-vps.sh` (depuis le PC ou le VPS) copie le code dans `~/meteo-collecte`, installe les unités
(emplacement du code, linger, arrêt de `meteo-direct.timer` pour ne pas compter deux fois le quota). utilisateur `deploiement/meteo-collecte.service` et `.timer` **sans les activer**, crée `~/.config/meteo-collecte/env`
vide (600) et lance un `--config` et un `--publier` de contrôle. `--activer` active le minuteur, seulement si
linger est actif, `/srv/weather.gastinel.me` est accessible en écriture et `meteo-direct.timer` est arrêté.
Les secrets ne sont jamais saisis par script : Théo les met dans le fichier env avec un éditeur.
Caddy (`weather.gastinel.me`, `/data/*` en lecture seule) : `deploy/appliquer-caddy-meteo.sh`, à lancer par Théo avec sudo.
Procédure complète : `NOTES
apport-deploiement-meteo-collecte-20261017.md`.
+32 -33
Voir le fichier
@@ -1,33 +1,32 @@
# EXEMPLE — non installé. Unité « utilisateur » proposée pour le VPS (à relire par Théo avant toute installation). # 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 -1
Voir le fichier
@@ -1,4 +1,4 @@
# EXEMPLE — non installé. Tick toutes les 5 min à hh:x4 et hh:x9 : # Minuteur utilisateur : tick toutes les 5 min à hh:x4 et hh:x9 (installé par deploy/deployer-vps.sh, NON activé).
# hh:x4 = passage principal Infoclimat (+ ROMMA si 10 min écoulées), hh:x9 = rattrapage ciblé. # hh:x4 = passage principal Infoclimat (+ ROMMA si 10 min écoulées), hh:x9 = rattrapage ciblé.
[Unit] [Unit]
+53
Voir le fichier
@@ -0,0 +1,53 @@
#!/bin/bash
# Caddy pour weather.gastinel.me : sert en LECTURE SEULE /data/* depuis /srv/weather.gastinel.me (JSON publiés
# par meteo-collecte), avec CORS pour le site LAN. Tout le reste : 404.
# Ajoute un bloc en fin de /etc/caddy/Caddyfile. Sauvegarde -> validation -> rechargement ; retour arrière si échec.
# Installation (root:root 755, après vérification du sha256 affiché par deployer-vps.sh) :
# sudo install -o root -g root -m 755 appliquer-caddy-meteo.sh /usr/local/sbin/appliquer-caddy-meteo.sh
# Usage : sudo /usr/local/sbin/appliquer-caddy-meteo.sh
set -euo pipefail
[ "$(id -u)" = 0 ] || { echo "A lancer avec sudo"; exit 1; }
CF=/etc/caddy/Caddyfile
BAK="$CF.avant-meteo-1017"
DOSSIER=/srv/weather.gastinel.me
PROPRIO=${SUDO_USER:-debian}
[ -e "$BAK" ] && { echo "Refus : $BAK existe deja (sauvegarde precedente conservee)."; exit 1; }
grep -q "weather.gastinel.me" "$CF" && { echo "Refus : weather.gastinel.me est deja dans le Caddyfile."; exit 1; }
# Dossier servi : copie de fichiers ordinaires faite par le collecteur (MC_SERVI, publier.copier_vers_servi) ;
# il n'est jamais le dossier de publication. Les liens symboliques y sont refusés (ni ce script ni Caddy ne les suivent).
[ -L "$DOSSIER" ] && { echo "Refus : $DOSSIER est un lien symbolique."; exit 1; }
install -d -m 755 -o "$PROPRIO" -g "$PROPRIO" "$DOSSIER"
echo "Dossier : $DOSSIER (proprietaire $PROPRIO)"
cp -a "$CF" "$BAK"
echo "Sauvegarde : $BAK"
cat >> "$CF" <<'CADDY'
# meteo-collecte (weather.gastinel.me) : donnees publiees, lecture seule.
weather.gastinel.me {
import /etc/caddy/securite.caddy
handle /data/* {
header Access-Control-Allow-Origin "*"
header Cache-Control "no-cache"
root * /srv/weather.gastinel.me
file_server
}
handle {
respond "Pas encore en ligne." 404
}
}
CADDY
if caddy validate --config "$CF" --adapter caddyfile && systemctl reload caddy; then
echo "OK : Caddy recharge."
if sudo -u caddy test -r "$DOSSIER" ; then echo "Caddy peut lire $DOSSIER."; else echo "ATTENTION : Caddy ne peut pas lire $DOSSIER."; fi
else
echo "ECHEC : restauration de $BAK"
cp -a "$BAK" "$CF"
systemctl reload caddy || true
exit 1
fi
+115
Voir le fichier
@@ -0,0 +1,115 @@
#!/usr/bin/env bash
# Déploiement de meteo-collecte sur le VPS cornafsuisse (utilisateur debian). Aucun appel API, aucun secret lu ni affiché.
#
# bash deploy/deployer-vps.sh copie le code, installe les unités (NON activées), --config et --publier de contrôle
# bash deploy/deployer-vps.sh --activer active meteo-collecte.timer, seulement si toutes les conditions sont réunies
#
# Lancé depuis le PC (ssh cornafsuisse) ou sur le VPS lui-même (détecté par le nom d'hôte).
# Sans sudo. Tout fichier existant remplacé est sauvegardé en <nom>.avant-deploiement-1017 (jamais écrasé).
# Les noms de fichiers ne sont jamais interpolés dans une commande distante : la liste passe en données NUL.
set -euo pipefail
HOTE_VPS=${HOTE_VPS:-cornafsuisse}
NOM_VPS=ov-edfba0
HORODATAGE=1017
ICI=$(cd "$(dirname "$0")/.." && pwd)
ACTIVER=0
[ "${1:-}" = "--activer" ] && ACTIVER=1
if [ "$(hostname)" = "$NOM_VPS" ]; then
vps() { bash -c "$1"; }
else
vps() { ssh -o BatchMode=yes -o ConnectTimeout=20 "$HOTE_VPS" "$1"; }
fi
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' EXIT
cd "$ICI"
if [ -n "$(git status --porcelain -- meteo_collecte config deploiement deploy)" ]; then
echo "ATTENTION : modifications non commitées ; le VPS recevra l'arbre de travail tel quel."
fi
echo "== 1. Liste des fichiers de code (séparateur NUL)"
find meteo_collecte config -type f ! -path '*/__pycache__/*' ! -name '*.pyc' -print0 | sort -z > "$TMP/liste0"
tr -cd '\0' < "$TMP/liste0" | wc -c
echo "== 2. Sauvegardes de ce qui sera remplacé (.avant-deploiement-$HORODATAGE)"
# Le script distant est fixe (guillemets simples) ; les noms arrivent sur stdin, séparés par NUL.
vps 'C="$HOME/meteo-collecte"; U="$HOME/.config/systemd/user"; H=1017
bak() { if [ -e "$1" ] && [ ! -e "$1.avant-deploiement-'"$HORODATAGE"'" ]; then cp -p -- "$1" "$1.avant-deploiement-'"$HORODATAGE"'"; echo "sauvegarde : $1"; fi; }
while IFS= read -r -d "" f; do bak "$C/$f"; done
bak "$U/meteo-collecte.service"; bak "$U/meteo-collecte.timer"; echo "sauvegardes terminees"' < "$TMP/liste0"
echo "== 3. Copie du code dans ~/meteo-collecte (var/ et public/ ne sont jamais touchés)"
vps 'mkdir -p "$HOME/meteo-collecte"'
tar -C "$ICI" -cf - --exclude='__pycache__' --exclude='*.pyc' meteo_collecte config \
| vps 'tar -C "$HOME/meteo-collecte" -xf -'
echo "== 4. Unités systemd utilisateur (installées, non activées)"
vps 'mkdir -p "$HOME/.config/systemd/user" && cat > "$HOME/.config/systemd/user/meteo-collecte.service"' \
< "$ICI/deploiement/meteo-collecte.service"
vps 'cat > "$HOME/.config/systemd/user/meteo-collecte.timer"' < "$ICI/deploiement/meteo-collecte.timer"
vps 'systemctl --user daemon-reload'
echo "== 5. Fichier de secrets : créé VIDE s'il n'existe pas (contenu jamais affiché)"
vps 'mkdir -p -m 700 "$HOME/.config/meteo-collecte"
E="$HOME/.config/meteo-collecte/env"
if [ ! -e "$E" ]; then (umask 077 && : > "$E"); echo "env cree (vide)"; else echo "env deja present"; fi
chmod 600 "$E"; echo "droits : $(stat -c %a "$E") taille : $(stat -c %s "$E") octets"'
echo "== 6. Script Caddy : copié dans deploy/ (dossier du collecteur, PAS dans ~), à installer en root par Théo"
vps 'mkdir -p "$HOME/meteo-collecte/deploy"'
vps 'cat > "$HOME/meteo-collecte/deploy/appliquer-caddy-meteo.sh"' < "$ICI/deploy/appliquer-caddy-meteo.sh"
SHA=$(sha256sum "$ICI/deploy/appliquer-caddy-meteo.sh" | cut -d' ' -f1)
echo "sha256 attendu : $SHA"
echo "Théo, sur le VPS, vérifier puis installer en root (la commande refuse si le hash diffère) :"
echo " cd ~/meteo-collecte/deploy && echo \"$SHA appliquer-caddy-meteo.sh\" | sha256sum -c - && \\"
echo " sudo install -o root -g root -m 755 appliquer-caddy-meteo.sh /usr/local/sbin/appliquer-caddy-meteo.sh"
echo " sudo /usr/local/sbin/appliquer-caddy-meteo.sh"
echo "== 7. Contrôle --config (noms de variables et « définie / absente » seulement)"
vps 'systemd-run --user --wait --pipe --quiet \
-p WorkingDirectory="$HOME/meteo-collecte" \
-p EnvironmentFile="$HOME/.config/meteo-collecte/env" \
-p Environment=MC_BASE="$HOME/meteo-collecte" \
-p Environment=MC_PUBLIC="$HOME/meteo-collecte/public" \
-p Environment=MC_SERVI= \
-p Environment=MC_DIRECT_COMPAT="$HOME/meteo-collecte/direct-compat.json" \
/usr/bin/python3 -m meteo_collecte.ordonnanceur --config' \
|| echo "ATTENTION : --config non obtenu (systemd-run --user indisponible ?)"
echo "== 8. Contrôle --publier (aucun appel réseau ; écrit dans ~/meteo-collecte/public ; MC_SERVI vide, donc"
echo " rien dans /srv ; MC_DIRECT_COMPAT vide, donc ~/meteo-direct/direct.json n'est jamais touché)"
vps 'cd "$HOME/meteo-collecte" && env -i HOME="$HOME" PATH="$PATH" MC_BASE="$HOME/meteo-collecte" \
MC_PUBLIC="$HOME/meteo-collecte/public" MC_SERVI= MC_DIRECT_COMPAT= /usr/bin/python3 -m meteo_collecte.ordonnanceur --publier \
&& ls -l "$HOME/meteo-collecte/public/data"'
if [ "$ACTIVER" = 0 ]; then
echo
echo "Minuteur NON active. Étapes suivantes : voir rapport-deploiement-meteo-collecte-20261017.md (dossier NOTES)."
echo "Activation, une fois le jeton saisi, le script Caddy installé et linger actif : bash deploy/deployer-vps.sh --activer"
exit 0
fi
echo "== 9. Activation (conditions vérifiées sur le VPS avant)"
vps 'bash -s' <<'DISTANT'
set -eu
ok=1
if [ "$(loginctl show-user "$USER" -p Linger --value 2>/dev/null)" != "yes" ]; then
echo "REFUS : linger desactive. Sans lui le minuteur s'arrete a la fin de la session SSH."
echo " Theo, sur le VPS : sudo loginctl enable-linger debian"; ok=0
fi
if [ ! -d /srv/weather.gastinel.me ] || [ -L /srv/weather.gastinel.me ] || [ ! -w /srv/weather.gastinel.me ]; then
echo "REFUS : /srv/weather.gastinel.me absent, lien, ou non accessible en ecriture."
echo " Theo, sur le VPS : sudo /usr/local/sbin/appliquer-caddy-meteo.sh (voir l'etape 6)"; ok=0
fi
if systemctl is-active --quiet meteo-direct.timer; then
echo "REFUS : meteo-direct.timer est actif (deux collecteurs compteraient le meme quota)."
echo " Theo, sur le VPS : sudo systemctl stop meteo-direct.timer (puis decider de sa desactivation)"; ok=0
fi
[ "$ok" = 1 ] || exit 1
systemctl --user daemon-reload
systemctl --user enable --now meteo-collecte.timer
systemctl --user list-timers meteo-collecte.timer --no-pager
DISTANT
+243 -241
Voir le fichier
@@ -1,241 +1,243 @@
"""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) direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN)
# Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites). servi: Path = None # si défini : copie des seuls fichiers réguliers de public/data/ (voir publier.py)
# On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur. # Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites).
var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT" # On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur.
var_cle_romma: str = "MC_CLE_ROMMA" var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT"
env: object = field(default=None, repr=False) var_cle_romma: str = "MC_CLE_ROMMA"
env: object = field(default=None, repr=False)
def secret(self, nom_variable):
"""Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide.""" def secret(self, nom_variable):
e = os.environ if self.env is None else self.env """Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide."""
v = (e.get(nom_variable) or "").strip() e = os.environ if self.env is None else self.env
if not v: v = (e.get(nom_variable) or "").strip()
raise LookupError("variable %s absente ou vide" % nom_variable) if not v:
return v raise LookupError("variable %s absente ou vide" % nom_variable)
return v
@classmethod
def depuis_env(cls, env=None): @classmethod
e = os.environ if env is None else env def depuis_env(cls, env=None):
home = Path.home() e = os.environ if env is None else env
base = Path(e.get("MC_BASE") or home / "meteo-collecte") home = Path.home()
base = Path(e.get("MC_BASE") or home / "meteo-collecte")
def chemin(nom, defaut):
return Path(e[nom]) if e.get(nom) else defaut def chemin(nom, defaut):
return Path(e[nom]) if e.get(nom) else defaut
def oui(nom, defaut):
v = e.get(nom) def oui(nom, defaut):
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes") v = e.get(nom)
return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes")
return cls(
base=base, return cls(
public=chemin("MC_PUBLIC", base / "public"), base=base,
quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"), public=chemin("MC_PUBLIC", base / "public"),
stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"), quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"),
plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)), stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"),
plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)), plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)),
alerte_active=oui("MC_ALERTE_ACTIVE", False), plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)),
ntfy_url=e.get("MC_NTFY_URL", ""), alerte_active=oui("MC_ALERTE_ACTIVE", False),
compte_par_station=oui("MC_COMPTE_PAR_STATION", False), ntfy_url=e.get("MC_NTFY_URL", ""),
lot_max=int(e.get("MC_LOT_MAX", 25)), compte_par_station=oui("MC_COMPTE_PAR_STATION", False),
romma_actif=oui("MC_ROMMA_ACTIF", True), lot_max=int(e.get("MC_LOT_MAX", 25)),
infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True), romma_actif=oui("MC_ROMMA_ACTIF", True),
direct_compat=chemin("MC_DIRECT_COMPAT", None), infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True),
env=env, direct_compat=chemin("MC_DIRECT_COMPAT", None),
) servi=chemin("MC_SERVI", None),
env=env,
)
# ---------------------------------------------------------------------------
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows)
def _dernier_dimanche(annee, mois): # ---------------------------------------------------------------------------
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7) def _dernier_dimanche(annee, mois):
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
def decalage_paris(utc):
"""Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST)."""
a = utc.year def decalage_paris(utc):
debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC) """Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST)."""
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC) a = utc.year
return dt.timedelta(hours=2 if debut <= utc < fin else 1) debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC)
fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC)
return dt.timedelta(hours=2 if debut <= utc < fin else 1)
def vers_paris(utc):
return (utc + decalage_paris(utc)).replace(tzinfo=None)
def vers_paris(utc):
return (utc + decalage_paris(utc)).replace(tzinfo=None)
def paris_vers_utc(local, maintenant=None):
"""Heure locale de Paris (naïve) -> instant UTC.
def paris_vers_utc(local, maintenant=None):
None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus """Heure locale de Paris (naïve) -> instant UTC.
récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
""" None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus
possibles = [] récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne).
for h in (2, 1): """
c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC) possibles = []
if (c + decalage_paris(c)).replace(tzinfo=None) == local: for h in (2, 1):
possibles.append(c) c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC)
if not possibles: if (c + decalage_paris(c)).replace(tzinfo=None) == local:
return None possibles.append(c)
if len(possibles) == 1 or maintenant is None: if not possibles:
return possibles[0] return None
passes = [c for c in possibles if c <= maintenant] if len(possibles) == 1 or maintenant is None:
return max(passes) if passes else min(possibles) return possibles[0]
passes = [c for c in possibles if c <= maintenant]
return max(passes) if passes else min(possibles)
def jour_paris(utc):
return str(vers_paris(utc).date())
def jour_paris(utc):
return str(vers_paris(utc).date())
def fmt_utc(t):
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
def fmt_utc(t):
return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S")
def lire_utc(s):
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
def lire_utc(s):
return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
def iso(t):
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
def iso(t):
return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
# ---------------------------------------------------------------------------
# Fichiers
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
# Fichiers
def lire_json(p, defaut): # ---------------------------------------------------------------------------
try:
return json.loads(Path(p).read_text(encoding="utf-8")) def lire_json(p, defaut):
except (OSError, ValueError): try:
return defaut return json.loads(Path(p).read_text(encoding="utf-8"))
except (OSError, ValueError):
return defaut
def ecrire_json(p, d, compact=True):
"""Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
p = Path(p) def ecrire_json(p, d, compact=True):
p.parent.mkdir(parents=True, exist_ok=True) """Écriture atomique : fichier temporaire dans le même dossier, puis os.replace."""
tmp = p.with_name(p.name + ".tmp-%d" % os.getpid()) p = Path(p)
texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None, p.parent.mkdir(parents=True, exist_ok=True)
indent=None if compact else 1) tmp = p.with_name(p.name + ".tmp-%d" % os.getpid())
tmp.write_text(texte, encoding="utf-8") texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None,
os.replace(tmp, p) indent=None if compact else 1)
tmp.write_text(texte, encoding="utf-8")
os.replace(tmp, p)
def scrub(texte, *secrets):
"""Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte)) def scrub(texte, *secrets):
for s in secrets: """Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL."""
if s: texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte))
texte = texte.replace(s, "***") for s in secrets:
enc = urllib.parse.quote(s, safe="") if s:
if enc != s: texte = texte.replace(s, "***")
texte = texte.replace(enc, "***") enc = urllib.parse.quote(s, safe="")
return texte if enc != s:
texte = texte.replace(enc, "***")
return texte
class Journal:
"""Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
class Journal:
def __init__(self, fichier): """Journal texte horodaté (heure de Paris). Tout message passe par `scrub`."""
self.fichier = Path(fichier)
self.secrets = [] def __init__(self, fichier):
self.fichier = Path(fichier)
def masquer(self, *secrets): self.secrets = []
self.secrets.extend(s for s in secrets if s)
def masquer(self, *secrets):
def __call__(self, msg, maintenant=None): self.secrets.extend(s for s in secrets if s)
t = maintenant or dt.datetime.now(UTC)
self.fichier.parent.mkdir(parents=True, exist_ok=True) def __call__(self, msg, maintenant=None):
with open(self.fichier, "a", encoding="utf-8") as f: t = maintenant or dt.datetime.now(UTC)
f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n") self.fichier.parent.mkdir(parents=True, exist_ok=True)
with open(self.fichier, "a", encoding="utf-8") as f:
f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n")
class Verrou:
"""Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
class Verrou:
def __init__(self, fichier): """Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu."""
self.fichier = Path(fichier)
self.f = None def __init__(self, fichier):
self.fichier = Path(fichier)
def __enter__(self): self.f = None
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.f = open(self.fichier, "w") def __enter__(self):
if fcntl is not None: self.fichier.parent.mkdir(parents=True, exist_ok=True)
try: self.f = open(self.fichier, "w")
fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB) if fcntl is not None:
except OSError: try:
self.f.close() fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
self.f = None except OSError:
return False self.f.close()
return True self.f = None
return False
def __exit__(self, *a): return True
if self.f:
self.f.close() def __exit__(self, *a):
if self.f:
self.f.close()
class Pause:
"""Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
class Pause:
def __init__(self, fichier, duree_s=15 * 60): """Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut."""
self.fichier = Path(fichier)
self.duree_s = duree_s def __init__(self, fichier, duree_s=15 * 60):
self.fichier = Path(fichier)
def active(self, maintenant): self.duree_s = duree_s
try:
return float(self.fichier.read_text()) > maintenant.timestamp() def active(self, maintenant):
except (OSError, ValueError): try:
return False return float(self.fichier.read_text()) > maintenant.timestamp()
except (OSError, ValueError):
def jusqua(self): return False
try:
return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC) def jusqua(self):
except (OSError, ValueError): try:
return None return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC)
except (OSError, ValueError):
def poser(self, maintenant): return None
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.fichier.write_text(str(maintenant.timestamp() + self.duree_s)) def poser(self, maintenant):
self.fichier.parent.mkdir(parents=True, exist_ok=True)
self.fichier.write_text(str(maintenant.timestamp() + self.duree_s))
+76 -74
Voir le fichier
@@ -1,74 +1,76 @@
"""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
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):
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.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {}) stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer( resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat)) cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
stockage.purger(maintenant, cfg.garder_jours) stockage.purger(maintenant, cfg.garder_jours)
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes) resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
finally: if cfg.servi:
stockage.fermer() resumes["servies"] = publier.copier_vers_servi(cfg.public, cfg.servi)
return resumes finally:
stockage.fermer()
return resumes
def _sans_planter(journal, maintenant, nom, f):
try:
return f() def _sans_planter(journal, maintenant, nom, f):
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue try:
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant) return f()
return {"source": nom, "action": "erreur_interne"} except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
return {"source": nom, "action": "erreur_interne"}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
cfg = Config.depuis_env() def main(argv=None):
if "--config" in argv: argv = sys.argv[1:] if argv is None else argv
for k, v in vars(cfg).items(): cfg = Config.depuis_env()
if k == "env": if "--config" in argv:
continue # l'environnement contient les secrets : jamais affiché for k, v in vars(cfg).items():
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement if k == "env":
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma): continue # l'environnement contient les secrets : jamais affiché
try: print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
cfg.secret(nom) for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
print("%-20s définie (valeur masquée)" % nom) try:
except LookupError: cfg.secret(nom)
print("%-20s absente" % nom) print("%-20s définie (valeur masquée)" % nom)
return 0 except LookupError:
tick(cfg, appels="--publier" not in argv) print("%-20s absente" % nom)
return 0 return 0
tick(cfg, appels="--publier" not in argv)
return 0
if __name__ == "__main__":
sys.exit(main())
if __name__ == "__main__":
sys.exit(main())
+140 -96
Voir le fichier
@@ -1,96 +1,140 @@
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/. """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.",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
def nom_fichier(source, station_id): }
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
def nom_fichier(source, station_id):
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
def _releve(r): return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
def _releve(r):
def _fiche(st): return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")} def _fiche(st):
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
def publier(cfg, stockage, maintenant, resumes=None): "licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
data = cfg.public / "data"
index = []
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures) def publier(cfg, stockage, maintenant, resumes=None):
for st in stockage.stations(): data = cfg.public / "data"
fiche = _fiche(st) index = []
der = stockage.derniere(st["source"], st["station_id"]) depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
if der: for st in stockage.stations():
fiche["derniere"] = _releve(der) fiche = _fiche(st)
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60) der = stockage.derniere(st["source"], st["station_id"])
else: if der:
fiche["derniere"], fiche["age_min"] = None, None fiche["derniere"] = _releve(der)
index.append(fiche) fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)] else:
ecrire_json(data / "station" / (fiche["id"] + ".json"), fiche["derniere"], fiche["age_min"] = None, None
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie)) index.append(fiche)
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index}) serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {})) ecrire_json(data / "station" / (fiche["id"] + ".json"),
if cfg.direct_compat: dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
publier_direct_compat(cfg, stockage, maintenant) ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
return len(index) ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
if cfg.direct_compat:
publier_direct_compat(cfg, stockage, maintenant)
def etat(cfg, maintenant, resumes): return len(index)
from .commun import Pause, lire_json
sources = {}
for src in ("infoclimat", "romma"): def etat(cfg, maintenant, resumes):
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {}) from .commun import Pause, lire_json
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src)) sources = {}
succes = e.get("dernier_succes_utc") for src in ("infoclimat", "romma"):
sources[src] = { e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None, p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
"en_pause": p.active(maintenant), succes = e.get("dernier_succes_utc")
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None, sources[src] = {
"dernier_passage": (resumes.get(src) or {}).get("action"), "dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
} "en_pause": p.active(maintenant),
return {"mis_a_jour_utc": iso(maintenant), "sources": sources} "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): return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
depuis = maintenant - dt.timedelta(hours=48)
stations, meta = {}, {} def publier_direct_compat(cfg, stockage, maintenant):
for st in stockage.stations(): """Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
if st["source"] != "infoclimat": depuis = maintenant - dt.timedelta(hours=48)
continue stations, meta = {}, {}
rel = [] for st in stockage.stations():
for r in stockage.serie("infoclimat", st["station_id"], depuis): if st["source"] != "infoclimat":
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression", continue
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")} rel = []
x["pluie_cumul_0h"] = r.get("pluie_cumul") for r in stockage.serie("infoclimat", st["station_id"], depuis):
rel.append(x) x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
stations[st["station_id"]] = {"nom": st["nom"], "releves": rel} "vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"], x["pluie_cumul_0h"] = r.get("pluie_cumul")
"licence": st["licence"] or ""} rel.append(x)
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)", stations[st["station_id"]] = {"nom": st["nom"], "releves": rel}
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations}) 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
+35 -34
Voir le fichier
@@ -1,34 +1,35 @@
"""Contrôles statiques des fichiers systemd d'exemple (pas de systemd sous Windows : rien n'est installé).""" """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()
+47
Voir le fichier
@@ -0,0 +1,47 @@
"""Copie vers le dossier servi : fichiers ordinaires seulement, aucun lien suivi."""
import os
import tempfile
import unittest
from pathlib import Path
from meteo_collecte.publier import copier_vers_servi
class TestCopieServi(unittest.TestCase):
def setUp(self):
self.tmp = Path(tempfile.mkdtemp())
self.src = self.tmp / "public"
self.dst = self.tmp / "servi"
(self.src / "data" / "station").mkdir(parents=True)
(self.src / "data" / "stations.json").write_text('{"ok": 1}', encoding="utf-8")
(self.src / "data" / "station" / "x.json").write_text("{}", encoding="utf-8")
self.secret = self.tmp / "hors_site.txt"
self.secret.write_text("NE DOIT PAS SORTIR", encoding="utf-8")
def test_copie_fichiers_reguliers(self):
self.assertEqual(copier_vers_servi(self.src, self.dst), 2)
self.assertEqual((self.dst / "data" / "stations.json").read_text(encoding="utf-8"), '{"ok": 1}')
self.assertFalse(any(p.name.endswith(".tmp") for p in self.dst.rglob("*")))
def test_lien_dans_la_source_refuse(self):
try:
os.symlink(self.secret, self.src / "data" / "lien.json")
except (OSError, NotImplementedError):
self.skipTest("liens symboliques non disponibles ici")
with self.assertRaises(ValueError):
copier_vers_servi(self.src, self.dst)
self.assertFalse((self.dst / "data" / "lien.json").exists())
def test_lien_dans_la_destination_remplace_sans_suivre(self):
self.dst.joinpath("data").mkdir(parents=True)
try:
os.symlink(self.secret, self.dst / "data" / "stations.json")
except (OSError, NotImplementedError):
self.skipTest("liens symboliques non disponibles ici")
copier_vers_servi(self.src, self.dst)
self.assertFalse((self.dst / "data" / "stations.json").is_symlink())
self.assertEqual(self.secret.read_text(encoding="utf-8"), "NE DOIT PAS SORTIR")
if __name__ == "__main__":
unittest.main()