From f0dea50fa52ab269020bad4b0dd2e7c5dc95eff1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Sun, 18 Oct 2026 21:06:35 +0200 Subject: [PATCH] Quota : compter les appels GWS passes par le relais SSH MC_JOURNAL_RELAIS (defaut ~/gws-relais/journal/appels.log, vide = desactive). Le quota additionne les lignes du journal sur le jour de Paris et sur les 24 h glissantes. Journal absent ou illisible : 0 appel et une ligne de journal. Co-Authored-By: Claude Sonnet 5.5 --- README.md | 1 + meteo_collecte/commun.py | 8 +++++ meteo_collecte/infoclimat.py | 65 +++++++++++++++++++++++++++++++++--- 3 files changed, 70 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index d5cc63c..8b07d86 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_JOURNAL_RELAIS` | journal des appels GWS via le relais SSH, ajoutés au quota (vide = désactivé) | `~/gws-relais/journal/appels.log` | | `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/meteo_collecte/commun.py b/meteo_collecte/commun.py index 935b928..8c243d7 100644 --- a/meteo_collecte/commun.py +++ b/meteo_collecte/commun.py @@ -42,6 +42,7 @@ class Config: 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) + journal_relais: Path = None # journal des appels GWS via le relais SSH (None = désactivé) # 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" @@ -69,6 +70,12 @@ class Config: v = e.get(nom) return defaut if v is None else v.strip().lower() in ("1", "oui", "true", "yes") + # Variable présente mais vide = désactivé ; absente = défaut. + if "MC_JOURNAL_RELAIS" in e: + journal_relais = Path(e["MC_JOURNAL_RELAIS"]) if (e["MC_JOURNAL_RELAIS"] or "").strip() else None + else: + journal_relais = home / "gws-relais" / "journal" / "appels.log" + return cls( base=base, public=chemin("MC_PUBLIC", base / "public"), @@ -84,6 +91,7 @@ class Config: infoclimat_actif=oui("MC_INFOCLIMAT_ACTIF", True), direct_compat=chemin("MC_DIRECT_COMPAT", None), servi=chemin("MC_SERVI", None), + journal_relais=journal_relais, env=env, ) diff --git a/meteo_collecte/infoclimat.py b/meteo_collecte/infoclimat.py index ebec2d0..74b08c2 100644 --- a/meteo_collecte/infoclimat.py +++ b/meteo_collecte/infoclimat.py @@ -8,7 +8,7 @@ 6. Cache serveur : les visiteurs lisent les fichiers publiés, jamais l'API. Garde-fous : verrou (ordonnanceur), statut vérifié même en HTTP 200, pause 15 min sur toute erreur, -quota commun ~/gws-collecte/quota.json (plafond 4999, jour de Paris) + plafond propre au site (1000/jour, +quota commun ~/gws-collecte/quota.json + journal du relais GWS (MC_JOURNAL_RELAIS) (plafond 4999, jour de Paris et 24 h) + plafond propre au site (1000/jour, compté sur le jour de Paris ET sur 24 h glissantes), alerte à 80 % (envoi réel désactivé par défaut). Le jeton est lu au moment de l'appel, n'est jamais écrit, et est masqué dans tout message. """ @@ -44,6 +44,9 @@ class ErreurInfoclimat(Exception): # Quota # --------------------------------------------------------------------------- +LECTURE_JOURNAL_MAX = 4_000_000 # octets lus en fin de journal du relais (le journal est en ajout seul) + + class Quota: """Deux compteurs : le commun (même format que direct.py et le collecteur GWS) et celui du site.""" @@ -51,6 +54,7 @@ class Quota: self.cfg = cfg self.journal = journal self.fichier_site = cfg.base / "var" / "quota_site.json" + self._deja_signales = set() self.envoyer_alerte = envoyer_alerte or (lambda texte: envoyer_ntfy(cfg, texte)) def _commun(self, maintenant): @@ -69,15 +73,68 @@ class Quota: s["horodatages"] = [t for t in s.get("horodatages", []) if t > limite] return s + def _relais(self, maintenant): + """(appels du jour de Paris, appels des 24 h glissantes) du journal du relais SSH de GWS. + + Lignes ` ` ; seules les secondes comptent. Ligne + invalide ou dans le futur (> 60 s) ignorée. Journal désactivé, absent ou illisible : (0, 0) et une ligne + de journal (une seule fois par message et par instance, pour ne pas inonder le journal). + """ + chemin = self.cfg.journal_relais + if not chemin: + return 0, 0 + try: + with open(chemin, "rb") as f: + f.seek(0, 2) + taille = f.tell() + f.seek(max(0, taille - LECTURE_JOURNAL_MAX)) + brut = f.read(LECTURE_JOURNAL_MAX) + except FileNotFoundError: + self._signaler("journal du relais absent (%s) : 0 appel compté" % chemin, maintenant) + return 0, 0 + except Exception as e: # illisible : jamais de plantage + self._signaler("journal du relais illisible (%s) : 0 appel compté" % str(e)[:200], maintenant) + return 0, 0 + now = maintenant.timestamp() + jour = jour_paris(maintenant) + n_jour = n_24h = 0 + for ligne in brut.decode("utf-8", "replace").splitlines(): + champs = ligne.split() + if len(champs) < 2: + continue + try: + ts = int(champs[0]) + if ts <= 0 or ts > now + 60: + continue + dans_jour = jour_paris(dt.datetime.fromtimestamp(ts, UTC)) == jour + except (ValueError, OverflowError, OSError): + continue + n_jour += dans_jour + n_24h += ts > now - 86400 + return n_jour, n_24h + + def _signaler(self, msg, maintenant): + if msg not in self._deja_signales: + self._deja_signales.add(msg) + try: + self.journal(msg, maintenant) + except Exception: + pass + def etat(self, maintenant): c, s = self._commun(maintenant), self._site(maintenant) - return {"commun_jour": c["requetes"], "plafond_commun": self.cfg.plafond_commun, + rj, r24 = self._relais(maintenant) + return {"commun_jour": c["requetes"], "relais_jour": rj, "relais_24h": r24, + "total_jour": c["requetes"] + rj, "plafond_commun": self.cfg.plafond_commun, "site_jour": s["requetes"], "site_24h": len(s["horodatages"]), "plafond_site": self.cfg.plafond_site} def peut(self, n, maintenant): e = self.etat(maintenant) - return (e["commun_jour"] + n <= self.cfg.plafond_commun and e["site_jour"] + n <= self.cfg.plafond_site - and e["site_24h"] + n <= self.cfg.plafond_site) + # Jour de Paris : compteur commun + relais. 24 h glissantes : le commun n'est pas horodaté, on prend donc + # les appels horodatés connus (site + relais), sous-estimation possible des autres appels du collecteur. + return (e["total_jour"] + n <= self.cfg.plafond_commun + and e["site_24h"] + e["relais_24h"] + n <= self.cfg.plafond_commun + and e["site_jour"] + n <= self.cfg.plafond_site and e["site_24h"] + n <= self.cfg.plafond_site) def noter(self, n, maintenant): c = self._commun(maintenant)