from __future__ import annotations import json import yaml from pydantic import ValidationError from .models import ConfigDocument, ConfigImportResult, ConfigService, Service, ServiceCreate from .store import Store # Observed runtime state is not configuration: it is re-learned from Docker # and probes and must not be frozen into an exported document. OBSERVED_FIELDS = frozenset( {"runtime_state", "runtime_health", "first_seen_at", "last_seen_at", "last_discovery_status"} ) CONFIG_FIELDS = frozenset(ServiceCreate.model_fields) - OBSERVED_FIELDS - {"depends_on"} def config_service(service: Service, names_by_id: dict[str, str]) -> ConfigService: """Every operator-owned field of a service, dependencies by name. The previous field-by-field copy omitted application/domain/role, their locks, category, visibility, lifecycle, monitoring and probe metadata and layout, so an export/import round trip silently lost them. """ return ConfigService( **service.model_dump(include=CONFIG_FIELDS), depends_on=[names_by_id[item] for item in service.depends_on if item in names_by_id], ) def _reject_yaml_aliases(content: str) -> None: """Refuse YAML anchors/aliases: nested aliases expand exponentially ("billion laughs") and a configuration document never needs them.""" for event in yaml.parse(content, Loader=yaml.SafeLoader): if isinstance(event, yaml.AliasEvent) or getattr(event, "anchor", None): raise ValueError("De configuratie mag geen YAML-anchors of -aliassen gebruiken") def parse_document(content: str, format_name: str) -> ConfigDocument: try: if format_name != "json": _reject_yaml_aliases(content) raw = json.loads(content) if format_name == "json" else yaml.safe_load(content) except (json.JSONDecodeError, yaml.YAMLError) as exc: raise ValueError(f"Invalid {format_name.upper()} configuration: {exc}") from exc if raw is None: raw = {"version": 1, "services": []} try: document = ConfigDocument.model_validate(raw) except ValidationError as exc: raise ValueError(f"De configuratie voldoet niet aan het schema: {exc}") from exc if document.version == 2 and not document.services: # Preserve the v1 contract's explicit unsupported-empty-v2 guard while # accepting real v2 documents that carry the richer service schema. raise ValueError("Voor een leeg document moet de configuratieversie 1 of lager zijn") names = [service.name.casefold() for service in document.services] if len(names) != len(set(names)): raise ValueError("Servicenamen moeten uniek zijn in de configuratie") for service in document.services: dependencies = [dependency.casefold() for dependency in service.depends_on] if len(dependencies) != len(set(dependencies)): raise ValueError(f"Service {service.name} heeft dubbele afhankelijkheden") if service.name.casefold() in dependencies: raise ValueError(f"Service {service.name} kan niet van zichzelf afhangen") # A merge document may reference services that already exist in the store, # so missing-reference validation belongs to import_document(). Cycles that # are fully contained in this document can still be rejected immediately. _validate_acyclic(document.services) return document def _validate_acyclic(services: list[ConfigService]) -> None: graph = { service.name.casefold(): [item.casefold() for item in service.depends_on] for service in services } 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 in graph.get(node, []): visit(dependency) visiting.remove(node) visited.add(node) for node in graph: visit(node) def _validate_import_graph(store: Store, document: ConfigDocument, mode: str) -> None: if mode not in {"merge", "replace"}: raise ValueError("Importmodus moet merge of replace zijn") projected: dict[str, ConfigService] = {} if mode == "merge": existing = store.list_services() names_by_id = {service.id: service.name for service in existing} for service in existing: projected[service.name.casefold()] = config_service(service, names_by_id) for service in document.services: key = service.name.casefold() previous = projected.get(key) if previous is not None and "depends_on" not in service.model_fields_set: # A merge keeps dependencies the document does not mention. service = service.model_copy(update={"depends_on": previous.depends_on}) projected[key] = service available = set(projected) for service in projected.values(): missing = [ dependency for dependency in service.depends_on if dependency.casefold() not in available ] if missing: raise ValueError( f"Service {service.name} verwijst naar onbekende afhankelijkheden: {', '.join(missing)}" ) _validate_acyclic(list(projected.values())) def export_document(store: Store) -> ConfigDocument: services = store.list_services() names = {service.id: service.name for service in services} return ConfigDocument(version=2, services=[config_service(service, names) for service in services]) def serialize_document(document: ConfigDocument, format_name: str) -> str: payload = document.model_dump(mode="json", exclude={"services": {"__all__": set(OBSERVED_FIELDS)}}) if format_name == "json": return json.dumps(payload, indent=2, sort_keys=False) return yaml.safe_dump(payload, sort_keys=False, allow_unicode=True) def import_document(store: Store, document: ConfigDocument, mode: str) -> ConfigImportResult: _validate_import_graph(store, document, mode) return store.import_config_services(document.services, mode)