from __future__ import annotations from typing import NamedTuple from .models import HealthStatus, Service from .store import Store SEVERITY = { HealthStatus.MAINTENANCE: 0, HealthStatus.UNMONITORED: 0, HealthStatus.UNKNOWN: 0, HealthStatus.HEALTHY: 1, HealthStatus.RECOVERING: 2, HealthStatus.DEGRADED: 3, HealthStatus.DOWN: 4, } class TopologyHealth(NamedTuple): services: list[Service] direct: dict[str, HealthStatus] effective: dict[str, HealthStatus] dependency: dict[str, HealthStatus] def topology_health(store: Store, *, services: list[Service] | None = None) -> TopologyHealth: """Resolve direct, dependency and effective health for the whole graph. One bulk evidence read plus one in-memory traversal. The former per-service recursive walk re-queried SQLite for every node on every dependency path and dominated server CPU. """ services = store.list_services() if services is None else services direct, _ = store.service_healths([service.id for service in services]) effective, dependency = status_maps(services, direct_statuses=direct) return TopologyHealth(services, direct, effective, dependency) def _single(service: Service, store: Store) -> TopologyHealth: services = [item for item in store.list_services() if item.id != service.id] return topology_health(store, services=[*services, service]) def dependency_status(service: Service, store: Store) -> HealthStatus: return _single(service, store).dependency.get(service.id, HealthStatus.UNKNOWN) def effective_status(service: Service, store: Store) -> HealthStatus: return _single(service, store).effective.get(service.id, HealthStatus.UNKNOWN) def status_maps( services: list[Service], *, direct_statuses: dict[str, HealthStatus] | None = None, ) -> tuple[dict[str, HealthStatus], dict[str, HealthStatus]]: """Calculate the complete topology in memory for one bounded API read.""" by_id = {service.id: service for service in services} def legacy_direct_state(service: Service) -> HealthStatus: runtime_state = (service.runtime_state or "").casefold() runtime_health = (service.runtime_health or "").casefold() if not service.enabled: return HealthStatus.UNKNOWN if service.maintenance_enabled: return HealthStatus.MAINTENANCE if runtime_health == "unhealthy" or runtime_state in {"exited", "dead", "stopped"}: return HealthStatus.DOWN if runtime_state == "restarting": return HealthStatus.DEGRADED if not service.monitoring_enabled: if runtime_health == "healthy": return HealthStatus.HEALTHY return HealthStatus.UNMONITORED if service.monitoring_state.value in {"unmonitored", "observed"} else HealthStatus.UNKNOWN return service.state direct = { service.id: (direct_statuses.get(service.id, HealthStatus.UNKNOWN) if direct_statuses else legacy_direct_state(service)) for service in services } effective: dict[str, HealthStatus] = {} dependency: dict[str, HealthStatus] = {} def visit(service_id: str, visiting: set[str]) -> HealthStatus: if service_id in effective: return effective[service_id] if service_id in visiting: return HealthStatus.UNKNOWN service = by_id.get(service_id) if service is None: return HealthStatus.UNKNOWN next_visiting = {*visiting, service_id} own = direct[service_id] if not service.depends_on: dependency[service_id] = HealthStatus.HEALTHY effective[service_id] = own return own dependencies = [visit(item, next_visiting) for item in service.depends_on] dependency_state = max(dependencies, key=lambda status: SEVERITY[status]) dependency[service_id] = dependency_state if own == HealthStatus.MAINTENANCE or own == HealthStatus.DOWN: result = own elif dependency_state == HealthStatus.DOWN or ( dependency_state in {HealthStatus.DEGRADED, HealthStatus.RECOVERING} and own in {HealthStatus.HEALTHY, HealthStatus.RECOVERING} ): result = HealthStatus.DEGRADED else: result = own effective[service_id] = result return result for service in services: visit(service.id, set()) return effective, dependency def validate_dependencies( depends_on: list[str], store: Store, *, service_id: str | None = None, ) -> None: if len(depends_on) != len(set(depends_on)): raise ValueError("Afhankelijkheden moeten uniek zijn") if service_id and service_id in depends_on: raise ValueError("Een service kan niet van zichzelf afhangen") services = store.list_services() known_ids = {service.id for service in services} missing = [dependency_id for dependency_id in depends_on if dependency_id not in known_ids] if missing: raise ValueError(f"Onbekende afhankelijkheids-id's: {', '.join(missing)}") if service_id is None: return graph = {service.id: list(service.depends_on) for service in services} graph[service_id] = list(depends_on) visiting: set[str] = set() visited: set[str] = set() def visit(node: str) -> None: if node in visiting: raise ValueError("De afhankelijkheidsgrafiek bevat een kring") if node in visited: return visiting.add(node) for dependency_id in graph.get(node, []): visit(dependency_id) visiting.remove(node) visited.add(node) for node in graph: visit(node)