Comparer les révisions
2
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
6b89a9d815 | |||
|
|
f0dea50fa5 | |||
Aucun fichier ne correspond à votre recherche
@@ -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
|
||||
|
||||
@@ -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,
|
||||
)
|
||||
|
||||
|
||||
@@ -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 `<secondes UTC> <id appareil> <couleur> <nom base64>` ; 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)
|
||||
|
||||
@@ -17,6 +17,7 @@ def config(dossier, **kw):
|
||||
d = Path(dossier)
|
||||
# Environnement simulé (dictionnaire) : les valeurs fictives ne sont jamais écrites sur disque.
|
||||
env = {"MC_BASE": str(d), "MC_QUOTA_COMMUN": str(d / "quota.json"),
|
||||
"MC_JOURNAL_RELAIS": "",
|
||||
"MC_JETON_INFOCLIMAT": JETON_FICTIF, "MC_CLE_ROMMA": CLE_FICTIVE}
|
||||
cfg = Config.depuis_env(env)
|
||||
for k, v in kw.items():
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
"""Quota : appels GWS via le relais SSH (journal `~/gws-relais/journal/appels.log`). Hors ligne, fichiers temporaires."""
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
from meteo_collecte import infoclimat as ic
|
||||
from meteo_collecte.commun import Config, ecrire_json
|
||||
from tests.aide import config, t
|
||||
|
||||
MAINTENANT = t(12, 0, jour=18) # 18/10/2026 12:00 UTC = 14:00 Paris (CEST)
|
||||
MINUIT_PARIS = t(22, 0, jour=17) # 18/10 00:00 Paris
|
||||
NOM = "TWFjIGRlIFRoZW8="
|
||||
|
||||
|
||||
def ligne(ts, ident="a1b2c3d4e5f60718", couleur=3):
|
||||
return "%d %s %d %s" % (int(ts.timestamp()), ident, couleur, NOM)
|
||||
|
||||
|
||||
class TestQuotaRelais(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory()
|
||||
self.cfg, self.journal = config(self.tmp.name)
|
||||
self.fichier = Path(self.tmp.name) / "appels.log"
|
||||
self.cfg.journal_relais = self.fichier
|
||||
|
||||
def tearDown(self):
|
||||
self.tmp.cleanup()
|
||||
|
||||
def ecrire(self, *lignes):
|
||||
self.fichier.write_text("\n".join(lignes) + "\n", encoding="utf-8")
|
||||
|
||||
def texte_journal(self):
|
||||
f = self.cfg.base / "var" / "journal.log"
|
||||
return f.read_text(encoding="utf-8") if f.exists() else ""
|
||||
|
||||
def etat(self):
|
||||
return ic.Quota(self.cfg, self.journal).etat(MAINTENANT)
|
||||
|
||||
def test_defaut_et_desactivation_de_la_config(self):
|
||||
d = Config.depuis_env({"MC_BASE": self.tmp.name})
|
||||
self.assertEqual(d.journal_relais, Path.home() / "gws-relais" / "journal" / "appels.log")
|
||||
self.assertIsNone(Config.depuis_env({"MC_BASE": self.tmp.name, "MC_JOURNAL_RELAIS": ""}).journal_relais)
|
||||
self.assertEqual(Config.depuis_env({"MC_JOURNAL_RELAIS": "/x/y.log"}).journal_relais, Path("/x/y.log"))
|
||||
|
||||
def test_journal_absent(self):
|
||||
e = self.etat()
|
||||
self.assertEqual((e["relais_jour"], e["relais_24h"], e["total_jour"]), (0, 0, 0))
|
||||
self.assertIn("absent", self.texte_journal())
|
||||
|
||||
def test_desactive_aucune_lecture_ni_message(self):
|
||||
self.ecrire(ligne(t(11, 0, jour=18)))
|
||||
self.cfg.journal_relais = None
|
||||
self.assertEqual(self.etat()["relais_jour"], 0)
|
||||
self.assertEqual(self.texte_journal(), "")
|
||||
|
||||
def test_journal_vide(self):
|
||||
self.fichier.write_text("", encoding="utf-8")
|
||||
e = self.etat()
|
||||
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 0))
|
||||
|
||||
def test_journal_illisible(self):
|
||||
self.cfg.journal_relais = Path(self.tmp.name) # un dossier : l'ouverture échoue
|
||||
e = self.etat()
|
||||
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 0))
|
||||
self.assertIn("illisible", self.texte_journal())
|
||||
|
||||
def test_lignes_invalides_ignorees(self):
|
||||
self.ecrire("", "n'importe quoi", "abc def 1 x", "-5 id 1 x", "99999999999999999999 id 1 x",
|
||||
"1.5e9 id 1 x", "seul", ligne(t(11, 0, jour=18)))
|
||||
self.fichier.write_bytes(self.fichier.read_bytes() + b"\xff\xfe\x00 garbage\n")
|
||||
e = self.etat()
|
||||
self.assertEqual((e["relais_jour"], e["relais_24h"]), (1, 1))
|
||||
|
||||
def test_hier_et_aujourd_hui(self):
|
||||
self.ecrire(ligne(t(10, 0, jour=16)), # 2 jours avant : hors jour, hors 24 h
|
||||
ligne(t(21, 59, jour=17)), # 17/10 23:59 Paris : hier, dans les 24 h
|
||||
ligne(MINUIT_PARIS), # 18/10 00:00 Paris : aujourd'hui
|
||||
ligne(t(11, 59, jour=18), ident="admin", couleur=0),
|
||||
ligne(t(12, 5, jour=18))) # futur (> 60 s) : ignoré
|
||||
e = self.etat()
|
||||
self.assertEqual(e["relais_jour"], 2)
|
||||
self.assertEqual(e["relais_24h"], 3)
|
||||
|
||||
def test_borne_24h(self):
|
||||
self.ecrire(ligne(t(12, 0, jour=17)), # exactement 24 h avant : exclu
|
||||
ligne(t(12, 1, jour=17)))
|
||||
self.assertEqual(self.etat()["relais_24h"], 1)
|
||||
|
||||
def test_total_additionne_le_compteur_commun(self):
|
||||
ecrire_json(self.cfg.quota_commun, {"date": "2026-10-18", "requetes": 100}, compact=False)
|
||||
self.ecrire(*[ligne(t(11, 0, jour=18))] * 40)
|
||||
e = self.etat()
|
||||
self.assertEqual((e["commun_jour"], e["relais_jour"], e["total_jour"]), (100, 40, 140))
|
||||
|
||||
def test_plafond_atteint_par_le_total(self):
|
||||
ecrire_json(self.cfg.quota_commun, {"date": "2026-10-18", "requetes": 4000}, compact=False)
|
||||
q = ic.Quota(self.cfg, self.journal)
|
||||
self.assertTrue(q.peut(1, MAINTENANT)) # sans relais : 4001 <= 4999
|
||||
self.ecrire(*[ligne(t(11, 0, jour=18))] * 998)
|
||||
self.assertTrue(q.peut(1, MAINTENANT)) # 4000 + 998 + 1 = 4999 : pile au plafond
|
||||
self.assertFalse(q.peut(2, MAINTENANT))
|
||||
self.ecrire(*[ligne(t(11, 0, jour=18))] * 999)
|
||||
self.assertFalse(q.peut(1, MAINTENANT))
|
||||
|
||||
def test_plafond_atteint_par_les_24h_glissantes_seules(self):
|
||||
# Le relais a fait 4999 appels hier soir (jour précédent) : le compteur du jour est à 0, mais 24 h pleines.
|
||||
self.ecrire(*[ligne(t(21, 0, jour=17))] * 4999)
|
||||
e = self.etat()
|
||||
self.assertEqual((e["relais_jour"], e["relais_24h"]), (0, 4999))
|
||||
self.assertFalse(ic.Quota(self.cfg, self.journal).peut(1, MAINTENANT))
|
||||
|
||||
def test_message_signale_une_seule_fois(self):
|
||||
q = ic.Quota(self.cfg, self.journal)
|
||||
q.etat(MAINTENANT)
|
||||
q.etat(MAINTENANT)
|
||||
self.assertEqual(self.texte_journal().count("absent"), 1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur