diff --git a/README.md b/README.md index 26b56c4..d5cc63c 100644 --- a/README.md +++ b/README.md @@ -37,6 +37,7 @@ publication continuent. Un verrou empêche deux ticks simultanés. | `MC_ROMMA_ACTIF` / `MC_INFOCLIMAT_ACTIF` | activer une source | 1 / 1 | | `MC_ALERTE_ACTIVE`, `MC_NTFY_URL` | alerte quota | 0, vide | | `MC_DIRECT_COMPAT` | écrire aussi l'ancien `direct.json` | vide | +| `MC_SERVI` | après publication, copie des seuls fichiers ordinaires de `public/data/` vers ce dossier (lu par Caddy) ; liens refusés | vide | ### Secrets diff --git a/deploiement/meteo-collecte.service b/deploiement/meteo-collecte.service index 0e7a2ab..bac0582 100644 --- a/deploiement/meteo-collecte.service +++ b/deploiement/meteo-collecte.service @@ -15,8 +15,10 @@ Type=oneshot WorkingDirectory=%h/meteo-collecte EnvironmentFile=%h/.config/meteo-collecte/env Environment=MC_BASE=%h/meteo-collecte -# Fichiers publiés : lus par Caddy (root /srv/weather.gastinel.me, voir deploy/appliquer-caddy-meteo.sh). -Environment=MC_PUBLIC=/srv/weather.gastinel.me +# Publication dans le dossier du collecteur, puis copie des seuls fichiers ordinaires vers MC_SERVI (lu par Caddy, +# qui ne sert que /data). Aucun lien symbolique n'est copié (publier.copier_vers_servi). +Environment=MC_PUBLIC=%h/meteo-collecte/public +Environment=MC_SERVI=/srv/weather.gastinel.me Environment=MC_QUOTA_COMMUN=%h/gws-collecte/quota.json # Ancien format direct.json, écrit à côté (PAS à la place de ~/meteo-direct/direct.json, lu par cornafserver). Environment=MC_DIRECT_COMPAT=%h/meteo-collecte/direct-compat.json diff --git a/deploy/appliquer-caddy-meteo.sh b/deploy/appliquer-caddy-meteo.sh index 612dc8c..045404a 100644 --- a/deploy/appliquer-caddy-meteo.sh +++ b/deploy/appliquer-caddy-meteo.sh @@ -1,49 +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. -# Usage (sur cornafsuisse, à lancer par Théo) : sudo bash ~/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 : appartient a l'utilisateur du collecteur, lisible par Caddy (user caddy). -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 +#!/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 diff --git a/deploy/deployer-vps.sh b/deploy/deployer-vps.sh index e98851f..063ecc5 100644 --- a/deploy/deployer-vps.sh +++ b/deploy/deployer-vps.sh @@ -1,109 +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 .avant-deploiement-1017 (sauvegarde jamais écrasée). -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)" ]; then - echo "ATTENTION : modifications non commitées dans le code ; le VPS recevra l'arbre de travail tel quel." -fi - -echo "== 1. Liste des fichiers de code" -find meteo_collecte config -type f ! -path '*/__pycache__/*' ! -name '*.pyc' | sort > "$TMP/liste" -wc -l < "$TMP/liste" - -echo "== 2. Sauvegardes de ce qui sera remplacé (.avant-deploiement-$HORODATAGE)" -{ - echo 'set -eu' - echo 'C="$HOME/meteo-collecte"; U="$HOME/.config/systemd/user"' - echo "bak() { if [ -e \"\$1\" ] && [ ! -e \"\$1.avant-deploiement-$HORODATAGE\" ]; then cp -p \"\$1\" \"\$1.avant-deploiement-$HORODATAGE\"; echo \"sauvegarde : \$1\"; fi; }" - while read -r f; do echo "bak \"\$C/$f\""; done < "$TMP/liste" - echo 'bak "$U/meteo-collecte.service"; bak "$U/meteo-collecte.timer"; echo "sauvegardes terminees"' -} > "$TMP/sauvegarde.sh" -vps "bash -s" < "$TMP/sauvegarde.sh" - -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 (à lancer par Théo avec sudo, NON lancé ici)" -vps 'cat > "$HOME/appliquer-caddy-meteo.sh"' < "$ICI/deploy/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=/srv/weather.gastinel.me \ - -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, PAS dans /srv ;" -echo " MC_DIRECT_COMPAT vide : ~/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_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" - echo "Pour activer (après le jeton, le script Caddy et linger) : 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 ] || [ ! -w /srv/weather.gastinel.me ]; then - echo "REFUS : /srv/weather.gastinel.me absent ou non accessible en ecriture." - echo " Theo, sur le VPS : sudo bash ~/appliquer-caddy-meteo.sh"; 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 +#!/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 .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 diff --git a/meteo_collecte/commun.py b/meteo_collecte/commun.py index 64b14ba..935b928 100644 --- a/meteo_collecte/commun.py +++ b/meteo_collecte/commun.py @@ -1,241 +1,243 @@ -"""Outils communs : configuration, heure de Paris, JSON atomique, journal, verrou, masquage des secrets. - -Aucun chemin, nom de serveur ni secret n'est écrit en dur : tout vient de variables d'environnement -(voir `Config.depuis_env`) avec des valeurs par défaut relatives au dossier personnel. -""" -import datetime as dt -import json -import os -import re -import urllib.parse -from dataclasses import dataclass, field -from pathlib import Path - -try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows - import fcntl -except ImportError: # pragma: no cover - fcntl = None - -UTC = dt.timezone.utc - - -# --------------------------------------------------------------------------- -# Configuration -# --------------------------------------------------------------------------- - -@dataclass -class Config: - base: Path # état, journal, base SQLite - public: Path # racine servie par Caddy (on écrit dans public/data/) - quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct - stations: Path # liste des stations Infoclimat suivies (JSON) - plafond_commun: int = 4999 # même plafond que le collecteur (décision du 29/09) - plafond_site: int = 1000 # plafond propre au site (décision du 16/10) - seuil_alerte: float = 0.80 - alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé - ntfy_url: str = "" - compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4) - lot_max: int = 25 - garder_jours: int = 14 - fiche_heures: int = 48 - romma_actif: bool = True - infoclimat_actif: bool = True - direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN) - # Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites). - # On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur. - var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT" - var_cle_romma: str = "MC_CLE_ROMMA" - env: object = field(default=None, repr=False) - - def secret(self, nom_variable): - """Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide.""" - e = os.environ if self.env is None else self.env - v = (e.get(nom_variable) or "").strip() - if not v: - raise LookupError("variable %s absente ou vide" % nom_variable) - return v - - @classmethod - def depuis_env(cls, env=None): - e = os.environ if env is None else env - home = Path.home() - base = Path(e.get("MC_BASE") or home / "meteo-collecte") - - def chemin(nom, defaut): - return Path(e[nom]) if e.get(nom) else defaut - - def oui(nom, defaut): - v = e.get(nom) - return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes") - - return cls( - base=base, - public=chemin("MC_PUBLIC", base / "public"), - quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"), - stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"), - plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)), - plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)), - alerte_active=oui("MC_ALERTE_ACTIVE", False), - ntfy_url=e.get("MC_NTFY_URL", ""), - compte_par_station=oui("MC_COMPTE_PAR_STATION", False), - lot_max=int(e.get("MC_LOT_MAX", 25)), - romma_actif=oui("MC_ROMMA_ACTIF", True), - infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True), - direct_compat=chemin("MC_DIRECT_COMPAT", None), - env=env, - ) - - -# --------------------------------------------------------------------------- -# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows) -# --------------------------------------------------------------------------- - -def _dernier_dimanche(annee, mois): - d = dt.date(annee, mois, 31) - return d - dt.timedelta(days=(d.weekday() + 1) % 7) - - -def decalage_paris(utc): - """Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST).""" - a = utc.year - debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC) - fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC) - return dt.timedelta(hours=2 if debut <= utc < fin else 1) - - -def vers_paris(utc): - return (utc + decalage_paris(utc)).replace(tzinfo=None) - - -def paris_vers_utc(local, maintenant=None): - """Heure locale de Paris (naïve) -> instant UTC. - - None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus - récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne). - """ - possibles = [] - for h in (2, 1): - c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC) - if (c + decalage_paris(c)).replace(tzinfo=None) == local: - possibles.append(c) - if not possibles: - return None - if len(possibles) == 1 or maintenant is None: - return possibles[0] - passes = [c for c in possibles if c <= maintenant] - return max(passes) if passes else min(possibles) - - -def jour_paris(utc): - return str(vers_paris(utc).date()) - - -def fmt_utc(t): - return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S") - - -def lire_utc(s): - return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC) - - -def iso(t): - return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ") - - -# --------------------------------------------------------------------------- -# Fichiers -# --------------------------------------------------------------------------- - -def lire_json(p, defaut): - try: - return json.loads(Path(p).read_text(encoding="utf-8")) - except (OSError, ValueError): - return defaut - - -def ecrire_json(p, d, compact=True): - """Écriture atomique : fichier temporaire dans le même dossier, puis os.replace.""" - p = Path(p) - p.parent.mkdir(parents=True, exist_ok=True) - tmp = p.with_name(p.name + ".tmp-%d" % os.getpid()) - texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None, - indent=None if compact else 1) - tmp.write_text(texte, encoding="utf-8") - os.replace(tmp, p) - - -def scrub(texte, *secrets): - """Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL.""" - texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte)) - for s in secrets: - if s: - texte = texte.replace(s, "***") - enc = urllib.parse.quote(s, safe="") - if enc != s: - texte = texte.replace(enc, "***") - return texte - - -class Journal: - """Journal texte horodaté (heure de Paris). Tout message passe par `scrub`.""" - - def __init__(self, fichier): - self.fichier = Path(fichier) - self.secrets = [] - - def masquer(self, *secrets): - self.secrets.extend(s for s in secrets if s) - - def __call__(self, msg, maintenant=None): - t = maintenant or dt.datetime.now(UTC) - self.fichier.parent.mkdir(parents=True, exist_ok=True) - with open(self.fichier, "a", encoding="utf-8") as f: - f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n") - - -class Verrou: - """Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu.""" - - def __init__(self, fichier): - self.fichier = Path(fichier) - self.f = None - - def __enter__(self): - self.fichier.parent.mkdir(parents=True, exist_ok=True) - self.f = open(self.fichier, "w") - if fcntl is not None: - try: - fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB) - except OSError: - self.f.close() - self.f = None - return False - return True - - def __exit__(self, *a): - if self.f: - self.f.close() - - -class Pause: - """Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut.""" - - def __init__(self, fichier, duree_s=15 * 60): - self.fichier = Path(fichier) - self.duree_s = duree_s - - def active(self, maintenant): - try: - return float(self.fichier.read_text()) > maintenant.timestamp() - except (OSError, ValueError): - return False - - def jusqua(self): - try: - return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC) - except (OSError, ValueError): - return None - - def poser(self, maintenant): - self.fichier.parent.mkdir(parents=True, exist_ok=True) - self.fichier.write_text(str(maintenant.timestamp() + self.duree_s)) +"""Outils communs : configuration, heure de Paris, JSON atomique, journal, verrou, masquage des secrets. + +Aucun chemin, nom de serveur ni secret n'est écrit en dur : tout vient de variables d'environnement +(voir `Config.depuis_env`) avec des valeurs par défaut relatives au dossier personnel. +""" +import datetime as dt +import json +import os +import re +import urllib.parse +from dataclasses import dataclass, field +from pathlib import Path + +try: # fcntl n'existe que sous Unix (le VPS) ; les tests tournent aussi sous Windows + import fcntl +except ImportError: # pragma: no cover + fcntl = None + +UTC = dt.timezone.utc + + +# --------------------------------------------------------------------------- +# Configuration +# --------------------------------------------------------------------------- + +@dataclass +class Config: + base: Path # état, journal, base SQLite + public: Path # racine servie par Caddy (on écrit dans public/data/) + quota_commun: Path # compteur partagé avec le collecteur GWS et meteo-direct + stations: Path # liste des stations Infoclimat suivies (JSON) + plafond_commun: int = 4999 # même plafond que le collecteur (décision du 29/09) + plafond_site: int = 1000 # plafond propre au site (décision du 16/10) + seuil_alerte: float = 0.80 + alerte_active: bool = False # aucun envoi réel tant que Théo ne l'a pas activé + ntfy_url: str = "" + compte_par_station: bool = False # parade si Infoclimat compte une requête par station (§2.4) + lot_max: int = 25 + garder_jours: int = 14 + fiche_heures: int = 48 + romma_actif: bool = True + infoclimat_actif: bool = True + direct_compat: Path = None # si défini : écrit aussi l'ancien direct.json (site LAN) + servi: Path = None # si défini : copie des seuls fichiers réguliers de public/data/ (voir publier.py) + # Secrets : uniquement des variables d'environnement, lues au moment de l'appel (jamais copiées ni écrites). + # On garde ici le *nom* de la variable et l'environnement à consulter, jamais la valeur. + var_jeton_infoclimat: str = "MC_JETON_INFOCLIMAT" + var_cle_romma: str = "MC_CLE_ROMMA" + env: object = field(default=None, repr=False) + + def secret(self, nom_variable): + """Valeur d'un secret lue dans l'environnement. LookupError si absente ou vide.""" + e = os.environ if self.env is None else self.env + v = (e.get(nom_variable) or "").strip() + if not v: + raise LookupError("variable %s absente ou vide" % nom_variable) + return v + + @classmethod + def depuis_env(cls, env=None): + e = os.environ if env is None else env + home = Path.home() + base = Path(e.get("MC_BASE") or home / "meteo-collecte") + + def chemin(nom, defaut): + return Path(e[nom]) if e.get(nom) else defaut + + def oui(nom, defaut): + v = e.get(nom) + return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes") + + return cls( + base=base, + public=chemin("MC_PUBLIC", base / "public"), + quota_commun=chemin("MC_QUOTA_COMMUN", home / "gws-collecte" / "quota.json"), + stations=chemin("MC_STATIONS", Path(__file__).resolve().parent.parent / "config" / "stations.json"), + plafond_commun=int(e.get("MC_PLAFOND_COMMUN", 4999)), + plafond_site=int(e.get("MC_PLAFOND_SITE", 1000)), + alerte_active=oui("MC_ALERTE_ACTIVE", False), + ntfy_url=e.get("MC_NTFY_URL", ""), + compte_par_station=oui("MC_COMPTE_PAR_STATION", False), + lot_max=int(e.get("MC_LOT_MAX", 25)), + romma_actif=oui("MC_ROMMA_ACTIF", True), + infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True), + direct_compat=chemin("MC_DIRECT_COMPAT", None), + servi=chemin("MC_SERVI", None), + env=env, + ) + + +# --------------------------------------------------------------------------- +# Heure de Paris (règle européenne codée ici : zoneinfo demande tzdata, absent sous Windows) +# --------------------------------------------------------------------------- + +def _dernier_dimanche(annee, mois): + d = dt.date(annee, mois, 31) + return d - dt.timedelta(days=(d.weekday() + 1) % 7) + + +def decalage_paris(utc): + """Décalage de Paris sur l'UTC à l'instant `utc` (aware) : 1 h (CET) ou 2 h (CEST).""" + a = utc.year + debut = dt.datetime.combine(_dernier_dimanche(a, 3), dt.time(1), UTC) + fin = dt.datetime.combine(_dernier_dimanche(a, 10), dt.time(1), UTC) + return dt.timedelta(hours=2 if debut <= utc < fin else 1) + + +def vers_paris(utc): + return (utc + decalage_paris(utc)).replace(tzinfo=None) + + +def paris_vers_utc(local, maintenant=None): + """Heure locale de Paris (naïve) -> instant UTC. + + None si l'heure n'existe pas (passage à l'heure d'été). Pour l'heure doublée d'octobre, on garde la plus + récente des deux qui n'est pas dans le futur par rapport à `maintenant` (sinon la plus ancienne). + """ + possibles = [] + for h in (2, 1): + c = (local - dt.timedelta(hours=h)).replace(tzinfo=UTC) + if (c + decalage_paris(c)).replace(tzinfo=None) == local: + possibles.append(c) + if not possibles: + return None + if len(possibles) == 1 or maintenant is None: + return possibles[0] + passes = [c for c in possibles if c <= maintenant] + return max(passes) if passes else min(possibles) + + +def jour_paris(utc): + return str(vers_paris(utc).date()) + + +def fmt_utc(t): + return t.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S") + + +def lire_utc(s): + return dt.datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC) + + +def iso(t): + return t.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ") + + +# --------------------------------------------------------------------------- +# Fichiers +# --------------------------------------------------------------------------- + +def lire_json(p, defaut): + try: + return json.loads(Path(p).read_text(encoding="utf-8")) + except (OSError, ValueError): + return defaut + + +def ecrire_json(p, d, compact=True): + """Écriture atomique : fichier temporaire dans le même dossier, puis os.replace.""" + p = Path(p) + p.parent.mkdir(parents=True, exist_ok=True) + tmp = p.with_name(p.name + ".tmp-%d" % os.getpid()) + texte = json.dumps(d, ensure_ascii=False, separators=(",", ":") if compact else None, + indent=None if compact else 1) + tmp.write_text(texte, encoding="utf-8") + os.replace(tmp, p) + + +def scrub(texte, *secrets): + """Masque tout paramètre token=/apikey= d'URL et chaque secret, en clair ou encodé pour l'URL.""" + texte = re.sub(r"(?i)\b(token|apikey)=[^&\s)\"']*", lambda m: m.group(1) + "=***", str(texte)) + for s in secrets: + if s: + texte = texte.replace(s, "***") + enc = urllib.parse.quote(s, safe="") + if enc != s: + texte = texte.replace(enc, "***") + return texte + + +class Journal: + """Journal texte horodaté (heure de Paris). Tout message passe par `scrub`.""" + + def __init__(self, fichier): + self.fichier = Path(fichier) + self.secrets = [] + + def masquer(self, *secrets): + self.secrets.extend(s for s in secrets if s) + + def __call__(self, msg, maintenant=None): + t = maintenant or dt.datetime.now(UTC) + self.fichier.parent.mkdir(parents=True, exist_ok=True) + with open(self.fichier, "a", encoding="utf-8") as f: + f.write(vers_paris(t).strftime("%Y-%m-%d %H:%M:%S ") + scrub(msg, *self.secrets) + "\n") + + +class Verrou: + """Verrou exclusif non bloquant (fcntl). Sans fcntl (Windows, tests), le verrou est toujours obtenu.""" + + def __init__(self, fichier): + self.fichier = Path(fichier) + self.f = None + + def __enter__(self): + self.fichier.parent.mkdir(parents=True, exist_ok=True) + self.f = open(self.fichier, "w") + if fcntl is not None: + try: + fcntl.flock(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB) + except OSError: + self.f.close() + self.f = None + return False + return True + + def __exit__(self, *a): + if self.f: + self.f.close() + + +class Pause: + """Pause après erreur (fichier contenant un timestamp), reprise de direct.py : 15 min par défaut.""" + + def __init__(self, fichier, duree_s=15 * 60): + self.fichier = Path(fichier) + self.duree_s = duree_s + + def active(self, maintenant): + try: + return float(self.fichier.read_text()) > maintenant.timestamp() + except (OSError, ValueError): + return False + + def jusqua(self): + try: + return dt.datetime.fromtimestamp(float(self.fichier.read_text()), UTC) + except (OSError, ValueError): + return None + + def poser(self, maintenant): + self.fichier.parent.mkdir(parents=True, exist_ok=True) + self.fichier.write_text(str(maintenant.timestamp() + self.duree_s)) diff --git a/meteo_collecte/ordonnanceur.py b/meteo_collecte/ordonnanceur.py index 77d589b..2771cf9 100644 --- a/meteo_collecte/ordonnanceur.py +++ b/meteo_collecte/ordonnanceur.py @@ -1,74 +1,76 @@ -"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9). - -Chaque source décide seule si elle appelle : -* ROMMA : au plus une requête global=1 toutes les 10 min ; -* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9. -Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche -ni l'autre source ni la publication. - - python3 -m meteo_collecte.ordonnanceur # un tick - python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau - python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret) -""" -import datetime as dt -import sys - -from . import infoclimat, publier, romma -from .commun import UTC, Config, Journal, Verrou, lire_json -from .stockage import Stockage - - -def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger, - appels=True): - maintenant = maintenant or dt.datetime.now(UTC) - var = cfg.base / "var" - journal = Journal(var / "collecte.log") - with Verrou(var / ".collecte.lock") as obtenu: - if not obtenu: - return {"action": "verrou"} # un tick précédent tourne encore - stockage = Stockage(var / "mesures.sqlite") - resumes = {} - try: - if appels and cfg.romma_actif: - resumes["romma"] = _sans_planter(journal, maintenant, "romma", - lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma)) - if appels and cfg.infoclimat_actif: - stations = lire_json(cfg.stations, {}).get("infoclimat", {}) - resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer( - cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat)) - stockage.purger(maintenant, cfg.garder_jours) - resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes) - finally: - stockage.fermer() - return resumes - - -def _sans_planter(journal, maintenant, nom, f): - try: - return f() - except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue - journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant) - return {"source": nom, "action": "erreur_interne"} - - -def main(argv=None): - argv = sys.argv[1:] if argv is None else argv - cfg = Config.depuis_env() - if "--config" in argv: - for k, v in vars(cfg).items(): - if k == "env": - continue # l'environnement contient les secrets : jamais affiché - print("%-20s %s" % (k, v)) # chemins et noms de variables seulement - for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma): - try: - cfg.secret(nom) - print("%-20s définie (valeur masquée)" % nom) - except LookupError: - print("%-20s absente" % nom) - return 0 - tick(cfg, appels="--publier" not in argv) - return 0 - - -if __name__ == "__main__": - sys.exit(main()) +"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9). + +Chaque source décide seule si elle appelle : +* ROMMA : au plus une requête global=1 toutes les 10 min ; +* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9. +Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche +ni l'autre source ni la publication. + + python3 -m meteo_collecte.ordonnanceur # un tick + python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau + python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret) +""" +import datetime as dt +import sys + +from . import infoclimat, publier, romma +from .commun import UTC, Config, Journal, Verrou, lire_json +from .stockage import Stockage + + +def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger, + appels=True): + maintenant = maintenant or dt.datetime.now(UTC) + var = cfg.base / "var" + journal = Journal(var / "collecte.log") + with Verrou(var / ".collecte.lock") as obtenu: + if not obtenu: + return {"action": "verrou"} # un tick précédent tourne encore + stockage = Stockage(var / "mesures.sqlite") + resumes = {} + try: + if appels and cfg.romma_actif: + resumes["romma"] = _sans_planter(journal, maintenant, "romma", + lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma)) + if appels and cfg.infoclimat_actif: + stations = lire_json(cfg.stations, {}).get("infoclimat", {}) + resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer( + cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat)) + stockage.purger(maintenant, cfg.garder_jours) + resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes) + if cfg.servi: + resumes["servies"] = publier.copier_vers_servi(cfg.public, cfg.servi) + finally: + stockage.fermer() + return resumes + + +def _sans_planter(journal, maintenant, nom, f): + try: + return f() + except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue + journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant) + return {"source": nom, "action": "erreur_interne"} + + +def main(argv=None): + argv = sys.argv[1:] if argv is None else argv + cfg = Config.depuis_env() + if "--config" in argv: + for k, v in vars(cfg).items(): + if k == "env": + continue # l'environnement contient les secrets : jamais affiché + print("%-20s %s" % (k, v)) # chemins et noms de variables seulement + for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma): + try: + cfg.secret(nom) + print("%-20s définie (valeur masquée)" % nom) + except LookupError: + print("%-20s absente" % nom) + return 0 + tick(cfg, appels="--publier" not in argv) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/meteo_collecte/publier.py b/meteo_collecte/publier.py index bac897f..f9bb58c 100644 --- a/meteo_collecte/publier.py +++ b/meteo_collecte/publier.py @@ -1,96 +1,140 @@ -"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous /data/. - -* data/stations.json : index de toutes les stations avec leur dernière mesure ; -* data/station/-.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ; -* data/etat.json : heure de mise à jour par source, sources en pause. - -Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage -(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers. -Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API. -""" -import datetime as dt -import re - -from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc -from .stockage import CHAMPS - -ATTRIBUTIONS = { - "infoclimat": "Données Infoclimat", - "romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur " - "interprétation.", - "meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)", -} - - -def nom_fichier(source, station_id): - """Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin).""" - return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id))) - - -def _releve(r): - return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None}) - - -def _fiche(st): - return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"], - "nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"), - "licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")} - - -def publier(cfg, stockage, maintenant, resumes=None): - data = cfg.public / "data" - index = [] - depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures) - for st in stockage.stations(): - fiche = _fiche(st) - der = stockage.derniere(st["source"], st["station_id"]) - if der: - fiche["derniere"] = _releve(der) - fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60) - else: - fiche["derniere"], fiche["age_min"] = None, None - index.append(fiche) - serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)] - ecrire_json(data / "station" / (fiche["id"] + ".json"), - dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie)) - ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index}) - ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {})) - if cfg.direct_compat: - publier_direct_compat(cfg, stockage, maintenant) - return len(index) - - -def etat(cfg, maintenant, resumes): - from .commun import Pause, lire_json - sources = {} - for src in ("infoclimat", "romma"): - e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {}) - p = Pause(cfg.base / "var" / ("pause_%s.txt" % src)) - succes = e.get("dernier_succes_utc") - sources[src] = { - "dernier_succes_utc": iso(lire_utc(succes)) if succes else None, - "en_pause": p.active(maintenant), - "pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None, - "dernier_passage": (resumes.get(src) or {}).get("action"), - } - return {"mis_a_jour_utc": iso(maintenant), "sources": sources} - - -def publier_direct_compat(cfg, stockage, maintenant): - """Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré.""" - depuis = maintenant - dt.timedelta(hours=48) - stations, meta = {}, {} - for st in stockage.stations(): - if st["source"] != "infoclimat": - continue - rel = [] - for r in stockage.serie("infoclimat", st["station_id"], depuis): - x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression", - "vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")} - x["pluie_cumul_0h"] = r.get("pluie_cumul") - rel.append(x) - stations[st["station_id"]] = {"nom": st["nom"], "releves": rel} - meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"], - "licence": st["licence"] or ""} - ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)", - "mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations}) +"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous /data/. + +* data/stations.json : index de toutes les stations avec leur dernière mesure ; +* data/station/-.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ; +* data/etat.json : heure de mise à jour par source, sources en pause. + +Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage +(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers. +Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API. +""" +import datetime as dt +import os +import re +import stat +from pathlib import Path + +from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc +from .stockage import CHAMPS + +ATTRIBUTIONS = { + "infoclimat": "Données Infoclimat", + "romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur " + "interprétation.", + "meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)", +} + + +def nom_fichier(source, station_id): + """Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin).""" + return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id))) + + +def _releve(r): + return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None}) + + +def _fiche(st): + return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"], + "nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"), + "licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")} + + +def publier(cfg, stockage, maintenant, resumes=None): + data = cfg.public / "data" + index = [] + depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures) + for st in stockage.stations(): + fiche = _fiche(st) + der = stockage.derniere(st["source"], st["station_id"]) + if der: + fiche["derniere"] = _releve(der) + fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60) + else: + fiche["derniere"], fiche["age_min"] = None, None + index.append(fiche) + serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)] + ecrire_json(data / "station" / (fiche["id"] + ".json"), + dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie)) + ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index}) + ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {})) + if cfg.direct_compat: + publier_direct_compat(cfg, stockage, maintenant) + return len(index) + + +def etat(cfg, maintenant, resumes): + from .commun import Pause, lire_json + sources = {} + for src in ("infoclimat", "romma"): + e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {}) + p = Pause(cfg.base / "var" / ("pause_%s.txt" % src)) + succes = e.get("dernier_succes_utc") + sources[src] = { + "dernier_succes_utc": iso(lire_utc(succes)) if succes else None, + "en_pause": p.active(maintenant), + "pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None, + "dernier_passage": (resumes.get(src) or {}).get("action"), + } + return {"mis_a_jour_utc": iso(maintenant), "sources": sources} + + +def publier_direct_compat(cfg, stockage, maintenant): + """Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré.""" + depuis = maintenant - dt.timedelta(hours=48) + stations, meta = {}, {} + for st in stockage.stations(): + if st["source"] != "infoclimat": + continue + rel = [] + for r in stockage.serie("infoclimat", st["station_id"], depuis): + x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression", + "vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")} + x["pluie_cumul_0h"] = r.get("pluie_cumul") + rel.append(x) + stations[st["station_id"]] = {"nom": st["nom"], "releves": rel} + meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"], + "licence": st["licence"] or ""} + ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)", + "mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations}) + + +def copier_vers_servi(src, dst): + """Copie data/ de `src` vers `dst` (dossier lu par Caddy, lecture seule côté serveur). + + Seuls les fichiers ordinaires sont copiés : tout lien symbolique dans la source fait échouer la copie + (ValueError, rien de copié pour ce fichier). Dans la destination, un lien est remplacé, jamais suivi : + écriture dans un fichier temporaire créé avec O_EXCL|O_NOFOLLOW, puis os.replace (atomique). + Renvoie le nombre de fichiers copiés.""" + src, dst = Path(src), Path(dst) + racine = src / "data" + dst.mkdir(parents=True, exist_ok=True) + n = 0 + for f in sorted(racine.rglob("*")): + st = os.lstat(f) + if stat.S_ISLNK(st.st_mode): + raise ValueError("lien symbolique refusé dans la source : %s" % f.name) + if not stat.S_ISREG(st.st_mode): + continue + rel = f.relative_to(src) + cible_dir = dst + for morceau in rel.parts[:-1]: + cible_dir = cible_dir / morceau + if cible_dir.is_symlink(): + raise ValueError("lien symbolique refusé dans la destination : %s" % cible_dir.name) + cible_dir.mkdir(exist_ok=True) + cible = cible_dir / rel.parts[-1] + tmp = cible_dir / (rel.parts[-1] + ".tmp") + if tmp.is_symlink() or tmp.exists(): + tmp.unlink() # supprime l'entrée (un lien n'est jamais suivi) + fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o644) + try: + with os.fdopen(fd, "wb") as out, open(f, "rb") as entree: + out.write(entree.read()) + except BaseException: + if tmp.exists() or tmp.is_symlink(): + tmp.unlink() + raise + os.replace(str(tmp), str(cible)) # remplace aussi un lien existant, sans le suivre + n += 1 + return n diff --git a/tests/test_servi.py b/tests/test_servi.py new file mode 100644 index 0000000..1ec7930 --- /dev/null +++ b/tests/test_servi.py @@ -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()