onec-interactive-runtime-core 0.1.19__py3-none-any.whl

onec_runtime/recovery.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from uuid import UUID
+
+from onec_runtime.errors import RecoveryIdentityMismatch
+from onec_runtime.rdbg.models import DebugTarget, ModuleLocation, StopEvent
+
+
+class RecoveryPhase(str, Enum):
+    CAPTURED = "captured"
+    FLUSHING = "flushing"
+    RESUMING = "resuming"
+
+
+class RecoveryOutcome(str, Enum):
+    RECOVERED = "recovered"
+    LOST = "lost"
+
+
+class SideEffectStatus(str, Enum):
+    PLANNED = "planned"
+    SENT = "sent"
+    ACKNOWLEDGED = "acknowledged"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    OUTCOME_UNKNOWN = "outcome_unknown"
+
+
+@dataclass(frozen=True, slots=True)
+class RootWriteRecord:
+    sequence: int
+    root: str
+    expression_sha256: str
+    status: SideEffectStatus
+    result_id: UUID | None
+    error: str = ""
+
+    @property
+    def replay_forbidden(self) -> bool:
+        return self.status in {
+            SideEffectStatus.ACKNOWLEDGED,
+            SideEffectStatus.SUCCEEDED,
+            SideEffectStatus.FAILED,
+            SideEffectStatus.OUTCOME_UNKNOWN,
+        }
+
+    @property
+    def succeeded(self) -> bool:
+        return self.status is SideEffectStatus.SUCCEEDED
+
+
+@dataclass(frozen=True, slots=True)
+class RecoveryCheckpoint:
+    sequence: int
+    runtime_generation: int
+    operation_id: int
+    phase: RecoveryPhase
+    target: DebugTarget
+    frame_location: ModuleLocation | None
+    stop_sequence: int
+    breakpoint_workspace: tuple[ModuleLocation, ...]
+    write_journal: tuple[RootWriteRecord, ...]
+    continue_sent: bool
+
+
+@dataclass(frozen=True, slots=True)
+class RecoveryIdentityEvidence:
+    target: DebugTarget
+    stop: StopEvent
+
+
+@dataclass(frozen=True, slots=True)
+class RecoveryResult:
+    outcome: RecoveryOutcome
+    phase: RecoveryPhase
+    checkpoint: RecoveryCheckpoint
+    reason: str
+    continuation: object | None = None
+
+
+def is_paused_target_state(state: str) -> bool:
+    return state.casefold() in {"stopped", "stoponnextline"}
+
+
+def validate_paused_identity(
+    checkpoint: RecoveryCheckpoint,
+    evidence: RecoveryIdentityEvidence,
+) -> None:
+    if evidence.target.target_id != checkpoint.target.target_id:
+        raise RecoveryIdentityMismatch("Recovered target identity changed")
+    if evidence.target.target_type != checkpoint.target.target_type:
+        raise RecoveryIdentityMismatch("Recovered target type changed")
+    if not is_paused_target_state(evidence.target.state):
+        raise RecoveryIdentityMismatch("Recovered target is not stopped")
+    if (
+        checkpoint.target.state_number is not None
+        and evidence.target.state_number is not None
+        and evidence.target.state_number != checkpoint.target.state_number
+    ):
+        raise RecoveryIdentityMismatch("Recovered target state number changed")
+    if checkpoint.frame_location is None:
+        raise RecoveryIdentityMismatch("Checkpoint has no frame-zero location")
+    if evidence.stop.location != checkpoint.frame_location:
+        raise RecoveryIdentityMismatch("Recovered frame-zero location changed")

onec_runtime/recovery_journal.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from threading import Lock
+from typing import Callable
+
+from onec_runtime.privacy import public_artifact_value
+
+
+AppendJsonl = Callable[[str, object], None]
+
+
+@dataclass(frozen=True, slots=True)
+class JournalEvent:
+    sequence: int
+    timestamp: str
+    stream: str
+    event: str
+    fields: dict[str, object]
+
+    def as_json(self) -> dict[str, object]:
+        return {
+            "sequence": self.sequence,
+            "timestamp": self.timestamp,
+            "event": self.event,
+            **self.fields,
+        }
+
+
+class RecoveryJournal:
+    def __init__(self, sink: AppendJsonl | None = None) -> None:
+        self._sink = sink
+        self._lock = Lock()
+        # Serialize the complete snapshot -> sink -> retire loop without
+        # holding the state lock across user I/O.  ``record`` may therefore be
+        # called by another thread (or by the sink itself), while recursive
+        # ``flush`` from the sink is deliberately unsupported.
+        self._flush_lock = Lock()
+        self._events: list[JournalEvent] = []
+        self._pending: list[JournalEvent] = []
+
+    @property
+    def events(self) -> tuple[JournalEvent, ...]:
+        return tuple(self._events)
+
+    @property
+    def pending_count(self) -> int:
+        return len(self._pending)
+
+    def record(self, stream: str, event: str, **fields: object) -> JournalEvent:
+        normalized = {key: public_artifact_value(value) for key, value in fields.items()}
+        with self._lock:
+            item = JournalEvent(
+                sequence=len(self._events) + 1,
+                timestamp=datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
+                stream=stream,
+                event=event,
+                fields=normalized,
+            )
+            self._events.append(item)
+            self._pending.append(item)
+            return item
+
+    def flush(self) -> None:
+        with self._flush_lock:
+            with self._lock:
+                pending = tuple(self._pending)
+            if self._sink is None:
+                with self._lock:
+                    del self._pending[: len(pending)]
+                return
+            for item in pending:
+                self._sink(item.stream, item.as_json())
+                with self._lock:
+                    # Concurrent records append after this snapshot; retire
+                    # only the committed prefix and never a later append.
+                    if self._pending and self._pending[0] is item:
+                        del self._pending[0]

onec_runtime/resources/extension/extension-manifest.json

@@ -0,0 +1,108 @@
+{
+  "schema_version": 1,
+  "product_id": "onec-interactive-runtime",
+  "extension_name": "OnecInteractiveRuntime",
+  "artifact_version": "0.1.2",
+  "protocol_version": "1",
+  "cfe_filename": "OnecInteractiveRuntime.cfe",
+  "cfe_size": 20556,
+  "cfe_sha256": "d052016b6f95540de0a498c191506217ef2b5b70f8ac4992cb821322e92aa06c",
+  "fingerprints": {
+    "identity": {
+      "product_id": "onec-interactive-runtime",
+      "extension_name": "OnecInteractiveRuntime",
+      "root_id": "fcac7610-e58e-4c3b-b637-9d809453a8a2",
+      "runtime_module_ids": [
+        "33445a61-8047-40aa-8144-690175755340",
+        "403bd06b-17d6-4171-94d6-e38fc5f8a585",
+        "4a0aa21a-4046-47f7-8421-5eeb79d0e9f0",
+        "c8a390d7-e463-4413-ae75-2bb83ce8c299"
+      ],
+      "purpose": "AddOn",
+      "name_prefix": "OnecInteractiveRuntime_",
+      "vendor": "onec-interactive-runtime"
+    },
+    "artifact": {
+      "artifact_version": "0.1.2",
+      "protocol_version": "1",
+      "language_bound_by_name": false,
+      "metadata": [
+        {
+          "name": "CommonModule.RuntimeContextStoreServer",
+          "object_id": "c8a390d7-e463-4413-ae75-2bb83ce8c299"
+        },
+        {
+          "name": "CommonModule.RuntimeContextStoreServer.Module",
+          "object_id": "c8a390d7-e463-4413-ae75-2bb83ce8c299"
+        },
+        {
+          "name": "CommonModule.RuntimeKernelServer",
+          "object_id": "4a0aa21a-4046-47f7-8421-5eeb79d0e9f0"
+        },
+        {
+          "name": "CommonModule.RuntimeKernelServer.Module",
+          "object_id": "4a0aa21a-4046-47f7-8421-5eeb79d0e9f0"
+        },
+        {
+          "name": "CommonModule.RuntimeTableTransferServer",
+          "object_id": "33445a61-8047-40aa-8144-690175755340"
+        },
+        {
+          "name": "CommonModule.RuntimeTableTransferServer.Module",
+          "object_id": "33445a61-8047-40aa-8144-690175755340"
+        },
+        {
+          "name": "CommonModule.RuntimeValueTransferServer",
+          "object_id": "403bd06b-17d6-4171-94d6-e38fc5f8a585"
+        },
+        {
+          "name": "CommonModule.RuntimeValueTransferServer.Module",
+          "object_id": "403bd06b-17d6-4171-94d6-e38fc5f8a585"
+        },
+        {
+          "name": "Configuration.OnecInteractiveRuntime",
+          "object_id": "fcac7610-e58e-4c3b-b637-9d809453a8a2"
+        },
+        {
+          "name": "Configuration.OnecInteractiveRuntime.ManagedApplicationModule",
+          "object_id": "96ff5058-0bc6-4207-935b-3cb72a166691"
+        }
+      ],
+      "source_sha256": {
+        "CommonModules/RuntimeKernelServer/Ext/Module.bsl": "fe05d7264bb4470d349e577ce967a054f96854b40cdea4dc6b02739208afc3b6",
+        "Ext/ManagedApplicationModule.bsl": "d58c93d80b76a813191f20e593ec96c2610d21dc4cd0f86d450c9bcea589cd2c"
+      }
+    },
+    "identity_sha256": "726065a5d3c6f5472e24a83fc0c474fd5f13c42eace441b90c7eba1b404df496",
+    "artifact_sha256": "e4147b6d09ca927d9e87a82f4beac35797b643b48480f0d59e3c7dfc87176f04"
+  },
+  "breakpoints": {
+    "managed": {
+      "module_type": "ExtensionModule",
+      "url": "",
+      "object_id": "fcac7610-e58e-4c3b-b637-9d809453a8a2",
+      "property_id": "d22e852a-cf8a-4f77-8ccb-3548e7792bea",
+      "line": 7,
+      "extension_name": "OnecInteractiveRuntime",
+      "ext_id": 0
+    },
+    "server_entry": {
+      "module_type": "ExtensionModule",
+      "url": "",
+      "object_id": "4a0aa21a-4046-47f7-8421-5eeb79d0e9f0",
+      "property_id": "d5963243-262e-4398-b4d7-fb16d06484f6",
+      "line": 110,
+      "extension_name": "OnecInteractiveRuntime",
+      "ext_id": 0
+    },
+    "server_service": {
+      "module_type": "ExtensionModule",
+      "url": "",
+      "object_id": "4a0aa21a-4046-47f7-8421-5eeb79d0e9f0",
+      "property_id": "d5963243-262e-4398-b4d7-fb16d06484f6",
+      "line": 117,
+      "extension_name": "OnecInteractiveRuntime",
+      "ext_id": 0
+    }
+  }
+}