cf-runtime 0.1.8__py3-none-any.whl

cf_runtime/lifecycle.py

@@ -0,0 +1,457 @@
+"""Provider-owned development runtime lifecycle."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path
+import signal
+import socket
+import subprocess
+import sys
+import time
+from typing import Callable
+import urllib.parse
+import urllib.request
+
+from .domain import RuntimeId
+from .locking import LifecycleLock
+from .manifest import (DEFAULT_RUNTIME_VERSION, DEFAULT_TOOL_VERSIONS, RuntimeManifest,
+                       development_manifest, validate_manifest_pair)
+from .paths import CogniflowHome
+from .target import RuntimeIdentity, resolve_runtime_target
+
+
+def _atomic_json(path: Path, payload: dict[str, object]) -> None:
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    try:
+        with temporary.open("w", encoding="utf-8", newline="\n") as stream:
+            stream.write(json.dumps(payload, sort_keys=True, separators=(",", ":")) + "\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def _post(url: str, *, data: bytes, content_type: str, timeout: float, accept: str | None = None) -> bytes:
+    headers = {"Content-Type": content_type}
+    if accept:
+        headers["Accept"] = accept
+    request = urllib.request.Request(url, data=data, headers=headers, method="POST")
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        return response.read()
+
+
+def _form(url: str, fields: dict[str, str], timeout: float, accept: str | None = None) -> bytes:
+    return _post(url, data=urllib.parse.urlencode(fields).encode(),
+                 content_type="application/x-www-form-urlencoded", timeout=timeout, accept=accept)
+
+
+def port_open(host: str, port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:
+        client.settimeout(0.2)
+        return client.connect_ex((host, port)) == 0
+
+
+def process_running(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    if os.name == "nt":
+        result = subprocess.run(
+            ["tasklist", "/FI", f"PID eq {pid}", "/FO", "CSV", "/NH"],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+        )
+        return result.returncode == 0 and f'"{pid}"' in result.stdout
+    try:
+        os.kill(pid, 0)
+        return True
+    except PermissionError:
+        return True
+    except (OSError, ValueError):
+        return False
+
+
+def process_command_line(pid: int) -> str | None:
+    if os.name != "nt":
+        try:
+            return (Path("/proc") / str(pid) / "cmdline").read_bytes().replace(b"\0", b" ").decode(errors="replace")
+        except OSError:
+            return None
+    command = ["powershell", "-NoProfile", "-Command",
+               f"(Get-CimInstance Win32_Process -Filter 'ProcessId={pid}').CommandLine"]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=False)
+    except OSError:
+        return None
+    return result.stdout.strip() if result.returncode == 0 and result.stdout.strip() else None
+
+
+def terminate_process(pid: int) -> None:
+    if os.name == "nt":
+        result = subprocess.run(["taskkill", "/PID", str(pid), "/T"], capture_output=True, text=True, check=False)
+        if result.returncode:
+            result = subprocess.run(["taskkill", "/PID", str(pid), "/T", "/F"], capture_output=True, text=True, check=False)
+        if result.returncode:
+            raise RuntimeError((result.stderr or result.stdout or "taskkill failed").strip())
+    else:
+        os.kill(pid, signal.SIGTERM)
+
+
+class DevelopmentRuntime:
+    def __init__(self, home: CogniflowHome, *, lock_timeout: float = 0.0,
+                 popen: Callable[..., subprocess.Popen[bytes]] = subprocess.Popen) -> None:
+        self.home = home
+        self.paths = home.runtime(RuntimeId.DEVELOPMENT)
+        self.lock_timeout = lock_timeout
+        self._popen = popen
+
+    def _lock(self) -> LifecycleLock:
+        return LifecycleLock(self.paths.lifecycle_lock, self.lock_timeout)
+
+    def prepare(self, source_root: Path, semantic_seed: Path) -> dict[str, object]:
+        with self._lock():
+            return self._prepare(source_root, semantic_seed)
+
+    def _prepare(self, source_root: Path, semantic_seed: Path) -> dict[str, object]:
+        source = source_root.expanduser().resolve(strict=False)
+        seed = semantic_seed.expanduser().resolve(strict=False)
+        if not source.is_dir():
+            raise ValueError("source_root must be an existing directory")
+        if not seed.is_file():
+            raise ValueError("semantic_seed must be an existing file")
+        revision = hashlib.sha256(seed.read_bytes()).hexdigest()
+        runtime_version = DEFAULT_RUNTIME_VERSION
+        tools = DEFAULT_TOOL_VERSIONS
+        command = None
+        if self.paths.manifest.is_file():
+            current = RuntimeManifest.read(self.paths.manifest)
+            if current.source_root != source:
+                raise ValueError("development manifest belongs to another source root")
+            runtime_version, tools, command = current.runtime_version, current.tool_versions, current.mcp_command
+        manifest = development_manifest(self.home, source_root=source, runtime_version=runtime_version,
+                                        semantic_revision=revision, tool_versions=tools,
+                                        **({"mcp_command": command} if command is not None else {}))
+        production_path = self.home.runtime(RuntimeId.PRODUCTION).manifest
+        if production_path.is_file():
+            validate_manifest_pair(manifest, RuntimeManifest.read(production_path))
+        self.paths.ensure_directories()
+        manifest.write(self.paths.manifest)
+        self.paths.identity.unlink(missing_ok=True)
+        return {"runtime_id": "development", "manifest": str(self.paths.manifest),
+                "semantic_revision": revision}
+
+    def start(self, source_root: Path, semantic_seed: Path, *, timeout: float) -> dict[str, object]:
+        with self._lock():
+            self._prepare(source_root, semantic_seed)
+            manifest = RuntimeManifest.read(self.paths.manifest)
+            started_pid: int | None = None
+            cleanup_errors: list[str] = []
+            try:
+                if port_open(manifest.fuseki_bind, manifest.fuseki_port):
+                    self._verified_state(manifest)
+                else:
+                    started_pid = self._start_process(manifest, timeout)
+                    self._write_state(manifest, started_pid)
+                self._load_semantics(manifest, semantic_seed.resolve(), timeout)
+                RuntimeIdentity.from_manifest(manifest).write(self.paths.identity, self.home)
+                self._ready(manifest, timeout)
+                resolve_runtime_target(self.home, RuntimeId.DEVELOPMENT)
+            except Exception as error:
+                for name, cleanup in (
+                    ("identity cleanup", lambda: self.paths.identity.unlink(missing_ok=True)),
+                    ("process cleanup", lambda: self._terminate_and_wait(started_pid, timeout=min(timeout, 5.0)) if started_pid is not None else None),
+                    ("lifecycle cleanup", lambda: self.paths.lifecycle_state.unlink(missing_ok=True) if started_pid is not None else None),
+                ):
+                    try:
+                        cleanup()
+                    except Exception as cleanup_error:
+                        cleanup_errors.append(f"{name}: {cleanup_error}")
+                if cleanup_errors:
+                    error.add_note("cleanup also failed: " + "; ".join(cleanup_errors))
+                raise
+            return {"runtime_id": "development", "status": "ready", "pid": self._state_pid(),
+                    "started": started_pid is not None, "manifest": str(self.paths.manifest)}
+
+    def status(self) -> dict[str, object]:
+        with self._lock():
+            manifest_exists = self.paths.manifest.is_file()
+            running = False
+            ready = False
+            pid = None
+            if manifest_exists:
+                manifest = RuntimeManifest.read(self.paths.manifest)
+                try:
+                    pid = self._verified_state(manifest)
+                    running = True
+                    self._ready(manifest, 1.0)
+                    ready = RuntimeIdentity.read(self.paths.identity) == RuntimeIdentity.from_manifest(manifest)
+                except (OSError, ValueError, RuntimeError):
+                    pass
+            return {"runtime_id": "development", "status": "ready" if ready else "running" if running else "stopped",
+                    "manifest_exists": manifest_exists, "running": running, "ready": ready, "pid": pid,
+                    "manifest": str(self.paths.manifest)}
+
+    def stop(self, *, timeout: float) -> dict[str, object]:
+        with self._lock():
+            self.paths.identity.unlink(missing_ok=True)
+            if not self.paths.lifecycle_state.is_file():
+                return {"runtime_id": "development", "status": "not_running", "pid": None}
+            manifest = RuntimeManifest.read(self.paths.manifest)
+            pid = self._verified_state(manifest, allow_stale=True)
+            if not process_running(pid):
+                self.paths.lifecycle_state.unlink(missing_ok=True)
+                return {"runtime_id": "development", "status": "stale_removed", "pid": pid}
+            self._terminate_and_wait(pid, timeout)
+            self.paths.lifecycle_state.unlink(missing_ok=True)
+            return {"runtime_id": "development", "status": "stopped", "pid": pid}
+
+    def _start_process(self, manifest: RuntimeManifest, timeout: float) -> int:
+        java_name = "java.exe" if os.name == "nt" else "java"
+        java = self.home.java_install(manifest.tool_versions["java"]) / "bin" / java_name
+        fuseki = self.home.fuseki_install(manifest.tool_versions["fuseki"]) / "fuseki-server.jar"
+        if not java.is_file() or not fuseki.is_file():
+            raise ValueError("managed Java or Fuseki installation is missing")
+        database = str(self.paths.fuseki_database).replace("\\", "/").replace('"', '\\"')
+        dataset = manifest.fuseki_dataset.replace('"', '\\"')
+        config = ("@prefix fuseki: <http://jena.apache.org/fuseki#> .\n"
+                  "@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n"
+                  "@prefix tdb2: <http://jena.apache.org/2016/tdb#> .\n"
+                  f'<#service> rdf:type fuseki:Service ; fuseki:name "{dataset}" ; '
+                  'fuseki:serviceQuery "query" ; fuseki:serviceUpdate "update" ; '
+                  'fuseki:serviceReadWriteGraphStore "data" ; fuseki:dataset <#dataset> .\n'
+                  f'<#dataset> rdf:type tdb2:DatasetTDB2 ; tdb2:location "{database}" .\n')
+        temporary = self.paths.fuseki_server_config.with_suffix(".tmp")
+        temporary.write_text(config, encoding="utf-8", newline="\n")
+        os.replace(temporary, self.paths.fuseki_server_config)
+        command = [str(java), "-jar", str(fuseki), "--localhost", f"--port={manifest.fuseki_port}",
+                   f"--config={self.paths.fuseki_server_config}"]
+        environment = os.environ.copy()
+        environment.update({"JAVA_HOME": str(java.parent.parent), "FUSEKI_BASE": str(self.paths.fuseki_config),
+                            "TMPDIR": str(self.paths.temp), "TEMP": str(self.paths.temp)})
+        with (self.paths.logs / "fuseki.out.log").open("ab") as out, (self.paths.logs / "fuseki.err.log").open("ab") as err:
+            process = self._popen(command, cwd=fuseki.parent, env=environment, stdout=out, stderr=err)
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if process.poll() is not None:
+                raise RuntimeError(f"Fuseki exited before readiness with code {process.returncode}")
+            try:
+                self._ready(manifest, min(1.0, timeout))
+                return process.pid
+            except Exception:
+                time.sleep(0.05)
+        error = TimeoutError("timed out waiting for managed Fuseki")
+        try:
+            self._terminate_and_wait(process.pid, timeout=min(max(timeout, 0.001), 5.0))
+        except Exception as cleanup_error:
+            error.add_note(f"cleanup also failed: {cleanup_error}")
+        raise error
+
+    def _load_semantics(self, manifest: RuntimeManifest, seed: Path, timeout: float) -> None:
+        base = f"http://{manifest.fuseki_bind}:{manifest.fuseki_port}/{manifest.fuseki_dataset}"
+        _form(base + "/update", {"update": "CLEAR ALL"}, timeout)
+        _post(base + "/data", data=seed.read_bytes(), content_type="application/trig", timeout=timeout)
+        body = _form(base + "/query", {"query": "ASK { GRAPH ?g { ?s ?p ?o } }"}, timeout,
+                      accept="application/sparql-results+json")
+        if json.loads(body.decode()).get("boolean") is not True:
+            raise RuntimeError("semantic seed readiness verification failed")
+
+    def _ready(self, manifest: RuntimeManifest, timeout: float) -> None:
+        endpoint = f"http://{manifest.fuseki_bind}:{manifest.fuseki_port}/{manifest.fuseki_dataset}/query"
+        _form(endpoint, {"query": "ASK { ?s ?p ?o }"}, timeout)
+
+    def _write_state(self, manifest: RuntimeManifest, pid: int) -> None:
+        _atomic_json(self.paths.lifecycle_state, {
+            "runtime_id": "development", "environment_kind": "development", "lifecycle_owner": "cf-runtime",
+            "source_root": str(manifest.source_root), "runtime_root": str(self.paths.runtime_root),
+            "fuseki_config": str(self.paths.fuseki_server_config), "fuseki_database": str(self.paths.fuseki_database),
+            "fuseki_port": manifest.fuseki_port, "fuseki_pid": pid,
+            "started_at": datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"),
+        })
+
+    def _state_pid(self) -> int:
+        return int(json.loads(self.paths.lifecycle_state.read_text(encoding="utf-8"))["fuseki_pid"])
+
+    def _verified_state(self, manifest: RuntimeManifest, *, allow_stale: bool = False) -> int:
+        try:
+            state = json.loads(self.paths.lifecycle_state.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as error:
+            raise ValueError("development port has no valid provider lifecycle state") from error
+        expected = {"runtime_id": "development", "environment_kind": "development", "lifecycle_owner": "cf-runtime",
+                    "source_root": str(manifest.source_root), "runtime_root": str(self.paths.runtime_root),
+                    "fuseki_config": str(self.paths.fuseki_server_config), "fuseki_database": str(self.paths.fuseki_database),
+                    "fuseki_port": manifest.fuseki_port}
+        if (not isinstance(state, dict) or set(state) != {*expected, "fuseki_pid", "started_at"}
+                or any(state.get(key) != value for key, value in expected.items())
+                or not isinstance(state.get("started_at"), str) or not state["started_at"]):
+            raise ValueError("lifecycle state is not owned by the canonical development runtime")
+        pid = state.get("fuseki_pid")
+        if isinstance(pid, bool) or not isinstance(pid, int) or pid <= 0:
+            raise ValueError("lifecycle state has no valid PID")
+        if allow_stale and not process_running(pid):
+            return pid
+        command = process_command_line(pid)
+        tokens = ("fuseki", str(self.paths.fuseki_server_config), str(manifest.fuseki_port), "--localhost")
+        if not process_running(pid) or command is None or not all(t.lower().replace("\\", "/") in command.lower().replace("\\", "/") for t in tokens):
+            raise ValueError("provider ownership of the Fuseki process could not be verified")
+        return pid
+
+    @staticmethod
+    def _terminate_and_wait(pid: int, timeout: float) -> None:
+        terminate_process(pid)
+        deadline = time.monotonic() + timeout
+        while process_running(pid) and time.monotonic() < deadline:
+            time.sleep(0.05)
+        if process_running(pid):
+            raise TimeoutError(f"PID {pid} did not stop")
+
+
+class ProductionRuntime(DevelopmentRuntime):
+    """Lifecycle owner for the installed production composition.
+
+    Production has no source-tree seed input: the seed is produced by the
+    target interpreter and published below the production data root.
+    """
+
+    def __init__(self, home: CogniflowHome, *, lock_timeout: float = 0.0,
+                 popen: Callable[..., subprocess.Popen[bytes]] = subprocess.Popen) -> None:
+        super().__init__(home, lock_timeout=lock_timeout, popen=popen)
+        self.paths = home.runtime(RuntimeId.PRODUCTION)
+
+    def _seed(self, manifest: RuntimeManifest) -> Path:
+        seed = self.home.root / "data" / "production" / "semantic-seed" / "cogniflow.trig"
+        seed.parent.mkdir(parents=True, exist_ok=True)
+        command = [str(manifest.python_executable), "-m", "cf_runtime.installed_seed", "--output", str(seed)]
+        environment = {"PYTHONNOUSERSITE": "1", "PYTHONDONTWRITEBYTECODE": "1",
+                       "PATH": str(Path(manifest.python_executable).parent),
+                       "PYTHONUNBUFFERED": "1"}
+        result = subprocess.run(command, cwd=str(manifest.installation_root), env=environment,
+                                capture_output=True, text=True, check=False, timeout=30)
+        if result.returncode != 0:
+            raise RuntimeError((result.stderr or result.stdout or "installed seed construction failed").strip())
+        expected = manifest.semantic_revision
+        actual = hashlib.sha256(seed.read_bytes()).hexdigest()
+        if actual != expected:
+            raise ValueError("installed semantic seed does not match the production manifest")
+        return seed
+
+    def start(self, *, timeout: float = 30.0) -> dict[str, object]:
+        with self._lock():
+            manifest = RuntimeManifest.read(self.paths.manifest)
+            if manifest.runtime_id is not RuntimeId.PRODUCTION:
+                raise ValueError("production lifecycle requires a production manifest")
+            seed = self._seed(manifest)
+            started_pid: int | None = None
+            try:
+                if port_open(manifest.fuseki_bind, manifest.fuseki_port):
+                    pid = self._verified_state(manifest)
+                    self._ready(manifest, timeout)
+                else:
+                    pid = self._start_process(manifest, timeout)
+                    started_pid = pid
+                    self._write_state(manifest, pid)
+                    self._load_semantics(manifest, seed, timeout)
+                    self._ready(manifest, timeout)
+                RuntimeIdentity.from_manifest(manifest).write(self.paths.identity, self.home)
+                resolve_runtime_target(self.home, RuntimeId.PRODUCTION)
+            except Exception as error:
+                cleanup_errors: list[str] = []
+                for name, cleanup in (
+                    ("identity cleanup", lambda: self.paths.identity.unlink(missing_ok=True)),
+                    ("process cleanup", lambda: self._terminate_and_wait(started_pid, min(timeout, 5.0)) if started_pid is not None else None),
+                    ("lifecycle cleanup", lambda: self.paths.lifecycle_state.unlink(missing_ok=True) if started_pid is not None else None),
+                ):
+                    try:
+                        cleanup()
+                    except Exception as cleanup_error:
+                        cleanup_errors.append(f"{name}: {cleanup_error}")
+                if cleanup_errors:
+                    error.add_note("cleanup also failed: " + "; ".join(cleanup_errors))
+                raise
+            return {"runtime_id": "production", "status": "ready", "pid": pid,
+                    "started": started_pid is not None, "manifest": str(self.paths.manifest),
+                    "semantic_revision": manifest.semantic_revision, "seed": str(seed)}
+
+    def status(self) -> dict[str, object]:
+        with self._lock():
+            exists = self.paths.manifest.is_file()
+            running = ready = False
+            pid = None
+            if exists:
+                try:
+                    manifest = RuntimeManifest.read(self.paths.manifest)
+                    pid = self._verified_state(manifest)
+                    running = True
+                    self._ready(manifest, 1.0)
+                    ready = RuntimeIdentity.read(self.paths.identity) == RuntimeIdentity.from_manifest(manifest)
+                except (OSError, ValueError, RuntimeError):
+                    pass
+            return {"runtime_id": "production", "status": "ready" if ready else "running" if running else "stopped",
+                    "manifest_exists": exists, "running": running, "ready": ready, "pid": pid,
+                    "manifest": str(self.paths.manifest),
+                    "semantic_revision": RuntimeManifest.read(self.paths.manifest).semantic_revision if exists else None}
+
+    def stop(self, *, timeout: float = 5.0) -> dict[str, object]:
+        with self._lock():
+            self.paths.identity.unlink(missing_ok=True)
+            if not self.paths.lifecycle_state.is_file():
+                return {"runtime_id": "production", "status": "not_running", "pid": None}
+            manifest = RuntimeManifest.read(self.paths.manifest)
+            pid = self._verified_state(manifest, allow_stale=True)
+            if process_running(pid):
+                self._terminate_and_wait(pid, timeout)
+            self.paths.lifecycle_state.unlink(missing_ok=True)
+            if port_open(manifest.fuseki_bind, manifest.fuseki_port):
+                raise RuntimeError("production Fuseki port remains in use")
+            return {"runtime_id": "production", "status": "stopped", "pid": pid}
+
+    def _write_state(self, manifest: RuntimeManifest, pid: int) -> None:
+        seed = self.home.root / "data" / "production" / "semantic-seed" / "cogniflow.trig"
+        java = self.home.java_install(manifest.tool_versions["java"]) / "bin" / ("java.exe" if os.name == "nt" else "java")
+        fuseki = self.home.fuseki_install(manifest.tool_versions["fuseki"]) / "fuseki-server.jar"
+        _atomic_json(self.paths.lifecycle_state, {
+            "runtime_id": "production", "environment_kind": "production", "lifecycle_owner": "cf-runtime",
+            "runtime_root": str(self.paths.runtime_root), "manifest": str(self.paths.manifest),
+            "fuseki_config": str(self.paths.fuseki_server_config), "fuseki_database": str(self.paths.fuseki_database),
+            "fuseki_port": manifest.fuseki_port, "fuseki_pid": pid,
+            "semantic_revision": manifest.semantic_revision,
+            "installation_root": str(manifest.installation_root), "environment_root": str(manifest.environment_root),
+            "target_python": str(manifest.python_executable), "java_executable": str(java),
+            "fuseki_jar": str(fuseki), "seed_path": str(seed),
+            "seed_sha256": hashlib.sha256(seed.read_bytes()).hexdigest() if seed.is_file() else "",
+            "started_at": datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"),
+        })
+
+    def _verified_state(self, manifest: RuntimeManifest, *, allow_stale: bool = False) -> int:
+        try:
+            state = json.loads(self.paths.lifecycle_state.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as error:
+            raise ValueError("production port has no valid provider lifecycle state") from error
+        expected = {"runtime_id": "production", "environment_kind": "production", "lifecycle_owner": "cf-runtime",
+                    "runtime_root": str(self.paths.runtime_root), "manifest": str(self.paths.manifest),
+                    "fuseki_config": str(self.paths.fuseki_server_config), "fuseki_database": str(self.paths.fuseki_database),
+                    "fuseki_port": manifest.fuseki_port, "semantic_revision": manifest.semantic_revision,
+                    "installation_root": str(manifest.installation_root), "environment_root": str(manifest.environment_root),
+                    "target_python": str(manifest.python_executable),
+                    "java_executable": str(self.home.java_install(manifest.tool_versions["java"]) / "bin" / ("java.exe" if os.name == "nt" else "java")),
+                    "fuseki_jar": str(self.home.fuseki_install(manifest.tool_versions["fuseki"]) / "fuseki-server.jar"),
+                    "seed_path": str(self.home.root / "data" / "production" / "semantic-seed" / "cogniflow.trig"),
+                    "seed_sha256": hashlib.sha256((self.home.root / "data" / "production" / "semantic-seed" / "cogniflow.trig").read_bytes()).hexdigest()}
+        if not isinstance(state, dict) or set(state) != {*expected, "fuseki_pid", "started_at"} or any(state.get(k) != v for k, v in expected.items()):
+            raise ValueError("lifecycle state is not owned by the canonical production runtime")
+        pid = state.get("fuseki_pid")
+        if isinstance(pid, bool) or not isinstance(pid, int) or pid <= 0:
+            raise ValueError("production lifecycle state has no valid PID")
+        if allow_stale and not process_running(pid):
+            return pid
+        command = process_command_line(pid)
+        tokens = ("fuseki", str(self.paths.fuseki_server_config), str(manifest.fuseki_port), "--localhost")
+        if not process_running(pid) or command is None or not all(t.lower().replace("\\", "/") in command.lower().replace("\\", "/") for t in tokens):
+            raise ValueError("provider ownership of the production Fuseki process could not be verified")
+        return pid

cf_runtime/locking.py

@@ -0,0 +1,64 @@
+"""Cross-platform exclusive lifecycle lock."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import time
+
+
+class LifecycleLockedError(RuntimeError):
+    pass
+
+
+class LifecycleLock:
+    def __init__(self, path: Path, timeout: float) -> None:
+        self.path = path
+        self.timeout = timeout
+        self._stream = None
+
+    def __enter__(self) -> LifecycleLock:
+        if self.timeout < 0:
+            raise ValueError("lock timeout cannot be negative")
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._stream = self.path.open("a+b")
+        self._stream.seek(0, os.SEEK_END)
+        if self._stream.tell() == 0:
+            self._stream.write(b"0")
+            self._stream.flush()
+        deadline = time.monotonic() + self.timeout
+        while True:
+            try:
+                self._acquire()
+                return self
+            except (BlockingIOError, OSError):
+                if time.monotonic() >= deadline:
+                    self._stream.close()
+                    self._stream = None
+                    raise LifecycleLockedError("development lifecycle is locked")
+                time.sleep(min(0.01, max(0.0, deadline - time.monotonic())))
+
+    def _acquire(self) -> None:
+        assert self._stream is not None
+        if os.name == "nt":
+            import msvcrt
+            self._stream.seek(0)
+            msvcrt.locking(self._stream.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+            fcntl.flock(self._stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+    def __exit__(self, _type: object, _value: object, _traceback: object) -> None:
+        if self._stream is None:
+            return
+        try:
+            if os.name == "nt":
+                import msvcrt
+                self._stream.seek(0)
+                msvcrt.locking(self._stream.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(self._stream.fileno(), fcntl.LOCK_UN)
+        finally:
+            self._stream.close()
+            self._stream = None