redeploy 0.1.1__py3-none-any.whl

redeploy/detect/probes.py

@@ -0,0 +1,272 @@
+"""Individual probes: docker, k3s, systemd, ports, health, version."""
+from __future__ import annotations
+
+import json
+import re
+from typing import Optional
+
+from ..models import (
+    AppHealthInfo, ConflictInfo, ConflictSeverity, DeployStrategy,
+    PortInfo, RuntimeInfo, ServiceInfo,
+)
+from .remote import RemoteProbe
+
+
+def probe_runtime(p: RemoteProbe) -> RuntimeInfo:
+    """Detect installed runtimes: docker, k3s, podman, systemd."""
+    def ver(cmd: str) -> Optional[str]:
+        r = p.run(cmd)
+        return r.out.splitlines()[0] if r.ok and r.out else None
+
+    docker = ver("docker --version 2>/dev/null")
+    dc = ver("docker compose version 2>/dev/null | head -1")
+    k3s = ver("k3s --version 2>/dev/null | head -1")
+    podman = ver("podman --version 2>/dev/null")
+    systemd = ver("systemctl --version 2>/dev/null | head -1")
+
+    k3s_ns: list[str] = []
+    if k3s:
+        r = p.run("k3s kubectl get ns -o name 2>/dev/null")
+        if r.ok:
+            k3s_ns = [line.replace("namespace/", "").strip() for line in r.out.splitlines() if line.strip()]
+
+    os_info = ver("cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | cut -d= -f2 | tr -d '\"'")
+    arch = ver("uname -m")
+
+    return RuntimeInfo(
+        docker=docker, docker_compose=dc, k3s=k3s, k3s_namespaces=k3s_ns,
+        podman=podman, systemd=systemd, os=os_info, arch=arch,
+    )
+
+
+def probe_ports(p: RemoteProbe) -> dict[int, PortInfo]:
+    """Detect listening ports and which process owns them."""
+    ports: dict[int, PortInfo] = {}
+    r = p.run("ss -tlnp 2>/dev/null | grep LISTEN")
+    if not r.ok:
+        return ports
+
+    for line in r.out.splitlines():
+        # extract port from Local Address:Port column
+        m = re.search(r':(\d+)\s', line)
+        if not m:
+            continue
+        port = int(m.group(1))
+        # extract process name
+        proc_m = re.search(r'users:\(\("([^"]+)"', line)
+        proc = proc_m.group(1) if proc_m else "unknown"
+        pid_m = re.search(r'pid=(\d+)', line)
+        pid = int(pid_m.group(1)) if pid_m else None
+        ports[port] = PortInfo(port=port, process=proc, pid=pid)
+
+    return ports
+
+
+def probe_iptables_dnat(p: RemoteProbe, ports: list[int]) -> list[tuple[int, str]]:
+    """Find iptables DNAT rules stealing specific ports (returns [(port, target_ip)])."""
+    results = []
+    r = p.run("iptables -t nat -L -n 2>/dev/null | grep DNAT")
+    if not r.ok:
+        return results
+    for port in ports:
+        count = 0
+        for line in r.out.splitlines():
+            if f"dpt:{port}" in line or f":{port} " in line:
+                m = re.search(r'to:([0-9.]+:\d+)', line)
+                target = m.group(1) if m else "unknown"
+                results.append((port, target))
+                count += 1
+        # multiple DNAT rules on same port = conflict
+    return results
+
+
+def probe_docker_services(p: RemoteProbe) -> list[ServiceInfo]:
+    """List running Docker containers."""
+    services = []
+    r = p.run(
+        "docker ps --format '{{.Names}}|{{.Image}}|{{.Status}}' 2>/dev/null"
+    )
+    if not r.ok:
+        return services
+
+    for line in r.out.splitlines():
+        parts = line.split("|")
+        if len(parts) < 2:
+            continue
+        name, image = parts[0].strip(), parts[1].strip()
+        status = parts[2].strip() if len(parts) > 2 else "unknown"
+        healthy = "healthy" in status.lower()
+
+        # get port mappings
+        rp = p.run(f"docker inspect {name} --format '{{{{json .NetworkSettings.Ports}}}}' 2>/dev/null")
+        ports: list[int] = []
+        if rp.ok and rp.out:
+            try:
+                pmap = json.loads(rp.out)
+                for k in pmap:
+                    m = re.match(r'(\d+)/', k)
+                    if m:
+                        ports.append(int(m.group(1)))
+            except json.JSONDecodeError:
+                pass
+
+        services.append(ServiceInfo(
+            name=name, image=image,
+            status="healthy" if healthy else status,
+            ports=ports,
+        ))
+    return services
+
+
+def probe_k3s_services(p: RemoteProbe, namespaces: list[str]) -> list[ServiceInfo]:
+    """List running k3s pods."""
+    services = []
+    for ns in namespaces:
+        if ns in ("kube-system", "kube-public", "kube-node-lease", "cert-manager"):
+            continue
+        r = p.run(
+            f"k3s kubectl get pods -n {ns} --no-headers 2>/dev/null"
+            " | awk '{print $1\"|\"$2\"|\"$3}'"
+        )
+        if not r.ok:
+            continue
+        for line in r.out.splitlines():
+            parts = line.split("|")
+            if len(parts) < 3:
+                continue
+            name, ready, phase = parts[0].strip(), parts[1].strip(), parts[2].strip()
+            services.append(ServiceInfo(
+                name=name, namespace=ns,
+                status=phase.lower(),
+            ))
+    return services
+
+
+def probe_systemd_services(p: RemoteProbe, app: str) -> list[ServiceInfo]:
+    """List app-related systemd units."""
+    services = []
+    r = p.run(
+        f"systemctl list-units --type=service --state=active --no-pager 2>/dev/null"
+        f" | grep -i {app} | awk '{{print $1\"|\"$3\"|\"$4}}'"
+    )
+    if not r.ok:
+        return services
+    for line in r.out.splitlines():
+        parts = line.split("|")
+        if not parts[0].strip():
+            continue
+        services.append(ServiceInfo(
+            name=parts[0].strip(),
+            unit=parts[0].strip(),
+            status=parts[1].strip() if len(parts) > 1 else "unknown",
+        ))
+    return services
+
+
+def probe_health(host: str, app: str, domain: Optional[str] = None) -> list[AppHealthInfo]:
+    """HTTP health checks against known endpoints."""
+    import httpx
+
+    results = []
+    base = f"https://{domain}" if domain else None
+    endpoints = []
+
+    if base:
+        endpoints += [
+            (f"{base}/api/v1/health", "backend"),
+            (f"{base}/firmware/health", "firmware"),
+            (f"{base}/", "frontend"),
+        ]
+
+    for url, name in endpoints:
+        try:
+            r = httpx.get(url, timeout=5, verify=False, follow_redirects=True)
+            version = None
+            if r.headers.get("content-type", "").startswith("application/json"):
+                try:
+                    body = r.json()
+                    version = body.get("version")
+                except Exception:
+                    pass
+            results.append(AppHealthInfo(
+                url=url, status_code=r.status_code,
+                version=version,
+                healthy=(r.status_code == 200),
+            ))
+        except Exception as e:
+            results.append(AppHealthInfo(url=url, healthy=False))
+
+    return results
+
+
+def detect_conflicts(
+    ports: dict[int, PortInfo],
+    iptables_dnat: list[tuple[int, str]],
+    runtime: RuntimeInfo,
+    docker_services: list[ServiceInfo],
+    k3s_services: list[ServiceInfo],
+) -> list[ConflictInfo]:
+    """Identify conflicts: port stealing, duplicate services, etc."""
+    conflicts = []
+
+    # Multiple DNAT rules on same port
+    seen_ports: dict[int, int] = {}
+    for port, target in iptables_dnat:
+        seen_ports[port] = seen_ports.get(port, 0) + 1
+    for port, count in seen_ports.items():
+        if count > 1:
+            conflicts.append(ConflictInfo(
+                type="port_steal",
+                description=f"Port {port} has {count} iptables DNAT rules — k3s may intercept before docker-proxy",
+                severity=ConflictSeverity.HIGH,
+                affected=[str(port)],
+                fix_hint=f"Stop k3s: `systemctl stop k3s && systemctl disable k3s`",
+            ))
+
+    # k3s running alongside Docker on same app
+    if runtime.k3s and docker_services:
+        docker_names = {s.name for s in docker_services}
+        k3s_names = {s.name for s in k3s_services}
+        overlap_hint = docker_names & {s.replace("-", "") for s in k3s_names}
+        if k3s_services:
+            conflicts.append(ConflictInfo(
+                type="dual_runtime",
+                description=f"k3s ({runtime.k3s}) and Docker both running — may serve same app from different versions",
+                severity=ConflictSeverity.HIGH,
+                affected=list(k3s_names),
+                fix_hint="Use `redeploy plan` to generate a migration plan",
+            ))
+
+    # Port 80/443 not owned by expected process
+    for port in (80, 443):
+        if port in ports:
+            proc = ports[port].process
+            if proc not in ("docker-proxy", "nginx", "traefik"):
+                conflicts.append(ConflictInfo(
+                    type="unexpected_port_owner",
+                    description=f"Port {port} owned by '{proc}' (expected docker-proxy/nginx/traefik)",
+                    severity=ConflictSeverity.MEDIUM,
+                    affected=[str(port)],
+                ))
+
+    return conflicts
+
+
+def detect_strategy(
+    runtime: RuntimeInfo,
+    docker_services: list[ServiceInfo],
+    k3s_services: list[ServiceInfo],
+    systemd_services: list[ServiceInfo],
+) -> DeployStrategy:
+    """Infer the current deployment strategy from detected services."""
+    if k3s_services and not docker_services:
+        return DeployStrategy.K3S
+    if docker_services and not k3s_services:
+        return DeployStrategy.DOCKER_FULL
+    if docker_services and k3s_services:
+        return DeployStrategy.K3S       # k3s is winning (has DNAT priority)
+    if systemd_services and runtime.podman:
+        return DeployStrategy.PODMAN_QUADLET
+    if systemd_services:
+        return DeployStrategy.SYSTEMD
+    return DeployStrategy.UNKNOWN

redeploy/detect/remote.py

@@ -0,0 +1,53 @@
+"""SSH remote executor for detect probes."""
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass
+class RunResult:
+    stdout: str
+    stderr: str
+    returncode: int
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0
+
+    @property
+    def out(self) -> str:
+        return self.stdout.strip()
+
+
+class RemoteProbe:
+    """Execute shell commands over SSH (or locally)."""
+
+    def __init__(self, host: str):
+        self.host = host
+        self.is_local = (host == "local" or host == "localhost")
+
+    def run(self, cmd: str, timeout: int = 30) -> RunResult:
+        if self.is_local:
+            result = subprocess.run(
+                cmd, shell=True, capture_output=True, text=True, timeout=timeout
+            )
+        else:
+            result = subprocess.run(
+                ["ssh", "-o", "StrictHostKeyChecking=no",
+                 "-o", "ConnectTimeout=10",
+                 "-o", "BatchMode=yes",
+                 self.host, cmd],
+                capture_output=True, text=True, timeout=timeout,
+            )
+        return RunResult(
+            stdout=result.stdout,
+            stderr=result.stderr,
+            returncode=result.returncode,
+        )
+
+    def is_reachable(self) -> bool:
+        if self.is_local:
+            return True
+        r = self.run("echo ok", timeout=10)
+        return r.ok and "ok" in r.out

redeploy/models.py

@@ -0,0 +1,189 @@
+"""Shared data models for redeploy: InfraState, MigrationPlan, Target."""
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+# ── Enums ─────────────────────────────────────────────────────────────────────
+
+class ConflictSeverity(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class StepAction(str, Enum):
+    SYSTEMCTL_STOP = "systemctl_stop"
+    SYSTEMCTL_DISABLE = "systemctl_disable"
+    SYSTEMCTL_START = "systemctl_start"
+    KUBECTL_DELETE = "kubectl_delete"
+    DOCKER_COMPOSE_UP = "docker_compose_up"
+    DOCKER_COMPOSE_DOWN = "docker_compose_down"
+    DOCKER_BUILD = "docker_build"
+    RSYNC = "rsync"
+    SCP = "scp"
+    SSH_CMD = "ssh_cmd"
+    HTTP_CHECK = "http_check"
+    VERSION_CHECK = "version_check"
+    WAIT = "wait"
+
+
+class StepStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    DONE = "done"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+class DeployStrategy(str, Enum):
+    DOCKER_FULL = "docker_full"
+    NATIVE_KIOSK = "native_kiosk"
+    DOCKER_KIOSK = "docker_kiosk"
+    PODMAN_QUADLET = "podman_quadlet"
+    K3S = "k3s"
+    SYSTEMD = "systemd"
+    UNKNOWN = "unknown"
+
+
+# ── InfraState (output of detect) ─────────────────────────────────────────────
+
+class ServiceInfo(BaseModel):
+    name: str
+    image: Optional[str] = None
+    status: str = "unknown"
+    version: Optional[str] = None
+    ports: list[int] = Field(default_factory=list)
+    labels: dict[str, str] = Field(default_factory=dict)
+    namespace: Optional[str] = None      # k3s/k8s namespace
+    unit: Optional[str] = None           # systemd unit name
+
+
+class PortInfo(BaseModel):
+    port: int
+    process: str
+    pid: Optional[int] = None
+    via: Optional[str] = None            # "traefik", "nginx", "ingress-nginx"
+    protocol: str = "tcp"
+
+
+class ConflictInfo(BaseModel):
+    type: str                             # "port_steal", "version_mismatch", "duplicate_service"
+    description: str
+    severity: ConflictSeverity = ConflictSeverity.MEDIUM
+    affected: list[str] = Field(default_factory=list)
+    fix_hint: Optional[str] = None
+
+
+class RuntimeInfo(BaseModel):
+    docker: Optional[str] = None
+    docker_compose: Optional[str] = None
+    k3s: Optional[str] = None
+    k3s_namespaces: list[str] = Field(default_factory=list)
+    podman: Optional[str] = None
+    systemd: Optional[str] = None
+    os: Optional[str] = None
+    arch: Optional[str] = None
+
+
+class AppHealthInfo(BaseModel):
+    url: str
+    status_code: Optional[int] = None
+    version: Optional[str] = None
+    healthy: bool = False
+    response_ms: Optional[float] = None
+
+
+class InfraState(BaseModel):
+    """Full detected state of infrastructure — output of `detect`."""
+    host: str                             # "root@1.2.3.4" or "local"
+    app: str = "unknown"
+    scanned_at: datetime = Field(default_factory=datetime.utcnow)
+
+    runtime: RuntimeInfo = Field(default_factory=RuntimeInfo)
+    ports: dict[int, PortInfo] = Field(default_factory=dict)
+
+    services: dict[str, list[ServiceInfo]] = Field(
+        default_factory=lambda: {"docker": [], "k3s": [], "systemd": [], "podman": []}
+    )
+
+    health: list[AppHealthInfo] = Field(default_factory=list)
+    conflicts: list[ConflictInfo] = Field(default_factory=list)
+    raw: dict[str, Any] = Field(default_factory=dict)    # raw probe output
+
+    detected_strategy: DeployStrategy = DeployStrategy.UNKNOWN
+    current_version: Optional[str] = None
+
+
+# ── Target (input to plan) ─────────────────────────────────────────────────────
+
+class TargetConfig(BaseModel):
+    """Desired infrastructure state — input to `plan`."""
+    strategy: DeployStrategy = DeployStrategy.DOCKER_FULL
+    app: str = "c2004"
+    version: Optional[str] = None
+
+    compose_files: list[str] = Field(default_factory=list)
+    env_file: Optional[str] = None
+    remote_dir: str = "~/c2004"
+    domain: Optional[str] = None
+
+    stop_services: list[str] = Field(default_factory=list)   # systemd units to stop
+    disable_services: list[str] = Field(default_factory=list)
+    delete_k3s_namespaces: list[str] = Field(default_factory=list)
+
+    verify_url: Optional[str] = None
+    verify_version: Optional[str] = None
+
+
+# ── MigrationStep ─────────────────────────────────────────────────────────────
+
+class MigrationStep(BaseModel):
+    id: str
+    action: StepAction
+    description: str
+    status: StepStatus = StepStatus.PENDING
+
+    # action-specific params
+    service: Optional[str] = None        # systemctl service name
+    command: Optional[str] = None        # raw SSH command
+    compose: Optional[str] = None        # compose file path
+    flags: list[str] = Field(default_factory=list)
+    url: Optional[str] = None            # HTTP check URL
+    expect: Optional[str] = None         # expected string in response
+    src: Optional[str] = None            # rsync/scp source
+    dst: Optional[str] = None            # rsync/scp destination
+    seconds: int = 0                     # wait duration
+    namespace: Optional[str] = None      # k3s namespace
+
+    reason: Optional[str] = None
+    risk: ConflictSeverity = ConflictSeverity.LOW
+    rollback_command: Optional[str] = None
+
+    result: Optional[str] = None         # filled after apply
+    error: Optional[str] = None
+
+
+# ── MigrationPlan (output of plan, input to apply) ───────────────────────────
+
+class MigrationPlan(BaseModel):
+    """Full migration plan — output of `plan`, input to `apply`."""
+    infra_file: str = "infra.yaml"
+    target_file: Optional[str] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+    host: str
+    app: str
+    from_strategy: DeployStrategy
+    to_strategy: DeployStrategy
+
+    risk: ConflictSeverity = ConflictSeverity.LOW
+    estimated_downtime: str = "unknown"
+    steps: list[MigrationStep] = Field(default_factory=list)
+
+    notes: list[str] = Field(default_factory=list)

redeploy/plan/__init__.py

@@ -0,0 +1,4 @@
+"""plan — Generate MigrationPlan from InfraState + TargetConfig."""
+from .planner import Planner
+
+__all__ = ["Planner"]