153 lignes
7.4 KiB
Python
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
|