gpustack-runtime 0.1.39.post1__tar.gz → 0.1.39.post3__tar.gz

{gpustack_runtime-0.1.39.post1 → gpustack_runtime-0.1.39.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpustack-runtime
-Version: 0.1.39.post1
+Version: 0.1.39.post3
 Summary: GPUStack Runtime is library for detecting GPU resources and launching GPU workloads.
 Project-URL: Homepage, https://github.com/gpustack/runtime
 Project-URL: Bug Tracker, https://github.com/gpustack/gpustack/issues
@@ -15,8 +15,9 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: argcomplete>=3.6.3
 Requires-Dist: docker>=7.1.0
-Requires-Dist: gpustack-runner>=0.1.23.post2
+Requires-Dist: gpustack-runner>=0.1.23.post5
 Requires-Dist: kubernetes>=33.1.0
+Requires-Dist: mthreads-ml-py>=2.2.10
 Requires-Dist: nvidia-ml-py>=13.580.65
 Requires-Dist: podman==5.6.0
 Requires-Dist: pyyaml

{gpustack_runtime-0.1.39.post1 → gpustack_runtime-0.1.39.post3}/gpustack_runtime/__main__.py

@@ -16,12 +16,15 @@ from .cmds import (
     DeleteWorkloadsSubCommand,
     DeleteWorkloadSubCommand,
     DetectDevicesSubCommand,
+    ExecSelfSubCommand,
     ExecWorkloadSubCommand,
     GetDevicesTopologySubCommand,
     GetWorkloadSubCommand,
+    InspectSelfSubCommand,
     InspectWorkloadSubCommand,
     ListImagesSubCommand,
     ListWorkloadsSubCommand,
+    LogsSelfSubCommand,
     LogsWorkloadSubCommand,
     SaveImagesSubCommand,
 )
@@ -71,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-0.1.39.post1 → gpustack_runtime-0.1.39.post3}/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.post1'
-__version_tuple__ = version_tuple = (0, 1, 39, 'post1')
+__version__ = version = '0.1.39.post3'
+__version_tuple__ = version_tuple = (0, 1, 39, 'post3')
 try:
     from ._version_appendix import git_commit
     __commit_id__ = commit_id = git_commit

gpustack_runtime-0.1.39.post3/gpustack_runtime/_version_appendix.py

@@ -0,0 +1 @@
+git_commit = "d65920e"

{gpustack_runtime-0.1.39.post1 → gpustack_runtime-0.1.39.post3}/gpustack_runtime/cmds/__init__.py

@@ -4,10 +4,13 @@ from .deployer import (
     CreateWorkloadSubCommand,
     DeleteWorkloadsSubCommand,
     DeleteWorkloadSubCommand,
+    ExecSelfSubCommand,
     ExecWorkloadSubCommand,
     GetWorkloadSubCommand,
+    InspectSelfSubCommand,
     InspectWorkloadSubCommand,
     ListWorkloadsSubCommand,
+    LogsSelfSubCommand,
     LogsWorkloadSubCommand,
 )
 from .detector import DetectDevicesSubCommand, GetDevicesTopologySubCommand
@@ -26,12 +29,15 @@ __all__ = [
     "DeleteWorkloadSubCommand",
     "DeleteWorkloadsSubCommand",
     "DetectDevicesSubCommand",
+    "ExecSelfSubCommand",
     "ExecWorkloadSubCommand",
     "GetDevicesTopologySubCommand",
     "GetWorkloadSubCommand",
+    "InspectSelfSubCommand",
     "InspectWorkloadSubCommand",
     "ListImagesSubCommand",
     "ListWorkloadsSubCommand",
+    "LogsSelfSubCommand",
     "LogsWorkloadSubCommand",
     "PlatformedImage",
     "SaveImagesSubCommand",

{gpustack_runtime-0.1.39.post1 → gpustack_runtime-0.1.39.post3}/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,19 +81,6 @@ _IGNORE_ENVS_SUFFIX = (
     "_DRIVER_CAPABILITIES",
 )
 
-_IGNORE_SENSITIVE_ENVS_SUFFIX = (
-    "_KEY",
-    "_key",
-    "_TOKEN",
-    "_token",
-    "_SECRET",
-    "_secret",
-    "_PASSWORD",
-    "_password",
-    "_PASS",
-    "_pass",
-)
-
 
 class CreateWorkloadSubCommand(SubCommand):
     """
@@ -784,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:

{gpustack_runtime-0.1.39.post1 → gpustack_runtime-0.1.39.post3}/gpustack_runtime/deployer/__init__.py

@@ -373,6 +373,198 @@ def exec_workload(
     raise UnsupportedError(_NO_AVAILABLE_DEPLOYER_MSG)
 
 
+def inspect_workload(
+    name: WorkloadName,
+    namespace: WorkloadNamespace | None = None,
+) -> str:
+    """
+    Inspect the given workload.
+
+    Args:
+        name:
+            The name of the workload to inspect.
+        namespace:
+            The namespace of the workload.
+
+    Returns:
+        The inspection data as a dictionary.
+
+    Raises:
+        UnsupportedError:
+            If no deployer supports the given workload.
+        OperationError:
+            If the deployer fails to inspect the workload.
+
+    """
+    for dep in _DEPLOYERS:
+        if not dep.is_supported():
+            continue
+
+        return dep.inspect(
+            name=name,
+            namespace=namespace,
+        )
+
+    raise UnsupportedError(_NO_AVAILABLE_DEPLOYER_MSG)
+
+
+def logs_self(
+    timestamps: bool = False,
+    tail: int | None = None,
+    since: int | None = None,
+    follow: bool = False,
+) -> Generator[bytes | str, None, None] | bytes | str:
+    """
+    Get the logs of the deployer itself.
+    Only works in mirrored deployment mode.
+
+    Args:
+        timestamps:
+            Whether to include timestamps in the logs.
+        tail:
+            The number of lines from the end of the logs to show.
+        since:
+            Show logs since a given time (in seconds).
+        follow:
+            Whether to follow the logs.
+
+    Returns:
+        The logs as a byte string, a string or a generator yielding byte strings or strings if follow is True.
+
+    Raises:
+        UnsupportedError:
+            If no deployer supports the given workload.
+        OperationError:
+            If the deployer fails to get the logs of the workload.
+
+    """
+    for dep in _DEPLOYERS:
+        if not dep.is_supported():
+            continue
+
+        if hasattr(dep, "endoscopic_logs"):
+            return dep.endoscopic_logs(
+                timestamps=timestamps,
+                tail=tail,
+                since=since,
+                follow=follow,
+            )
+
+    raise UnsupportedError(_NO_AVAILABLE_DEPLOYER_MSG)
+
+
+async def async_logs_self(
+    timestamps: bool = False,
+    tail: int | None = None,
+    since: int | None = None,
+    follow: bool = False,
+) -> AsyncGenerator[bytes | str, None, None] | bytes | str:
+    """
+    Asynchronously get the logs of the deployer itself.
+    Only works in mirrored deployment mode.
+
+    Args:
+        timestamps:
+            Whether to include timestamps in the logs.
+        tail:
+            The number of lines from the end of the logs to show.
+        since:
+            Show logs since a given time (in seconds).
+        follow:
+            Whether to follow the logs.
+
+    Returns:
+        The logs as a byte string, a string or a generator yielding byte strings or strings if follow is True.
+
+    Raises:
+        UnsupportedError:
+            If no deployer supports the given workload.
+        OperationError:
+            If the deployer fails to get the logs of the workload.
+
+    """
+    for dep in _DEPLOYERS:
+        if not dep.is_supported():
+            continue
+
+        if hasattr(dep, "async_endoscopic_logs"):
+            return await dep.async_endoscopic_logs(
+                timestamps=timestamps,
+                tail=tail,
+                since=since,
+                follow=follow,
+            )
+
+    raise UnsupportedError(_NO_AVAILABLE_DEPLOYER_MSG)
+
+
+def exec_self(
+    detach: bool = True,
+    command: list[str] | None = None,
+    args: list[str] | None = None,
+) -> WorkloadExecStream | bytes | str:
+    """
+    Execute a command in the deployer itself.
+    Only works in mirrored deployment mode.
+
+    Args:
+        detach:
+            Whether to detach from the command execution.
+        command:
+            The command to execute.
+        args:
+            The arguments to pass to the command.
+
+    Returns:
+        If detach is False, return a WorkloadExecStream.
+        otherwise, return the output of the command as a byte string or string.
+
+    Raises:
+        UnsupportedError:
+            If no deployer supports the given workload.
+        OperationError:
+            If the deployer fails to execute the command in the workload.
+
+    """
+    for dep in _DEPLOYERS:
+        if not dep.is_supported():
+            continue
+
+        if hasattr(dep, "endoscopic_exec"):
+            return dep.endoscopic_exec(
+                detach=detach,
+                command=command,
+                args=args,
+            )
+
+    raise UnsupportedError(_NO_AVAILABLE_DEPLOYER_MSG)
+
+
+def inspect_self() -> str:
+    """
+    Inspect the deployer itself.
+    Only works in mirrored deployment mode.
+
+    Returns:
+        The inspection data as a dictionary.
+
+    Raises:
+        UnsupportedError:
+            If no deployer supports the given workload.
+        OperationError:
+            If the deployer fails to inspect the workload.
+
+    """
+    for dep in _DEPLOYERS:
+        if not dep.is_supported():
+            continue
+
+        if hasattr(dep, "endoscopic_inspect"):
+            return dep.endoscopic_inspect()
+
+    raise UnsupportedError(_NO_AVAILABLE_DEPLOYER_MSG)
+
+
 __all__ = [
     "Container",
     "ContainerCapabilities",
@@ -408,12 +600,17 @@ __all__ = [
     "WorkloadSecuritySysctl",
     "WorkloadStatus",
     "WorkloadStatusStateEnum",
+    "async_logs_self",
     "async_logs_workload",
     "create_workload",
     "delete_workload",
+    "exec_self",
     "exec_workload",
     "get_workload",
+    "inspect_self",
+    "inspect_workload",
     "list_workloads",
+    "logs_self",
     "logs_workload",
     "supported_list",
 ]