feat: 实现 Sense Brain 控制连接器 (#152)
This commit is contained in:
@@ -0,0 +1,7 @@
|
||||
"""Credential-free Sense control-plane connector for Brain."""
|
||||
|
||||
from .consumer import ApplyResult, SourceConfigConsumer, SourceConfigError
|
||||
from .replay import SQLiteReplayStore
|
||||
from .status import RuntimeStatusPublisher
|
||||
|
||||
__all__ = ["ApplyResult", "SourceConfigConsumer", "SourceConfigError", "SQLiteReplayStore", "RuntimeStatusPublisher"]
|
||||
@@ -0,0 +1,57 @@
|
||||
"""Machine-authenticated adapters with bounded timeout/backoff and a kill switch."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import time
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from typing import Callable
|
||||
|
||||
from yovision_brain.integration.machine_identity.token import Signer, Verifier, bearer_token
|
||||
|
||||
from .consumer import ApplyResult, SourceConfigConsumer
|
||||
|
||||
_REQUEST_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{15,127}$")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ConnectorResponse:
|
||||
status: int
|
||||
body: bytes
|
||||
correlation_id: str
|
||||
|
||||
|
||||
class SourceConfigEndpoint:
|
||||
def __init__(self, consumer: SourceConfigConsumer, verifier: Verifier, *, enabled: bool = True, max_body_bytes: int = 10 * 1024 * 1024) -> None:
|
||||
self._consumer, self._verifier, self._enabled, self._max = consumer, verifier, enabled, max_body_bytes
|
||||
|
||||
def receive(self, authorization: str, body: bytes, correlation_id: str) -> ApplyResult:
|
||||
if not self._enabled: raise RuntimeError("CONNECTOR_DISABLED")
|
||||
if not _REQUEST_ID.fullmatch(correlation_id): raise ValueError("INVALID_CORRELATION_ID")
|
||||
if len(body) > self._max: raise ValueError("REQUEST_TOO_LARGE")
|
||||
token=bearer_token(authorization)
|
||||
self._verifier.verify(token,"yovision-brain","source-config:write","POST","/machine/v1/source-config",body)
|
||||
return self._consumer.apply(body)
|
||||
|
||||
|
||||
class StatusSender:
|
||||
def __init__(self, signer: Signer, send: Callable[[str, bytes, str, float], ConnectorResponse], *, enabled: bool = True, timeout_seconds: float = 5.0, max_attempts: int = 4, sleeper: Callable[[float], None] = time.sleep) -> None:
|
||||
if timeout_seconds <= 0 or max_attempts < 1: raise ValueError("invalid connector retry policy")
|
||||
self._signer,self._send,self._enabled,self._timeout,self._attempts,self._sleep=signer,send,enabled,timeout_seconds,max_attempts,sleeper
|
||||
|
||||
def publish(self, body: bytes, correlation_id: str) -> ConnectorResponse:
|
||||
if not self._enabled: raise RuntimeError("CONNECTOR_DISABLED")
|
||||
if not _REQUEST_ID.fullmatch(correlation_id): raise ValueError("INVALID_CORRELATION_ID")
|
||||
last: Exception|None=None
|
||||
for attempt in range(self._attempts):
|
||||
try:
|
||||
# A retry gets a fresh jti: the previous request may have been
|
||||
# accepted even when its response was lost.
|
||||
token=self._signer.mint("yovision-sense",("runtime-status:write",),"POST","/machine/v1/runtime-status",body)
|
||||
response=self._send("Bearer "+token,body,correlation_id,self._timeout)
|
||||
if 200<=response.status<300:return response
|
||||
if response.status<500:raise RuntimeError(f"STATUS_REJECTED_{response.status}")
|
||||
last=RuntimeError(f"STATUS_REMOTE_{response.status}")
|
||||
except (TimeoutError,ConnectionError) as exc:last=exc
|
||||
if attempt+1<self._attempts:self._sleep(min(2**attempt,30))
|
||||
raise RuntimeError("STATUS_DELIVERY_EXHAUSTED") from last
|
||||
@@ -0,0 +1,250 @@
|
||||
"""Strict source-config/v1 validation and atomic last-known-good application."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import re
|
||||
import sqlite3
|
||||
import threading
|
||||
import time
|
||||
from contextlib import closing
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Callable, Mapping
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
from yovision_brain.rules.models import AreaDefinition, DirectionalLineDefinition, NormalizedPoint, RuleSet
|
||||
|
||||
VERSION = "yovision.source-config/v1"
|
||||
_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._~-]{0,127}$")
|
||||
_EXTENSION_NAMESPACE = re.compile(r"^[A-Za-z][A-Za-z0-9.-]{0,127}$")
|
||||
_SECRET = re.compile(r"password|secret|credential|cookie|jwt|username|stream_uri", re.I)
|
||||
|
||||
|
||||
class SourceConfigError(ValueError):
|
||||
def __init__(self, code: str) -> None:
|
||||
super().__init__(code)
|
||||
self.code = code
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class AppliedConfig:
|
||||
config_id: str
|
||||
revision: int
|
||||
logical_device_id: str
|
||||
media_ref: str
|
||||
profile_encoding: str
|
||||
frame_rate: float
|
||||
rule_state: str
|
||||
rules: RuleSet | None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ApplyResult:
|
||||
config_id: str
|
||||
revision: int
|
||||
state: str
|
||||
config: AppliedConfig | None
|
||||
|
||||
|
||||
class SourceConfigConsumer:
|
||||
"""Persists validated snapshots before atomically changing the active pointer."""
|
||||
|
||||
def __init__(self, state_path: str | Path, *, clock: Callable[[], float] | None = None) -> None:
|
||||
self._path = str(state_path)
|
||||
self._clock = clock or time.time
|
||||
self._lock = threading.RLock()
|
||||
with closing(self._connect()) as connection:
|
||||
connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS source_snapshots (
|
||||
config_id TEXT NOT NULL, revision INTEGER NOT NULL, effective_at INTEGER NOT NULL,
|
||||
state TEXT NOT NULL, payload TEXT NOT NULL, PRIMARY KEY(config_id, revision));
|
||||
CREATE TABLE IF NOT EXISTS source_active (
|
||||
config_id TEXT PRIMARY KEY, revision INTEGER NOT NULL,
|
||||
FOREIGN KEY(config_id, revision) REFERENCES source_snapshots(config_id, revision));
|
||||
"""
|
||||
)
|
||||
connection.commit()
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(self._path, timeout=5)
|
||||
connection.execute("PRAGMA foreign_keys=ON")
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
return connection
|
||||
|
||||
def apply(self, body: bytes) -> ApplyResult:
|
||||
document = _parse_and_validate(body)
|
||||
config_id, revision = document["config_id"], document["revision"]
|
||||
mapped = _map(document)
|
||||
effective_at = int(_timestamp(document["effective_at"]))
|
||||
with self._lock, closing(self._connect()) as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
latest = connection.execute(
|
||||
"SELECT revision, payload, state, effective_at FROM source_snapshots WHERE config_id=? ORDER BY revision DESC LIMIT 1",
|
||||
(config_id,),
|
||||
).fetchone()
|
||||
if latest and revision < latest[0]:
|
||||
connection.rollback()
|
||||
raise SourceConfigError("STALE_REVISION")
|
||||
canonical = body.decode("utf-8")
|
||||
if latest and revision == latest[0]:
|
||||
if json.loads(latest[1]) != document:
|
||||
connection.rollback()
|
||||
raise SourceConfigError("REVISION_CONFLICT")
|
||||
connection.rollback()
|
||||
return ApplyResult(config_id, revision, "idempotent", self.get_active(config_id))
|
||||
connection.execute(
|
||||
"INSERT INTO source_snapshots(config_id, revision, effective_at, state, payload) VALUES (?, ?, ?, ?, ?)",
|
||||
(config_id, revision, effective_at, document["rule_set"]["state"], canonical),
|
||||
)
|
||||
if effective_at <= int(self._clock()):
|
||||
connection.execute(
|
||||
"INSERT INTO source_active(config_id, revision) VALUES (?, ?) ON CONFLICT(config_id) DO UPDATE SET revision=excluded.revision",
|
||||
(config_id, revision),
|
||||
)
|
||||
state = "applied"
|
||||
else:
|
||||
state = "scheduled"
|
||||
connection.commit()
|
||||
return ApplyResult(config_id, revision, state, mapped if state == "applied" else self.get_active(config_id))
|
||||
|
||||
def activate_due(self) -> tuple[AppliedConfig, ...]:
|
||||
now = int(self._clock())
|
||||
activated: list[AppliedConfig] = []
|
||||
with self._lock, closing(self._connect()) as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
rows = connection.execute(
|
||||
"SELECT s.payload FROM source_snapshots s JOIN (SELECT config_id, MAX(revision) revision FROM source_snapshots WHERE effective_at<=? GROUP BY config_id) d ON d.config_id=s.config_id AND d.revision=s.revision",
|
||||
(now,),
|
||||
).fetchall()
|
||||
for (payload,) in rows:
|
||||
document = json.loads(payload)
|
||||
connection.execute(
|
||||
"INSERT INTO source_active(config_id, revision) VALUES (?, ?) ON CONFLICT(config_id) DO UPDATE SET revision=excluded.revision",
|
||||
(document["config_id"], document["revision"]),
|
||||
)
|
||||
activated.append(_map(document))
|
||||
connection.commit()
|
||||
return tuple(activated)
|
||||
|
||||
def get_active(self, config_id: str) -> AppliedConfig | None:
|
||||
with closing(self._connect()) as connection:
|
||||
row = connection.execute(
|
||||
"SELECT s.payload FROM source_active a JOIN source_snapshots s ON s.config_id=a.config_id AND s.revision=a.revision WHERE a.config_id=?",
|
||||
(config_id,),
|
||||
).fetchone()
|
||||
return _map(json.loads(row[0])) if row else None
|
||||
|
||||
|
||||
def _parse_and_validate(body: bytes) -> dict[str, object]:
|
||||
try:
|
||||
document = json.loads(body.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError):
|
||||
raise SourceConfigError("CONFIG_INVALID") from None
|
||||
if not isinstance(document, dict):
|
||||
raise SourceConfigError("CONFIG_INVALID")
|
||||
if document.get("schema_version") != VERSION:
|
||||
raise SourceConfigError("UNSUPPORTED_SCHEMA_VERSION")
|
||||
if _contains_secret(document):
|
||||
raise SourceConfigError("CONFIG_INVALID")
|
||||
required = {"schema_version", "config_id", "revision", "published_at", "effective_at", "site", "logical_device", "profile", "media", "rule_set", "integrity"}
|
||||
if set(document) - (required | {"extensions"}) or not required <= set(document):
|
||||
raise SourceConfigError("CONFIG_INVALID")
|
||||
extensions = document.get("extensions", {})
|
||||
if not isinstance(extensions, dict) or any(
|
||||
not isinstance(namespace, str)
|
||||
or not _EXTENSION_NAMESPACE.fullmatch(namespace)
|
||||
or not isinstance(value, dict)
|
||||
for namespace, value in extensions.items()
|
||||
):
|
||||
raise SourceConfigError("CONFIG_INVALID")
|
||||
integrity = document.get("integrity")
|
||||
if not isinstance(integrity, dict) or set(integrity) != {"algorithm", "value"} or integrity.get("algorithm") != "sha256":
|
||||
raise SourceConfigError("CONFIG_INVALID")
|
||||
unsigned = dict(document); unsigned.pop("integrity")
|
||||
digest = hashlib.sha256(json.dumps(unsigned, ensure_ascii=False, separators=(",", ":"), sort_keys=True).encode()).hexdigest()
|
||||
if not hmac.compare_digest(digest, str(integrity.get("value", ""))):
|
||||
raise SourceConfigError("CONFIG_INVALID")
|
||||
try:
|
||||
if not _ID.fullmatch(document["config_id"]) or isinstance(document["revision"], bool) or document["revision"] < 1:
|
||||
raise ValueError
|
||||
published, effective = _timestamp(document["published_at"]), _timestamp(document["effective_at"])
|
||||
if effective < published:
|
||||
raise ValueError
|
||||
for field in ("site", "logical_device"):
|
||||
if not isinstance(document[field], dict) or set(document[field]) != {"id"} or not _ID.fullmatch(document[field]["id"]): raise ValueError
|
||||
_validate_profile(document["profile"])
|
||||
media = document["media"]
|
||||
if not isinstance(media, dict) or set(media) != {"ref", "transport"} or media["transport"] != "rtsp" or not isinstance(media["ref"], str) or not media["ref"].startswith("media:") or any(marker in media["ref"] for marker in ("?", "#", "@", "\\", "://")): raise ValueError
|
||||
_validate_rules(document["rule_set"], document["profile"])
|
||||
except (KeyError, TypeError, ValueError, AttributeError):
|
||||
raise SourceConfigError("CONFIG_INVALID") from None
|
||||
return document
|
||||
|
||||
|
||||
def _validate_profile(profile: object) -> None:
|
||||
if not isinstance(profile, dict) or set(profile) != {"id", "width", "height", "encoding", "frame_rate"}: raise ValueError
|
||||
if not _ID.fullmatch(profile["id"]) or profile["encoding"] not in {"H264", "H265", "MJPEG"}: raise ValueError
|
||||
for field in ("width", "height"):
|
||||
if isinstance(profile[field], bool) or not isinstance(profile[field], int) or profile[field] < 1: raise ValueError
|
||||
if isinstance(profile["frame_rate"], bool) or not isinstance(profile["frame_rate"], (int, float)) or profile["frame_rate"] <= 0: raise ValueError
|
||||
|
||||
|
||||
def _validate_rules(rules: object, profile: Mapping[str, object]) -> None:
|
||||
if not isinstance(rules, dict) or set(rules) != {"version", "state", "profile_binding", "areas", "directional_lines"}: raise ValueError
|
||||
if not _ID.fullmatch(rules["version"]) or rules["state"] not in {"active", "disabled", "recalibration_required"}: raise ValueError
|
||||
binding = rules["profile_binding"]
|
||||
if binding != {"profile_id": profile["id"], "width": profile["width"], "height": profile["height"]}: raise ValueError
|
||||
if not isinstance(rules["areas"], list) or not isinstance(rules["directional_lines"], list) or len(rules["areas"]) > 1024 or len(rules["directional_lines"]) > 1024: raise ValueError
|
||||
identifiers: set[str] = set()
|
||||
for area in rules["areas"]:
|
||||
if not isinstance(area, dict) or set(area) != {"id", "version", "kind", "enabled", "points"} or area["kind"] != "danger_area" or not isinstance(area["enabled"], bool) or not 3 <= len(area["points"]) <= 256: raise ValueError
|
||||
_rule_identity(area, identifiers); points = tuple(_point(value) for value in area["points"])
|
||||
polygon = sum(a[0]*b[1]-b[0]*a[1] for a,b in zip(points, points[1:]+points[:1])) / 2
|
||||
if abs(polygon) < 1e-9: raise ValueError
|
||||
for line in rules["directional_lines"]:
|
||||
if not isinstance(line, dict) or set(line) != {"id", "version", "kind", "enabled", "start", "end", "trigger_direction"} or line["kind"] != "directional_line" or not isinstance(line["enabled"], bool) or line["trigger_direction"] not in {"left_to_right", "right_to_left"}: raise ValueError
|
||||
_rule_identity(line, identifiers)
|
||||
if _point(line["start"]) == _point(line["end"]): raise ValueError
|
||||
|
||||
|
||||
def _rule_identity(rule: Mapping[str, object], identifiers: set[str]) -> None:
|
||||
if not isinstance(rule["id"], str) or not _ID.fullmatch(rule["id"]) or rule["id"] in identifiers or isinstance(rule["version"], bool) or not isinstance(rule["version"], int) or rule["version"] < 1: raise ValueError
|
||||
identifiers.add(rule["id"])
|
||||
|
||||
|
||||
def _point(value: object) -> tuple[float, float]:
|
||||
if not isinstance(value, dict) or set(value) != {"x", "y"}: raise ValueError
|
||||
x, y = value["x"], value["y"]
|
||||
if isinstance(x, bool) or isinstance(y, bool) or not isinstance(x, (int,float)) or not isinstance(y,(int,float)) or not 0 <= x <= 1 or not 0 <= y <= 1: raise ValueError
|
||||
return float(x), float(y)
|
||||
|
||||
|
||||
def _map(document: Mapping[str, object]) -> AppliedConfig:
|
||||
profile, rules = document["profile"], document["rule_set"]
|
||||
rule_set = None
|
||||
if rules["state"] == "active":
|
||||
rule_set = RuleSet(
|
||||
version=rules["version"], profile_id=profile["id"], width=profile["width"], height=profile["height"],
|
||||
areas=tuple(AreaDefinition(a["id"], tuple(NormalizedPoint(**p) for p in a["points"])) for a in rules["areas"] if a["enabled"]),
|
||||
directional_lines=tuple(DirectionalLineDefinition(l["id"], NormalizedPoint(**l["start"]), NormalizedPoint(**l["end"]), l["trigger_direction"]) for l in rules["directional_lines"] if l["enabled"]),
|
||||
)
|
||||
return AppliedConfig(document["config_id"], document["revision"], document["logical_device"]["id"], document["media"]["ref"], profile["encoding"], float(profile["frame_rate"]), rules["state"], rule_set)
|
||||
|
||||
|
||||
def _timestamp(value: object) -> float:
|
||||
if not isinstance(value, str) or not value.endswith("Z"): raise ValueError
|
||||
return datetime.fromisoformat(value[:-1] + "+00:00").astimezone(timezone.utc).timestamp()
|
||||
|
||||
|
||||
def _contains_secret(value: object) -> bool:
|
||||
if isinstance(value, dict): return any(_SECRET.search(str(k)) or _contains_secret(v) for k,v in value.items())
|
||||
if isinstance(value, list): return any(_contains_secret(item) for item in value)
|
||||
if isinstance(value, str):
|
||||
split=urlsplit(value)
|
||||
return bool(split.username or split.password or value.startswith("file:") or re.match(r"^[A-Za-z]:[\\/]", value))
|
||||
return False
|
||||
@@ -0,0 +1,44 @@
|
||||
"""Brain-owned durable replay storage; never shared with Sense or Bell."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sqlite3
|
||||
import threading
|
||||
from contextlib import closing
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class SQLiteReplayStore:
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self._path = str(path)
|
||||
self._lock = threading.Lock()
|
||||
with closing(self._connect()) as connection:
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute(
|
||||
"CREATE TABLE IF NOT EXISTS machine_replay (principal TEXT NOT NULL, token_id TEXT NOT NULL, expires_at INTEGER NOT NULL, PRIMARY KEY(principal, token_id))"
|
||||
)
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(self._path, timeout=5, isolation_level=None)
|
||||
connection.execute("PRAGMA busy_timeout=5000")
|
||||
return connection
|
||||
|
||||
def consume(self, principal: str, token_id: str, expires_at: int, now: int) -> bool:
|
||||
if not principal or not token_id or expires_at <= now:
|
||||
return False
|
||||
with self._lock, closing(self._connect()) as connection:
|
||||
try:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
connection.execute("DELETE FROM machine_replay WHERE expires_at <= ?", (now,))
|
||||
connection.execute(
|
||||
"INSERT INTO machine_replay(principal, token_id, expires_at) VALUES (?, ?, ?)",
|
||||
(principal, token_id, expires_at),
|
||||
)
|
||||
connection.execute("COMMIT")
|
||||
return True
|
||||
except sqlite3.IntegrityError:
|
||||
connection.execute("ROLLBACK")
|
||||
return False
|
||||
except Exception:
|
||||
connection.execute("ROLLBACK")
|
||||
return False
|
||||
@@ -0,0 +1,77 @@
|
||||
"""Persistent sequence allocation and safe runtime-status/v1 production."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sqlite3
|
||||
import threading
|
||||
import uuid
|
||||
from contextlib import closing
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Mapping, Sequence
|
||||
|
||||
_LOGICAL_REF = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$")
|
||||
_VERSION = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$")
|
||||
_ERROR_CODE = re.compile(r"^[A-Z][A-Z0-9_]{2,63}$")
|
||||
_RUNTIME_STATES = {"unconfigured", "starting", "running", "degraded", "failed", "stopped"}
|
||||
|
||||
|
||||
class RuntimeStatusPublisher:
|
||||
def __init__(self, state_path: str | Path, brain_instance_ref: str) -> None:
|
||||
self._path, self._instance, self._lock = str(state_path), brain_instance_ref, threading.Lock()
|
||||
with closing(self._connect()) as connection:
|
||||
connection.execute("CREATE TABLE IF NOT EXISTS runtime_sequence(instance_ref TEXT PRIMARY KEY, sequence INTEGER NOT NULL)")
|
||||
connection.commit()
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
return sqlite3.connect(self._path, timeout=5)
|
||||
|
||||
def build(self, *, runtime_state: str, runtime_version: str, started_at: datetime | None, model_ref: str, model_version: str, configurations: Sequence[Mapping[str, object]], health: Mapping[str, object], inputs: Sequence[Mapping[str, object]], observed_at: datetime | None = None) -> bytes:
|
||||
_validate(runtime_state, runtime_version, self._instance, model_ref, model_version, configurations, health, inputs)
|
||||
with self._lock, closing(self._connect()) as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
row=connection.execute("SELECT sequence FROM runtime_sequence WHERE instance_ref=?",(self._instance,)).fetchone();sequence=(row[0]+1) if row else 0
|
||||
connection.execute("INSERT INTO runtime_sequence(instance_ref,sequence) VALUES(?,?) ON CONFLICT(instance_ref) DO UPDATE SET sequence=excluded.sequence",(self._instance,sequence));connection.commit()
|
||||
observed=(observed_at or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
document={"schema_version":"yovision.runtime-status/v1","status_id":str(uuid.uuid4()),"brain_instance_ref":self._instance,"sequence":sequence,"observed_at":_utc(observed),"runtime":{"state":runtime_state,"version":runtime_version,"started_at":_utc(started_at) if started_at else None},"model":{"model_ref":model_ref,"version":model_version},"configurations":list(configurations),"health":dict(health),"inputs":list(inputs)}
|
||||
raw=json.dumps(document,separators=(",",":"),sort_keys=True).encode()
|
||||
lowered=raw.lower();
|
||||
for marker in (b"password",b"credential",b"stream_uri",b"cookie",b"jwt",b"file://"):
|
||||
if marker in lowered: raise ValueError("runtime status contains sensitive field")
|
||||
return raw
|
||||
|
||||
|
||||
def _utc(value: datetime) -> str:
|
||||
if value.tzinfo is None: raise ValueError("runtime timestamp must be timezone-aware")
|
||||
return value.astimezone(timezone.utc).isoformat(timespec="seconds").replace("+00:00","Z")
|
||||
|
||||
|
||||
def _validate(runtime_state: str, runtime_version: str, instance: str, model_ref: str, model_version: str, configurations: Sequence[Mapping[str, object]], health: Mapping[str, object], inputs: Sequence[Mapping[str, object]]) -> None:
|
||||
if runtime_state not in _RUNTIME_STATES or not _VERSION.fullmatch(runtime_version) or not _LOGICAL_REF.fullmatch(instance) or not _LOGICAL_REF.fullmatch(model_ref) or not _VERSION.fullmatch(model_version):
|
||||
raise ValueError("invalid runtime identity or version")
|
||||
if len(configurations) > 4096 or len(inputs) > 4096:
|
||||
raise ValueError("runtime status collection too large")
|
||||
seen: set[str] = set()
|
||||
for item in configurations:
|
||||
if set(item) != {"config_id", "apply_state", "applied_revision", "error_code"} or not isinstance(item["config_id"], str) or not _LOGICAL_REF.fullmatch(item["config_id"]) or item["config_id"] in seen:
|
||||
raise ValueError("invalid configuration status")
|
||||
seen.add(item["config_id"]); state=item["apply_state"]; revision=item["applied_revision"]; error=item["error_code"]
|
||||
if state not in {"not_configured","applying","applied","rejected"} or (state=="not_configured" and revision is not None) or (state=="applied" and (isinstance(revision,bool) or not isinstance(revision,int) or revision<1)) or (state=="rejected" and (not isinstance(error,str) or not _ERROR_CODE.fullmatch(error))):
|
||||
raise ValueError("invalid configuration status")
|
||||
if set(health) != {"overall","error_codes","metrics"} or health["overall"] not in {"healthy","degraded","unhealthy"} or not _codes(health["error_codes"],32) or not _metrics(health["metrics"]):
|
||||
raise ValueError("invalid health status")
|
||||
for item in inputs:
|
||||
if set(item) != {"input_ref","state","error_codes","metrics"} or not isinstance(item["input_ref"],str) or not _LOGICAL_REF.fullmatch(item["input_ref"]) or item["state"] not in _RUNTIME_STATES or not _codes(item["error_codes"],16) or not _metrics(item["metrics"]):
|
||||
raise ValueError("invalid input status")
|
||||
|
||||
|
||||
def _codes(value: object, limit: int) -> bool:
|
||||
return isinstance(value,list) and len(value)<=limit and len(set(value))==len(value) and all(isinstance(code,str) and _ERROR_CODE.fullmatch(code) for code in value)
|
||||
|
||||
|
||||
def _metrics(value: object) -> bool:
|
||||
if not isinstance(value,Mapping) or set(value)!={"load_percent","queue_depth","latency_ms"}: return False
|
||||
load,queue,latency=value["load_percent"],value["queue_depth"],value["latency_ms"]
|
||||
return not isinstance(load,bool) and isinstance(load,(int,float)) and 0<=load<=100 and not isinstance(queue,bool) and isinstance(queue,int) and queue>=0 and not isinstance(latency,bool) and isinstance(latency,(int,float)) and latency>=0
|
||||
@@ -0,0 +1,101 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import threading
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import pytest
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
|
||||
|
||||
from yovision_brain.integration.machine_identity.token import KeyRecord, Registry, Signer, Verifier
|
||||
from yovision_brain.integration.sense_control.connector import ConnectorResponse, SourceConfigEndpoint, StatusSender
|
||||
from yovision_brain.integration.sense_control.consumer import SourceConfigConsumer, SourceConfigError
|
||||
from yovision_brain.integration.sense_control.replay import SQLiteReplayStore
|
||||
from yovision_brain.integration.sense_control.status import RuntimeStatusPublisher
|
||||
|
||||
|
||||
def source_document(revision: int = 1, *, state: str = "active", effective: int = 0) -> bytes:
|
||||
now=datetime(2026,8,31,tzinfo=timezone.utc)
|
||||
document={"schema_version":"yovision.source-config/v1","config_id":"gate-primary","revision":revision,"published_at":now.isoformat().replace("+00:00","Z"),"effective_at":(now+timedelta(seconds=effective)).isoformat().replace("+00:00","Z"),"site":{"id":"site-east"},"logical_device":{"id":"camera-1"},"profile":{"id":"main","width":1920,"height":1080,"encoding":"H264","frame_rate":25},"media":{"ref":"media:site-east/camera-1/main","transport":"rtsp"},"rule_set":{"version":f"rules-{revision}","state":state,"profile_binding":{"profile_id":"main","width":1920,"height":1080},"areas":[{"id":"danger","version":1,"kind":"danger_area","enabled":True,"points":[{"x":.1,"y":.1},{"x":.8,"y":.1},{"x":.5,"y":.8}]}],"directional_lines":[]}}
|
||||
digest=hashlib.sha256(json.dumps(document,separators=(",",":"),sort_keys=True).encode()).hexdigest();document["integrity"]={"algorithm":"sha256","value":digest}
|
||||
return json.dumps(document,separators=(",",":"),sort_keys=True).encode()
|
||||
|
||||
|
||||
def with_extension(body: bytes, extensions: object) -> bytes:
|
||||
document=json.loads(body);document["extensions"]=extensions;unsigned=dict(document);unsigned.pop("integrity");document["integrity"]["value"]=hashlib.sha256(json.dumps(unsigned,separators=(",",":"),sort_keys=True).encode()).hexdigest();return json.dumps(document,separators=(",",":"),sort_keys=True).encode()
|
||||
|
||||
|
||||
def identity(tmp_path, now: int):
|
||||
private=Ed25519PrivateKey.generate();signer=Signer("yv:sense:east","sense-key-01",private,clock=lambda:now)
|
||||
registry=Registry([KeyRecord("yv:sense:east","sense-key-01",private.public_key(),"yovision-brain",frozenset({"source-config:write"}))])
|
||||
replay=SQLiteReplayStore(tmp_path/"replay.sqlite")
|
||||
return signer,Verifier(registry,replay,clock=lambda:now)
|
||||
|
||||
|
||||
def test_authenticated_apply_is_idempotent_and_replay_survives_restart(tmp_path):
|
||||
now=int(datetime(2026,8,31,tzinfo=timezone.utc).timestamp());signer,verifier=identity(tmp_path,now);body=source_document();consumer=SourceConfigConsumer(tmp_path/"state.sqlite",clock=lambda:now);endpoint=SourceConfigEndpoint(consumer,verifier)
|
||||
token=signer.mint("yovision-brain",("source-config:write",),"POST","/machine/v1/source-config",body)
|
||||
result=endpoint.receive("Bearer "+token,body,"corr-request-0001");assert result.state=="applied" and result.config.rules is not None
|
||||
with pytest.raises(ValueError,match="machine_token_replayed"):endpoint.receive("Bearer "+token,body,"corr-request-0001")
|
||||
restarted=SourceConfigEndpoint(SourceConfigConsumer(tmp_path/"state.sqlite",clock=lambda:now),Verifier(verifier._registry,SQLiteReplayStore(tmp_path/"replay.sqlite"),clock=lambda:now))
|
||||
with pytest.raises(ValueError,match="machine_token_replayed"):restarted.receive("Bearer "+token,body,"corr-request-0002")
|
||||
new_token=signer.mint("yovision-brain",("source-config:write",),"POST","/machine/v1/source-config",body);assert restarted.receive("Bearer "+new_token,body,"corr-request-0003").state=="idempotent"
|
||||
|
||||
|
||||
def test_atomic_replay_accepts_once_under_concurrency(tmp_path):
|
||||
store=SQLiteReplayStore(tmp_path/"atomic.sqlite");results=[]
|
||||
threads=[threading.Thread(target=lambda:results.append(store.consume("yv:sense:east","token-id",200,100))) for _ in range(12)]
|
||||
for thread in threads:thread.start()
|
||||
for thread in threads:thread.join()
|
||||
assert results.count(True)==1
|
||||
|
||||
|
||||
def test_stale_unknown_profile_and_recalibration_are_safe(tmp_path):
|
||||
now=int(datetime(2026,8,31,tzinfo=timezone.utc).timestamp());consumer=SourceConfigConsumer(tmp_path/"state.sqlite",clock=lambda:now)
|
||||
assert consumer.apply(source_document(2)).config.rules is not None
|
||||
with pytest.raises(SourceConfigError,match="STALE_REVISION"):consumer.apply(source_document(1))
|
||||
invalid=json.loads(source_document(3));invalid["profile"]["width"]=1280;invalid["integrity"]["value"]="0"*64
|
||||
with pytest.raises(SourceConfigError,match="CONFIG_INVALID"):consumer.apply(json.dumps(invalid).encode())
|
||||
unknown=json.loads(source_document(3));unknown["schema_version"]="yovision.source-config/v2"
|
||||
with pytest.raises(SourceConfigError,match="UNSUPPORTED_SCHEMA_VERSION"):consumer.apply(json.dumps(unknown).encode())
|
||||
safe=consumer.apply(source_document(3,state="recalibration_required"));assert safe.config.rule_state=="recalibration_required" and safe.config.rules is None
|
||||
|
||||
|
||||
def test_future_effective_snapshot_activates_atomically_after_restart(tmp_path):
|
||||
base=int(datetime(2026,8,31,tzinfo=timezone.utc).timestamp());current=[base];path=tmp_path/"state.sqlite";consumer=SourceConfigConsumer(path,clock=lambda:current[0])
|
||||
assert consumer.apply(source_document(1)).state=="applied";scheduled=consumer.apply(source_document(2,effective=60));assert scheduled.state=="scheduled" and scheduled.config.revision==1
|
||||
current[0]+=61;restarted=SourceConfigConsumer(path,clock=lambda:current[0]);activated=restarted.activate_due();assert activated[0].revision==2 and restarted.get_active("gate-primary").revision==2
|
||||
|
||||
|
||||
def test_unknown_valid_extension_namespace_is_ignored(tmp_path):
|
||||
now=int(datetime(2026,8,31,tzinfo=timezone.utc).timestamp());consumer=SourceConfigConsumer(tmp_path/"state.sqlite",clock=lambda:now)
|
||||
result=consumer.apply(with_extension(source_document(),{"vendor.example":{"feature":"safe"}}));assert result.state=="applied" and result.config.revision==1
|
||||
|
||||
|
||||
@pytest.mark.parametrize("extensions", [[], {"1invalid":{}}, {"vendor_ok":{}}, {"vendor.example":"not-an-object"}])
|
||||
def test_invalid_extensions_are_rejected(tmp_path, extensions):
|
||||
now=int(datetime(2026,8,31,tzinfo=timezone.utc).timestamp());consumer=SourceConfigConsumer(tmp_path/"state.sqlite",clock=lambda:now)
|
||||
with pytest.raises(SourceConfigError,match="CONFIG_INVALID"):consumer.apply(with_extension(source_document(),extensions))
|
||||
|
||||
|
||||
def test_status_sequence_restart_retry_timeout_and_disable(tmp_path):
|
||||
path=tmp_path/"status.sqlite";publisher=RuntimeStatusPublisher(path,"brain-east-01");health={"overall":"healthy","error_codes":[],"metrics":{"load_percent":1.0,"queue_depth":0,"latency_ms":2.0}}
|
||||
one=json.loads(publisher.build(runtime_state="running",runtime_version="1.0.0",started_at=datetime.now(timezone.utc),model_ref="people-detection",model_version="1",configurations=[],health=health,inputs=[]));two=json.loads(RuntimeStatusPublisher(path,"brain-east-01").build(runtime_state="running",runtime_version="1.0.0",started_at=None,model_ref="people-detection",model_version="1",configurations=[],health=health,inputs=[]));assert (one["sequence"],two["sequence"])==(0,1)
|
||||
private=Ed25519PrivateKey.generate();signer=Signer("yv:brain:east","brain-key-01",private,clock=lambda:1_787_000_000);attempts=[]
|
||||
def send(_auth,_body,_corr,timeout):attempts.append(timeout);raise TimeoutError
|
||||
sender=StatusSender(signer,send,max_attempts=3,sleeper=lambda _:None)
|
||||
with pytest.raises(RuntimeError,match="STATUS_DELIVERY_EXHAUSTED"):sender.publish(b"{}","corr-request-0001")
|
||||
assert attempts==[5.0,5.0,5.0]
|
||||
disabled=StatusSender(signer,lambda *_:ConnectorResponse(204,b"","corr-request-0001"),enabled=False)
|
||||
with pytest.raises(RuntimeError,match="CONNECTOR_DISABLED"):disabled.publish(b"{}","corr-request-0001")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("request_id", ["short", "0123456789abcde\n", "0123456789abcde!", "a"*129])
|
||||
def test_connector_rejects_unsafe_request_ids(tmp_path, request_id):
|
||||
now=int(datetime(2026,8,31,tzinfo=timezone.utc).timestamp());signer,verifier=identity(tmp_path,now);body=source_document();endpoint=SourceConfigEndpoint(SourceConfigConsumer(tmp_path/"state.sqlite",clock=lambda:now),verifier)
|
||||
token=signer.mint("yovision-brain",("source-config:write",),"POST","/machine/v1/source-config",body)
|
||||
with pytest.raises(ValueError,match="INVALID_CORRELATION_ID"):endpoint.receive("Bearer "+token,body,request_id)
|
||||
status_signer=Signer("yv:brain:east","brain-key-01",Ed25519PrivateKey.generate(),clock=lambda:now)
|
||||
sender=StatusSender(status_signer,lambda *_:ConnectorResponse(204,b"",request_id))
|
||||
with pytest.raises(ValueError,match="INVALID_CORRELATION_ID"):sender.publish(b"{}",request_id)
|
||||
Reference in New Issue
Block a user