termainer 0.4.0__py3-none-any.whl

termainer/providers/docker.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+import shlex
+import shutil
+from typing import AsyncIterator, Dict, List, Optional
+
+from ..remote.ssh import SSHConnection
+from .base import ContainerDetails, ContainerStats, ContainerSummary
+
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]")
+
+
+class DockerProvider:
+    name = "docker"
+
+    def __init__(self, ssh: Optional[SSHConnection] = None) -> None:
+        self._docker_path: Optional[str] = None
+        self._ssh = ssh
+
+    async def is_available(self) -> bool:
+        if self._ssh:
+            try:
+                await self._ssh.run(["docker", "info"])
+                self._docker_path = "docker"
+                return True
+            except RuntimeError:
+                return False
+        self._docker_path = shutil.which("docker")
+        if not self._docker_path:
+            return False
+        proc = await asyncio.create_subprocess_exec(
+            self._docker_path, "info",
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        code = await proc.wait()
+        return code == 0
+
+    async def list_containers(self) -> List[ContainerSummary]:
+        raw_ids = await self._run("ps", "-a", "-q", "--no-trunc")
+        ids = [i.strip() for i in raw_ids.split("\n") if i.strip()]
+        if not ids:
+            return []
+
+        raw_details = await self._run("inspect", *ids)
+        data = json.loads(raw_details)
+        if not isinstance(data, list):
+            data = [data]
+
+        containers = []
+        for item in data:
+            cid = item.get("Id", "")
+            if cid.startswith("sha256:"):
+                cid = cid[7:]
+            config = item.get("Config", {}) or {}
+            state = item.get("State", {}) or {}
+            net_settings = item.get("NetworkSettings", {}) or {}
+            host_config = item.get("HostConfig", {}) or {}
+
+            ports_raw = net_settings.get("Ports", {}) or {}
+            port_str = ", ".join(
+                f"{b[0]['HostPort']}->{port}"
+                if b and isinstance(b, list) and len(b) > 0 and "HostPort" in b[0]
+                else port
+                for port, b in ports_raw.items()
+            )
+
+            networks_raw = net_settings.get("Networks", {}) or {}
+            net_str = ", ".join(networks_raw.keys())
+
+            restart = (host_config.get("RestartPolicy", {}) or {}).get("Name", "")
+
+            containers.append({
+                "id": cid,
+                "names": item.get("Name", "").lstrip("/"),
+                "image": config.get("Image", ""),
+                "status": state.get("Status", "unknown"),
+                "createdat": item.get("Created", ""),
+                "ports": port_str,
+                "networks": net_str,
+                "restartpolicy": restart,
+            })
+        return containers
+
+    async def inspect(self, container_id: str) -> ContainerDetails:
+        raw = await self._run("inspect", container_id)
+        data = json.loads(raw)
+        if isinstance(data, list):
+            return data[0] if data else {}
+        return data
+
+    async def stats(self, container_id: str) -> AsyncIterator[ContainerStats]:
+        if self._ssh:
+            stream = await self._ssh.stream(
+                ["docker", "stats", "--format", "{{json .}}", container_id]
+            )
+        else:
+            proc = await asyncio.create_subprocess_exec(
+                self._docker_path, "stats", "--format", "{{json .}}", container_id,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stream = proc.stdout
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            raw = _ANSI_RE.sub("", line.decode("utf-8", errors="replace")).strip()
+            if raw:
+                yield json.loads(raw)
+
+    async def logs(
+        self, container_id: str, tail: int = 100, follow: bool = False
+    ) -> AsyncIterator[str]:
+        cmd = ["logs", "--tail", str(tail)]
+        if follow:
+            cmd.append("-f")
+        cmd.append(container_id)
+
+        if self._ssh:
+            stream = await self._ssh.stream(["docker"] + cmd)
+        else:
+            proc = await asyncio.create_subprocess_exec(
+                self._docker_path, *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+            stream = proc.stdout
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace").rstrip("\n")
+            if not follow:
+                break
+
+    async def get_env(self, container_id: str) -> Dict[str, str]:
+        details = await self.inspect(container_id)
+        env_list: List[str] = (
+            details.get("Config", {}).get("Env", [])
+        )
+        env_dict: Dict[str, str] = {}
+        for entry in env_list:
+            if "=" in entry:
+                key, _, val = entry.partition("=")
+                env_dict[key] = val
+        return env_dict
+
+    async def start(self, container_id: str) -> None:
+        await self._run("start", container_id)
+
+    async def stop(self, container_id: str) -> None:
+        await self._run("stop", container_id)
+
+    async def restart(self, container_id: str) -> None:
+        await self._run("restart", container_id)
+
+    async def remove(self, container_id: str, force: bool = False) -> None:
+        args = ["rm"]
+        if force:
+            args.append("-f")
+        args.append(container_id)
+        await self._run(*args)
+
+    async def set_restart_policy(self, container_id: str, policy: str) -> None:
+        await self._run("update", "--restart", policy, container_id)
+
+    async def exec_command(self, container_id: str, command: str) -> AsyncIterator[str]:
+        try:
+            parts = shlex.split(command)
+        except ValueError:
+            parts = command.split()
+        cmd = ["exec", container_id] + parts
+        if self._ssh:
+            stream = await self._ssh.stream(["docker"] + cmd)
+        else:
+            proc = await asyncio.create_subprocess_exec(
+                self._docker_path, *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+            stream = proc.stdout
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace").rstrip("\n")
+
+    async def close(self) -> None:
+        pass
+
+    async def _run(self, *args: str) -> str:
+        if self._ssh:
+            return await self._ssh.run(["docker"] + list(args))
+        if self._docker_path is None:
+            self._docker_path = shutil.which("docker")
+        if self._docker_path is None:
+            raise RuntimeError("docker not found in PATH")
+        proc = await asyncio.create_subprocess_exec(
+            self._docker_path, *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"docker {' '.join(args)} failed: {stderr.decode()}"
+            )
+        return stdout.decode("utf-8", errors="replace")

termainer/providers/kubernetes.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import shlex
+import shutil
+from datetime import datetime, timezone
+from typing import AsyncIterator, Dict, List, Optional, Tuple
+
+from ..remote.ssh import SSHConnection
+from .base import ContainerDetails, ContainerStats, ContainerSummary
+
+
+class KubernetesProvider:
+    name = "kubernetes"
+
+    def __init__(self, ssh: Optional[SSHConnection] = None) -> None:
+        self._kubectl_path: Optional[str] = None
+        self._ssh = ssh
+
+    async def is_available(self) -> bool:
+        if self._ssh:
+            try:
+                await self._ssh.run(["kubectl", "cluster-info"])
+                self._kubectl_path = "kubectl"
+                return True
+            except RuntimeError:
+                return False
+        self._kubectl_path = shutil.which("kubectl")
+        if not self._kubectl_path:
+            return False
+        proc = await asyncio.create_subprocess_exec(
+            self._kubectl_path, "cluster-info",
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        code = await proc.wait()
+        return code == 0
+
+    async def list_containers(self) -> List[ContainerSummary]:
+        raw = await self._run(
+            "get", "pods", "--all-namespaces", "-o", "json"
+        )
+        data = json.loads(raw)
+        pods = []
+        for item in data.get("items", []):
+            status = item.get("status", {})
+            spec = item.get("spec", {})
+            metadata = item.get("metadata", {})
+            container_statuses = status.get("containerStatuses", [])
+            containers = spec.get("containers", [])
+            ready = sum(1 for c in container_statuses if c.get("ready"))
+            total = len(containers)
+            restarts = sum(int(c.get("restartCount", 0)) for c in container_statuses)
+            images = [c.get("image", "") for c in containers]
+            namespace = metadata.get("namespace", "default")
+            name = metadata.get("name", "unknown")
+            pods.append({
+                "id": f"{namespace}/{name}",
+                "name": name,
+                "namespace": namespace,
+                "status": status.get("phase", "Unknown"),
+                "image": ", ".join(images),
+                "node": spec.get("nodeName", ""),
+                "ready": f"{ready}/{total}",
+                "restart": str(restarts),
+                "created": self._age(metadata.get("creationTimestamp", "")),
+                "networks": status.get("podIP", ""),
+                "ports": self._ports(containers),
+                "containers": [c.get("name", "") for c in containers],
+                "raw": item,
+            })
+        return pods
+
+    async def inspect(self, container_id: str) -> ContainerDetails:
+        namespace, name = self._parse_id(container_id)
+        raw = await self._run(
+            "get", "pod", name, "-n", namespace, "-o", "json"
+        )
+        return json.loads(raw)
+
+    async def stats(self, container_id: str) -> AsyncIterator[ContainerStats]:
+        namespace, name = self._parse_id(container_id)
+        while True:
+            try:
+                raw = await self._run(
+                    "top", "pod", name, "-n", namespace
+                )
+                lines = raw.strip().split("\n")
+                if len(lines) >= 2:
+                    parts = lines[1].split()
+                    if len(parts) >= 3:
+                        yield {
+                            "pod": name,
+                            "namespace": namespace,
+                            "cpu": parts[1],
+                            "memory": parts[2],
+                        }
+            except RuntimeError:
+                yield {"pod": name, "namespace": namespace, "cpu": "N/A", "memory": "N/A"}
+            await asyncio.sleep(2)
+
+    async def logs(
+        self, container_id: str, tail: int = 100, follow: bool = False
+    ) -> AsyncIterator[str]:
+        namespace, name = self._parse_id(container_id)
+        cmd = ["logs", "--tail", str(tail), name, "-n", namespace]
+        if follow:
+            cmd.append("-f")
+
+        if self._ssh:
+            stream = await self._ssh.stream(["kubectl"] + cmd)
+        else:
+            proc = await asyncio.create_subprocess_exec(
+                self._kubectl_path, *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+            stream = proc.stdout
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace").rstrip("\n")
+            if not follow:
+                break
+
+    async def get_env(self, container_id: str) -> Dict[str, str]:
+        details = await self.inspect(container_id)
+        env_dict: Dict[str, str] = {}
+        containers = (
+            details.get("spec", {}).get("containers", [])
+        )
+        for container in containers:
+            for env in container.get("env", []):
+                key = env.get("name", "")
+                val = env.get("value", "")
+                if not val and env.get("valueFrom"):
+                    val = "<valueFrom>"
+                if key:
+                    env_dict[key] = val
+        return env_dict
+
+    async def start(self, container_id: str) -> None:
+        raise RuntimeError("Start no aplica a pods de Kubernetes")
+
+    async def stop(self, container_id: str) -> None:
+        raise RuntimeError("Stop no aplica a pods de Kubernetes; usa delete/scale en una futura vista Kubernetes")
+
+    async def restart(self, container_id: str) -> None:
+        raise RuntimeError("Restart de Kubernetes se implementara sobre deployments/rollouts")
+
+    async def remove(self, container_id: str, force: bool = False) -> None:
+        namespace, name = self._parse_id(container_id)
+        await self._run("delete", "pod", name, "-n", namespace)
+
+    async def set_restart_policy(self, container_id: str, policy: str) -> None:
+        raise RuntimeError(
+            "En Kubernetes la política de reinicio (restartPolicy) está definida en el "
+            "manifiesto del Deployment/StatefulSet y no puede cambiarse en un pod en ejecución. "
+            "Usa 'kubectl edit deployment <nombre>' para modificarla y forzar un rollout."
+        )
+
+    async def exec_command(self, container_id: str, command: str) -> AsyncIterator[str]:
+        namespace, name = self._parse_id(container_id)
+        try:
+            parts = shlex.split(command)
+        except ValueError:
+            parts = command.split()
+        cmd = ["exec", name, "-n", namespace, "--"] + parts
+        if self._ssh:
+            stream = await self._ssh.stream(["kubectl"] + cmd)
+        else:
+            proc = await asyncio.create_subprocess_exec(
+                self._kubectl_path, *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+            stream = proc.stdout
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace").rstrip("\n")
+
+    async def close(self) -> None:
+        pass
+
+    def _parse_id(self, container_id: str) -> Tuple[str, str]:
+        if "/" in container_id:
+            namespace, name = container_id.split("/", 1)
+            return namespace, name
+        return "default", container_id
+
+    @staticmethod
+    def _ports(containers: list[dict]) -> str:
+        ports = []
+        for container in containers:
+            for port in container.get("ports", []):
+                container_port = port.get("containerPort")
+                protocol = port.get("protocol", "TCP")
+                if container_port:
+                    ports.append(f"{container_port}/{protocol.lower()}")
+        return ", ".join(ports)
+
+    @staticmethod
+    def _age(timestamp: str) -> str:
+        if not timestamp:
+            return ""
+        try:
+            created = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+        except ValueError:
+            return timestamp
+        delta = datetime.now(timezone.utc) - created
+        seconds = int(delta.total_seconds())
+        if seconds < 60:
+            return f"{seconds}s"
+        minutes = seconds // 60
+        if minutes < 60:
+            return f"{minutes}m"
+        hours = minutes // 60
+        if hours < 24:
+            return f"{hours}h"
+        return f"{hours // 24}d"
+
+    async def _run(self, *args: str) -> str:
+        if self._ssh:
+            return await self._ssh.run(["kubectl"] + list(args))
+        proc = await asyncio.create_subprocess_exec(
+            self._kubectl_path, *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"kubectl {' '.join(args)} failed: {stderr.decode()}"
+            )
+        return stdout.decode("utf-8", errors="replace")

termainer/providers/openshift.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+from typing import AsyncIterator, List, Optional
+
+from ..remote.ssh import SSHConnection
+from .kubernetes import KubernetesProvider
+
+
+class OpenShiftProvider(KubernetesProvider):
+    name = "openshift"
+
+    def __init__(self, ssh: Optional[SSHConnection] = None) -> None:
+        super().__init__(ssh=ssh)
+        self._oc_path: Optional[str] = None
+
+    async def is_available(self) -> bool:
+        if self._ssh:
+            try:
+                await self._ssh.run(["oc", "whoami"])
+                self._kubectl_path = "oc"
+                return True
+            except RuntimeError:
+                return False
+        self._kubectl_path = shutil.which("oc")
+        if not self._kubectl_path:
+            return False
+        proc = await asyncio.create_subprocess_exec(
+            self._kubectl_path, "whoami",
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        code = await proc.wait()
+        return code == 0
+
+    async def list_containers(self) -> List[dict]:
+        raw = await self._run(
+            "get", "pods", "--all-namespaces", "-o", "json"
+        )
+        data = json.loads(raw)
+        pods = []
+        for item in data.get("items", []):
+            pods.append({
+                "id": f"{item['metadata']['namespace']}/{item['metadata']['name']}",
+                "name": item["metadata"]["name"],
+                "namespace": item["metadata"]["namespace"],
+                "status": item["status"]["phase"],
+                "node": item.get("spec", {}).get("nodeName", ""),
+                "containers": [
+                    c["name"] for c in item["spec"]["containers"]
+                ],
+                "raw": item,
+            })
+        return pods
+
+    async def stats(self, container_id: str) -> AsyncIterator[dict]:
+        namespace, name = self._parse_id(container_id)
+        while True:
+            try:
+                raw = await self._run(
+                    "adm", "top", "pod", name, "-n", namespace
+                )
+                lines = raw.strip().split("\n")
+                if len(lines) >= 2:
+                    parts = lines[1].split()
+                    if len(parts) >= 3:
+                        yield {
+                            "pod": name,
+                            "namespace": namespace,
+                            "cpu": parts[1],
+                            "memory": parts[2],
+                        }
+            except RuntimeError:
+                yield {"pod": name, "namespace": namespace, "cpu": "N/A", "memory": "N/A"}
+            await asyncio.sleep(2)

termainer/providers/podman.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import shlex
+import shutil
+from typing import AsyncIterator, Dict, List, Optional
+
+from ..remote.ssh import SSHConnection
+from .base import ContainerDetails, ContainerStats, ContainerSummary
+
+
+class PodmanProvider:
+    name = "podman"
+
+    def __init__(self, ssh: Optional[SSHConnection] = None) -> None:
+        self._podman_path: Optional[str] = None
+        self._ssh = ssh
+
+    async def is_available(self) -> bool:
+        if self._ssh:
+            try:
+                await self._ssh.run(["podman", "info"])
+                self._podman_path = "podman"
+                return True
+            except RuntimeError:
+                return False
+        self._podman_path = shutil.which("podman")
+        if not self._podman_path:
+            return False
+        proc = await asyncio.create_subprocess_exec(
+            self._podman_path, "info",
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        code = await proc.wait()
+        return code == 0
+
+    async def list_containers(self) -> List[ContainerSummary]:
+        raw = await self._run("ps", "-a", "--format", "json")
+        data = json.loads(raw)
+        if isinstance(data, list):
+            return data
+        return [data] if data else []
+
+    async def inspect(self, container_id: str) -> ContainerDetails:
+        raw = await self._run("inspect", container_id)
+        data = json.loads(raw)
+        if isinstance(data, list):
+            return data[0] if data else {}
+        return data
+
+    async def stats(self, container_id: str) -> AsyncIterator[ContainerStats]:
+        while True:
+            raw = await self._run("stats", "--no-stream", "--format", "json", container_id)
+            if raw.strip():
+                data = json.loads(raw)
+                if isinstance(data, list):
+                    if data:
+                        yield data[0]
+                else:
+                    yield data
+            await asyncio.sleep(1)
+
+    async def logs(
+        self, container_id: str, tail: int = 100, follow: bool = False
+    ) -> AsyncIterator[str]:
+        cmd = ["logs", "--tail", str(tail)]
+        if follow:
+            cmd.append("-f")
+        cmd.append(container_id)
+
+        if self._ssh:
+            stream = await self._ssh.stream(["podman"] + cmd)
+        else:
+            proc = await asyncio.create_subprocess_exec(
+                self._podman_path, *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+            stream = proc.stdout
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace").rstrip("\n")
+            if not follow:
+                break
+
+    async def get_env(self, container_id: str) -> Dict[str, str]:
+        details = await self.inspect(container_id)
+        env_list: List[str] = (
+            details.get("Config", {}).get("Env", [])
+        )
+        env_dict: Dict[str, str] = {}
+        for entry in env_list:
+            if "=" in entry:
+                key, _, val = entry.partition("=")
+                env_dict[key] = val
+        return env_dict
+
+    async def start(self, container_id: str) -> None:
+        await self._run("start", container_id)
+
+    async def stop(self, container_id: str) -> None:
+        await self._run("stop", container_id)
+
+    async def restart(self, container_id: str) -> None:
+        await self._run("restart", container_id)
+
+    async def remove(self, container_id: str, force: bool = False) -> None:
+        args = ["rm"]
+        if force:
+            args.append("-f")
+        args.append(container_id)
+        await self._run(*args)
+
+    async def set_restart_policy(self, container_id: str, policy: str) -> None:
+        await self._run("update", "--restart", policy, container_id)
+
+    async def exec_command(self, container_id: str, command: str) -> AsyncIterator[str]:
+        try:
+            parts = shlex.split(command)
+        except ValueError:
+            parts = command.split()
+        cmd = ["exec", container_id] + parts
+        if self._ssh:
+            stream = await self._ssh.stream(["podman"] + cmd)
+        else:
+            proc = await asyncio.create_subprocess_exec(
+                self._podman_path, *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+            )
+            stream = proc.stdout
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            yield line.decode("utf-8", errors="replace").rstrip("\n")
+
+    async def close(self) -> None:
+        pass
+
+    async def _run(self, *args: str) -> str:
+        if self._ssh:
+            return await self._ssh.run(["podman"] + list(args))
+        proc = await asyncio.create_subprocess_exec(
+            self._podman_path, *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"podman {' '.join(args)} failed: {stderr.decode()}"
+            )
+        return stdout.decode("utf-8", errors="replace")