Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
41 changes: 0 additions & 41 deletions .github/workflows/ci.yml

This file was deleted.

2 changes: 2 additions & 0 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -191,6 +191,8 @@ Ces mêmes contrôles sont exécutés automatiquement par [la CI](.github/workfl
- `GET /api/domains` - List all monitored domains
- `POST /api/domains/bulk` - Add multiple domains
- `DELETE /api/domains/{domain_name}` - Remove a domain
- `GET /api/domains/{domain_name}/alert-policy` - Read a domain alert policy
- `PUT /api/domains/{domain_name}/alert-policy` - Configure threshold, reminders and channel
- `GET /api/check/{domain_name}` - Check single domain certificate
- `GET /health` - Health check endpoint

Expand Down
97 changes: 97 additions & 0 deletions backend/alerts.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,97 @@
"""Alert policies, state transitions and notification journal."""

from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import Iterable

from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String, Text
from sqlalchemy.orm import Session

try:
from .database import Base
except ImportError:
from database import Base


class AlertPolicy(Base):
__tablename__ = "alert_policies"

domain_name = Column(String(253), ForeignKey("domains.name", ondelete="CASCADE"), primary_key=True)
threshold_days = Column(Integer, nullable=False, default=30)
reminder_interval_hours = Column(Integer, nullable=False, default=168)
enabled = Column(Boolean, nullable=False, default=True)
channel = Column(String(32), nullable=False, default="email")


class AlertState(Base):
__tablename__ = "alert_states"

domain_name = Column(String(253), ForeignKey("domains.name", ondelete="CASCADE"), primary_key=True)
state = Column(String(16), nullable=False, default="healthy")
last_notified_at = Column(DateTime, nullable=True)


class NotificationLog(Base):
__tablename__ = "notification_logs"

id = Column(Integer, primary_key=True, autoincrement=True)
domain_name = Column(String(253), ForeignKey("domains.name", ondelete="CASCADE"), nullable=False)
event_type = Column(String(16), nullable=False)
channel = Column(String(32), nullable=False)
success = Column(Boolean, nullable=False)
error_message = Column(Text, nullable=True)
created_at = Column(DateTime, nullable=False, default=datetime.utcnow)


@dataclass(frozen=True)
class AlertEvent:
domain: str
event_type: str
channel: str
certificate: dict


def get_policy(session: Session, domain: str) -> AlertPolicy:
return session.get(AlertPolicy, domain) or AlertPolicy(
domain_name=domain, threshold_days=30, reminder_interval_hours=168, enabled=True, channel="email"
)


def select_alert_events(session: Session, results: Iterable[dict], now: datetime | None = None) -> list[AlertEvent]:
now = now or datetime.utcnow()
events = []
for certificate in results:
domain = certificate["domain"]
policy = get_policy(session, domain)
state = session.get(AlertState, domain)
current_state = state.state if state else "healthy"
is_critical = certificate["status"] == "Erreur" or (
certificate.get("days_left") is not None and certificate["days_left"] < policy.threshold_days
)
if not policy.enabled:
continue
if is_critical and current_state == "healthy":
events.append(AlertEvent(domain, "problem", policy.channel, certificate))
elif is_critical and current_state == "critical" and state and state.last_notified_at:
if now >= state.last_notified_at + timedelta(hours=policy.reminder_interval_hours):
events.append(AlertEvent(domain, "reminder", policy.channel, certificate))
elif not is_critical and current_state == "critical":
events.append(AlertEvent(domain, "resolved", policy.channel, certificate))
return events


def record_notification(session: Session, events: Iterable[AlertEvent], success: bool, error_message: str | None = None, now: datetime | None = None) -> None:
now = now or datetime.utcnow()
for event in events:
session.add(NotificationLog(
domain_name=event.domain, event_type=event.event_type, channel=event.channel,
success=success, error_message=error_message, created_at=now,
))
if success:
state = session.get(AlertState, event.domain)
if state is None:
state = AlertState(domain_name=event.domain)
session.add(state)
state.state = "healthy" if event.event_type == "resolved" else "critical"
state.last_notified_at = now
session.commit()
28 changes: 19 additions & 9 deletions backend/cron_job.py
Original file line number Diff line number Diff line change
Expand Up @@ -13,8 +13,10 @@
from typing import List, Dict
try:
from .database import SessionLocal, initialize_database, list_domains, save_statuses
from .alerts import record_notification, select_alert_events
except ImportError:
from database import SessionLocal, initialize_database, list_domains, save_statuses
from alerts import record_notification, select_alert_events

# Seuil en jours pour considérer qu'un certificat "Expire bientôt"
ALERT_THRESHOLD_DAYS = 30
Expand Down Expand Up @@ -156,7 +158,7 @@ async def get_ssl_expiry_info(hostname: str) -> Dict:
await asyncio.sleep(RETRY_BACKOFF * (2**attempt))

# --- Logique d'envoi d'email ---
def send_summary_report(critical_certs: list):
def send_summary_report(events: list) -> tuple[bool, str | None]:
"""Envoie un rapport récapitulatif par email avec les certificats critiques."""
# Lit la configuration depuis les variables d'environnement chargées par Docker Compose
sender_email = os.getenv("SMTP_SENDER_EMAIL")
Expand All @@ -167,12 +169,13 @@ def send_summary_report(critical_certs: list):

if not all([sender_email, password, recipients_str, smtp_server]):
print("-> AVERTISSEMENT: Variables d'environnement pour l'email non configurées. Envoi annulé.")
return
return False, "Configuration SMTP incomplète."

recipients = [email.strip() for email in recipients_str.split(',')]

msg = EmailMessage()
msg['Subject'] = f"🚨 Rapport SSL-Cert-Monitor : {len(critical_certs)} certificat(s) requièrent votre attention"
has_resolution = any(event.event_type == "resolved" for event in events)
msg['Subject'] = f"{'✅ Résolution' if has_resolution else '🚨 Alerte'} SSL-Cert-Monitor : {len(events)} événement(s)"
msg['From'] = sender_email
msg['To'] = ", ".join(recipients)

Expand All @@ -181,9 +184,11 @@ def send_summary_report(critical_certs: list):
"\nLe rapport de surveillance quotidien a identifié les certificats suivants comme étant critiques :",
"\n"
]
for cert in critical_certs:
for event in events:
cert = event.certificate
body_lines.append("----------------------------------------")
body_lines.append(f"Domaine : {cert['domain']}")
body_lines.append(f"Événement : {event.event_type}")
body_lines.append(f"Statut : {cert['status']}")
if cert.get('days_left') is not None:
body_lines.append(f"Jours restants : {cert['days_left']}")
Expand All @@ -199,9 +204,11 @@ def send_summary_report(critical_certs: list):
server.starttls()
server.login(sender_email, password)
server.send_message(msg)
print("-> ✅ Rapport email envoyé avec succès.")
print("-> ✅ Notification email envoyée avec succès.")
return True, None
except Exception as e:
print(f"-> ❌ Échec de l'envoi de l'email : {e}")
return False, str(e)

# --- Logique de vérification SSL Asynchrone ---
# --- Fonction Principale du Script ---
Expand Down Expand Up @@ -230,11 +237,14 @@ async def check_with_limit(domain: str) -> Dict:
print(f"-> Vérification terminée. {len(results)} domaines traités. Rapport mis à jour en base.")

# Filtrage des certificats critiques et envoi de l'email
critical_certs = [cert for cert in results if cert['status'] in ['Expire bientôt', 'Expiré', 'Erreur']]
if critical_certs:
send_summary_report(critical_certs)
with SessionLocal() as session:
events = select_alert_events(session, results)
if events:
success, error = send_summary_report(events)
with SessionLocal() as session:
record_notification(session, events, success, error)
else:
print("-> Tous les certificats sont OK. Aucun email envoyé.")
print("-> Aucun nouvel événement d'alerte. Aucun email envoyé.")

if __name__ == "__main__":
asyncio.run(main())
42 changes: 36 additions & 6 deletions backend/main.py
Original file line number Diff line number Diff line change
Expand Up @@ -2,13 +2,10 @@
import os
from fastapi import Depends, FastAPI, Header, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from pydantic import BaseModel, Field
from typing import List
try:
from .domain_utils import normalize_domain
except ImportError:
from domain_utils import normalize_domain
from database import SessionLocal, add_domains, delete_domain as remove_domain, initialize_database, list_domains, list_statuses
from database import Domain, SessionLocal, add_domains, delete_domain as remove_domain, initialize_database, list_domains, list_statuses
from alerts import AlertPolicy, get_policy
# On importe la fonction de check unique
from cron_job import get_ssl_expiry_info

Expand All @@ -31,6 +28,11 @@
)

class DomainList(BaseModel): domains: List[str]
class AlertPolicyUpdate(BaseModel):
threshold_days: int = Field(default=30, ge=1, le=3650)
reminder_interval_hours: int = Field(default=168, ge=0, le=8760)
enabled: bool = True
channel: str = Field(default="email", pattern="^email$")

initialize_database()

Expand Down Expand Up @@ -86,6 +88,34 @@ async def delete_domain(domain_name: str):
raise HTTPException(status_code=404, detail="Domaine non trouvé.")
return {"message": f"Domaine '{domain_name}' supprimé."}

@app.get("/api/domains/{domain_name}/alert-policy", dependencies=[Depends(require_api_auth)])
async def get_alert_policy(domain_name: str):
with SessionLocal() as session:
if not session.get(Domain, domain_name):
raise HTTPException(status_code=404, detail="Domaine non trouvé.")
policy = get_policy(session, domain_name)
return {
"domain": domain_name,
"threshold_days": policy.threshold_days,
"reminder_interval_hours": policy.reminder_interval_hours,
"enabled": policy.enabled,
"channel": policy.channel,
}

@app.put("/api/domains/{domain_name}/alert-policy", dependencies=[Depends(require_api_auth)])
async def update_alert_policy(domain_name: str, update: AlertPolicyUpdate):
with SessionLocal() as session:
if not session.get(Domain, domain_name):
raise HTTPException(status_code=404, detail="Domaine non trouvé.")
policy = session.get(AlertPolicy, domain_name) or AlertPolicy(domain_name=domain_name)
policy.threshold_days = update.threshold_days
policy.reminder_interval_hours = update.reminder_interval_hours
policy.enabled = update.enabled
policy.channel = update.channel
session.add(policy)
session.commit()
return {"message": "Politique d'alerte mise à jour.", **update.model_dump()}

@app.get("/health")
async def health_check():
return {"status": "healthy"}
35 changes: 35 additions & 0 deletions backend/tests/test_alerts.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,35 @@
from datetime import datetime, timedelta

from sqlalchemy import create_engine, select
from sqlalchemy.orm import sessionmaker

from backend.alerts import AlertState, NotificationLog, record_notification, select_alert_events
from backend.database import Base, Domain


def test_alerts_are_deduplicated_reminded_and_resolved(tmp_path):
engine = create_engine(f"sqlite:///{tmp_path / 'alerts.db'}")
Base.metadata.create_all(engine)
sessions = sessionmaker(bind=engine)
now = datetime(2026, 1, 1)
critical = {"domain": "example.com", "status": "Expire bientôt", "days_left": 10}
healthy = {"domain": "example.com", "status": "OK", "days_left": 90}

with sessions() as session:
session.add(Domain(name="example.com"))
session.commit()
first = select_alert_events(session, [critical], now)
assert [event.event_type for event in first] == ["problem"]
record_notification(session, first, True, now=now)

assert select_alert_events(session, [critical], now + timedelta(days=1)) == []
reminder = select_alert_events(session, [critical], now + timedelta(days=8))
assert [event.event_type for event in reminder] == ["reminder"]
record_notification(session, reminder, True, now=now + timedelta(days=8))

resolution = select_alert_events(session, [healthy], now + timedelta(days=8))
assert [event.event_type for event in resolution] == ["resolved"]
record_notification(session, resolution, True, now=now + timedelta(days=8))

assert session.scalar(select(AlertState.state).where(AlertState.domain_name == "example.com")) == "healthy"
assert session.scalar(select(NotificationLog.success).where(NotificationLog.domain_name == "example.com")) is True