diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml deleted file mode 100644 index e0bf07e..0000000 --- a/.github/workflows/ci.yml +++ /dev/null @@ -1,41 +0,0 @@ -name: CI - -on: - push: - branches: [main] - pull_request: - branches: [main] - -jobs: - backend: - runs-on: ubuntu-latest - defaults: - run: - working-directory: backend - steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 - with: - python-version: "3.10" - cache: pip - cache-dependency-path: backend/requirements.txt - - run: python -m pip install -r requirements.txt pytest - - run: python -m pytest tests -q - - run: python -m compileall -q . - - frontend: - runs-on: ubuntu-latest - defaults: - run: - working-directory: frontend - steps: - - uses: actions/checkout@v4 - - uses: actions/setup-node@v4 - with: - node-version: 20 - cache: npm - cache-dependency-path: frontend/package-lock.json - - run: npm ci - - run: npm run lint - - run: npm run typecheck - - run: npm run build diff --git a/README.md b/README.md index 7980760..48a977b 100644 --- a/README.md +++ b/README.md @@ -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 diff --git a/backend/alerts.py b/backend/alerts.py new file mode 100644 index 0000000..0ebd86f --- /dev/null +++ b/backend/alerts.py @@ -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() diff --git a/backend/cron_job.py b/backend/cron_job.py index a73d247..b0c445e 100644 --- a/backend/cron_job.py +++ b/backend/cron_job.py @@ -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 @@ -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") @@ -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) @@ -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']}") @@ -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 --- @@ -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()) diff --git a/backend/main.py b/backend/main.py index 2fe2a0c..495b94b 100644 --- a/backend/main.py +++ b/backend/main.py @@ -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 @@ -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() @@ -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"} diff --git a/backend/tests/test_alerts.py b/backend/tests/test_alerts.py new file mode 100644 index 0000000..44a6d70 --- /dev/null +++ b/backend/tests/test_alerts.py @@ -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