| """Validate complete API snapshots and the provenance of their observations.""" |
|
|
| from __future__ import annotations |
|
|
| from copy import deepcopy |
| import json |
| import re |
| from typing import Any, Mapping |
|
|
| from . import adapter as _adapter |
| from . import recovery_policy as _policy |
| from .spec import DRIFT_EVENT_ID, SNAPSHOT_SCHEMA, TARGETS, TASK_IDS |
|
|
| _BUSINESS_FIELDS = frozenset( |
| { |
| "schema", |
| "raw", |
| "remaining", |
| "initial_budget", |
| "receipts", |
| "applied_boundary_events", |
| "active_task_id", |
| "policy_version", |
| "activated_tasks", |
| "task_targets", |
| "active_receipt_start", |
| } |
| ) |
|
|
| _RAW_FIELDS = frozenset({"database", "counters"}) |
|
|
| _DATABASE_TABLES = frozenset( |
| { |
| "service_integration", |
| "api_credential", |
| "retry_budget", |
| "rate_limit_bucket", |
| "fault_policy", |
| "api_call_attempt", |
| "idempotency_key", |
| "audit_event", |
| "incident_window", |
| } |
| ) |
|
|
| _POLICY_VERSIONS = frozenset({"recovery-policy-v1", "recovery-policy-v2"}) |
|
|
| _SNAPSHOT_FIELDS = frozenset( |
| { |
| "schema", |
| "raw", |
| "remaining", |
| "initial_budget", |
| "receipts", |
| "applied_boundary_events", |
| "active_task_id", |
| "policy_version", |
| "activated_tasks", |
| "task_targets", |
| "active_receipt_start", |
| "capability_observations", |
| } |
| ) |
|
|
| _RECEIPT_FIELDS = frozenset( |
| { |
| "index", |
| "task_id", |
| "tool", |
| "actor", |
| "arguments", |
| "status", |
| "cost", |
| "before_hash", |
| "after_business_hash", |
| } |
| ) |
|
|
| _HEX_SHA256 = re.compile(r"[0-9a-f]{64}\Z") |
|
|
| _OBSERVATION_FIELDS = { |
| "credential": frozenset( |
| { |
| "kind", |
| "credential_id", |
| "integration_id", |
| "operations", |
| "task_id", |
| "receipt_index", |
| } |
| ), |
| "retry_budget": frozenset( |
| { |
| "kind", |
| "retry_budget_id", |
| "integration_id", |
| "task_id", |
| "receipt_index", |
| } |
| ), |
| "rate_bucket": frozenset( |
| { |
| "kind", |
| "rate_limit_bucket_id", |
| "integration_id", |
| "operation", |
| "task_id", |
| "receipt_index", |
| } |
| ), |
| "recovery_profile": frozenset( |
| { |
| "kind", |
| "recovery_profile_id", |
| "failure_signal", |
| "operation_class", |
| "task_id", |
| "receipt_index", |
| } |
| ), |
| } |
|
|
| _OBSERVATION_TOOLS = { |
| "credential": "list_api_credentials", |
| "retry_budget": "list_retry_budgets", |
| "rate_bucket": "inspect_rate_limit_status", |
| "recovery_profile": "search_recovery_evidence", |
| } |
|
|
| _PUBLIC_TOOL_NAMES = frozenset(row["name"] for row in _adapter.PUBLIC_TOOLS) |
|
|
| def _canonical(value: Any) -> str: |
| return json.dumps( |
| value, |
| ensure_ascii=True, |
| sort_keys=True, |
| separators=(",", ":"), |
| allow_nan=False, |
| ) |
|
|
| def _is_int(value: Any) -> bool: |
| return type(value) is int |
|
|
| def _nonempty_text(value: Any) -> bool: |
| return isinstance(value, str) and bool(value) |
|
|
| def _validate_business_state(snapshot: Any) -> None: |
| if not isinstance(snapshot, dict) or set(snapshot) != _BUSINESS_FIELDS: |
| raise ValueError("API Reliability v6 snapshot fields are incomplete or unexpected") |
| if snapshot["schema"] != SNAPSHOT_SCHEMA: |
| raise ValueError("unsupported API Reliability v6 snapshot schema") |
|
|
| raw = snapshot["raw"] |
| if not isinstance(raw, dict) or set(raw) != _RAW_FIELDS: |
| raise ValueError("API Reliability v6 raw snapshot is malformed") |
| database = raw["database"] |
| counters = raw["counters"] |
| if not isinstance(database, dict) or set(database) != _DATABASE_TABLES: |
| raise ValueError("API Reliability v6 database tables are incomplete or unexpected") |
| if any( |
| not isinstance(rows, list) |
| or any(not isinstance(row, dict) for row in rows) |
| for rows in database.values() |
| ): |
| raise ValueError("API Reliability v6 database rows must be objects") |
| if not isinstance(counters, dict) or any( |
| not isinstance(name, str) |
| or not _is_int(value) |
| or value < 0 |
| for name, value in counters.items() |
| ): |
| raise ValueError("API Reliability v6 counters are malformed") |
|
|
| remaining = snapshot["remaining"] |
| initial_budget = snapshot["initial_budget"] |
| if ( |
| not _is_int(remaining) |
| or not _is_int(initial_budget) |
| or initial_budget < 0 |
| or remaining < 0 |
| or remaining > initial_budget |
| ): |
| raise ValueError("API Reliability v6 budget state is invalid") |
|
|
| receipts = snapshot["receipts"] |
| if not isinstance(receipts, list) or any( |
| not isinstance(receipt, dict) for receipt in receipts |
| ): |
| raise ValueError("API Reliability v6 receipts must be a list of objects") |
|
|
| events = snapshot["applied_boundary_events"] |
| if ( |
| not isinstance(events, list) |
| or any(not isinstance(event, str) for event in events) |
| or len(events) != len(set(events)) |
| or set(events) - {DRIFT_EVENT_ID} |
| ): |
| raise ValueError("API Reliability v6 boundary-event ledger is invalid") |
|
|
| policy_version = snapshot["policy_version"] |
| if policy_version not in _POLICY_VERSIONS: |
| raise ValueError("API Reliability v6 policy version is invalid") |
| if (DRIFT_EVENT_ID in events) != (policy_version == "recovery-policy-v2"): |
| raise ValueError("API Reliability v6 drift event and policy version disagree") |
|
|
| activated = snapshot["activated_tasks"] |
| if ( |
| not isinstance(activated, list) |
| or any(task_id not in TASK_IDS for task_id in activated) |
| or len(activated) != len(set(activated)) |
| or activated != list(TASK_IDS[: len(activated)]) |
| ): |
| raise ValueError("API Reliability v6 activated tasks must be one exact prefix") |
|
|
| active_task_id = snapshot["active_task_id"] |
| if active_task_id is not None and active_task_id not in TASK_IDS: |
| raise ValueError("API Reliability v6 active task is invalid") |
| if active_task_id is None: |
| if activated or snapshot["task_targets"]: |
| raise ValueError("API Reliability v6 inactive snapshot retains active task state") |
| elif not activated or activated[-1] != active_task_id: |
| raise ValueError("API Reliability v6 active task does not match the task prefix") |
|
|
| targets = snapshot["task_targets"] |
| if not isinstance(targets, list) or any(not isinstance(row, dict) for row in targets): |
| raise ValueError("API Reliability v6 task targets must be a list of objects") |
| expected_targets = [] if active_task_id is None else list(TARGETS[active_task_id]) |
| if targets != expected_targets: |
| raise ValueError("API Reliability v6 task targets do not match the active task") |
|
|
| receipt_start = snapshot["active_receipt_start"] |
| if ( |
| not _is_int(receipt_start) |
| or receipt_start < 0 |
| or receipt_start > len(receipts) |
| ): |
| raise ValueError("API Reliability v6 receipt boundary is invalid") |
|
|
| def _validate_receipts(snapshot: Mapping[str, Any]) -> None: |
| receipts = snapshot["receipts"] |
| activated = snapshot["activated_tasks"] |
| task_positions = {task_id: index for index, task_id in enumerate(activated)} |
| prior_position = -1 |
| saw_task_receipt = False |
|
|
| for expected_index, receipt in enumerate(receipts, 1): |
| if set(receipt) != _RECEIPT_FIELDS: |
| raise ValueError("API Reliability v8 receipt fields are malformed") |
| if not _is_int(receipt["index"]) or receipt["index"] != expected_index: |
| raise ValueError("API Reliability v8 receipt indices must be exact integers") |
| if not _is_int(receipt["cost"]) or receipt["cost"] < 0: |
| raise ValueError("API Reliability v8 receipt cost must be a non-negative integer") |
| if receipt["actor"] != _adapter.ROLE: |
| raise ValueError("API Reliability v8 receipt actor is invalid") |
| if receipt["tool"] not in _PUBLIC_TOOL_NAMES: |
| raise ValueError("API Reliability v8 receipt tool is invalid") |
| if not isinstance(receipt["arguments"], dict): |
| raise ValueError("API Reliability v8 receipt arguments must be an object") |
| if receipt["status"] not in {"success", "error"}: |
| raise ValueError("API Reliability v8 receipt status is invalid") |
| if any( |
| not isinstance(receipt[field], str) |
| or _HEX_SHA256.fullmatch(receipt[field]) is None |
| for field in ("before_hash", "after_business_hash") |
| ): |
| raise ValueError("API Reliability v8 receipt business hashes are invalid") |
|
|
| task_id = receipt["task_id"] |
| if task_id is None: |
| if saw_task_receipt: |
| raise ValueError("API Reliability v8 pre-task receipts must form a prefix") |
| continue |
| saw_task_receipt = True |
| if task_id not in task_positions: |
| raise ValueError("API Reliability v8 receipt references an unactivated task") |
| position = task_positions[task_id] |
| if position < prior_position: |
| raise ValueError("API Reliability v8 receipt task order is not monotonic") |
| prior_position = position |
|
|
| def _validate_capability_observations(snapshot: Mapping[str, Any]) -> None: |
| observations = snapshot["capability_observations"] |
| if not isinstance(observations, list): |
| raise ValueError("API Reliability v8 capability observations must be a list") |
| receipts = snapshot["receipts"] |
| activated = set(snapshot["activated_tasks"]) |
| allowed_signals = set(_policy.FAILURE_SIGNALS) |
| allowed_classes = set(_policy.OPERATION_CLASSES) |
| allowed_profiles = set(_policy.RECOVERY_PROFILES) |
|
|
| for observation in observations: |
| if not isinstance(observation, dict): |
| raise ValueError("API Reliability v8 capability observation must be an object") |
| kind = observation.get("kind") |
| if kind not in _OBSERVATION_FIELDS or set(observation) != _OBSERVATION_FIELDS[kind]: |
| raise ValueError("API Reliability v8 capability observation fields are malformed") |
| receipt_index = observation["receipt_index"] |
| if not _is_int(receipt_index) or not 1 <= receipt_index <= len(receipts): |
| raise ValueError("API Reliability v8 capability receipt index is invalid") |
| receipt = receipts[receipt_index - 1] |
| if ( |
| receipt["index"] != receipt_index |
| or receipt["tool"] != _OBSERVATION_TOOLS[kind] |
| or receipt["status"] != "success" |
| or receipt["task_id"] != observation["task_id"] |
| ): |
| raise ValueError("API Reliability v8 capability provenance is invalid") |
| task_id = observation["task_id"] |
| if task_id not in activated: |
| raise ValueError("API Reliability v8 capability observation is from the future") |
| visible_targets = [ |
| target |
| for prefix_task in TASK_IDS[: TASK_IDS.index(task_id) + 1] |
| for target in TARGETS[prefix_task] |
| ] |
|
|
| if kind == "credential": |
| if not _nonempty_text(observation["credential_id"]) or not _nonempty_text( |
| observation["integration_id"] |
| ): |
| raise ValueError("API Reliability v8 credential observation is malformed") |
| operations = observation["operations"] |
| if ( |
| not isinstance(operations, list) |
| or not operations |
| or any(not _nonempty_text(item) for item in operations) |
| or len(operations) != len(set(operations)) |
| ): |
| raise ValueError("API Reliability v8 credential operations are malformed") |
| if not any( |
| target["integration_id"] == observation["integration_id"] |
| for target in visible_targets |
| ): |
| raise ValueError("API Reliability v8 credential observation is from the future") |
| elif kind == "retry_budget": |
| if not _nonempty_text(observation["retry_budget_id"]) or not _nonempty_text( |
| observation["integration_id"] |
| ): |
| raise ValueError("API Reliability v8 retry-budget observation is malformed") |
| if not any( |
| target["integration_id"] == observation["integration_id"] |
| for target in visible_targets |
| ): |
| raise ValueError("API Reliability v8 retry-budget observation is from the future") |
| elif kind == "rate_bucket": |
| if any( |
| not _nonempty_text(observation[field]) |
| for field in ("rate_limit_bucket_id", "integration_id", "operation") |
| ): |
| raise ValueError("API Reliability v8 rate-bucket observation is malformed") |
| if not any( |
| target["integration_id"] == observation["integration_id"] |
| and target["operation"] == observation["operation"] |
| for target in visible_targets |
| ): |
| raise ValueError("API Reliability v8 rate-bucket observation is from the future") |
| else: |
| if ( |
| not _nonempty_text(observation["recovery_profile_id"]) |
| or observation["recovery_profile_id"] not in allowed_profiles |
| or observation["failure_signal"] not in allowed_signals |
| or observation["operation_class"] not in allowed_classes |
| ): |
| raise ValueError("API Reliability v8 recovery-profile observation is malformed") |
| if not any( |
| target["failure_signal"] == observation["failure_signal"] |
| and target["operation_class"] == observation["operation_class"] |
| for target in visible_targets |
| ): |
| raise ValueError("API Reliability v8 recovery-profile observation is from the future") |
|
|
| def validate_snapshot(snapshot: Any) -> None: |
| if not isinstance(snapshot, dict) or set(snapshot) != _SNAPSHOT_FIELDS: |
| raise ValueError("API Reliability v8 snapshot fields are incomplete or unexpected") |
| if snapshot["schema"] != SNAPSHOT_SCHEMA: |
| raise ValueError("unsupported API Reliability v8 snapshot schema") |
|
|
| inherited = deepcopy(snapshot) |
| inherited.pop("capability_observations") |
| _validate_business_state(inherited) |
| _validate_receipts(snapshot) |
| _validate_capability_observations(snapshot) |
| try: |
| _canonical(snapshot) |
| except (TypeError, ValueError) as error: |
| raise ValueError("API Reliability v8 snapshot is not canonical JSON") from error |
|
|
