msdev 0.9.0__py3-none-any.whl

msdev/core/services/execution.py

@@ -0,0 +1,136 @@
+"""Typed command execution application service."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Mapping
+
+from ..limits import (
+    DEFAULT_EXEC_TIMEOUT_SECONDS,
+    validate_exec_timeout_seconds,
+)
+from .context import ServiceContext
+
+
+@dataclass(frozen=True)
+class ExecRequest:
+    environment: str
+    argv: tuple[str, ...]
+    cwd: str | None = None
+    env: Mapping[str, str] = field(default_factory=dict)
+    timeout_seconds: float = DEFAULT_EXEC_TIMEOUT_SECONDS
+
+
+@dataclass(frozen=True)
+class ExecResult:
+    environment: str
+    returncode: int
+    stdout: str
+    stderr: str
+    stdout_truncated: bool = False
+    stderr_truncated: bool = False
+    output_drain_truncated: bool = False
+    timed_out: bool = False
+    cancelled: bool = False
+    cwd: str | None = None
+    runtime: dict[str, Any] | None = None
+    environments: tuple[Any, ...] = ()
+    raw: dict[str, Any] = field(default_factory=dict, repr=False)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"environment": self.environment, **self.raw}
+
+
+class ExecutionService:
+    def __init__(self, context: ServiceContext):
+        self.context = context
+
+    @staticmethod
+    def _validate(request: ExecRequest) -> tuple[str, tuple[str, ...], dict[str, str]]:
+        environment = (
+            request.environment
+            if isinstance(request.environment, str) and request.environment.strip()
+            else ""
+        )
+        if not environment:
+            raise ValueError("environment must be a non-empty string")
+        argv = tuple(request.argv)
+        if not argv or not all(isinstance(item, str) and item for item in argv):
+            raise ValueError("exec argv must be a non-empty string array")
+        env: dict[str, str] = {}
+        for key, value in request.env.items():
+            if not isinstance(key, str) or not key:
+                raise ValueError("environment names must be non-empty strings")
+            if not isinstance(value, str):
+                raise ValueError("environment values must be strings")
+            env[key] = value
+        if request.cwd is not None and not isinstance(request.cwd, str):
+            raise ValueError("cwd must be a string")
+        validate_exec_timeout_seconds(request.timeout_seconds)
+        return environment, argv, env
+
+    @staticmethod
+    def _params(
+        request: ExecRequest,
+        argv: tuple[str, ...],
+        env: dict[str, str],
+    ) -> dict[str, Any]:
+        return {
+            "command": list(argv),
+            "cwd": request.cwd,
+            "env": env,
+            "timeout_seconds": validate_exec_timeout_seconds(
+                request.timeout_seconds
+            ),
+        }
+
+    @staticmethod
+    def _result(environment: str, result: Any) -> ExecResult:
+        if not isinstance(result, dict):
+            raise RuntimeError("exec returned a non-object result")
+        if "returncode" not in result:
+            raise RuntimeError("exec result is missing returncode")
+        raw = dict(result)
+        runtime = raw.get("runtime")
+        if runtime is not None and not isinstance(runtime, dict):
+            raise RuntimeError("exec result runtime must be an object")
+        environments = raw.get("environments") or ()
+        if not isinstance(environments, (list, tuple)):
+            raise RuntimeError("exec result environments must be an array")
+        return ExecResult(
+            environment=environment,
+            returncode=int(raw["returncode"]),
+            stdout=str(raw.get("stdout") or ""),
+            stderr=str(raw.get("stderr") or ""),
+            stdout_truncated=bool(raw.get("stdout_truncated", False)),
+            stderr_truncated=bool(raw.get("stderr_truncated", False)),
+            output_drain_truncated=bool(
+                raw.get("output_drain_truncated", False)
+            ),
+            timed_out=bool(raw.get("timed_out", False)),
+            cancelled=bool(raw.get("cancelled", False)),
+            cwd=raw.get("cwd"),
+            runtime=runtime,
+            environments=tuple(environments),
+            raw=raw,
+        )
+
+    def run(self, request: ExecRequest) -> ExecResult:
+        environment, argv, env = self._validate(request)
+        result = self.context.transport_for_environment(environment).call(
+            "exec",
+            self._params(request, argv, env),
+        )
+        return self._result(environment, result)
+
+    def stream(
+        self,
+        request: ExecRequest,
+        on_output: Callable[[str, bytes], None],
+    ) -> ExecResult:
+        environment, argv, env = self._validate(request)
+        result = self.context.transport_for_environment(environment).stream_exec(
+            self._params(request, argv, env),
+            on_output,
+        )
+        return self._result(environment, result)