gpustack-runtime 0.1.39.post1__py3-none-any.whl → 0.1.39.post3__py3-none-any.whl

gpustack_runtime/deployer/__types__.py

@@ -1020,11 +1020,13 @@ class WorkloadPlan(WorkloadSecurity):
                 c.execution.command_script = None
             # Add default registry if needed.
             if (
-                envs.GPUSTACK_RUNTIME_DEPLOY_DEFAULT_IMAGE_REGISTRY
-                and envs.GPUSTACK_RUNTIME_DEPLOY_DEFAULT_IMAGE_REGISTRY
+                envs.GPUSTACK_RUNTIME_DEPLOY_DEFAULT_CONTAINER_REGISTRY
+                and envs.GPUSTACK_RUNTIME_DEPLOY_DEFAULT_CONTAINER_REGISTRY
                 not in ["docker.io", "index.docker.io"]
             ):
-                image_registry = envs.GPUSTACK_RUNTIME_DEPLOY_DEFAULT_IMAGE_NAMESPACE
+                image_registry = (
+                    envs.GPUSTACK_RUNTIME_DEPLOY_DEFAULT_CONTAINER_NAMESPACE
+                )
                 image_split = c.image.split("/")
                 if len(image_split) == 1:
                     c.image = f"{image_registry}/library/{c.image}"
@@ -1245,6 +1247,25 @@ class WorkloadExecStream(ABC):
         raise NotImplementedError
 
 
+def _default_args(func):
+    """
+    Decorator to set default args for deployer methods.
+
+    """
+
+    def wrapper(self, *args, async_mode=None, **kwargs):
+        if async_mode is None:
+            async_mode = envs.GPUSTACK_RUNTIME_DEPLOY_ASYNC
+        return func(
+            self,
+            *args,
+            async_mode=async_mode,
+            **kwargs,
+        )
+
+    return wrapper
+
+
 class Deployer(ABC):
     """
     Base class for all deployers.
@@ -1326,20 +1347,6 @@ class Deployer(ABC):
         """
         raise NotImplementedError
 
-    @staticmethod
-    def _default_args(func):
-        def wrapper(self, *args, async_mode=None, **kwargs):
-            if async_mode is None:
-                async_mode = envs.GPUSTACK_RUNTIME_DEPLOY_ASYNC
-            return func(
-                self,
-                *args,
-                async_mode=async_mode,
-                **kwargs,
-            )
-
-        return wrapper
-
     def __init__(self, name: str):
         self._name = name
 
@@ -2130,3 +2137,361 @@ class Deployer(ABC):
 
         """
         raise NotImplementedError
+
+    @_default_args
+    def inspect(
+        self,
+        name: WorkloadName,
+        namespace: WorkloadNamespace | None = None,
+        async_mode: bool | None = None,
+    ) -> str | None:
+        """
+        Inspect a workload.
+
+        Args:
+            name:
+                The name of the workload.
+            namespace:
+                The namespace of the workload.
+            async_mode:
+                Whether to execute in a separate thread.
+
+        Returns:
+            The inspection result. None if not found.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the workload fails to inspect.
+
+        """
+        if async_mode:
+            try:
+                future = self.pool.submit(
+                    self._inspect,
+                    name,
+                    namespace,
+                )
+                return future.result()
+            except OperationError:
+                raise
+            except Exception as e:
+                msg = "Asynchronous workload inspect failed."
+                raise OperationError(msg) from e
+        else:
+            return self._inspect(name, namespace)
+
+    @abstractmethod
+    def _inspect(
+        self,
+        name: WorkloadName,
+        namespace: WorkloadNamespace | None = None,
+    ) -> str | None:
+        """
+        Inspect a workload.
+
+        Args:
+            name:
+                The name of the workload.
+            namespace:
+                The namespace of the workload.
+
+        Returns:
+            The inspection result. None if not found.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the workload fails to inspect.
+
+        """
+        raise NotImplementedError
+
+
+class EndoscopicDeployer(Deployer):
+    """
+    Base class for endoscopic deployers.
+    """
+
+    async def async_endoscopic_logs(
+        self,
+        timestamps: bool = False,
+        tail: int | None = None,
+        since: int | None = None,
+        follow: bool = False,
+        async_mode: bool | None = None,
+    ) -> AsyncGenerator[bytes | str, None, None] | bytes | str:
+        """
+        Asynchronously get the logs of the deployer itself.
+        Only works in mirrored deployment mode.
+
+        Args:
+            timestamps:
+                Show timestamps in the logs.
+            tail:
+                Number of lines to show from the end of the logs.
+            since:
+                Show logs since the given epoch in seconds.
+            follow:
+                Whether to follow the logs.
+            async_mode:
+                Whether to execute in a separate thread.
+
+        Returns:
+            The logs as a byte string or a generator yielding byte strings if follow is True.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the deployer fails to get logs.
+
+        """
+
+        def run_sync_gen(f: bool) -> Generator[bytes | str, None, None] | bytes | str:
+            return self.endoscopic_logs(
+                timestamps=timestamps,
+                tail=tail,
+                since=since,
+                follow=f,
+                async_mode=async_mode,
+            )
+
+        if not follow:
+            return run_sync_gen(False)
+
+        async def async_gen() -> AsyncGenerator[bytes | str, None, None]:
+            loop = asyncio.get_event_loop()
+            sync_gen = await loop.run_in_executor(self.pool, run_sync_gen, True)
+            with contextlib.closing(sync_gen) as gen:
+                for chunk in gen:
+                    yield chunk
+
+        return async_gen()
+
+    @_default_args
+    def endoscopic_logs(
+        self,
+        timestamps: bool = False,
+        tail: int | None = None,
+        since: int | None = None,
+        follow: bool = False,
+        async_mode: bool | None = None,
+    ) -> Generator[bytes | str, None, None] | bytes | str:
+        """
+        Get the logs of the deployer itself.
+        Only works in mirrored deployment mode.
+
+        Args:
+            timestamps:
+                Show timestamps in the logs.
+            tail:
+                Number of lines to show from the end of the logs.
+            since:
+                Show logs since the given epoch in seconds.
+            follow:
+                Whether to follow the logs.
+            async_mode:
+                Whether to execute in a separate thread.
+
+        Returns:
+            The logs as a byte string or a generator yielding byte strings if follow is True.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the deployer fails to get logs.
+
+        """
+        if async_mode:
+            try:
+                future = self.pool.submit(
+                    self._endoscopic_logs,
+                    timestamps,
+                    tail,
+                    since,
+                    follow,
+                )
+                return future.result()
+            except OperationError:
+                raise
+            except Exception as e:
+                msg = "Asynchronous endoscopic logs failed."
+                raise OperationError(msg) from e
+        else:
+            return self._endoscopic_logs(timestamps, tail, since, follow)
+
+    @abstractmethod
+    def _endoscopic_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:
+                Show timestamps in the logs.
+            tail:
+                Number of lines to show from the end of the logs.
+            since:
+                Show logs since the given epoch in seconds.
+            follow:
+                Whether to follow the logs.
+
+        Returns:
+            The logs as a byte string or a generator yielding byte strings if follow is True.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the deployer fails to get logs.
+
+        """
+        raise NotImplementedError
+
+    @_default_args
+    def endoscopic_exec(
+        self,
+        detach: bool = True,
+        command: list[str] | None = None,
+        args: list[str] | None = None,
+        async_mode: bool | 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.
+            command:
+                The command to execute.
+                If not specified, use /bin/sh and implicitly attach.
+            args:
+                The arguments to pass to the command.
+            async_mode:
+                Whether to execute in a separate thread.
+
+        Returns:
+            If detach is False, return a WorkloadExecStream.
+            otherwise, return the output of the command as a byte string or string.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the deployer fails to execute the command.
+
+        """
+        if async_mode:
+            try:
+                future = self.pool.submit(
+                    self._endoscopic_exec,
+                    detach,
+                    command,
+                    args,
+                )
+                return future.result()
+            except OperationError:
+                raise
+            except Exception as e:
+                msg = "Asynchronous endoscopic exec failed."
+                raise OperationError(msg) from e
+        else:
+            return self._endoscopic_exec(detach, command, args)
+
+    @abstractmethod
+    def _endoscopic_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.
+            command:
+                The command to execute.
+                If not specified, use /bin/sh and implicitly attach.
+            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 the deployer is not supported in the current environment.
+            OperationError:
+                If the deployer fails to execute the command.
+
+        """
+        raise NotImplementedError
+
+    def endoscopic_inspect(
+        self,
+        async_mode: bool | None = None,
+    ) -> str:
+        """
+        Inspect the deployer itself.
+        Only works in mirrored deployment mode.
+
+        Args:
+            async_mode:
+                Whether to execute in a separate thread.
+
+        Returns:
+            The inspection result.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the deployer fails to execute the command.
+
+        """
+        if async_mode:
+            try:
+                future = self.pool.submit(
+                    self._endoscopic_inspect,
+                )
+                return future.result()
+            except OperationError:
+                raise
+            except Exception as e:
+                msg = "Asynchronous endoscopic inspect failed."
+                raise OperationError(msg) from e
+        else:
+            return self._endoscopic_inspect()
+
+    @abstractmethod
+    def _endoscopic_inspect(self) -> str:
+        """
+        Inspect the deployer itself.
+        Only works in mirrored deployment mode.
+
+        Returns:
+            The inspection result.
+
+        Raises:
+            UnsupportedError:
+                If the deployer is not supported in the current environment.
+            OperationError:
+                If the deployer fails to execute the command.
+
+        """
+        raise NotImplementedError

gpustack_runtime/deployer/__utils__.py

@@ -42,6 +42,25 @@ Regex for RFC1035 domain name, which must:
     - start with an alphabetic character
     - end with an alphanumeric character
 """
+_SENSITIVE_ENVS_SUFFIX = (
+    "key",
+    "keys",
+    "token",
+    "tokens",
+    "secret",
+    "secrets",
+    "password",
+    "passwords",
+    "passwd",
+    "pass",
+    "credential",
+    "credentials",
+    "cred",
+    "auth",
+)
+"""
+Suffixes of environment variable names that are considered sensitive.
+"""
 
 
 @lru_cache
@@ -775,3 +794,18 @@ def make_image_with(
     else:
         image += f":{tag}"
     return image
+
+
+def sensitive_env_var(name: str) -> bool:
+    """
+    Check if the given environment variable name is considered sensitive.
+
+    Args:
+        name:
+            The environment variable name to check.
+
+    Returns:
+        True if the name is considered sensitive, False otherwise.
+
+    """
+    return name.lower().endswith(_SENSITIVE_ENVS_SUFFIX)