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>
Cette révision appartient à :
Théo GastineletClaude Haiku 5.5 a révisé 2026-10-17 16:45:09 +02:00
1 Parent 21f7fca8b6
révision 778825198e
8 fichiers modifiés
+679 -571

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -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
+4 -2
Voir le fichier
@@ -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
+53 -49
Voir le fichier
@@ -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
+115 -109
Voir le fichier
@@ -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 <nom>.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 <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.
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))
+76 -74
Voir le fichier
@@ -1,74 +1,76 @@
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
Chaque source décide seule si elle appelle :
* ROMMA : au plus une requête global=1 toutes les 10 min ;
* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9.
Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche
ni l'autre source ni la publication.
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
"""
import datetime as dt
import sys
from . import infoclimat, publier, romma
from .commun import UTC, Config, Journal, Verrou, lire_json
from .stockage import Stockage
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
appels=True):
maintenant = maintenant or dt.datetime.now(UTC)
var = cfg.base / "var"
journal = Journal(var / "collecte.log")
with Verrou(var / ".collecte.lock") as obtenu:
if not obtenu:
return {"action": "verrou"} # un tick précédent tourne encore
stockage = Stockage(var / "mesures.sqlite")
resumes = {}
try:
if appels and cfg.romma_actif:
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
if appels and cfg.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
stockage.purger(maintenant, cfg.garder_jours)
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
finally:
stockage.fermer()
return resumes
def _sans_planter(journal, maintenant, nom, f):
try:
return f()
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
return {"source": nom, "action": "erreur_interne"}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
cfg = Config.depuis_env()
if "--config" in argv:
for k, v in vars(cfg).items():
if k == "env":
continue # l'environnement contient les secrets : jamais affiché
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
try:
cfg.secret(nom)
print("%-20s définie (valeur masquée)" % nom)
except LookupError:
print("%-20s absente" % nom)
return 0
tick(cfg, appels="--publier" not in argv)
return 0
if __name__ == "__main__":
sys.exit(main())
"""Ordonnanceur : lancé par le minuteur systemd toutes les 5 min (hh:x4 et hh:x9).
Chaque source décide seule si elle appelle :
* ROMMA : au plus une requête global=1 toutes les 10 min ;
* Infoclimat : passage principal à hh:x4 si une station est due, rattrapage ciblé à hh:x9.
Puis publication des fichiers statiques et purge de la base (14 jours). Une source en erreur n'empêche
ni l'autre source ni la publication.
python3 -m meteo_collecte.ordonnanceur # un tick
python3 -m meteo_collecte.ordonnanceur --publier # republie sans aucun appel réseau
python3 -m meteo_collecte.ordonnanceur --config # affiche la configuration (sans secret)
"""
import datetime as dt
import sys
from . import infoclimat, publier, romma
from .commun import UTC, Config, Journal, Verrou, lire_json
from .stockage import Stockage
def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger,
appels=True):
maintenant = maintenant or dt.datetime.now(UTC)
var = cfg.base / "var"
journal = Journal(var / "collecte.log")
with Verrou(var / ".collecte.lock") as obtenu:
if not obtenu:
return {"action": "verrou"} # un tick précédent tourne encore
stockage = Stockage(var / "mesures.sqlite")
resumes = {}
try:
if appels and cfg.romma_actif:
resumes["romma"] = _sans_planter(journal, maintenant, "romma",
lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma))
if appels and cfg.infoclimat_actif:
stations = lire_json(cfg.stations, {}).get("infoclimat", {})
resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer(
cfg, stockage, journal, maintenant, stations, fetch=fetch_infoclimat))
stockage.purger(maintenant, cfg.garder_jours)
resumes["publiees"] = publier.publier(cfg, stockage, maintenant, resumes)
if cfg.servi:
resumes["servies"] = publier.copier_vers_servi(cfg.public, cfg.servi)
finally:
stockage.fermer()
return resumes
def _sans_planter(journal, maintenant, nom, f):
try:
return f()
except Exception as e: # bug local (disque, base…) : journalisé, la suite du tick continue
journal("ERREUR interne %s : %s" % (nom, str(e)[:300]), maintenant)
return {"source": nom, "action": "erreur_interne"}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
cfg = Config.depuis_env()
if "--config" in argv:
for k, v in vars(cfg).items():
if k == "env":
continue # l'environnement contient les secrets : jamais affiché
print("%-20s %s" % (k, v)) # chemins et noms de variables seulement
for nom in (cfg.var_jeton_infoclimat, cfg.var_cle_romma):
try:
cfg.secret(nom)
print("%-20s définie (valeur masquée)" % nom)
except LookupError:
print("%-20s absente" % nom)
return 0
tick(cfg, appels="--publier" not in argv)
return 0
if __name__ == "__main__":
sys.exit(main())
+140 -96
Voir le fichier
@@ -1,96 +1,140 @@
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
* data/stations.json : index de toutes les stations avec leur dernière mesure ;
* data/station/<source>-<id>.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ;
* data/etat.json : heure de mise à jour par source, sources en pause.
Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage
(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers.
Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API.
"""
import datetime as dt
import re
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
from .stockage import CHAMPS
ATTRIBUTIONS = {
"infoclimat": "Données Infoclimat",
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
"interprétation.",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
}
def nom_fichier(source, station_id):
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
def _releve(r):
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
def _fiche(st):
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
def publier(cfg, stockage, maintenant, resumes=None):
data = cfg.public / "data"
index = []
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
for st in stockage.stations():
fiche = _fiche(st)
der = stockage.derniere(st["source"], st["station_id"])
if der:
fiche["derniere"] = _releve(der)
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
else:
fiche["derniere"], fiche["age_min"] = None, None
index.append(fiche)
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
ecrire_json(data / "station" / (fiche["id"] + ".json"),
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
if cfg.direct_compat:
publier_direct_compat(cfg, stockage, maintenant)
return len(index)
def etat(cfg, maintenant, resumes):
from .commun import Pause, lire_json
sources = {}
for src in ("infoclimat", "romma"):
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
succes = e.get("dernier_succes_utc")
sources[src] = {
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
"en_pause": p.active(maintenant),
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
"dernier_passage": (resumes.get(src) or {}).get("action"),
}
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
def publier_direct_compat(cfg, stockage, maintenant):
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
depuis = maintenant - dt.timedelta(hours=48)
stations, meta = {}, {}
for st in stockage.stations():
if st["source"] != "infoclimat":
continue
rel = []
for r in stockage.serie("infoclimat", st["station_id"], depuis):
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
x["pluie_cumul_0h"] = r.get("pluie_cumul")
rel.append(x)
stations[st["station_id"]] = {"nom": st["nom"], "releves": rel}
meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"],
"licence": st["licence"] or ""}
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations})
"""Publication en fichiers statiques (§3.3) : écriture atomique (.tmp puis os.replace) sous <public>/data/.
* data/stations.json : index de toutes les stations avec leur dernière mesure ;
* data/station/<source>-<id>.json : 48 h de relevés d'une station, chargé à l'ouverture de sa fiche ;
* data/etat.json : heure de mise à jour par source, sources en pause.
Une station = une source. Aucune valeur n'est mélangée ni moyennée entre sources ; le dédoublonnage
(« Aussi publiée par… ») se fera côté site, à partir de ces fichiers.
Le navigateur ne voit jamais ni jeton, ni clé, ni URL d'API.
"""
import datetime as dt
import os
import re
import stat
from pathlib import Path
from .commun import UTC, ecrire_json, fmt_utc, iso, lire_utc
from .stockage import CHAMPS
ATTRIBUTIONS = {
"infoclimat": "Données Infoclimat",
"romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur "
"interprétation.",
"meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)",
}
def nom_fichier(source, station_id):
"""Nom sûr : seuls lettres, chiffres, tiret et soulignement (un identifiant ne choisit pas le chemin)."""
return "%s-%s" % (re.sub(r"[^A-Za-z0-9_]", "_", source), re.sub(r"[^A-Za-z0-9_-]", "_", str(station_id)))
def _releve(r):
return dict({"dh_utc": r["dh_utc"]}, **{c: r[c] for c in CHAMPS if r.get(c) is not None})
def _fiche(st):
return {"id": nom_fichier(st["source"], st["station_id"]), "source": st["source"], "station_id": st["station_id"],
"nom": st.get("nom"), "lat": st.get("lat"), "lon": st.get("lon"), "altitude": st.get("altitude"),
"licence": st.get("licence"), "lien": st.get("lien"), "attribution": ATTRIBUTIONS.get(st["source"], "")}
def publier(cfg, stockage, maintenant, resumes=None):
data = cfg.public / "data"
index = []
depuis = maintenant - dt.timedelta(hours=cfg.fiche_heures)
for st in stockage.stations():
fiche = _fiche(st)
der = stockage.derniere(st["source"], st["station_id"])
if der:
fiche["derniere"] = _releve(der)
fiche["age_min"] = int((maintenant - lire_utc(der["dh_utc"])).total_seconds() // 60)
else:
fiche["derniere"], fiche["age_min"] = None, None
index.append(fiche)
serie = [_releve(r) for r in stockage.serie(st["source"], st["station_id"], depuis)]
ecrire_json(data / "station" / (fiche["id"] + ".json"),
dict(fiche, mis_a_jour_utc=iso(maintenant), releves=serie))
ecrire_json(data / "stations.json", {"mis_a_jour_utc": iso(maintenant), "stations": index})
ecrire_json(data / "etat.json", etat(cfg, maintenant, resumes or {}))
if cfg.direct_compat:
publier_direct_compat(cfg, stockage, maintenant)
return len(index)
def etat(cfg, maintenant, resumes):
from .commun import Pause, lire_json
sources = {}
for src in ("infoclimat", "romma"):
e = lire_json(cfg.base / "var" / ("etat_%s.json" % src), {})
p = Pause(cfg.base / "var" / ("pause_%s.txt" % src))
succes = e.get("dernier_succes_utc")
sources[src] = {
"dernier_succes_utc": iso(lire_utc(succes)) if succes else None,
"en_pause": p.active(maintenant),
"pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None,
"dernier_passage": (resumes.get(src) or {}).get("action"),
}
return {"mis_a_jour_utc": iso(maintenant), "sources": sources}
def publier_direct_compat(cfg, stockage, maintenant):
"""Ancien direct.json (même forme que meteo-direct) pour le site LAN et Mind, tant qu'ils n'ont pas migré."""
depuis = maintenant - dt.timedelta(hours=48)
stations, meta = {}, {}
for st in stockage.stations():
if st["source"] != "infoclimat":
continue
rel = []
for r in stockage.serie("infoclimat", st["station_id"], depuis):
x = {c: r.get(c) for c in ("dh_utc", "temperature", "humidite", "point_de_rosee", "pression",
"vent_moyen", "vent_rafales", "vent_direction", "pluie_1h")}
x["pluie_cumul_0h"] = r.get("pluie_cumul")
rel.append(x)
stations[st["station_id"]] = {"nom": st["nom"], "releves": rel}
meta[st["station_id"]] = {"altitude": st["altitude"], "lat": st["lat"], "lon": st["lon"],
"licence": st["licence"] or ""}
ecrire_json(cfg.direct_compat, {"source": "Infoclimat (licences CC BY ou CC BY-NC selon la station)",
"mis_a_jour_utc": iso(maintenant), "metadonnees": meta, "stations": stations})
def copier_vers_servi(src, dst):
"""Copie data/ de `src` vers `dst` (dossier lu par Caddy, lecture seule côté serveur).
Seuls les fichiers ordinaires sont copiés : tout lien symbolique dans la source fait échouer la copie
(ValueError, rien de copié pour ce fichier). Dans la destination, un lien est remplacé, jamais suivi :
écriture dans un fichier temporaire créé avec O_EXCL|O_NOFOLLOW, puis os.replace (atomique).
Renvoie le nombre de fichiers copiés."""
src, dst = Path(src), Path(dst)
racine = src / "data"
dst.mkdir(parents=True, exist_ok=True)
n = 0
for f in sorted(racine.rglob("*")):
st = os.lstat(f)
if stat.S_ISLNK(st.st_mode):
raise ValueError("lien symbolique refusé dans la source : %s" % f.name)
if not stat.S_ISREG(st.st_mode):
continue
rel = f.relative_to(src)
cible_dir = dst
for morceau in rel.parts[:-1]:
cible_dir = cible_dir / morceau
if cible_dir.is_symlink():
raise ValueError("lien symbolique refusé dans la destination : %s" % cible_dir.name)
cible_dir.mkdir(exist_ok=True)
cible = cible_dir / rel.parts[-1]
tmp = cible_dir / (rel.parts[-1] + ".tmp")
if tmp.is_symlink() or tmp.exists():
tmp.unlink() # supprime l'entrée (un lien n'est jamais suivi)
fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o644)
try:
with os.fdopen(fd, "wb") as out, open(f, "rb") as entree:
out.write(entree.read())
except BaseException:
if tmp.exists() or tmp.is_symlink():
tmp.unlink()
raise
os.replace(str(tmp), str(cible)) # remplace aussi un lien existant, sans le suivre
n += 1
return n
+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()