msdev 0.9.0__py3-none-any.whl

msdev/core/services/node.py

@@ -0,0 +1,210 @@
+"""Node registry and SSH lifecycle application service."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+from ..resources import Node, parse_variable_assignment
+from ..transport import RpcError
+from .context import ServiceContext
+
+
+@dataclass(frozen=True)
+class NodeAddRequest:
+    name: str
+    ssh_host: str | None = None
+    remote_bin: str = "~/.local/bin/msdevd"
+    auto_bootstrap: bool = True
+    force: bool = False
+
+
+@dataclass(frozen=True)
+class NodeListResult:
+    nodes: tuple[Node, ...]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"nodes": [asdict(node) for node in self.nodes]}
+
+
+@dataclass(frozen=True)
+class NodeConnectionResult:
+    node: str
+    ssh_host: str
+    state: str | None = None
+    persist: str | None = None
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class NodeConnectionBatch:
+    action: str
+    items: tuple[NodeConnectionResult, ...]
+    exit_code: int
+
+
+class NodeService:
+    def __init__(self, context: ServiceContext):
+        self.context = context
+
+    @staticmethod
+    def _required(value: str | None, label: str) -> str:
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"{label} must be a non-empty string")
+        return value
+
+    @staticmethod
+    def _boolean(value: Any, label: str) -> bool:
+        if type(value) is not bool:
+            raise ValueError(f"{label} must be a boolean")
+        return value
+
+    def add(self, request: NodeAddRequest) -> Node:
+        name = self._required(request.name, "node name")
+        node = Node(
+            name=name,
+            ssh_host=self._required(request.ssh_host or name, "SSH host"),
+            remote_bin=self._required(request.remote_bin, "remote binary"),
+            auto_bootstrap=self._boolean(
+                request.auto_bootstrap,
+                "auto_bootstrap",
+            ),
+        )
+        force = self._boolean(request.force, "force")
+        transport = self.context.create_transport(node)
+        validate = getattr(transport, "validate", None)
+        if validate is None:
+            raise TypeError("node transport does not support SSH validation")
+        validate()
+        self.context.node_store.add(
+            node,
+            force=force,
+            create_host_environment=True,
+        )
+        return node
+
+    def list(self) -> NodeListResult:
+        return NodeListResult(tuple(self.context.node_store.list()))
+
+    def update_variables(
+        self,
+        name: str,
+        *,
+        set_values: tuple[str, ...] = (),
+        unset_keys: tuple[str, ...] = (),
+    ) -> Node:
+        node_name = self._required(name, "node name")
+        updates: dict[str, str] = {}
+        for assignment in set_values:
+            key, value = parse_variable_assignment(assignment)
+            updates[key] = value
+        for key in unset_keys:
+            parsed_key, _ = parse_variable_assignment(f"{key}=")
+            if parsed_key in updates:
+                raise ValueError(
+                    f"environment variable cannot be set and unset: {key}"
+                )
+        return self.context.node_store.update_variables(
+            node_name,
+            set_values=updates,
+            unset_keys=unset_keys,
+        )
+
+    def remove(self, name: str, *, cascade: bool = False) -> tuple[str, ...]:
+        node_name = self._required(name, "node name")
+        self._boolean(cascade, "cascade")
+        return tuple(self.context.node_store.remove(node_name, cascade=cascade))
+
+    def status(self, name: str) -> dict[str, Any]:
+        node_name = self._required(name, "node name")
+        result = self.context.transport_for_node(node_name).call("node.info")
+        if not isinstance(result, dict):
+            raise RuntimeError("node.info returned a non-object result")
+        return result
+
+    def bootstrap(
+        self,
+        name: str,
+        package_path: Path | None = None,
+    ) -> dict[str, Any]:
+        node = self.context.node_store.get(self._required(name, "node name"))
+        return self.context.bootstrap(node, package_path)
+
+    def _connection_nodes(
+        self,
+        name: str | None,
+        all_nodes: bool,
+    ) -> list[Node]:
+        self._boolean(all_nodes, "all_nodes")
+        if all_nodes and name:
+            raise ValueError("node name and --all cannot be used together")
+        if all_nodes:
+            nodes = self.context.node_store.list()
+            if not nodes:
+                raise ValueError("no SSH nodes registered")
+            return nodes
+        if not name:
+            raise ValueError("node name or --all is required")
+        return [self.context.node_store.get(self._required(name, "node name"))]
+
+    def _connection(
+        self,
+        action: str,
+        name: str | None,
+        all_nodes: bool,
+    ) -> NodeConnectionBatch:
+        items: list[NodeConnectionResult] = []
+        failed = False
+        for node in self._connection_nodes(name, all_nodes):
+            operation = getattr(self.context.create_transport(node), action)
+            try:
+                result = operation()
+                if action == "connect":
+                    state = (
+                        "already connected"
+                        if result["already_connected"]
+                        else "connected"
+                    )
+                    persist = str(result["persist"])
+                else:
+                    state = (
+                        "already disconnected"
+                        if result["already_disconnected"]
+                        else "disconnected"
+                    )
+                    persist = None
+                items.append(
+                    NodeConnectionResult(
+                        node.name,
+                        node.ssh_host,
+                        state,
+                        persist,
+                    )
+                )
+            except (RpcError, OSError) as exc:
+                failed = True
+                items.append(
+                    NodeConnectionResult(
+                        node.name,
+                        node.ssh_host,
+                        error=str(exc),
+                    )
+                )
+        return NodeConnectionBatch(action, tuple(items), 1 if failed else 0)
+
+    def connect(
+        self,
+        name: str | None = None,
+        *,
+        all_nodes: bool = False,
+    ) -> NodeConnectionBatch:
+        return self._connection("connect", name, all_nodes)
+
+    def disconnect(
+        self,
+        name: str | None = None,
+        *,
+        all_nodes: bool = False,
+    ) -> NodeConnectionBatch:
+        return self._connection("disconnect", name, all_nodes)

msdev/core/services/npu.py

@@ -0,0 +1,116 @@
+"""NPU discovery application service."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..transport import RpcError
+from .context import ServiceContext
+
+
+@dataclass(frozen=True)
+class NpuNodeResult:
+    node: str
+    ssh_host: str | None
+    result: dict[str, Any] | None = None
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class NpuListResult:
+    items: tuple[NpuNodeResult, ...]
+    all_nodes: bool
+    exit_code: int
+
+    def to_dict(self) -> dict[str, Any]:
+        if not self.all_nodes:
+            item = self.items[0]
+            return {
+                "node": item.node,
+                **(item.result or {}),
+                "exit_code": self.exit_code,
+            }
+        nodes: dict[str, Any] = {}
+        for item in self.items:
+            value: dict[str, Any] = {"ssh_host": item.ssh_host}
+            if item.error is not None:
+                value["error"] = item.error
+            else:
+                value["result"] = item.result
+            nodes[item.node] = value
+        return {"nodes": nodes, "exit_code": self.exit_code}
+
+
+class NpuService:
+    def __init__(self, context: ServiceContext):
+        self.context = context
+
+    def list(
+        self,
+        *,
+        node: str | None = None,
+        all_nodes: bool = False,
+    ) -> NpuListResult:
+        if type(all_nodes) is not bool:
+            raise ValueError("all_nodes must be a boolean")
+        if node is not None and not isinstance(node, str):
+            raise ValueError("node must be a non-empty string")
+        node_name = node if isinstance(node, str) and node.strip() else ""
+        if all_nodes and node_name:
+            raise ValueError("node and all_nodes cannot be used together")
+        if all_nodes:
+            configured = self.context.node_store.list()
+            if not configured:
+                raise ValueError("no SSH nodes registered")
+            items: list[NpuNodeResult] = []
+            failed = False
+            for configured_node in configured:
+                try:
+                    result = self.context.create_transport(
+                        configured_node
+                    ).call("npu.list")
+                    if not isinstance(result, dict):
+                        raise RuntimeError(
+                            "npu.list returned a non-object result"
+                        )
+                    items.append(
+                        NpuNodeResult(
+                            node=configured_node.name,
+                            ssh_host=configured_node.ssh_host,
+                            result=result,
+                        )
+                    )
+                    if not result.get("available"):
+                        failed = True
+                except (RpcError, OSError) as exc:
+                    failed = True
+                    items.append(
+                        NpuNodeResult(
+                            node=configured_node.name,
+                            ssh_host=configured_node.ssh_host,
+                            error=str(exc),
+                        )
+                    )
+            return NpuListResult(
+                items=tuple(items),
+                all_nodes=True,
+                exit_code=1 if failed else 0,
+            )
+
+        if not node_name:
+            raise ValueError("node is required unless all_nodes is true")
+        result = self.context.transport_for_node(node_name).call("npu.list")
+        if not isinstance(result, dict):
+            raise RuntimeError("npu.list returned a non-object result")
+        return NpuListResult(
+            items=(
+                NpuNodeResult(
+                    node=node_name,
+                    ssh_host=None,
+                    result=result,
+                ),
+            ),
+            all_nodes=False,
+            exit_code=0 if result.get("available") else 1,
+        )