Fichiers
meteo-collecte/meteo_collecte/publier.py
T

153 lignes
7.4 KiB
Python

"""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.",
"weatherlink": "Station Gastinel (Davis), données WeatherLink de la station",
"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"),
}
if cfg.weatherlink_actif:
e = lire_json(cfg.base / "var" / "etat_weatherlink.json", {})
succes = [c.get("dernier_succes_utc") for c in e.get("comptes", {}).values() if c.get("dernier_succes_utc")]
pauses = [Pause(p, 0) for p in sorted((cfg.base / "var").glob("pause_weatherlink_*.txt"))]
actives = [p for p in pauses if p.active(maintenant)]
sources["weatherlink"] = {
"dernier_succes_utc": iso(lire_utc(max(succes))) if succes else None,
"en_pause": bool(actives),
"pause_jusqua_utc": iso(max(p.jusqua() for p in actives)) if actives else None,
"dernier_passage": ((resumes.get("weatherlink") 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