termainer 0.4.0__py3-none-any.whl

termainer/providers/swarm.py

@@ -0,0 +1,211 @@
+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 SwarmProvider:
+    name = "swarm"
+
+    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:
+                state = (await self._ssh.run(["docker", "info", "--format", "{{.Swarm.LocalNodeState}}"])).strip().lower()
+                self._docker_path = "docker"
+                return state == "active"
+            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",
+            "--format",
+            "{{.Swarm.LocalNodeState}}",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        stdout, _ = await proc.communicate()
+        if proc.returncode != 0:
+            return False
+        state = stdout.decode("utf-8", errors="replace").strip().lower()
+        return state == "active"
+
+    async def list_containers(self) -> List[ContainerSummary]:
+        raw = await self._run("service", "ls", "--format", "{{json .}}")
+        services: List[ContainerSummary] = []
+        for line in raw.strip().split("\n"):
+            if not line.strip():
+                continue
+            item = json.loads(line)
+            sid = item.get("ID", "")
+            name = item.get("Name", "")
+            mode = item.get("Mode", "")
+            replicas = item.get("Replicas", "")
+            image = item.get("Image", "")
+            ports = item.get("Ports", "")
+            status = f"{mode} {replicas}".strip()
+            services.append(
+                {
+                    "id": sid,
+                    "name": name,
+                    "image": image,
+                    "status": status,
+                    "ports": ports,
+                    "mode": mode,
+                    "replicas": replicas,
+                }
+            )
+        return services
+
+    async def inspect(self, container_id: str) -> ContainerDetails:
+        raw = await self._run("service", "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:
+            yield {
+                "cpu": "N/A",
+                "memory": "N/A",
+                "net_io": "N/A",
+                "pids": "N/A",
+            }
+            await asyncio.sleep(2)
+
+    async def logs(
+        self, container_id: str, tail: int = 100, follow: bool = False
+    ) -> AsyncIterator[str]:
+        cmd = ["service", "logs", "--raw", "--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("Spec", {})
+            .get("TaskTemplate", {})
+            .get("ContainerSpec", {})
+            .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("service", "scale", f"{container_id}=1")
+
+    async def stop(self, container_id: str) -> None:
+        await self._run("service", "scale", f"{container_id}=0")
+
+    async def restart(self, container_id: str) -> None:
+        await self._run("service", "update", "--force", container_id)
+
+    async def remove(self, container_id: str, force: bool = False) -> None:
+        await self._run("service", "rm", container_id)
+
+    async def set_restart_policy(self, container_id: str, policy: str) -> None:
+        # policy: "none" | "on-failure" | "any"
+        await self._run("service", "update", f"--restart-condition={policy}", container_id)
+
+    async def exec_command(self, container_id: str, command: str) -> AsyncIterator[str]:
+        # Swarm services don't support exec directly — find a running task container first
+        try:
+            raw = await self._run(
+                "service", "ps", container_id,
+                "--filter", "desired-state=running",
+                "--format", "{{.ID}}", "--no-trunc",
+            )
+            task_ids = [t.strip() for t in raw.strip().split("\n") if t.strip()]
+        except Exception as e:
+            yield f"[error buscando tareas del servicio: {e}]"
+            return
+        if not task_ids:
+            yield "[error: no hay tareas en ejecución para este servicio]"
+            return
+        try:
+            cid_raw = await self._run(
+                "inspect", "--format",
+                "{{.Status.ContainerStatus.ContainerID}}",
+                task_ids[0],
+            )
+            actual_cid = cid_raw.strip()
+        except Exception as e:
+            yield f"[error obteniendo contenedor de la tarea: {e}]"
+            return
+        if not actual_cid:
+            yield "[error: no se encontró contenedor para la tarea]"
+            return
+        try:
+            parts = shlex.split(command)
+        except ValueError:
+            parts = command.split()
+        cmd = ["exec", actual_cid] + 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))
+        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/remote/ssh.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import tempfile
+from typing import Optional
+
+
+class SSHConnection:
+    def __init__(
+        self,
+        host: str,
+        user: Optional[str] = None,
+        key_path: Optional[str] = None,
+        password: Optional[str] = None,
+        port: int = 22,
+    ) -> None:
+        self.host = host
+        self.user = user  # None → let SSH config resolve the user
+        self.key_path = os.path.expanduser(key_path) if key_path else None
+        self.password = password
+        self.port = port
+        self._use_sshpass = bool(password) and shutil.which("sshpass") is not None
+        self._password_warned = False
+        self._tunnel_proc: Optional[asyncio.subprocess.Process] = None
+        self._tunnel_socket: Optional[str] = None
+
+    def _build_base_args(self) -> list[str]:
+        args = [
+            "-o", "StrictHostKeyChecking=no",
+            "-o", "ConnectTimeout=10",
+            "-o", "BatchMode=yes",
+        ]
+        if self.key_path:
+            args.extend(["-i", self.key_path])
+        if self.port != 22:
+            args.extend(["-p", str(self.port)])
+        return args
+
+    def _target(self) -> str:
+        if self.user:
+            return f"{self.user}@{self.host}"
+        return self.host
+
+    def _build_command(self, remote_cmd: list[str]) -> list[str]:
+        if self._use_sshpass:
+            cmd = ["sshpass", "-e", "ssh"]
+        else:
+            cmd = ["ssh"]
+        cmd.extend(self._build_base_args())
+        cmd.append(self._target())
+        cmd.extend(remote_cmd)
+        return cmd
+
+    async def run(self, command: list[str]) -> str:
+        cmd = self._build_command(command)
+        env = os.environ.copy()
+        if self._use_sshpass:
+            env["SSHPASS"] = self.password
+
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            err = stderr.decode("utf-8", errors="replace").strip()
+            if not self._use_sshpass and self.password and not self._password_warned:
+                self._password_warned = True
+                raise RuntimeError(
+                    f"SSH command failed: {err}\n"
+                    "Hint: install 'sshpass' for password-based authentication"
+                )
+            raise RuntimeError(f"SSH command failed: {err}")
+        return stdout.decode("utf-8", errors="replace")
+
+    async def stream(self, command: list[str]) -> asyncio.StreamReader:
+        cmd = self._build_command(command)
+        env = os.environ.copy()
+        if self._use_sshpass:
+            env["SSHPASS"] = self.password
+
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            env=env,
+        )
+        return proc.stdout
+
+    async def create_tunnel(
+        self,
+        remote_socket: str = "/var/run/docker.sock",
+    ) -> str:
+        """Create an SSH tunnel forwarding a remote Unix socket to a local temp socket.
+
+        Args:
+            remote_socket: Path to the remote Unix socket to forward.
+
+        Returns:
+            Path to the local tunnel socket.
+
+        Raises:
+            RuntimeError: If the tunnel process fails to start.
+        """
+        tmp = tempfile.mktemp(suffix=".sock", prefix="termainer-")
+        cmd = ["ssh", "-N", "-L", f"{tmp}:{remote_socket}"]
+        cmd.extend(self._build_base_args())
+        cmd.append(self._target())
+
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        # Wait for the socket to appear or process to fail
+        for _ in range(20):
+            if proc.returncode is not None:
+                _, stderr = await proc.communicate()
+                raise RuntimeError(
+                    f"SSH tunnel failed: {stderr.decode('utf-8', errors='replace').strip()}"
+                )
+            if os.path.exists(tmp):
+                break
+            await asyncio.sleep(0.25)
+        else:
+            # Socket never appeared — kill the process
+            proc.kill()
+            await proc.wait()
+            raise RuntimeError("SSH tunnel timed out waiting for socket")
+
+        self._tunnel_proc = proc
+        self._tunnel_socket = tmp
+        return tmp
+
+    async def close_tunnel(self) -> None:
+        """Close the SSH tunnel if one is open."""
+        if self._tunnel_proc:
+            try:
+                self._tunnel_proc.kill()
+                await self._tunnel_proc.wait()
+            except Exception:
+                pass
+            self._tunnel_proc = None
+        if self._tunnel_socket:
+            try:
+                os.unlink(self._tunnel_socket)
+            except (FileNotFoundError, OSError):
+                pass
+            self._tunnel_socket = None
+
+    def __repr__(self) -> str:
+        user = self.user or ""
+        return f"{user}@{self.host}:{self.port}" if user else f"{self.host}:{self.port}"

termainer/server_manager.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from .providers.base import ContainerSummary, Provider
+from .providers.docker import DockerProvider
+from .providers.kubernetes import KubernetesProvider
+from .providers.openshift import OpenShiftProvider
+from .providers.podman import PodmanProvider
+from .providers.swarm import SwarmProvider
+from .remote.ssh import SSHConnection
+
+
+PROVIDER_MAP: dict[str, type] = {
+    "docker": DockerProvider,
+    "podman": PodmanProvider,
+    "kubernetes": KubernetesProvider,
+    "k8s": KubernetesProvider,
+    "openshift": OpenShiftProvider,
+    "swarm": SwarmProvider,
+}
+
+
+@dataclass
+class ServerConnection:
+    label: str
+    provider: Provider
+    ssh: Optional[SSHConnection] = None
+
+
+class ServerManager:
+    def __init__(self, servers: Optional[List[ServerConnection]] = None) -> None:
+        self.servers: List[ServerConnection] = servers or []
+
+    @property
+    def server_count(self) -> int:
+        return len(self.servers)
+
+    @property
+    def server_labels(self) -> List[str]:
+        return [s.label for s in self.servers]
+
+    def get_provider(self, label: str) -> Provider:
+        for s in self.servers:
+            if s.label == label:
+                return s.provider
+        raise KeyError(f"Server '{label}' not found")
+
+    def has_local(self) -> bool:
+        return any(s.ssh is None for s in self.servers)
+
+    def get_connection(self, label: str) -> Optional[SSHConnection]:
+        for s in self.servers:
+            if s.label == label:
+                return s.ssh
+        return None
+
+    async def list_all_containers(self) -> List[ContainerSummary]:
+        results: List[ContainerSummary] = []
+        for server in self.servers:
+            try:
+                containers = await server.provider.list_containers()
+                for c in containers:
+                    c["_server"] = server.label
+                results.extend(containers)
+            except Exception:
+                pass
+        return results
+
+    async def close_all(self) -> None:
+        for server in self.servers:
+            try:
+                await server.provider.close()
+            except Exception:
+                pass
+
+
+def provider_class_for(name: str) -> type:
+    cls = PROVIDER_MAP.get(name.lower())
+    if cls is None:
+        available = ", ".join(sorted(PROVIDER_MAP))
+        raise RuntimeError(f"Unknown provider '{name}'. Available: {available}")
+    return cls

termainer/ssh_config.py

@@ -0,0 +1,138 @@
+"""Parser for ~/.ssh/config and SSH server discovery."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional
+
+
+class SSHServer:
+    """Represents a server entry from ~/.ssh/config."""
+
+    def __init__(
+        self,
+        host: str,
+        hostname: Optional[str] = None,
+        user: Optional[str] = None,
+        port: int = 22,
+        identity_file: Optional[str] = None,
+    ) -> None:
+        self.host = host  # The "Host" identifier (connection alias)
+        self.hostname = hostname or host  # Actual hostname to connect to
+        self.user = user  # None = let SSH use its default (local user)
+        self.port = port
+        self.identity_file = identity_file
+
+    @property
+    def display_name(self) -> str:
+        """User-friendly display name."""
+        if self.hostname != self.host:
+            return f"{self.host} ({self.hostname})"
+        return self.host
+
+    def __repr__(self) -> str:
+        return f"SSHServer(host={self.host}, hostname={self.hostname}, user={self.user}, port={self.port})"
+
+
+def parse_ssh_config(config_path: Optional[str] = None) -> Dict[str, SSHServer]:
+    """
+    Parse ~/.ssh/config file and return a dict of SSHServer objects.
+
+    Args:
+        config_path: Optional path to SSH config file. Defaults to ~/.ssh/config
+
+    Returns:
+        Dict mapping connection aliases to SSHServer objects
+    """
+    if config_path is None:
+        config_path = str(Path.home() / ".ssh" / "config")
+
+    ssh_servers: Dict[str, SSHServer] = {}
+
+    config_file = Path(config_path)
+    if not config_file.exists():
+        return ssh_servers
+
+    current_host: Optional[str] = None
+    current_config: Dict[str, str] = {}
+
+    try:
+        with open(config_file) as f:
+            for line in f:
+                line = line.strip()
+
+                # Skip comments and empty lines
+                if not line or line.startswith("#"):
+                    continue
+
+                # Split key-value pairs (SSH config uses space-separated)
+                parts = line.split(None, 1)
+                if len(parts) != 2:
+                    continue
+
+                key, value = parts[0].lower(), parts[1].strip()
+
+                # New host definition
+                if key == "host":
+                    # Save previous host if it exists
+                    if current_host:
+                        ssh_servers[current_host] = _build_ssh_server(current_host, current_config)
+                    current_host = value
+                    current_config = {}
+                else:
+                    # Collect config directives
+                    if current_host:  # Only collect if we're in a Host block
+                        current_config[key] = value
+
+        # Don't forget the last host
+        if current_host:
+            ssh_servers[current_host] = _build_ssh_server(current_host, current_config)
+
+    except (IOError, OSError):
+        pass  # Return empty dict if file can't be read
+
+    return ssh_servers
+
+
+def _build_ssh_server(host: str, config: Dict[str, str]) -> SSHServer:
+    """Build an SSHServer object from parsed config dict."""
+    hostname = config.get("hostname", host)
+    user = config.get("user")  # None if not specified → let SSH use local user
+    port = int(config.get("port", "22"))
+    identity_file = config.get("identityfile")
+
+    return SSHServer(
+        host=host,
+        hostname=hostname,
+        user=user,
+        port=port,
+        identity_file=identity_file,
+    )
+
+
+def get_ssh_servers() -> Dict[str, SSHServer]:
+    """
+    Convenience function to get all SSH servers from ~/.ssh/config.
+
+    Returns:
+        Dict mapping connection aliases to SSHServer objects
+    """
+    return parse_ssh_config()
+
+
+def filter_ssh_servers_for_container_mgmt(servers: Dict[str, SSHServer]) -> Dict[str, SSHServer]:
+    """
+    Filter SSH servers that likely have container runtimes.
+    Simple heuristic: exclude localhost and 127.0.0.1.
+
+    Args:
+        servers: Dict of SSHServer objects
+
+    Returns:
+        Filtered dict excluding local servers
+    """
+    return {
+        alias: server
+        for alias, server in servers.items()
+        if server.hostname not in ("localhost", "127.0.0.1")
+    }