gpustack-runtime 0.1.39__py3-none-any.whl → 0.1.39.post2__py3-none-any.whl

gpustack_runtime/__main__.py

@@ -12,17 +12,19 @@ from . import deployer, detector
 from ._version import commit_id, version
 from .cmds import (
     CopyImagesSubCommand,
-    CreateRunnerWorkloadSubCommand,
     CreateWorkloadSubCommand,
     DeleteWorkloadsSubCommand,
     DeleteWorkloadSubCommand,
     DetectDevicesSubCommand,
+    ExecSelfSubCommand,
     ExecWorkloadSubCommand,
     GetDevicesTopologySubCommand,
     GetWorkloadSubCommand,
+    InspectSelfSubCommand,
     InspectWorkloadSubCommand,
     ListImagesSubCommand,
     ListWorkloadsSubCommand,
+    LogsSelfSubCommand,
     LogsWorkloadSubCommand,
     SaveImagesSubCommand,
 )
@@ -59,7 +61,6 @@ def main():
     subcommand_parser = parser.add_subparsers(
         help="gpustack-runtime command helpers",
     )
-    CreateRunnerWorkloadSubCommand.register(subcommand_parser)
     CreateWorkloadSubCommand.register(subcommand_parser)
     DeleteWorkloadSubCommand.register(subcommand_parser)
     DeleteWorkloadsSubCommand.register(subcommand_parser)
@@ -73,6 +74,9 @@ def main():
     ListImagesSubCommand.register(subcommand_parser)
     SaveImagesSubCommand.register(subcommand_parser)
     CopyImagesSubCommand.register(subcommand_parser)
+    LogsSelfSubCommand.register(subcommand_parser)
+    ExecSelfSubCommand.register(subcommand_parser)
+    InspectSelfSubCommand.register(subcommand_parser)
 
     # Autocomplete
     argcomplete.autocomplete(parser)

gpustack_runtime/_version.py

@@ -27,8 +27,8 @@ version_tuple: VERSION_TUPLE
 __commit_id__: COMMIT_ID
 commit_id: COMMIT_ID
 
-__version__ = version = '0.1.39'
-__version_tuple__ = version_tuple = (0, 1, 39)
+__version__ = version = '0.1.39.post2'
+__version_tuple__ = version_tuple = (0, 1, 39, 'post2')
 try:
     from ._version_appendix import git_commit
     __commit_id__ = commit_id = git_commit

gpustack_runtime/_version_appendix.py

@@ -1 +1 @@
-git_commit = "c8c93ed"
+git_commit = "e044bab"

gpustack_runtime/cmds/__init__.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 from .deployer import (
-    CreateRunnerWorkloadSubCommand,
     CreateWorkloadSubCommand,
     DeleteWorkloadsSubCommand,
     DeleteWorkloadSubCommand,
+    ExecSelfSubCommand,
     ExecWorkloadSubCommand,
     GetWorkloadSubCommand,
+    InspectSelfSubCommand,
     InspectWorkloadSubCommand,
     ListWorkloadsSubCommand,
+    LogsSelfSubCommand,
     LogsWorkloadSubCommand,
 )
 from .detector import DetectDevicesSubCommand, GetDevicesTopologySubCommand
@@ -23,17 +25,19 @@ from .images import (
 
 __all__ = [
     "CopyImagesSubCommand",
-    "CreateRunnerWorkloadSubCommand",
     "CreateWorkloadSubCommand",
     "DeleteWorkloadSubCommand",
     "DeleteWorkloadsSubCommand",
     "DetectDevicesSubCommand",
+    "ExecSelfSubCommand",
     "ExecWorkloadSubCommand",
     "GetDevicesTopologySubCommand",
     "GetWorkloadSubCommand",
+    "InspectSelfSubCommand",
     "InspectWorkloadSubCommand",
     "ListImagesSubCommand",
     "ListWorkloadsSubCommand",
+    "LogsSelfSubCommand",
     "LogsWorkloadSubCommand",
     "PlatformedImage",
     "SaveImagesSubCommand",

gpustack_runtime/cmds/deployer.py

@@ -23,14 +23,17 @@ from ..deployer import (
     WorkloadPlan,
     WorkloadStatus,
     WorkloadStatusStateEnum,
+    async_logs_self,
     async_logs_workload,
     create_workload,
     delete_workload,
+    exec_self,
     exec_workload,
     get_workload,
+    inspect_self,
+    inspect_workload,
     list_workloads,
 )
-from ..deployer.__utils__ import safe_json, safe_yaml
 from ..detector import supported_backends
 from .__types__ import SubCommand
 
@@ -78,251 +81,6 @@ _IGNORE_ENVS_SUFFIX = (
     "_DRIVER_CAPABILITIES",
 )
 
-_IGNORE_SENSITIVE_ENVS_SUFFIX = (
-    "_KEY",
-    "_key",
-    "_TOKEN",
-    "_token",
-    "_SECRET",
-    "_secret",
-    "_PASSWORD",
-    "_password",
-    "_PASS",
-    "_pass",
-)
-
-
-class CreateRunnerWorkloadSubCommand(SubCommand):
-    """
-    Command to create a runner workload deployment.
-    """
-
-    backend: str
-    device: str
-    command_script: str | None
-    port: int
-    host_network: bool
-    check: bool
-    namespace: str
-    service: str
-    version: str
-    name: str
-    volume: str
-    extra_args: list[str]
-
-    @staticmethod
-    def register(parser: _SubParsersAction):
-        deploy_parser = parser.add_parser(
-            "create-runner",
-            help="Create a runner workload deployment",
-        )
-
-        deploy_parser.add_argument(
-            "--backend",
-            type=str,
-            help="Backend to use (default: detect from current environment)",
-            choices=supported_backends(),
-        )
-
-        deploy_parser.add_argument(
-            "--device",
-            type=str,
-            help="Device to use, multiple devices join by comma (default: all devices)",
-            default="all",
-        )
-
-        deploy_parser.add_argument(
-            "--command-script-file",
-            type=str,
-            help="Path of command script for the workload",
-        )
-
-        deploy_parser.add_argument(
-            "--port",
-            type=int,
-            help="Port to expose",
-        )
-
-        deploy_parser.add_argument(
-            "--host-network",
-            action="store_true",
-            help="Use host network (default: False)",
-            default=False,
-        )
-
-        deploy_parser.add_argument(
-            "--check",
-            action="store_true",
-            help="Enable health check, needs --port (default: False)",
-            default=False,
-        )
-
-        deploy_parser.add_argument(
-            "--namespace",
-            type=str,
-            help="Namespace of the runner",
-        )
-
-        deploy_parser.add_argument(
-            "service",
-            type=str,
-            help="Service of the runner",
-        )
-
-        deploy_parser.add_argument(
-            "version",
-            type=str,
-            help="Version of the runner",
-        )
-
-        deploy_parser.add_argument(
-            "volume",
-            type=str,
-            help="Volume to mount",
-        )
-
-        deploy_parser.add_argument(
-            "extra_args",
-            nargs=REMAINDER,
-            help="Extra arguments for the runner",
-        )
-
-        deploy_parser.set_defaults(func=CreateRunnerWorkloadSubCommand)
-
-    def __init__(self, args: Namespace):
-        self.backend = args.backend
-        self.device = args.device
-        self.command_script = None
-        self.port = args.port
-        self.host_network = args.host_network
-        self.check = args.check
-        self.namespace = args.namespace
-        self.service = args.service
-        self.version = args.version
-        self.name = f"{args.service}-{args.version}".lower().replace(".", "-")
-        self.volume = args.volume
-        self.extra_args = args.extra_args
-
-        if not self.name or not self.volume:
-            msg = "The name and volume arguments are required."
-            raise ValueError(msg)
-
-        if args.command_script_file:
-            command_script_file = Path(args.command_script_file)
-            if not command_script_file.is_file():
-                msg = f"The command script file '{command_script_file}' does not exist."
-                raise ValueError(msg)
-            self.command_script = command_script_file.read_text(
-                encoding="utf-8",
-            ).strip()
-
-    def run(self):
-        env = [
-            ContainerEnv(
-                name=name,
-                value=value,
-            )
-            for name, value in os.environ.items()
-            if not name.startswith(_IGNORE_ENVS_PREFIX)
-            and not name.endswith(_IGNORE_ENVS_SUFFIX)
-        ]
-        if self.backend:
-            resources = ContainerResources(
-                **{
-                    v: self.device
-                    for k, v in envs.GPUSTACK_RUNTIME_DETECT_BACKEND_MAP_RESOURCE_KEY.items()
-                    if k == self.backend
-                },
-            )
-        else:
-            resources = ContainerResources(
-                **{
-                    envs.GPUSTACK_RUNTIME_DEPLOY_AUTOMAP_RESOURCE_KEY: self.device,
-                },
-            )
-        mounts = [
-            ContainerMount(
-                path=self.volume,
-            ),
-        ]
-        execution = ContainerExecution(
-            command_script=self.command_script,
-            args=self.extra_args,
-        )
-        ports = (
-            [
-                ContainerPort(
-                    internal=self.port,
-                ),
-            ]
-            if self.port
-            else None
-        )
-        checks = (
-            [
-                ContainerCheck(
-                    delay=60,
-                    interval=10,
-                    timeout=5,
-                    retries=6,
-                    tcp=ContainerCheckTCP(port=self.port),
-                    teardown=True,
-                ),
-            ]
-            if self.check and self.port
-            else None
-        )
-        plan = WorkloadPlan(
-            name=self.name,
-            namespace=self.namespace,
-            host_network=self.host_network,
-            containers=[
-                Container(
-                    restart_policy=(
-                        ContainerRestartPolicyEnum.NEVER
-                        if not self.check
-                        else ContainerRestartPolicyEnum.ALWAYS
-                    ),
-                    image=f"gpustack/runner:{self.backend if self.backend else 'Host'}X.Y-{self.service}{self.version}",
-                    name=self.name,
-                    envs=env,
-                    resources=resources,
-                    mounts=mounts,
-                    execution=execution,
-                    ports=ports,
-                    checks=checks,
-                ),
-            ],
-        )
-        create_workload(plan)
-        print(f"Created workload '{self.name}'.")
-
-        while True:
-            st = get_workload(
-                name=self.name,
-                namespace=self.namespace,
-            )
-            if st and st.state not in (
-                WorkloadStatusStateEnum.PENDING,
-                WorkloadStatusStateEnum.INITIALIZING,
-            ):
-                break
-            time.sleep(1)
-
-        print("\033[2J\033[H", end="")
-
-        async def stream_logs():
-            logs_result = await async_logs_workload(
-                name=self.name,
-                namespace=self.namespace,
-                tail=-1,
-                follow=True,
-            )
-            async for line in logs_result:
-                print(line.decode("utf-8").rstrip())
-
-        asyncio.run(stream_logs())
-
 
 class CreateWorkloadSubCommand(SubCommand):
     """
@@ -358,8 +116,7 @@ class CreateWorkloadSubCommand(SubCommand):
         deploy_parser.add_argument(
             "--device",
             type=str,
-            help="Device to use, multiple devices join by comma (default: all devices)",
-            default="all",
+            help="Device to use, multiple devices join by comma, all for all devices",
         )
 
         deploy_parser.add_argument(
@@ -456,20 +213,22 @@ class CreateWorkloadSubCommand(SubCommand):
             if not name.startswith(_IGNORE_ENVS_PREFIX)
             and not name.endswith(_IGNORE_ENVS_SUFFIX)
         ]
-        if self.backend:
-            resources = ContainerResources(
-                **{
-                    v: self.device
-                    for k, v in envs.GPUSTACK_RUNTIME_DETECT_BACKEND_MAP_RESOURCE_KEY.items()
-                    if k == self.backend
-                },
-            )
-        else:
-            resources = ContainerResources(
-                **{
-                    envs.GPUSTACK_RUNTIME_DEPLOY_AUTOMAP_RESOURCE_KEY: self.device,
-                },
-            )
+        resources = None
+        if self.device:
+            if self.backend:
+                resources = ContainerResources(
+                    **{
+                        v: self.device
+                        for k, v in envs.GPUSTACK_RUNTIME_DETECT_BACKEND_MAP_RESOURCE_KEY.items()
+                        if k == self.backend
+                    },
+                )
+            else:
+                resources = ContainerResources(
+                    **{
+                        envs.GPUSTACK_RUNTIME_DEPLOY_AUTOMAP_RESOURCE_KEY: self.device,
+                    },
+                )
         mounts = [
             ContainerMount(
                 path=self.volume,
@@ -1015,35 +774,175 @@ class InspectWorkloadSubCommand(SubCommand):
             raise ValueError(msg)
 
     def run(self):
-        workload = get_workload(self.name, self.namespace)
-        if not workload:
+        result = inspect_workload(self.name, self.namespace)
+        if not result:
             print(f"Workload '{self.name}' not found.")
             return
 
-        if hasattr(workload, "_d_containers"):
-            result = []
-            for c in workload._d_containers:  # noqa: SLF001
-                c_attrs = c.attrs
-                # Mask sensitive environment variables
-                if "Env" in c_attrs["Config"]:
-                    for i, env in enumerate(c_attrs["Config"]["Env"] or []):
-                        env_name, _ = env.split("=", maxsplit=1)
-                        if env_name.endswith(_IGNORE_SENSITIVE_ENVS_SUFFIX):
-                            c_attrs["Config"]["Env"][i] = f"{env_name}=******"
-                result.append(c_attrs)
-            print(safe_json(result, indent=2))
-        elif hasattr(workload, "_k_pod"):
-            k_pod = workload._k_pod  # noqa: SLF001
-            # Remove managed fields to reduce output size
-            k_pod.metadata.managed_fields = None
-            # Mask sensitive environment variables
-            for c in k_pod.spec.containers:
-                for env in c.env or []:
-                    if env.name.endswith(_IGNORE_SENSITIVE_ENVS_SUFFIX):
-                        env.value = "******"
-            print(safe_yaml(k_pod, indent=2, sort_keys=False))
-        else:
-            print("No detailed inspection information available for this workload.")
+        print(result)
+
+
+class LogsSelfSubCommand(SubCommand):
+    """
+    Command to get the logs of the deployer itself.
+    """
+
+    tail: int
+    follow: bool
+
+    @staticmethod
+    def register(parser: _SubParsersAction):
+        logs_parser = parser.add_parser(
+            "logs-self",
+            help="Get the logs of the deployer itself",
+        )
+
+        logs_parser.add_argument(
+            "--tail",
+            type=int,
+            help="Number of lines to show from the end of the logs (default: -1)",
+            default=-1,
+        )
+
+        logs_parser.add_argument(
+            "--follow",
+            "-f",
+            action="store_true",
+            help="Follow the logs in real-time",
+        )
+
+        logs_parser.set_defaults(func=LogsSelfSubCommand)
+
+    def __init__(self, args: Namespace):
+        self.tail = args.tail
+        self.follow = args.follow
+
+    def run(self):
+        print("\033[2J\033[H", end="")
+
+        async def stream_logs():
+            logs_result = await async_logs_self(
+                tail=self.tail,
+                follow=self.follow,
+            )
+            if self.follow:
+                async for line in logs_result:
+                    print(line.decode("utf-8").rstrip())
+            elif isinstance(logs_result, str):
+                print(logs_result.rstrip())
+            else:
+                print(logs_result.decode("utf-8").rstrip())
+
+        asyncio.run(stream_logs())
+
+
+class ExecSelfSubCommand(SubCommand):
+    """
+    Command to execute a command in the deployer itself.
+    """
+
+    interactive: bool
+    command: list[str]
+
+    @staticmethod
+    def register(parser: _SubParsersAction):
+        exec_parser = parser.add_parser(
+            "exec-self",
+            help="Execute a command in the deployer itself",
+        )
+
+        exec_parser.add_argument(
+            "--interactive",
+            "-i",
+            action="store_true",
+            help="Interactive mode",
+        )
+
+        exec_parser.add_argument(
+            "command",
+            nargs=REMAINDER,
+            help="Command to execute in the workload",
+        )
+
+        exec_parser.set_defaults(func=ExecSelfSubCommand)
+
+    def __init__(self, args: Namespace):
+        self.interactive = args.interactive
+        self.command = args.command
+
+    def run(self):
+        try:
+            if self.interactive:
+                from dockerpty import io, pty  # noqa: PLC0415
+        except ImportError:
+            print(
+                "dockerpty is required for interactive mode. "
+                "Please install it via 'pip install dockerpty'.",
+            )
+            sys.exit(1)
+
+        print("\033[2J\033[H", end="")
+        exec_result = exec_self(
+            detach=not self.interactive,
+            command=self.command,
+        )
+
+        # Non-interactive mode: print output and exit with the command's exit code
+
+        if not self.interactive:
+            if isinstance(exec_result, bytes):
+                print(exec_result.decode("utf-8").rstrip())
+            else:
+                print(exec_result)
+            return
+
+        # Interactive mode: use dockerpty to attach to the exec session
+
+        class ExecOperation(pty.Operation):
+            def __init__(self, sock):
+                self.stdin = sys.stdin
+                self.stdout = sys.stdout
+                self.sock = io.Stream(sock)
+
+            def israw(self, **_):
+                return self.stdout.isatty()
+
+            def start(self, **_):
+                sock = self.sockets()
+                return [
+                    io.Pump(io.Stream(self.stdin), sock, wait_for_output=False),
+                    io.Pump(sock, io.Stream(self.stdout), propagate_close=False),
+                ]
+
+            def resize(self, height, width, **_):
+                pass
+
+            def sockets(self):
+                return self.sock
+
+        exec_op = ExecOperation(exec_result)
+        pty.PseudoTerminal(None, exec_op).start()
+
+
+class InspectSelfSubCommand(SubCommand):
+    """
+    Command to diagnose the deployer itself.
+    """
+
+    @staticmethod
+    def register(parser: _SubParsersAction):
+        inspect_parser = parser.add_parser(
+            "inspect-self",
+            help="Inspect the deployer itself",
+        )
+
+        inspect_parser.set_defaults(func=InspectSelfSubCommand)
+
+    def __init__(self, args: Namespace):
+        pass
+
+    def run(self):
+        print(inspect_self())
 
 
 def format_workloads_json(sts: list[WorkloadStatus]) -> str: