Arrangement des alertes chat
This commit is contained in:
37
.env
37
.env
@@ -9,25 +9,23 @@ AUTH_USERS=[{"user":"Michel","pass":"210462"}]
|
||||
MQTT_HOST=162.19.78.131
|
||||
MQTT_USER=sondes
|
||||
MQTT_PASS=3J@bjYP0
|
||||
MQTT_PORT_MEUDON=1883
|
||||
MQTT_PORT=1883
|
||||
|
||||
# Synology Chat
|
||||
SYNOLOGY_CHAT_WEBHOOK_URL=https://192.168.1.250/webapi/entry.cgi?api=SYNO.Chat.External&method=incoming&version=2&token=UN7nhD70vrhrHFh1VeDdOpsklIHiIFRop2qB7b6YusMEY3clY3R8CXe4hFzz4KKc
|
||||
SYNOLOGY_CHAT_VERIFY_SSL=false
|
||||
SYNO_CHAT_WEBHOOK=https://mj91.fr/chat/webapi/entry.cgi?api=SYNO.Chat.External&method=incoming&version=2&token=QpLWAZEqIW1EOBHkfDkmr1LqC3P3J1SASWfqpchZdd1xPY7xGbYerS4lCADJnPrm
|
||||
SYNO_CHAT_VERIFY_SSL=true
|
||||
SYNO_CHAT_BOTNAME="Gestion Gyro"
|
||||
SYNO_CHAT_TIMEOUT=10
|
||||
SYNO_CHAT_GYRO_ENABLED=1
|
||||
|
||||
# Boucle rapide du gyro
|
||||
GYRO_WINDOW_MIN=3
|
||||
GYRO_NEEDED_POINTS=2
|
||||
GYRO_CHECK_SEC=20
|
||||
GYRO_NORMAL_CONFIRM=6
|
||||
GYRO_MODE=mqtt
|
||||
GYRO_MODE_CONTINUOUS=1
|
||||
GYRO_HYSTERESIS=0.3
|
||||
ALERT_OK_SMS_GYRO=0
|
||||
ALERT_OK_SMS=0
|
||||
GYRO_SMS_MIN_SEC=120
|
||||
GYRO_MQTT_TOPIC_SACLAY=Saclay/gyrophare
|
||||
GYRO_MQTT_TOPIC_MEUDON=Meudon/gyrophare
|
||||
|
||||
# Délais
|
||||
ALERT_CONTINUOUS_MINUTES=30
|
||||
ALERT_LOOKBACK_MINUTES=120
|
||||
@@ -47,24 +45,3 @@ MAIL_TO_SACLAY=robots@domo91.fr,nicolas.thibaut@bw-paris-saclay.com
|
||||
MAIL_FROM_SACLAY="DOMO91 Saclay <services@domo91.fr>"
|
||||
MAIL_TO_MEUDON=robots@domo91.fr,chef@parismeudonermitage.com
|
||||
MAIL_FROM_MEUDON="DOMO91 Meudon <services@domo91.fr>"
|
||||
|
||||
# --- Paramètres SMS ----
|
||||
OVH_ENDPOINT=ovh-eu
|
||||
OVH_APPLICATION_KEY=f725d07b2f98a195
|
||||
OVH_APPLICATION_SECRET=5ca392a0a728e2395edd426bb1e11ad6
|
||||
OVH_CONSUMER_KEY=305f2e8611e58b83930de84ee65c99f9
|
||||
OVH_SMS_SERVICE=sms-jm164396-1
|
||||
OVH_SMS_SENDER=DOMO91FR
|
||||
SMS_RECEIVER=+33759600180
|
||||
ALERT_SMS_TO_SACLAY=Michel:+33759600180
|
||||
ALERT_SMS_TO_MEUDON=Michel:+33759600180
|
||||
|
||||
ALERT_SMS_CLIENT_TO_MEUDON=Sekou:+33625903364,Damien:+33680388259
|
||||
ALERT_SMS_CLIENT_TO_SACLAY=Nicolas:+33682069405,Sabrina:+33650270939
|
||||
# Activer/désactiver globalement l’envoi client
|
||||
ALERT_SMS_CLIENT_ENABLED=1
|
||||
# 1) couper les SMS internes
|
||||
ALERT_INTERNAL_SMS_ENABLED=0# 0 = coupe tous les SMS “internes” (déclenchement)
|
||||
|
||||
# 2) limiter le flux par cooldown (par sonde)
|
||||
ALERT_SMS_COOLDOWN_SEC=3600
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,958 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# ========= Site =========
|
||||
SITE = "Saclay"
|
||||
PROGRAM_NAME = f"Monitor_{SITE}"
|
||||
|
||||
# ========= Imports & .env =========
|
||||
import os, re, time, ssl, smtplib, logging
|
||||
import datetime as dt
|
||||
from email.message import EmailMessage
|
||||
from datetime import datetime
|
||||
from dotenv import load_dotenv, find_dotenv
|
||||
load_dotenv(find_dotenv(usecwd=True), override=False)
|
||||
from utils_sms import normaliser_sms
|
||||
|
||||
def _env_bool(name: str, default: bool) -> bool:
|
||||
v = os.getenv(name, str(int(default))).strip().lower()
|
||||
return v in ("1", "true", "yes", "on")
|
||||
|
||||
# MySQL
|
||||
import mysql.connector
|
||||
from mysql.connector import Error as MySQLError
|
||||
from dotenv import load_dotenv
|
||||
load_dotenv()
|
||||
|
||||
# OVH (SMS)
|
||||
try:
|
||||
import ovh
|
||||
from ovh.exceptions import APIError as OVHAPIError
|
||||
_ovh_available = True
|
||||
except Exception:
|
||||
ovh = None # type: ignore
|
||||
class OVHAPIError(Exception): ...
|
||||
_ovh_available = False
|
||||
|
||||
# MQTT
|
||||
try:
|
||||
import paho.mqtt.client as mqtt
|
||||
_mqtt_ok = True
|
||||
except Exception:
|
||||
_mqtt_ok = False
|
||||
|
||||
# ========= Logger =========
|
||||
level = getattr(logging, os.getenv("LOGLEVEL", "INFO").upper(), logging.INFO)
|
||||
log = logging.getLogger(PROGRAM_NAME.lower())
|
||||
if not log.handlers:
|
||||
logging.basicConfig(level=level, format="%(asctime)s %(levelname)s %(message)s")
|
||||
|
||||
# ========= DB utils =========
|
||||
def open_alert(conn, table_alertes: str, sonde: str, dt_: datetime) -> bool:
|
||||
"""
|
||||
Ouvre UNE alerte si aucune alerte 'En cours' n'existe encore pour la sonde.
|
||||
Retourne True si une nouvelle alerte a été créée (→ notifier par mail & SMS client).
|
||||
"""
|
||||
cur = conn.cursor()
|
||||
cur.execute(
|
||||
f"SELECT 1 FROM `{table_alertes}` WHERE Sonde=%s AND Etat='En cours' LIMIT 1",
|
||||
(sonde,)
|
||||
)
|
||||
if cur.fetchone():
|
||||
cur.close()
|
||||
return False # déjà ouverte
|
||||
cur.execute(
|
||||
f"INSERT INTO `{table_alertes}` (Sonde, Debut_defaut, Etat) VALUES (%s, %s, 'En cours')",
|
||||
(sonde, dt_.strftime('%Y-%m-%d %H:%M:%S'))
|
||||
)
|
||||
conn.commit()
|
||||
cur.close()
|
||||
return True
|
||||
|
||||
def close_alert(conn, table_alertes: str, sonde: str) -> bool:
|
||||
"""
|
||||
Ferme l'alerte 'En cours' si présente.
|
||||
Retourne True si une alerte est passée à 'Acquitté' (→ notifier par mail).
|
||||
"""
|
||||
cur = conn.cursor()
|
||||
cur.execute(
|
||||
f"UPDATE `{table_alertes}` SET Etat='Acquitté' "
|
||||
f"WHERE Sonde=%s AND Etat='En cours' "
|
||||
f"ORDER BY Debut_defaut DESC LIMIT 1",
|
||||
(sonde,)
|
||||
)
|
||||
changed = (cur.rowcount == 1)
|
||||
conn.commit()
|
||||
cur.close()
|
||||
return changed
|
||||
|
||||
def get_db():
|
||||
return mysql.connector.connect(
|
||||
host=os.getenv("DB_HOST"),
|
||||
user=os.getenv("DB_USER"),
|
||||
password=os.getenv("DB_PASS"),
|
||||
database=os.getenv("DB_NAME", "Sondes"),
|
||||
port=int(os.getenv("DB_PORT", "3306")),
|
||||
autocommit=True,
|
||||
)
|
||||
|
||||
# --- Journalisation Gyro en table dédiée `Gyro` ---
|
||||
def insert_gyro_log(lieu: str, etat: str, topic: str, payload_raw: str,
|
||||
qos: int | None, retained: int | None, when: datetime):
|
||||
cnx = get_db()
|
||||
try:
|
||||
cur = cnx.cursor()
|
||||
cur.execute(
|
||||
"INSERT INTO Sondes.Gyro (Lieu, Sonde, Etat, Date, Topic, Payload, QoS, Retained) "
|
||||
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s)",
|
||||
(
|
||||
lieu,
|
||||
os.getenv("GYRO_SONDE_NAME", "Gyro"),
|
||||
etat, # 'ON' ou 'OFF'
|
||||
when.strftime('%Y-%m-%d %H:%M:%S'),
|
||||
topic,
|
||||
payload_raw,
|
||||
qos,
|
||||
retained
|
||||
)
|
||||
)
|
||||
cnx.commit()
|
||||
log.info("Gyro inséré: %s %s (%s)", lieu, etat, topic)
|
||||
except MySQLError as err:
|
||||
log.exception("Erreur DB insert_gyro_log: %s", err)
|
||||
finally:
|
||||
cnx.close()
|
||||
|
||||
def should_insert_gyro(lieu: str, etat: str, sonde: str = "Gyro") -> bool:
|
||||
sql = "SELECT Etat FROM Sondes.Gyro WHERE Lieu=%s AND Sonde=%s ORDER BY Date DESC LIMIT 1"
|
||||
cnx = get_db()
|
||||
try:
|
||||
cur = cnx.cursor()
|
||||
cur.execute(sql, (lieu, sonde))
|
||||
row = cur.fetchone()
|
||||
return (row is None) or (row[0] != etat)
|
||||
finally:
|
||||
cnx.close()
|
||||
|
||||
# --- Lecture des dernières mesures de température (en ignorant lignes d'état) ---
|
||||
def lire_sondes_depuis_db(site: str):
|
||||
table = site
|
||||
sql = f"""
|
||||
SELECT t1.Sonde, t1.Temperature, t1.Date
|
||||
FROM `{table}` t1
|
||||
JOIN (
|
||||
SELECT Sonde, MAX(Date) AS MaxDate
|
||||
FROM `{table}`
|
||||
WHERE Temperature IS NOT NULL
|
||||
GROUP BY Sonde
|
||||
) t2 ON t1.Sonde=t2.Sonde AND t1.Date=t2.MaxDate
|
||||
WHERE t1.Temperature IS NOT NULL
|
||||
"""
|
||||
cnx = get_db()
|
||||
try:
|
||||
cur = cnx.cursor(dictionary=True)
|
||||
cur.execute(sql)
|
||||
rows = cur.fetchall()
|
||||
for r in rows:
|
||||
r["Temperature"] = float(r["Temperature"]) # garanti NOT NULL
|
||||
return rows
|
||||
except MySQLError as err:
|
||||
log.exception("Erreur DB (lire_sondes_depuis_db): %s", err)
|
||||
return []
|
||||
finally:
|
||||
cnx.close()
|
||||
|
||||
|
||||
def lire_cfg_chambres(site: str):
|
||||
"""
|
||||
Retourne {sonde: {"temp_max": float, "active": bool}}
|
||||
depuis Chambres_froides pour le site.
|
||||
"""
|
||||
dbname = os.getenv("DB_NAME", "Sondes")
|
||||
sql = f"""
|
||||
SELECT Sonde, Temp_Max, Etat
|
||||
FROM `{dbname}`.`Chambres_froides`
|
||||
WHERE Lieu=%s
|
||||
"""
|
||||
cnx = get_db()
|
||||
cfg: dict[str, dict] = {}
|
||||
try:
|
||||
cur = cnx.cursor()
|
||||
cur.execute(sql, (site,))
|
||||
for sonde, temp_max, etat in cur.fetchall():
|
||||
cfg[str(sonde)] = {
|
||||
"temp_max": float(temp_max),
|
||||
"active": str(etat).upper() == "ON",
|
||||
}
|
||||
return cfg
|
||||
except MySQLError as err:
|
||||
log.exception("Erreur DB (lire_cfg_chambres): %s", err)
|
||||
return cfg
|
||||
finally:
|
||||
cnx.close()
|
||||
|
||||
def compute_site_alarm(last_values: list[dict], cfg: dict[str, dict], hysteresis: float = 0.0):
|
||||
"""
|
||||
Retourne (is_on: bool, trigger: (sonde,temp,seuil) | None)
|
||||
"""
|
||||
for row in last_values:
|
||||
sonde = str(row["Sonde"])
|
||||
meta = cfg.get(sonde)
|
||||
if not meta or not meta.get("active", False):
|
||||
continue
|
||||
temp = float(row["Temperature"])
|
||||
seuil = float(meta["temp_max"])
|
||||
if temp > seuil + float(hysteresis):
|
||||
return True, (sonde, temp, seuil)
|
||||
return False, None
|
||||
|
||||
def lire_seuils_depuis_db(site: str):
|
||||
sql = """
|
||||
SELECT Sonde, Temp_Max
|
||||
FROM Sondes.Chambres_froides
|
||||
WHERE Lieu=%s AND Etat='ON'
|
||||
"""
|
||||
cnx = get_db()
|
||||
seuils = {}
|
||||
try:
|
||||
cur = cnx.cursor()
|
||||
cur.execute(sql, (site, ))
|
||||
for sonde, s in cur.fetchall():
|
||||
seuils[str(sonde)] = float(s)
|
||||
return seuils
|
||||
except MySQLError as err:
|
||||
log.exception("Erreur DB (lire_seuils_depuis_db): %s", err)
|
||||
return seuils
|
||||
finally:
|
||||
cnx.close()
|
||||
|
||||
# --- Dépassement continu (configurable) ---
|
||||
def depassement_depuis_30min(site: str, sonde: str, seuil: float) -> bool:
|
||||
"""
|
||||
True si la sonde est > seuil de façon CONTINUE depuis CONT_MIN minutes.
|
||||
CONT_MIN = ALERT_CONTINUOUS_MINUTES (defaut 30)
|
||||
LOOKBACK = ALERT_LOOKBACK_MINUTES (defaut max(60, CONT_MIN*3))
|
||||
"""
|
||||
CONT_MIN = int(os.getenv("ALERT_CONTINUOUS_MINUTES", "30"))
|
||||
LOOKBACK = int(os.getenv("ALERT_LOOKBACK_MINUTES", str(max(60, int(os.getenv("ALERT_CONTINUOUS_MINUTES", "30"))*3))))
|
||||
|
||||
table = site
|
||||
cnx = get_db()
|
||||
try:
|
||||
cur = cnx.cursor()
|
||||
cur.execute(f"""
|
||||
SELECT Temperature, Date
|
||||
FROM `{table}`
|
||||
WHERE Sonde=%s
|
||||
AND Date >= (NOW() - INTERVAL %s MINUTE)
|
||||
ORDER BY Date DESC
|
||||
""", (sonde, LOOKBACK))
|
||||
rows = cur.fetchall()
|
||||
if not rows:
|
||||
return False
|
||||
|
||||
last_temp, last_dt = float(rows[0][0]), rows[0][1]
|
||||
if last_temp <= float(seuil):
|
||||
return False
|
||||
|
||||
# Début de la séquence continue > seuil
|
||||
start_dt = last_dt
|
||||
for temp, d in rows[1:]:
|
||||
if float(temp) > float(seuil):
|
||||
start_dt = d
|
||||
else:
|
||||
break
|
||||
|
||||
tzinfo = getattr(start_dt, "tzinfo", None)
|
||||
now = dt.datetime.now(tz=tzinfo)
|
||||
dur_min = (now - start_dt).total_seconds() / 60.0
|
||||
log.debug("Seq>seuil %s: start=%s, now=%s, dur=%.1fmin, need>=%d",
|
||||
sonde, start_dt, now, dur_min, CONT_MIN)
|
||||
return dur_min >= CONT_MIN
|
||||
|
||||
except MySQLError as err:
|
||||
log.exception("Erreur DB (depassement_depuis_30min, continu): %s", err)
|
||||
return False
|
||||
finally:
|
||||
cnx.close()
|
||||
|
||||
# ========= Helpers listes/numéros =========
|
||||
def _split_list(raw: str | None) -> list[str]:
|
||||
return [x.strip() for x in re.split(r"[;,]", raw or "") if x.strip()]
|
||||
|
||||
def _parse_labeled_phones(raw: str | None) -> list[tuple[str, str]]:
|
||||
out: list[tuple[str, str]] = []
|
||||
for tok in re.split(r"[;,]", raw or ""):
|
||||
tok = tok.strip()
|
||||
if not tok:
|
||||
continue
|
||||
if ":" in tok:
|
||||
name, num = tok.split(":", 1)
|
||||
out.append((name.strip(), num.strip()))
|
||||
else:
|
||||
out.append(("", tok))
|
||||
return out
|
||||
|
||||
def _resolve_sms_receivers(labeled: list[tuple[str, str]]) -> list[str]:
|
||||
only = os.getenv("ALERT_SMS_ONLY")
|
||||
if not only:
|
||||
return [num for (_n, num) in labeled]
|
||||
allow = {x.strip() for x in re.split(r"[;,]", only) if x.strip()}
|
||||
return [num for (name, num) in labeled if (name and name in allow) or (num in allow)]
|
||||
|
||||
def _human_labeled_list(labeled: list[tuple[str, str]]) -> str:
|
||||
return ", ".join([f"{n}({p})" if n else p for n, p in labeled])
|
||||
|
||||
# ========= Notifier (SMS interne + SMS client + Mail) =========
|
||||
class Notifier:
|
||||
def __init__(self):
|
||||
# OVH SMS
|
||||
self.ovh_enabled = _ovh_available and all(
|
||||
os.getenv(k) for k in ("OVH_APPLICATION_KEY","OVH_APPLICATION_SECRET","OVH_CONSUMER_KEY","OVH_SMS_SERVICE","OVH_SMS_SENDER")
|
||||
)
|
||||
if self.ovh_enabled:
|
||||
self.ovh_client = ovh.Client(
|
||||
endpoint=os.getenv("OVH_ENDPOINT","ovh-eu"),
|
||||
application_key=os.getenv("OVH_APPLICATION_KEY"),
|
||||
application_secret=os.getenv("OVH_APPLICATION_SECRET"),
|
||||
consumer_key=os.getenv("OVH_CONSUMER_KEY"),
|
||||
)
|
||||
self.ovh_service = os.getenv("OVH_SMS_SERVICE")
|
||||
self.ovh_sender = os.getenv("OVH_SMS_SENDER")
|
||||
raw_sms = (os.getenv(f"ALERT_SMS_TO_{SITE}") or os.getenv(f"ALERT_SMS_TO_{SITE.upper()}") or os.getenv("ALERT_SMS_TO"))
|
||||
self.sms_labeled = _parse_labeled_phones(raw_sms)
|
||||
else:
|
||||
self.sms_labeled = []
|
||||
|
||||
# SMS CLIENTS (site-spécifique + génériques + compat FR)
|
||||
raw_sms_client = (
|
||||
os.getenv(f"ALERT_SMS_CLIENT_TO_{SITE}") or
|
||||
os.getenv(f"ALERT_SMS_CLIENT_TO_{SITE.upper()}") or
|
||||
os.getenv("ALERT_SMS_CLIENT_TO") or
|
||||
os.getenv(f"ALERTE_CLIENT_{SITE}") or
|
||||
os.getenv("ALERTE_CLIENT")
|
||||
)
|
||||
self.sms_client_labeled = _parse_labeled_phones(raw_sms_client)
|
||||
self.sms_client_enabled = (os.getenv("ALERT_SMS_CLIENT_ENABLED", "1") == "1")
|
||||
|
||||
# SMTP
|
||||
self.smtp_host = os.getenv("SMTP_HOST")
|
||||
self.smtp_port = int(os.getenv("SMTP_PORT","465"))
|
||||
self.smtp_user = os.getenv("SMTP_USER")
|
||||
self.smtp_pass = os.getenv("SMTP_PASS")
|
||||
self.smtp_security = (os.getenv("SMTP_SECURITY","SSL") or "SSL").upper()
|
||||
|
||||
raw_mail_to = (os.getenv(f"MAIL_TO_{SITE}") or os.getenv(f"MAIL_TO_{SITE.upper()}") or os.getenv("MAIL_TO") or "")
|
||||
self.mail_to = _split_list(raw_mail_to)
|
||||
self.mail_from = (os.getenv(f"MAIL_FROM_{SITE}") or os.getenv(f"MAIL_FROM_{SITE.upper()}") or os.getenv("MAIL_FROM") or self.smtp_user)
|
||||
|
||||
self.smtp_enabled = all([self.smtp_host, self.smtp_port, self.smtp_user, self.smtp_pass, self.mail_to])
|
||||
|
||||
def send_sms(self, message: str, tag: str = f"monitor-{SITE.lower()}") -> bool:
|
||||
if not self.ovh_enabled or not self.sms_labeled:
|
||||
log.warning("SMS désactivé ou aucun destinataire.")
|
||||
return False
|
||||
receivers = _resolve_sms_receivers(self.sms_labeled)
|
||||
if not receivers:
|
||||
log.warning("ALERT_SMS_ONLY filtre tous les destinataires (aucun envoi).")
|
||||
return False
|
||||
|
||||
# ✅ Normalisation GSM-7 + préfixe site
|
||||
message = normaliser_sms(message, prefix=SITE)
|
||||
|
||||
payload = {
|
||||
"sender": self.ovh_sender,
|
||||
"receivers": receivers,
|
||||
"message": message,
|
||||
"priority": "high",
|
||||
"coding": "7bit",
|
||||
"class": "phoneDisplay",
|
||||
"noStopClause": True,
|
||||
"senderForResponse": False,
|
||||
"validityPeriod": 2880,
|
||||
"tag": tag,
|
||||
}
|
||||
try:
|
||||
log.info("Envoi SMS vers: %s", _human_labeled_list([(n,p) for (n,p) in self.sms_labeled if p in receivers]))
|
||||
resp = self.ovh_client.post(f"/sms/{self.ovh_service}/jobs", **payload)
|
||||
ids = resp.get("ids") or []
|
||||
log.info("SMS OVH envoyé (job ids=%s)", ids)
|
||||
try:
|
||||
if ids:
|
||||
job_id = ids[0]
|
||||
for _ in range(3):
|
||||
job = self.ovh_client.get(f"/sms/{self.ovh_service}/jobs/{job_id}")
|
||||
if job.get("status") in ("done","error","cancelled"):
|
||||
log.info("Statut job SMS: %s", job.get("status")); break
|
||||
time.sleep(1.5)
|
||||
except Exception as e:
|
||||
log.debug("Suivi job OVH indisponible (OK): %s", e)
|
||||
return True
|
||||
except OVHAPIError as err:
|
||||
log.exception("Erreur API OVH: %s", err); return False
|
||||
except Exception as err:
|
||||
log.exception("Echec envoi SMS OVH: %s", err); return False
|
||||
|
||||
def send_sms_client(self, message: str, tag: str = f"monitor-client-{SITE.lower()}") -> bool:
|
||||
if not self.ovh_enabled:
|
||||
log.warning("SMS client: OVH non configuré."); return False
|
||||
if not self.sms_client_enabled or not self.sms_client_labeled:
|
||||
log.info("SMS client: désactivé ou aucun destinataire."); return False
|
||||
|
||||
only = os.getenv("ALERT_SMS_CLIENT_ONLY")
|
||||
if only:
|
||||
allow = {x.strip() for x in re.split(r"[;,]", only) if x.strip()}
|
||||
labeled = [(n, p) for (n, p) in self.sms_client_labeled if (n and n in allow) or (p in allow)]
|
||||
else:
|
||||
labeled = self.sms_client_labeled
|
||||
|
||||
receivers = [num for (_n, num) in labeled]
|
||||
if not receivers:
|
||||
log.info("SMS client: filtre vide → aucun envoi."); return False
|
||||
|
||||
message = normaliser_sms(message, prefix=SITE)
|
||||
|
||||
payload = {
|
||||
"sender": self.ovh_sender,
|
||||
"receivers": receivers,
|
||||
"message": message,
|
||||
"priority": "high",
|
||||
"coding": "7bit",
|
||||
"class": "phoneDisplay",
|
||||
"noStopClause": True,
|
||||
"senderForResponse": False,
|
||||
"validityPeriod": 2880,
|
||||
"tag": tag,
|
||||
}
|
||||
try:
|
||||
log.info("Envoi SMS CLIENT vers: %s", _human_labeled_list(labeled))
|
||||
resp = self.ovh_client.post(f"/sms/{self.ovh_service}/jobs", **payload)
|
||||
log.info("SMS CLIENT OVH envoyé (job ids=%s)", resp.get("ids"))
|
||||
return True
|
||||
except Exception as err:
|
||||
log.exception("Echec SMS CLIENT OVH: %s", err); return False
|
||||
|
||||
def send_email(self, subject: str, body: str) -> bool:
|
||||
if not self.smtp_enabled:
|
||||
log.warning("SMTP non configuré, email non envoyé."); return False
|
||||
|
||||
msg = EmailMessage()
|
||||
msg["From"] = self.mail_from
|
||||
msg["To"] = ", ".join(self.mail_to)
|
||||
msg["Subject"] = subject
|
||||
msg.set_content(body)
|
||||
|
||||
timeout = int(os.getenv("SMTP_TIMEOUT","60"))
|
||||
debug = os.getenv("SMTP_DEBUG","0") == "1"
|
||||
|
||||
def _send_ssl():
|
||||
with smtplib.SMTP_SSL(self.smtp_host, 465, context=ssl.create_default_context(), timeout=timeout) as server:
|
||||
if debug: server.set_debuglevel(1)
|
||||
server.login(self.smtp_user, self.smtp_pass)
|
||||
server.send_message(msg)
|
||||
|
||||
def _send_starttls():
|
||||
with smtplib.SMTP(self.smtp_host, self.smtp_port, timeout=timeout) as server:
|
||||
if debug: server.set_debuglevel(1)
|
||||
server.ehlo(); server.starttls(context=ssl.create_default_context()); server.ehlo()
|
||||
server.login(self.smtp_user, self.smtp_pass)
|
||||
server.send_message(msg)
|
||||
|
||||
try:
|
||||
if self.smtp_security == "STARTTLS":
|
||||
try:
|
||||
_send_starttls()
|
||||
except (smtplib.SMTPServerDisconnected, TimeoutError, smtplib.SMTPConnectError) as err:
|
||||
log.warning("STARTTLS/587 a échoué (%s). Tentative en SSL/465...", err)
|
||||
_send_ssl()
|
||||
else:
|
||||
_send_ssl()
|
||||
log.info("Email envoyé à %s", self.mail_to)
|
||||
return True
|
||||
except (smtplib.SMTPException, ssl.SSLError, TimeoutError) as err:
|
||||
log.exception("Erreur SMTP: %s", err); return False
|
||||
except Exception as err:
|
||||
log.exception("Echec envoi email: %s", err); return False
|
||||
|
||||
# ========= Mise en forme messages =========
|
||||
from zoneinfo import ZoneInfo
|
||||
PARIS = ZoneInfo("Europe/Paris")
|
||||
|
||||
def fmt_deg(v: float) -> str:
|
||||
s = f"{float(v):.1f}".replace(".", ","); return f"{s}°C"
|
||||
|
||||
def now_paris() -> dt.datetime:
|
||||
return dt.datetime.now(tz=PARIS)
|
||||
|
||||
def build_alert_text(site: str, sonde: str, temp: float, seuil: float, when: dt.datetime | None = None):
|
||||
when = when or now_paris()
|
||||
subject = f"[ALERTE {site}] {sonde} au-dessus du seuil"
|
||||
lines = [
|
||||
subject + ":",
|
||||
f"Sonde: {sonde}",
|
||||
f"Température: {fmt_deg(temp)} (seuil {fmt_deg(seuil)})",
|
||||
f"Site: {site}",
|
||||
f"Heure: {when.strftime('%Y-%m-%d %H:%M:%S')}"
|
||||
]
|
||||
txt = "\n".join(lines)
|
||||
return subject, txt, txt
|
||||
|
||||
def build_ok_text(site: str, sonde: str, temp: float, seuil: float, when: dt.datetime | None = None):
|
||||
when = when or now_paris()
|
||||
subject = f"[OK {site}] {sonde} revenue normale"
|
||||
lines = [
|
||||
subject + ":",
|
||||
f"Sonde: {sonde}",
|
||||
f"Température: {fmt_deg(temp)} <= seuil {fmt_deg(seuil)}",
|
||||
f"Site: {site}",
|
||||
f"Heure: {when.strftime('%Y-%m-%d %H:%M:%S')}"
|
||||
]
|
||||
txt = "\n".join(lines)
|
||||
return subject, txt, txt
|
||||
|
||||
def build_client_alert_sms(site: str, sonde: str, temp: float, seuil: float, when: dt.datetime | None = None) -> str:
|
||||
when = when or now_paris()
|
||||
# Court, 1 ligne; accents/° nettoyés par normaliser_sms
|
||||
return f"ALERTE CLIENT {sonde}: T={fmt_deg(temp)} > S={fmt_deg(seuil)} H:{when.strftime('%H:%M')}"
|
||||
|
||||
# ========= Gyrophare MQTT =========
|
||||
class MQTTPublisher:
|
||||
def __init__(self, site: str):
|
||||
self.enabled = bool(_mqtt_ok)
|
||||
self.site = site
|
||||
self.topic = (
|
||||
os.getenv(f"GYRO_MQTT_TOPIC_{site}") or
|
||||
os.getenv(f"GYRO_MQTT_TOPIC_{site.upper()}") or
|
||||
os.getenv("GYRO_MQTT_TOPIC") or
|
||||
f"Sondes/{site}/Gyro/cmd"
|
||||
)
|
||||
self.last_state: bool | None = None
|
||||
|
||||
if not self.enabled:
|
||||
log.info("Gyro MQTT désactivé (paho-mqtt absent).")
|
||||
return
|
||||
if not self.topic:
|
||||
log.warning("Topic MQTT manquant pour %s (GYRO_MQTT_TOPIC_%s)", site, site)
|
||||
self.enabled = False
|
||||
return
|
||||
|
||||
host = os.getenv("MQTT_HOST", "localhost")
|
||||
port = int(os.getenv("MQTT_PORT", "1883"))
|
||||
user = os.getenv("MQTT_USER")
|
||||
pwd = os.getenv("MQTT_PASS")
|
||||
tls = (os.getenv("MQTT_TLS", "0") == "1")
|
||||
|
||||
# --- Création du client MQTT : compatible paho 1.x et 2.x ---
|
||||
cbver = getattr(mqtt, "CallbackAPIVersion", None)
|
||||
if cbver is not None:
|
||||
api_v = (
|
||||
getattr(cbver, "VERSION2", None)
|
||||
or getattr(cbver, "V5", None)
|
||||
or getattr(cbver, "v5", None)
|
||||
or getattr(cbver, "V311", None)
|
||||
)
|
||||
try:
|
||||
self.client = mqtt.Client(callback_api_version=api_v) if api_v else mqtt.Client()
|
||||
except TypeError:
|
||||
self.client = mqtt.Client()
|
||||
else:
|
||||
self.client = mqtt.Client()
|
||||
# ------------------------------------------------------------
|
||||
|
||||
if user and pwd:
|
||||
self.client.username_pw_set(user, pwd)
|
||||
if tls:
|
||||
self.client.tls_set()
|
||||
|
||||
try:
|
||||
# Attacher le callback avant de s'abonner
|
||||
self.client.on_message = self._on_message
|
||||
|
||||
self.client.connect(host, port, keepalive=30)
|
||||
|
||||
# Abonnements (depuis env ou valeurs par défaut raisonnables)
|
||||
subs_env = (
|
||||
os.getenv(f"GYRO_MQTT_SUB_{site}") or
|
||||
os.getenv(f"GYRO_MQTT_SUB_{site.upper()}") or
|
||||
os.getenv("GYRO_MQTT_SUB") or
|
||||
""
|
||||
)
|
||||
subs = [t.strip() for t in subs_env.split(",") if t.strip()]
|
||||
if not subs:
|
||||
subs = [
|
||||
self.topic, # ex: Sondes/Saclay/Gyro/cmd
|
||||
f"Sondes/{site}/Gyro/#",
|
||||
f"{site}/Gyro/#",
|
||||
"Gyro/#",
|
||||
]
|
||||
for t in subs:
|
||||
try:
|
||||
self.client.subscribe(t, qos=2)
|
||||
log.info("MQTT subscribe: %s", t)
|
||||
except Exception as e:
|
||||
log.warning("Subscribe échoué (%s): %s", t, e)
|
||||
|
||||
self.client.loop_start()
|
||||
log.info("MQTT connecté (%s:%s), topic=%s", host, port, self.topic)
|
||||
except Exception as e:
|
||||
log.exception("MQTT connexion impossible: %s", e)
|
||||
self.enabled = False
|
||||
|
||||
# --- Callback réception MQTT ---
|
||||
def _on_message(self, client, userdata, msg):
|
||||
lieu = self.site
|
||||
topic = msg.topic
|
||||
payload_raw = msg.payload.decode(errors="ignore").strip()
|
||||
upper = payload_raw.upper()
|
||||
|
||||
# 1) Évènements gyrophare
|
||||
if upper in ("ON", "OFF") or "gyro" in topic.lower() or "gyrophare" in topic.lower():
|
||||
etat = upper if upper in ("ON", "OFF") else ("ON" if "on" in upper else "OFF")
|
||||
try:
|
||||
if should_insert_gyro(lieu, etat):
|
||||
insert_gyro_log(
|
||||
lieu=lieu,
|
||||
etat=etat,
|
||||
topic=topic,
|
||||
payload_raw=payload_raw,
|
||||
qos=getattr(msg, "qos", None),
|
||||
retained=getattr(msg, "retain", None),
|
||||
when=now_paris()
|
||||
)
|
||||
except Exception as e:
|
||||
log.exception("Insert Gyro échoué: %s", e)
|
||||
return # ne pas poursuivre vers un parse température ici
|
||||
|
||||
# 2) Pas du gyro → ignorer ici (la collecte T° est gérée ailleurs)
|
||||
try:
|
||||
float(payload_raw.replace(",", "."))
|
||||
except ValueError:
|
||||
log.debug("Payload non géré (ni gyro ni nombre): %s %s", topic, payload_raw)
|
||||
|
||||
def set(self, on: bool):
|
||||
if not self.enabled:
|
||||
return
|
||||
if self.last_state is not None and self.last_state == on:
|
||||
return
|
||||
payload = "ON" if on else "OFF"
|
||||
try:
|
||||
r = self.client.publish(self.topic, payload=payload, qos=2, retain=True)
|
||||
try:
|
||||
r.wait_for_publish(timeout=3)
|
||||
except Exception:
|
||||
pass
|
||||
if getattr(r, 'rc', 0) != 0:
|
||||
log.warning("MQTT publish rc=%s (topic=%s)", getattr(r, 'rc', None), self.topic)
|
||||
else:
|
||||
log.info("Gyro %s -> %s (MQTT)", self.site, payload.upper())
|
||||
# Enregistrer en base l'événement gyro
|
||||
try:
|
||||
insert_gyro_log(
|
||||
lieu=self.site,
|
||||
etat=payload,
|
||||
topic=self.topic,
|
||||
payload_raw=payload,
|
||||
qos=2,
|
||||
retained=1 if getattr(r, 'is_published', lambda: False)() else None,
|
||||
when=now_paris()
|
||||
)
|
||||
except Exception as e:
|
||||
log.exception("Insert événement gyro en base a échoué: %s", e)
|
||||
self.last_state = on
|
||||
except Exception as e:
|
||||
log.exception("MQTT publish erreur: %s", e)
|
||||
|
||||
# ========= Contrôleur Gyro réactif =========
|
||||
import enum, threading
|
||||
|
||||
class _GyroState(enum.Enum):
|
||||
IDLE = 0
|
||||
PULSE_ON = 1
|
||||
COOLDOWN = 2
|
||||
|
||||
class GyroPulseController:
|
||||
"""
|
||||
Boucle rapide indépendante :
|
||||
- MODE CONTINU (défaut) : ON tant que l’alarme persiste, OFF quand normal confirmé.
|
||||
- MODE PULSE : ON (PULSE_SEC) puis OFF (COOLDOWN_SEC), tant que l’alarme persiste.
|
||||
|
||||
Ajouts :
|
||||
- SMS ALERTE immédiat à l’allumage
|
||||
- SMS OK immédiat à l’extinction (activé par défaut)
|
||||
"""
|
||||
def __init__(self, site: str, beacon, notifier, *,
|
||||
check_sec: int = int(os.getenv("GYRO_CHECK_SEC", "20")),
|
||||
pulse_sec: int = int(os.getenv("GYRO_PULSE_SEC", "60")),
|
||||
cooldown_sec: int = int(os.getenv("GYRO_COOLDOWN_SEC", "600")),
|
||||
normal_confirm: int = int(os.getenv("GYRO_NORMAL_CONFIRM", "2"))):
|
||||
self.site = site
|
||||
self.beacon = beacon
|
||||
self.notifier = notifier
|
||||
self.check_sec = check_sec
|
||||
self.pulse_sec = pulse_sec
|
||||
self.cooldown_sec = cooldown_sec
|
||||
self.normal_confirm = normal_confirm
|
||||
|
||||
self.state = _GyroState.IDLE
|
||||
self._t_pulse_end = 0.0
|
||||
self._t_cooldown_end = 0.0
|
||||
self._normal_count = 0
|
||||
self._stop = threading.Event()
|
||||
self._thread = None
|
||||
self._current = None # dernier état effectif
|
||||
|
||||
# Anti-spam SMS & SMS OK activé par défaut
|
||||
self._last_sms: dict[str, float] = {} # {sonde: ts dernier envoi}
|
||||
self._sms_min_sec = int(os.getenv("ALERT_SMS_COOLDOWN_SEC") or os.getenv("GYRO_SMS_MIN_SEC", "120"))
|
||||
self._send_ok = (os.getenv("ALERT_OK_SMS_GYRO", "1") == "1")
|
||||
|
||||
# Conserver le dernier déclencheur (pour SMS OK)
|
||||
self._last_trigger: tuple[str, float, float] | None = None # (sonde, temp, seuil)
|
||||
|
||||
def _set_gyro(self, on: bool):
|
||||
if self._current is not on:
|
||||
self.beacon.set(on)
|
||||
self._current = on
|
||||
|
||||
def start(self):
|
||||
if self._thread and self._thread.is_alive():
|
||||
return
|
||||
self._stop.clear()
|
||||
self._thread = threading.Thread(target=self._run, daemon=True)
|
||||
self._thread.start()
|
||||
log.info("GyroPulseController démarré (site=%s, check=%ss, pulse=%ss, cooldown=%ss, confirm=%d)",
|
||||
self.site, self.check_sec, self.pulse_sec, self.cooldown_sec, self.normal_confirm)
|
||||
|
||||
def stop(self):
|
||||
self._stop.set()
|
||||
|
||||
def _sms_can_send(self, sonde: str) -> bool:
|
||||
t = time.time()
|
||||
last = self._last_sms.get(sonde, 0.0)
|
||||
if (t - last) >= self._sms_min_sec:
|
||||
self._last_sms[sonde] = t
|
||||
return True
|
||||
return False
|
||||
|
||||
def _send_alert_sms(self, trigger: tuple[str, float, float] | None):
|
||||
if not _env_bool("ALERT_INTERNAL_SMS_ENABLED", True):
|
||||
return
|
||||
if not trigger:
|
||||
return
|
||||
sonde, temp, seuil = trigger
|
||||
if self._sms_can_send(sonde):
|
||||
_, sms_text, _ = build_alert_text(self.site, sonde, temp, seuil, when=now_paris())
|
||||
self.notifier.send_sms(sms_text)
|
||||
|
||||
def _send_ok_sms_from_last_trigger(self):
|
||||
if not _env_bool("ALERT_OK_SMS_GYRO", True):
|
||||
return
|
||||
if not self._send_ok or not self._last_trigger:
|
||||
return
|
||||
sonde, _temp_prev, seuil = self._last_trigger
|
||||
|
||||
# Température courante pour le SMS OK
|
||||
rows = lire_sondes_depuis_db(self.site)
|
||||
curr_temp = None
|
||||
for r in rows:
|
||||
if str(r["Sonde"]) == sonde:
|
||||
curr_temp = float(r["Temperature"]); break
|
||||
if curr_temp is None:
|
||||
curr_temp = seuil - 0.1 # fallback léger
|
||||
|
||||
if self._sms_can_send(sonde):
|
||||
_, sms_text, _ = build_ok_text(self.site, sonde, curr_temp, seuil, when=now_paris())
|
||||
self.notifier.send_sms(sms_text)
|
||||
|
||||
self._last_trigger = None # reset
|
||||
|
||||
def _is_alarm_now(self) -> tuple[bool, tuple[str, float, float] | None]:
|
||||
last_rows = lire_sondes_depuis_db(self.site)
|
||||
cfg = lire_cfg_chambres(self.site)
|
||||
return compute_site_alarm(last_rows, cfg, hysteresis=float(os.getenv("GYRO_HYSTERESIS", "0.0")))
|
||||
|
||||
def _run(self):
|
||||
while not self._stop.is_set():
|
||||
now = time.time()
|
||||
try:
|
||||
active, trigger = self._is_alarm_now()
|
||||
except Exception as e:
|
||||
log.exception("Gyro fast-loop: erreur lecture état: %s", e)
|
||||
active, trigger = (False, None)
|
||||
|
||||
if self.state == _GyroState.IDLE:
|
||||
if active:
|
||||
self._set_gyro(True)
|
||||
self._t_pulse_end = now + self.pulse_sec
|
||||
self._normal_count = 0
|
||||
self.state = _GyroState.PULSE_ON
|
||||
self._last_trigger = trigger
|
||||
if trigger:
|
||||
s, t, se = trigger
|
||||
log.info("Gyro → ON déclenché par %s: %.2f > %.2f (mode %s)",
|
||||
s, t, se, "CONTINU" if os.getenv("GYRO_MODE_CONTINUOUS", "1") == "1" else "PULSE")
|
||||
# SMS alerte immédiat (optionnel)
|
||||
if os.getenv("ALERT_INTERNAL_SMS_ENABLED", "0") == "1":
|
||||
self._send_alert_sms(trigger)
|
||||
|
||||
elif self.state == _GyroState.PULSE_ON:
|
||||
if not active:
|
||||
self._normal_count += 1
|
||||
if self._normal_count >= self.normal_confirm:
|
||||
self._set_gyro(False)
|
||||
self.state = _GyroState.IDLE
|
||||
self._normal_count = 0
|
||||
log.info("Gyro → OFF (retour à la normale confirmé)")
|
||||
# SMS OK immédiat
|
||||
if os.getenv("ALERT_OK_SMS_GYRO", "0") == "1":
|
||||
self._send_ok_sms_from_last_trigger()
|
||||
else:
|
||||
self._normal_count = 0
|
||||
if os.getenv("GYRO_MODE_CONTINUOUS", "1") != "1":
|
||||
if now >= self._t_pulse_end:
|
||||
self._set_gyro(False)
|
||||
self._t_cooldown_end = now + self.cooldown_sec
|
||||
self.state = _GyroState.COOLDOWN
|
||||
log.info("Gyro → OFF, cooldown %ss (alerte persiste)", self.cooldown_sec)
|
||||
|
||||
elif self.state == _GyroState.COOLDOWN:
|
||||
if not active:
|
||||
self._normal_count += 1
|
||||
if self._normal_count >= self.normal_confirm:
|
||||
self.state = _GyroState.IDLE
|
||||
self._normal_count = 0
|
||||
log.info("Gyro: retour IDLE (plus d’alerte)")
|
||||
else:
|
||||
self._normal_count = 0
|
||||
if now >= self._t_cooldown_end:
|
||||
self._set_gyro(True)
|
||||
self._t_pulse_end = now + self.pulse_sec
|
||||
self.state = _GyroState.PULSE_ON
|
||||
log.info("Gyro → ON (re-pulse)")
|
||||
|
||||
time.sleep(self.check_sec)
|
||||
|
||||
# ========= Notifs haut-niveau =========
|
||||
notifier = Notifier()
|
||||
beacon = MQTTPublisher(SITE)
|
||||
|
||||
def notifier_sur_depassement(site: str, sonde: str, temp: float, seuil: float):
|
||||
"""
|
||||
MAIL quand l'alerte est confirmée (≥30 min) et ouverte en base.
|
||||
+ SMS CLIENT couplé (ALERTE_CLIENT_{SITE}).
|
||||
(Le SMS d'alerte interne est envoyé immédiatement par la boucle gyro.)
|
||||
"""
|
||||
subject, _sms_text, email_body = build_alert_text(site, sonde, temp, seuil)
|
||||
notifier.send_email(subject, email_body) # MAIL (≥30 min)
|
||||
|
||||
# ➕ SMS client couplé au mail 30 min
|
||||
if os.getenv("ALERT_SMS_CLIENT_ENABLED", "1") == "1":
|
||||
client_msg = build_client_alert_sms(site, sonde, temp, seuil)
|
||||
notifier.send_sms_client(client_msg, tag=f"client-{SITE.lower()}")
|
||||
|
||||
def notifier_acquittement(site: str, sonde: str, temp: float, seuil: float):
|
||||
"""
|
||||
MAIL lorsque l’alerte est acquittée en base.
|
||||
(Le SMS "OK" est envoyé immédiatement par la boucle gyro.)
|
||||
"""
|
||||
subject, sms_text, email_body = build_ok_text(site, sonde, temp, seuil)
|
||||
notifier.send_email(subject, email_body) # mail d'acquittement
|
||||
# Optionnel: SMS "OK" côté cycle si souhaité
|
||||
if os.getenv("ALERT_OK_SMS", "0") == "1":
|
||||
notifier.send_sms(sms_text)
|
||||
|
||||
# ========= Cycle & boucle =========
|
||||
def run_monitor_cycle(site: str = SITE):
|
||||
# 1) Lecture dernières mesures + config
|
||||
last_rows = lire_sondes_depuis_db(site)
|
||||
cfg = lire_cfg_chambres(site)
|
||||
|
||||
# 2) Info: état instantané (le gyro est piloté par la boucle rapide)
|
||||
try:
|
||||
gyro_on, trigger = compute_site_alarm(last_rows, cfg, hysteresis=float(os.getenv("GYRO_HYSTERESIS", "0.0")))
|
||||
if trigger:
|
||||
s, t, se = trigger
|
||||
log.info("Dépassement détecté (gyro géré par boucle rapide) : %s %.2f > %.2f", s, t, se)
|
||||
else:
|
||||
log.info("Aucun dépassement au moment du cycle")
|
||||
except Exception as e:
|
||||
log.exception("Erreur calcul alarme (info): %s", e)
|
||||
|
||||
# 3) Alertes "officielles" temporisées (≥30 min) → mail + SMS client
|
||||
seuils = {s: meta["temp_max"] for s, meta in cfg.items() if meta.get("active", False)}
|
||||
|
||||
for r in last_rows:
|
||||
nom = str(r["Sonde"])
|
||||
temp = float(r["Temperature"])
|
||||
|
||||
if nom not in seuils:
|
||||
continue # sonde non gérée dans Chambres_froides → ignorée
|
||||
|
||||
seuil = float(seuils[nom])
|
||||
now_ = now_paris()
|
||||
|
||||
if temp > seuil:
|
||||
if depassement_depuis_30min(site, nom, seuil):
|
||||
conn = None
|
||||
try:
|
||||
conn = get_db()
|
||||
if open_alert(conn, f"Alertes_{site}", nom, now_):
|
||||
notifier_sur_depassement(site, nom, temp, seuil)
|
||||
finally:
|
||||
if conn:
|
||||
conn.close()
|
||||
else:
|
||||
conn = None
|
||||
try:
|
||||
conn = get_db()
|
||||
if close_alert(conn, f"Alertes_{site}", nom):
|
||||
notifier_acquittement(site, nom, temp, seuil)
|
||||
finally:
|
||||
if conn:
|
||||
conn.close()
|
||||
|
||||
def run_monitor_loop(site: str = SITE, period_sec: int = 300):
|
||||
log.info("%s démarré (site=%s, période=%ss) ✅", PROGRAM_NAME, site, period_sec)
|
||||
|
||||
# Démarrage du contrôleur gyro rapide (thread) + notifier pour SMS immédiats
|
||||
try:
|
||||
global _gyro_controller
|
||||
_gyro_controller = GyroPulseController(site, beacon, notifier)
|
||||
_gyro_controller.start()
|
||||
except Exception as e:
|
||||
log.exception("Impossible de démarrer le GyroPulseController: %s", e)
|
||||
|
||||
while True:
|
||||
t0 = time.time()
|
||||
try:
|
||||
run_monitor_cycle(site)
|
||||
except Exception as err:
|
||||
log.exception("Erreur cycle monitoring: %s", err)
|
||||
time.sleep(max(0, period_sec - (time.time() - t0)))
|
||||
|
||||
# ========= CLI =========
|
||||
if __name__ == "__main__":
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(description=PROGRAM_NAME)
|
||||
p.add_argument("--period", type=int, default=300)
|
||||
p.add_argument("--test-sms", action="store_true")
|
||||
p.add_argument("--test-mail", action="store_true")
|
||||
p.add_argument("--test-alert", action="store_true")
|
||||
p.add_argument("--test-ok", action="store_true")
|
||||
p.add_argument("--once", action="store_true")
|
||||
args = p.parse_args()
|
||||
|
||||
if args.test_sms:
|
||||
n = Notifier()
|
||||
n.send_sms("TEST DOMO91 (transactionnel)")
|
||||
elif args.test_mail:
|
||||
notifier.send_email(f"[TEST {SITE}] Mail", "OK")
|
||||
elif args.test_alert:
|
||||
notifier_sur_depassement(SITE, "Congelateur", -14.5, -15.0)
|
||||
elif args.test_ok:
|
||||
notifier_acquittement(SITE, "Congelateur", -15.2, -15.0)
|
||||
else:
|
||||
if args.once:
|
||||
run_monitor_cycle(SITE)
|
||||
else:
|
||||
run_monitor_loop(SITE, period_sec=args.period)
|
||||
@@ -1,44 +1,144 @@
|
||||
# gyro_control.py
|
||||
import os, time, logging, threading
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
from typing import Any
|
||||
|
||||
import mysql.connector
|
||||
import paho.mqtt.client as mqtt
|
||||
import requests
|
||||
from dotenv import find_dotenv, load_dotenv
|
||||
|
||||
load_dotenv(find_dotenv(usecwd=True), override=False)
|
||||
|
||||
_ALLOWED_SITE_RE = re.compile(r"^[A-Za-z0-9_]+$")
|
||||
|
||||
|
||||
def safe_site(site: str) -> str:
|
||||
site = (site or "").strip()
|
||||
if not site or not _ALLOWED_SITE_RE.fullmatch(site):
|
||||
raise ValueError(f"Nom de site invalide: {site!r}")
|
||||
return site
|
||||
|
||||
|
||||
def _env_str(name: str, default: str = "") -> str:
|
||||
return (os.getenv(name, default) or "").strip()
|
||||
|
||||
|
||||
def _env_bool(name: str, default: bool = False) -> bool:
|
||||
value = _env_str(name, "1" if default else "0").lower()
|
||||
return value in ("1", "true", "yes", "on")
|
||||
|
||||
|
||||
logging.basicConfig(
|
||||
level=getattr(logging, _env_str("LOGLEVEL", "INFO").upper(), logging.INFO),
|
||||
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
|
||||
)
|
||||
log = logging.getLogger("gyro")
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
|
||||
|
||||
DEF_CHECK_SEC = int(os.getenv("GYRO_CHECK_SEC", "20"))
|
||||
DEF_NORMAL_CONFIRM = int(os.getenv("GYRO_NORMAL_CONFIRM", "2"))
|
||||
DEF_CHECK_SEC = int(_env_str("GYRO_CHECK_SEC", "20"))
|
||||
DEF_NORMAL_CONFIRM = int(_env_str("GYRO_NORMAL_CONFIRM", "6"))
|
||||
|
||||
|
||||
def send_synology_chat(message: str, *, site: str, username: str | None = None) -> bool:
|
||||
webhook = (
|
||||
_env_str(f"SYNO_CHAT_WEBHOOK_{site}")
|
||||
or _env_str(f"SYNO_CHAT_WEBHOOK_{site.upper()}")
|
||||
or _env_str("SYNO_CHAT_WEBHOOK")
|
||||
)
|
||||
if not webhook:
|
||||
log.info("[%s] Synology Chat non configuré.", site)
|
||||
return False
|
||||
|
||||
botname = username or _env_str("SYNO_CHAT_BOTNAME", "Gestion Gyro")
|
||||
timeout = int(_env_str("SYNO_CHAT_TIMEOUT", "10"))
|
||||
verify_ssl = _env_bool("SYNO_CHAT_VERIFY_SSL", True)
|
||||
|
||||
chat_payload: dict[str, str] = {"text": message}
|
||||
if botname:
|
||||
chat_payload["username"] = botname
|
||||
|
||||
form_data = {"payload": json.dumps(chat_payload, ensure_ascii=False)}
|
||||
|
||||
try:
|
||||
response = requests.post(
|
||||
webhook,
|
||||
data=form_data,
|
||||
timeout=timeout,
|
||||
verify=verify_ssl,
|
||||
)
|
||||
response.raise_for_status()
|
||||
|
||||
txt = (response.text or "").strip()
|
||||
log.info("[%s] Réponse Synology Chat: %s", site, txt[:300] if txt else "<vide>")
|
||||
|
||||
try:
|
||||
data = response.json()
|
||||
if isinstance(data, dict):
|
||||
success = bool(data.get("success", False))
|
||||
if not success:
|
||||
log.warning("[%s] Synology Chat a répondu sans succès: %s", site, data)
|
||||
return success
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
return txt.lower() == "ok" or not txt
|
||||
|
||||
except requests.RequestException as exc:
|
||||
log.exception("[%s] Echec envoi Synology Chat: %s", site, exc)
|
||||
return False
|
||||
|
||||
|
||||
class MqttGyroDriver:
|
||||
def __init__(self, host, port, user, password, topic_cmd):
|
||||
def __init__(self, host: str, port: int, user: str, password: str, topic_cmd: str):
|
||||
self.topic_cmd = topic_cmd
|
||||
try:
|
||||
self.client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
|
||||
except Exception:
|
||||
self.client = mqtt.Client()
|
||||
|
||||
if user:
|
||||
self.client.username_pw_set(user, password or "")
|
||||
self.client.connect(host, int(port or 1883), keepalive=30)
|
||||
self.client.connect(host, int(port), keepalive=30)
|
||||
self.client.loop_start()
|
||||
log.info("MQTT connecté (%s:%s), topic=%s", host, port, topic_cmd)
|
||||
|
||||
def set(self, on: bool):
|
||||
def set(self, on: bool) -> None:
|
||||
payload = "ON" if on else "OFF"
|
||||
res = self.client.publish(self.topic_cmd, payload=payload, qos=1, retain=False)
|
||||
res.wait_for_publish(timeout=5)
|
||||
result = self.client.publish(self.topic_cmd, payload=payload, qos=1, retain=False)
|
||||
result.wait_for_publish(timeout=5)
|
||||
log.info("MQTT → %s : %s", self.topic_cmd, payload)
|
||||
|
||||
def close(self):
|
||||
def close(self) -> None:
|
||||
try:
|
||||
self.client.loop_stop()
|
||||
self.client.disconnect()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
class GyroController:
|
||||
"""
|
||||
Gyro ON en continu tant qu'il existe au moins une alerte Etat='En cours'.
|
||||
Gyro OFF après 'normal_confirm' lectures consécutives sans alerte.
|
||||
Notification Chat sur transition ON/OFF.
|
||||
"""
|
||||
def __init__(self, *, site_name: str, db_cfg: dict, alertes_table: str,
|
||||
mqtt_driver: MqttGyroDriver, check_sec: int = DEF_CHECK_SEC,
|
||||
normal_confirm: int = DEF_NORMAL_CONFIRM):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
site_name: str,
|
||||
db_cfg: dict[str, Any],
|
||||
alertes_table: str,
|
||||
mqtt_driver: MqttGyroDriver,
|
||||
check_sec: int = DEF_CHECK_SEC,
|
||||
normal_confirm: int = DEF_NORMAL_CONFIRM,
|
||||
):
|
||||
self.site = site_name
|
||||
self.db_cfg = db_cfg
|
||||
self.alertes_table = alertes_table
|
||||
@@ -47,29 +147,68 @@ class GyroController:
|
||||
self.normal_confirm = normal_confirm
|
||||
|
||||
self._stop = threading.Event()
|
||||
self._thread = None
|
||||
self._current_on = None
|
||||
self._thread: threading.Thread | None = None
|
||||
self._current_on: bool | None = None
|
||||
self._normal_count = 0
|
||||
|
||||
def _set_gyro(self, on: bool):
|
||||
if self._current_on is not on:
|
||||
def _send_chat_on(self) -> None:
|
||||
if not _env_bool("SYNO_CHAT_GYRO_ENABLED", True):
|
||||
return
|
||||
message = (
|
||||
f":rotating_light: [{self.site}] GYRO DECLENCHE\n"
|
||||
f"Table alertes: {self.alertes_table}\n"
|
||||
"Etat: au moins une alerte en cours"
|
||||
)
|
||||
send_synology_chat(message, site=self.site)
|
||||
|
||||
def _send_chat_off(self) -> None:
|
||||
if not _env_bool("SYNO_CHAT_GYRO_ENABLED", True):
|
||||
return
|
||||
message = (
|
||||
f":white_check_mark: [{self.site}] GYRO RETOUR NORMALE\n"
|
||||
f"Table alertes: {self.alertes_table}\n"
|
||||
"Etat: plus d'alerte en cours"
|
||||
)
|
||||
send_synology_chat(message, site=self.site)
|
||||
|
||||
def _set_gyro(self, on: bool) -> None:
|
||||
if self._current_on is on:
|
||||
return
|
||||
|
||||
previous = self._current_on
|
||||
self.mqtt.set(on)
|
||||
self._current_on = on
|
||||
|
||||
if previous is None:
|
||||
log.info("[%s] Etat initial Gyro: %s", self.site, "ON" if on else "OFF")
|
||||
return
|
||||
|
||||
if on:
|
||||
log.info("[%s] Transition Gyro OFF → ON", self.site)
|
||||
self._send_chat_on()
|
||||
else:
|
||||
log.info("[%s] Transition Gyro ON → OFF", self.site)
|
||||
self._send_chat_off()
|
||||
|
||||
def _has_active_alert(self, cur) -> bool:
|
||||
cur.execute(f"SELECT COUNT(*) FROM `{self.alertes_table}` WHERE Etat='En cours'")
|
||||
return cur.fetchone()[0] > 0
|
||||
row = cur.fetchone()
|
||||
return bool(row and row[0] > 0)
|
||||
|
||||
def start(self):
|
||||
def start(self) -> None:
|
||||
if self._thread and self._thread.is_alive():
|
||||
return
|
||||
self._stop.clear()
|
||||
self._thread = threading.Thread(target=self._run, daemon=True)
|
||||
self._thread.start()
|
||||
log.info("[%s] GyroController démarré (check=%ss, confirm=%d)",
|
||||
self.site, self.check_sec, self.normal_confirm)
|
||||
log.info(
|
||||
"[%s] GyroController démarré (check=%ss, confirm=%d)",
|
||||
self.site,
|
||||
self.check_sec,
|
||||
self.normal_confirm,
|
||||
)
|
||||
|
||||
def stop(self):
|
||||
def stop(self) -> None:
|
||||
self._stop.set()
|
||||
|
||||
def _connect_mysql(self):
|
||||
@@ -78,18 +217,17 @@ class GyroController:
|
||||
cnx = mysql.connector.connect(autocommit=True, **self.db_cfg)
|
||||
cur = cnx.cursor()
|
||||
return cnx, cur
|
||||
except Exception as e:
|
||||
log.error("[%s] Connexion MySQL KO (%s). Retry 5s…", self.site, e)
|
||||
except Exception as exc:
|
||||
log.error("[%s] Connexion MySQL KO (%s). Retry 5s...", self.site, exc)
|
||||
time.sleep(5)
|
||||
return None, None
|
||||
|
||||
def _run(self):
|
||||
def _run(self) -> None:
|
||||
cnx, cur = self._connect_mysql()
|
||||
if not cnx:
|
||||
if not cnx or not cur:
|
||||
return
|
||||
|
||||
try:
|
||||
# au démarrage, on force OFF par sécurité (optionnel)
|
||||
try:
|
||||
self._set_gyro(False)
|
||||
except Exception:
|
||||
@@ -98,14 +236,15 @@ class GyroController:
|
||||
while not self._stop.is_set():
|
||||
try:
|
||||
active = self._has_active_alert(cur)
|
||||
except Exception as e:
|
||||
log.error("[%s] Lecture alertes KO: %s -> reconnexion MySQL", self.site, e)
|
||||
except Exception as exc:
|
||||
log.error("[%s] Lecture alertes KO: %s -> reconnexion MySQL", self.site, exc)
|
||||
try:
|
||||
cur.close(); cnx.close()
|
||||
cur.close()
|
||||
cnx.close()
|
||||
except Exception:
|
||||
pass
|
||||
cnx, cur = self._connect_mysql()
|
||||
if not cnx:
|
||||
if not cnx or not cur:
|
||||
break
|
||||
active = False
|
||||
|
||||
@@ -125,38 +264,67 @@ class GyroController:
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
cur.close(); cnx.close()
|
||||
cur.close()
|
||||
cnx.close()
|
||||
except Exception:
|
||||
pass
|
||||
log.info("[%s] GyroController stoppé", self.site)
|
||||
|
||||
if __name__ == "__main__":
|
||||
# ---- CONFIG À ADAPTER ----
|
||||
SITE = "Meudon"
|
||||
ALERTES_TABLE = "Alertes_Meudon" # adaptez au nom réel
|
||||
|
||||
DB_CFG = dict(
|
||||
host=(os.getenv("DB_HOST") or "162.19.78.131").strip(),
|
||||
user=(os.getenv("DB_USER") or "sondes").strip(),
|
||||
password=os.getenv("DB_PASSWORD") or "TX.)-U1!zq5Axdk4",
|
||||
database=(os.getenv("DB_NAME") or "Sondes").strip(),
|
||||
port=int(os.getenv("DB_PORT") or 3306),
|
||||
def build_db_cfg() -> dict[str, Any]:
|
||||
return {
|
||||
"host": _env_str("DB_HOST", "162.19.78.131"),
|
||||
"user": _env_str("DB_USER", "sondes"),
|
||||
"password": _env_str("DB_PASS"),
|
||||
"database": _env_str("DB_NAME", "Sondes"),
|
||||
"port": int(_env_str("DB_PORT", "3306")),
|
||||
}
|
||||
|
||||
|
||||
def build_topic(site: str) -> str:
|
||||
return (
|
||||
_env_str(f"GYRO_MQTT_TOPIC_{site}")
|
||||
or _env_str(f"GYRO_MQTT_TOPIC_{site.upper()}")
|
||||
or _env_str("GYRO_MQTT_TOPIC")
|
||||
or f"{site}/gyrophare"
|
||||
)
|
||||
|
||||
MQTT_HOST = (os.getenv("MQTT_HOST") or "162.19.78.131").strip()
|
||||
MQTT_PORT = int(os.getenv("MQTT_PORT") or 1883)
|
||||
MQTT_USER = os.getenv("MQTT_USER") or "sondes"
|
||||
MQTT_PASS = os.getenv("MQTT_PASSWORD") or "3J@bjYP0"
|
||||
|
||||
TOPIC_CMD = "Meudon/gyrophare/cmd"
|
||||
if __name__ == "__main__":
|
||||
import argparse
|
||||
|
||||
print("MQTT_HOST =", repr(MQTT_HOST))
|
||||
print("MQTT_PORT =", repr(MQTT_PORT))
|
||||
parser = argparse.ArgumentParser(description="Contrôle du gyrophare via table d'alertes")
|
||||
parser.add_argument("--site", default=_env_str("SITE", "Saclay"))
|
||||
parser.add_argument("--test-chat", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
drv = MqttGyroDriver(MQTT_HOST, MQTT_PORT, MQTT_USER, MQTT_PASS, TOPIC_CMD)
|
||||
ctl = GyroController(site_name=SITE, db_cfg=DB_CFG, alertes_table=ALERTES_TABLE,
|
||||
mqtt_driver=drv, check_sec=DEF_CHECK_SEC, normal_confirm=DEF_NORMAL_CONFIRM)
|
||||
ctl.start()
|
||||
site = safe_site(args.site)
|
||||
|
||||
if args.test_chat:
|
||||
send_synology_chat(f":speech_balloon: [TEST {site}] Notification Synology Chat OK", site=site)
|
||||
raise SystemExit(0)
|
||||
|
||||
alertes_table = _env_str("ALERTES_TABLE", f"Alertes_{site}")
|
||||
db_cfg = build_db_cfg()
|
||||
|
||||
mqtt_host = _env_str("MQTT_HOST", "162.19.78.131")
|
||||
mqtt_port = int(_env_str("MQTT_PORT", "1883"))
|
||||
mqtt_user = _env_str("MQTT_USER", "sondes")
|
||||
mqtt_pass = _env_str("MQTT_PASS")
|
||||
topic_cmd = build_topic(site)
|
||||
|
||||
log.info("[%s] MQTT host=%s port=%s topic=%s", site, mqtt_host, mqtt_port, topic_cmd)
|
||||
|
||||
driver = MqttGyroDriver(mqtt_host, mqtt_port, mqtt_user, mqtt_pass, topic_cmd)
|
||||
controller = GyroController(
|
||||
site_name=site,
|
||||
db_cfg=db_cfg,
|
||||
alertes_table=alertes_table,
|
||||
mqtt_driver=driver,
|
||||
check_sec=DEF_CHECK_SEC,
|
||||
normal_confirm=DEF_NORMAL_CONFIRM,
|
||||
)
|
||||
controller.start()
|
||||
|
||||
try:
|
||||
while True:
|
||||
@@ -164,5 +332,5 @@ if __name__ == "__main__":
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
finally:
|
||||
ctl.stop()
|
||||
drv.close()
|
||||
controller.stop()
|
||||
driver.close()
|
||||
|
||||
@@ -1,71 +0,0 @@
|
||||
import os
|
||||
import ovh
|
||||
from dotenv import load_dotenv
|
||||
import unicodedata, re
|
||||
|
||||
load_dotenv()
|
||||
|
||||
def normaliser_sms(message: str, prefix: str = "") -> str:
|
||||
REPL = {"°": "C", "’": "'", "“": '"', "”": '"', "–": "-", "—": "-", "…": "..."}
|
||||
for k, v in REPL.items():
|
||||
message = message.replace(k, v)
|
||||
message = unicodedata.normalize("NFKD", message).encode("ascii", "ignore").decode("ascii")
|
||||
rules = [
|
||||
(r"\bTemperature\b", "T"),
|
||||
(r"\bTemp[ée]rature\b", "T"),
|
||||
(r"\bSeuil\b", "S"),
|
||||
(r"\bHeure\b", "H"),
|
||||
(r"\s{2,}", " "),
|
||||
]
|
||||
for pat, repl in rules:
|
||||
message = re.sub(pat, repl, message, flags=re.IGNORECASE)
|
||||
if prefix:
|
||||
message = f"[{prefix}] {message}"
|
||||
return message[:160]
|
||||
|
||||
def envoyer_sms(message: str, lieu: str = ""):
|
||||
try:
|
||||
client = ovh.Client(
|
||||
endpoint=os.getenv("OVH_ENDPOINT"),
|
||||
application_key=os.getenv("OVH_APP_KEY"),
|
||||
application_secret=os.getenv("OVH_APP_SECRET"),
|
||||
consumer_key=os.getenv("OVH_CONSUMER_KEY"),
|
||||
)
|
||||
|
||||
services = client.get('/sms/')
|
||||
if not services:
|
||||
print("❌ Aucun service SMS OVH trouvé", flush=True)
|
||||
return
|
||||
|
||||
service_name = services[0]
|
||||
numero_dest = os.getenv("SMS_RECEIVER")
|
||||
sender = os.getenv("OVH_SMS_SENDER")
|
||||
|
||||
if numero_dest.startswith('+'):
|
||||
numero_dest = '00' + numero_dest[1:]
|
||||
|
||||
if not numero_dest or not numero_dest.isdigit():
|
||||
print(f"❌ Numéro de téléphone invalide ou manquant : '{numero_dest}'", flush=True)
|
||||
return
|
||||
message = normaliser_sms(message, prefix=lieu)
|
||||
payload = {
|
||||
"sender": sender,
|
||||
"receivers": [numero_dest],
|
||||
"message": message, # Pas d'encodage ni de nettoyage ici
|
||||
"priority": "high",
|
||||
"noStopClause": False
|
||||
|
||||
}
|
||||
|
||||
print("📤 Requête envoyée à OVH :")
|
||||
print(payload)
|
||||
|
||||
result = client.post(f'/sms/{service_name}/jobs', **payload)
|
||||
|
||||
print(f"📱 SMS envoyé à {numero_dest} pour {lieu}. Job ID : {result['ids']}", flush=True)
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Erreur envoi SMS : {e}", flush=True)
|
||||
|
||||
if __name__ == "__main__":
|
||||
envoyer_sms("Test SMS OVH", lieu="utils_sms")
|
||||
Reference in New Issue
Block a user