netx/netx_api/lldp_collect_service.py

"""LLDP collect policy + dashboard (network topology management)."""

from __future__ import annotations

from datetime import datetime, timedelta

from fastapi import HTTPException
from sqlalchemy.orm import Session

from .lldp_collect_schemas import (
    LldpCollectDashboardOut,
    LldpCollectJobSummary,
    LldpCollectPolicyOut,
    LldpCollectPolicyUpdate,
    LldpCollectTargetRef,
)
from .models import LldpCollectPolicy, TopoDiscoverJob, TopoFabricStats
from .topology_schemas import FabricDiscoverRequest
from .topology_service import (
    get_discover_job,
    prune_discover_jobs,
    reclaim_stale_discover_jobs,
    start_discover_job,
)

POLICY_ID = 1
DEFAULT_HISTORY_KEEP = 30
MAX_INTERVAL_HOURS = 8760  # 365d


def _utcnow() -> datetime:
    return datetime.utcnow()


def _normalize_interval_hours(row: LldpCollectPolicy) -> int:
    hours = int(getattr(row, "interval_hours", 0) or 0)
    if hours <= 0:
        hours = max(1, int(row.interval_days or 1)) * 24
    return max(1, min(MAX_INTERVAL_HOURS, hours))


def ensure_policy(db: Session) -> LldpCollectPolicy:
    row = db.get(LldpCollectPolicy, POLICY_ID)
    if row is None:
        row = LldpCollectPolicy(
            id=POLICY_ID,
            enabled=False,
            interval_days=1,
            interval_hours=24,
            concurrency=4,
            scope_mode="all",
            selected_targets=[],
            auto_add_unmatched=True,
            history_keep=DEFAULT_HISTORY_KEEP,
            updated_at=_utcnow(),
        )
        db.add(row)
        db.commit()
        db.refresh(row)
    # Heal legacy rows missing hours.
    if int(getattr(row, "interval_hours", 0) or 0) <= 0:
        row.interval_hours = max(1, int(row.interval_days or 1)) * 24
        db.commit()
        db.refresh(row)
    return row


def _policy_out(row: LldpCollectPolicy) -> LldpCollectPolicyOut:
    refs: list[LldpCollectTargetRef] = []
    for raw in row.selected_targets or []:
        if not isinstance(raw, dict):
            continue
        tid = str(raw.get("id") or "").strip()
        if not tid:
            continue
        src = str(raw.get("source") or "managed").strip().lower() or "managed"
        if src not in {"managed", "ume"}:
            src = "managed"
        refs.append(LldpCollectTargetRef(source=src, id=tid))
    keep = getattr(row, "history_keep", None)
    if keep is None:
        keep = DEFAULT_HISTORY_KEEP
    hours = _normalize_interval_hours(row)
    days = max(1, min(365, (hours + 23) // 24))
    return LldpCollectPolicyOut(
        enabled=bool(row.enabled),
        interval_days=days,
        interval_hours=hours,
        concurrency=int(row.concurrency or 4),
        scope_mode="selected" if str(row.scope_mode or "") == "selected" else "all",
        selected_targets=refs,
        auto_add_unmatched=bool(row.auto_add_unmatched),
        history_keep=max(0, min(200, int(keep))),
        updated_at=row.updated_at,
    )


def get_policy(db: Session) -> LldpCollectPolicyOut:
    return _policy_out(ensure_policy(db))


def update_policy(db: Session, body: LldpCollectPolicyUpdate) -> LldpCollectPolicyOut:
    row = ensure_policy(db)
    data = body.model_dump(exclude_unset=True)
    if "enabled" in data and data["enabled"] is not None:
        row.enabled = bool(data["enabled"])
    if "interval_hours" in data and data["interval_hours"] is not None:
        hours = max(1, min(MAX_INTERVAL_HOURS, int(data["interval_hours"])))
        row.interval_hours = hours
        row.interval_days = max(1, min(365, (hours + 23) // 24))
    elif "interval_days" in data and data["interval_days"] is not None:
        days = max(1, min(365, int(data["interval_days"])))
        row.interval_days = days
        row.interval_hours = days * 24
    if "concurrency" in data and data["concurrency"] is not None:
        row.concurrency = max(1, min(16, int(data["concurrency"])))
    if "scope_mode" in data and data["scope_mode"] is not None:
        mode = str(data["scope_mode"] or "").strip().lower()
        if mode not in {"all", "selected"}:
            raise HTTPException(status_code=400, detail="invalid_scope_mode")
        row.scope_mode = mode
    if "selected_targets" in data and data["selected_targets"] is not None:
        cleaned: list[dict[str, str]] = []
        for ref in data["selected_targets"] or []:
            if isinstance(ref, LldpCollectTargetRef):
                tid = ref.id.strip()
                src = ref.source.strip().lower() or "managed"
            elif isinstance(ref, dict):
                tid = str(ref.get("id") or "").strip()
                src = str(ref.get("source") or "managed").strip().lower() or "managed"
            else:
                continue
            if not tid:
                continue
            if src not in {"managed", "ume"}:
                src = "managed"
            cleaned.append({"source": src, "id": tid})
        row.selected_targets = cleaned
    if "auto_add_unmatched" in data and data["auto_add_unmatched"] is not None:
        row.auto_add_unmatched = bool(data["auto_add_unmatched"])
    if "history_keep" in data and data["history_keep"] is not None:
        row.history_keep = max(0, min(200, int(data["history_keep"])))
    row.updated_at = _utcnow()
    db.commit()
    db.refresh(row)
    prune_discover_jobs(db, keep=int(row.history_keep or 0))
    return _policy_out(row)


def _job_summary(job: TopoDiscoverJob | None) -> LldpCollectJobSummary | None:
    if job is None:
        return None
    return LldpCollectJobSummary(
        id=job.id,
        scope=job.scope or "",
        trigger_mode=getattr(job, "trigger_mode", None) or "manual",
        status=job.status or "",
        total=int(job.total or 0),
        done=int(job.done or 0),
        edges_added=int(job.edges_added or 0),
        edges_updated=int(job.edges_updated or 0),
        edges_stale=int(job.edges_stale or 0),
        edges_missing=int(job.edges_stale or 0),
        error=job.error or "",
        started_at=job.started_at,
        ended_at=job.ended_at,
        created_at=job.created_at,
    )


def has_running_job(db: Session) -> TopoDiscoverJob | None:
    reclaim_stale_discover_jobs(db)
    return (
        db.query(TopoDiscoverJob)
        .filter(TopoDiscoverJob.status.in_(["pending", "running"]))
        .order_by(TopoDiscoverJob.created_at.desc())
        .first()
    )


def last_finished_job(db: Session) -> TopoDiscoverJob | None:
    return (
        db.query(TopoDiscoverJob)
        .filter(TopoDiscoverJob.status.in_(["done", "failed"]))
        .order_by(TopoDiscoverJob.created_at.desc())
        .first()
    )


def next_due_at(db: Session, policy: LldpCollectPolicy) -> datetime | None:
    """Due time based on last *scheduled* successful collect only (manual must not reset)."""
    if not policy.enabled:
        return None
    hours = _normalize_interval_hours(policy)
    last = (
        db.query(TopoDiscoverJob)
        .filter(
            TopoDiscoverJob.status == "done",
            TopoDiscoverJob.trigger_mode == "schedule",
            TopoDiscoverJob.ended_at.isnot(None),
        )
        .order_by(TopoDiscoverJob.ended_at.desc())
        .first()
    )
    if last is None or last.ended_at is None:
        return _utcnow()
    return last.ended_at + timedelta(hours=hours)


def build_discover_request(policy: LldpCollectPolicy) -> FabricDiscoverRequest:
    concurrency = max(1, min(16, int(policy.concurrency or 4)))
    auto_add = bool(policy.auto_add_unmatched)
    if str(policy.scope_mode or "") == "selected":
        managed_ids: list[str] = []
        ume_ids: list[str] = []
        for raw in policy.selected_targets or []:
            if not isinstance(raw, dict):
                continue
            tid = str(raw.get("id") or "").strip()
            if not tid:
                continue
            src = str(raw.get("source") or "managed").strip().lower() or "managed"
            if src == "ume":
                ume_ids.append(tid)
            else:
                managed_ids.append(tid)
        if not managed_ids and not ume_ids:
            raise HTTPException(status_code=400, detail="no_selected_targets")
        return FabricDiscoverRequest(
            scope="ne_ids",
            ne_ids=[],
            managed_ne_ids=managed_ids,
            ume_ne_ids=ume_ids,
            concurrency=concurrency,
            auto_add_unmatched=auto_add,
        )
    return FabricDiscoverRequest(
        scope="all_inventory",
        ne_ids=[],
        managed_ne_ids=[],
        ume_ne_ids=[],
        concurrency=concurrency,
        auto_add_unmatched=auto_add,
    )


def start_collect(db: Session, *, trigger_mode: str = "manual") -> dict:
    if has_running_job(db) is not None:
        raise HTTPException(status_code=409, detail="lldp_collect_already_running")
    policy = ensure_policy(db)
    body = build_discover_request(policy)
    job = start_discover_job(db, body, trigger_mode=trigger_mode)
    prune_discover_jobs(db, keep=int(getattr(policy, "history_keep", DEFAULT_HISTORY_KEEP) or 0))
    return {"ok": True, "job": job.model_dump()}


def get_dashboard(db: Session) -> LldpCollectDashboardOut:
    policy = ensure_policy(db)
    stats = db.get(TopoFabricStats, "global")
    running = has_running_job(db)
    last = last_finished_job(db)
    return LldpCollectDashboardOut(
        policy=_policy_out(policy),
        fabric_node_count=int(stats.node_count if stats else 0),
        fabric_edge_count=int(stats.edge_count if stats else 0),
        fabric_edge_active=int(stats.edge_active if stats else 0),
        fabric_edge_stale=int(stats.edge_stale if stats else 0),
        fabric_edge_missing=int(stats.edge_stale if stats else 0),
        last_discover_at=stats.last_discover_at if stats else None,
        running_job=_job_summary(running),
        last_job=_job_summary(last),
        next_due_at=next_due_at(db, policy),
    )


def list_jobs(db: Session, *, page: int = 1, page_size: int = 20) -> dict:
    page = max(1, int(page or 1))
    page_size = max(1, min(100, int(page_size or 20)))
    q = db.query(TopoDiscoverJob).order_by(TopoDiscoverJob.created_at.desc())
    total = int(q.count())
    rows = q.offset((page - 1) * page_size).limit(page_size).all()
    return {
        "total": total,
        "page": page,
        "page_size": page_size,
        "items": [_job_summary(r).model_dump() for r in rows if _job_summary(r)],
    }


def get_job_detail(db: Session, job_id: str) -> dict:
    return get_discover_job(db, job_id).model_dump()