redeploy 0.1.1__py3-none-any.whl

redeploy/__init__.py

@@ -0,0 +1,2 @@
+"""redeploy — Infrastructure migration toolkit: detect → plan → apply."""
+__version__ = "0.1.1"

redeploy/apply/__init__.py

@@ -0,0 +1,4 @@
+"""apply — Execute a MigrationPlan step by step."""
+from .executor import Executor
+
+__all__ = ["Executor"]

redeploy/apply/executor.py

@@ -0,0 +1,199 @@
+"""Executor — runs MigrationPlan steps, handles rollback on failure."""
+from __future__ import annotations
+
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import yaml
+from loguru import logger
+
+from ..detect.remote import RemoteProbe
+from ..models import MigrationPlan, MigrationStep, StepAction, StepStatus
+
+
+class StepError(Exception):
+    def __init__(self, step: MigrationStep, msg: str):
+        self.step = step
+        super().__init__(f"[{step.id}] {msg}")
+
+
+class Executor:
+    """Execute MigrationPlan steps on a remote host."""
+
+    def __init__(self, plan: MigrationPlan, dry_run: bool = False):
+        self.plan = plan
+        self.dry_run = dry_run
+        self.probe = RemoteProbe(plan.host)
+        self._completed: list[MigrationStep] = []
+
+    def run(self) -> bool:
+        """Execute all steps. Returns True if all passed."""
+        prefix = "[DRY RUN] " if self.dry_run else ""
+        logger.info(f"{prefix}Applying plan: {len(self.plan.steps)} steps "
+                    f"({self.plan.from_strategy.value} → {self.plan.to_strategy.value})")
+
+        for step in self.plan.steps:
+            try:
+                self._execute_step(step)
+                self._completed.append(step)
+            except StepError as e:
+                logger.error(f"Step failed: {e}")
+                step.status = StepStatus.FAILED
+                step.error = str(e)
+                if not self.dry_run:
+                    self._rollback()
+                return False
+
+        logger.info(f"{'[DRY RUN] ' if self.dry_run else ''}All {len(self.plan.steps)} steps completed")
+        return True
+
+    # ── step dispatcher ───────────────────────────────────────────────────────
+
+    def _execute_step(self, step: MigrationStep) -> None:
+        logger.info(f"  {'[DRY]' if self.dry_run else '→'} [{step.id}] {step.description}")
+        step.status = StepStatus.RUNNING
+
+        if self.dry_run:
+            step.status = StepStatus.DONE
+            step.result = "dry-run"
+            return
+
+        dispatch = {
+            StepAction.SYSTEMCTL_STOP:    self._run_ssh,
+            StepAction.SYSTEMCTL_DISABLE: self._run_ssh,
+            StepAction.SYSTEMCTL_START:   self._run_ssh,
+            StepAction.KUBECTL_DELETE:    self._run_ssh,
+            StepAction.DOCKER_COMPOSE_UP: self._run_ssh,
+            StepAction.DOCKER_COMPOSE_DOWN: self._run_ssh,
+            StepAction.DOCKER_BUILD:      self._run_ssh,
+            StepAction.SSH_CMD:           self._run_ssh,
+            StepAction.SCP:               self._run_scp,
+            StepAction.RSYNC:             self._run_rsync,
+            StepAction.HTTP_CHECK:        self._run_http_check,
+            StepAction.VERSION_CHECK:     self._run_version_check,
+            StepAction.WAIT:              self._run_wait,
+        }
+
+        handler = dispatch.get(step.action)
+        if not handler:
+            raise StepError(step, f"No handler for action {step.action}")
+        handler(step)
+
+    # ── handlers ─────────────────────────────────────────────────────────────
+
+    def _run_ssh(self, step: MigrationStep) -> None:
+        cmd = step.command
+        if not cmd:
+            raise StepError(step, "No command specified")
+        r = self.probe.run(cmd, timeout=300)
+        step.result = r.out[:500]
+        if not r.ok:
+            raise StepError(step, f"exit={r.returncode}: {r.stderr[:200]}")
+        step.status = StepStatus.DONE
+
+    def _run_scp(self, step: MigrationStep) -> None:
+        if not step.src or not step.dst:
+            raise StepError(step, "scp requires src and dst")
+        if self.probe.is_local:
+            cmd = ["cp", step.src, step.dst]
+        else:
+            cmd = ["scp", "-o", "StrictHostKeyChecking=no",
+                   step.src, f"{self.plan.host}:{step.dst}"]
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        if result.returncode != 0:
+            raise StepError(step, f"scp failed: {result.stderr[:200]}")
+        step.status = StepStatus.DONE
+        step.result = "ok"
+
+    def _run_rsync(self, step: MigrationStep) -> None:
+        if not step.src or not step.dst:
+            raise StepError(step, "rsync requires src and dst")
+        if self.probe.is_local:
+            dst = step.dst
+        else:
+            dst = f"{self.plan.host}:{step.dst}"
+        cmd = ["rsync", "-az", "--delete", step.src, dst]
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+        if result.returncode != 0:
+            raise StepError(step, f"rsync failed: {result.stderr[:200]}")
+        step.status = StepStatus.DONE
+        step.result = "ok"
+
+    def _run_http_check(self, step: MigrationStep, retries: int = 5, delay: int = 8) -> None:
+        if not step.url:
+            raise StepError(step, "http_check requires url")
+        last_err = ""
+        for attempt in range(retries):
+            try:
+                r = httpx.get(step.url, timeout=10, verify=False, follow_redirects=True)
+                body = r.text
+                if step.expect and step.expect not in body:
+                    last_err = f"expected '{step.expect}' not found in response"
+                elif r.status_code >= 400:
+                    last_err = f"HTTP {r.status_code}"
+                else:
+                    step.status = StepStatus.DONE
+                    step.result = body[:200]
+                    return
+            except Exception as e:
+                last_err = str(e)
+            logger.debug(f"    retry {attempt + 1}/{retries}: {last_err}")
+            time.sleep(delay)
+        raise StepError(step, f"HTTP check failed after {retries} retries: {last_err}")
+
+    def _run_version_check(self, step: MigrationStep) -> None:
+        if not step.url or not step.expect:
+            raise StepError(step, "version_check requires url and expect")
+        try:
+            r = httpx.get(step.url, timeout=10, verify=False, follow_redirects=True)
+            body = r.text
+            if step.expect not in body:
+                raise StepError(step, f"version '{step.expect}' not found in response: {body[:100]}")
+            step.status = StepStatus.DONE
+            step.result = f"version {step.expect} confirmed"
+        except StepError:
+            raise
+        except Exception as e:
+            raise StepError(step, str(e))
+
+    def _run_wait(self, step: MigrationStep) -> None:
+        if step.seconds > 0:
+            logger.debug(f"    waiting {step.seconds}s...")
+            time.sleep(step.seconds)
+        step.status = StepStatus.DONE
+        step.result = f"waited {step.seconds}s"
+
+    # ── rollback ──────────────────────────────────────────────────────────────
+
+    def _rollback(self) -> None:
+        logger.warning("Rolling back completed steps...")
+        for step in reversed(self._completed):
+            if step.rollback_command:
+                logger.info(f"  ↩ rollback [{step.id}]: {step.rollback_command}")
+                r = self.probe.run(step.rollback_command, timeout=120)
+                if not r.ok:
+                    logger.warning(f"    rollback failed: {r.stderr[:100]}")
+
+    # ── summary ───────────────────────────────────────────────────────────────
+
+    def summary(self) -> str:
+        total = len(self.plan.steps)
+        done = sum(1 for s in self.plan.steps if s.status == StepStatus.DONE)
+        failed = sum(1 for s in self.plan.steps if s.status == StepStatus.FAILED)
+        icon = "✅" if failed == 0 else "❌"
+        return f"{icon} {done}/{total} steps completed" + (f", {failed} failed" if failed else "")
+
+    @staticmethod
+    def from_file(plan_path: Path) -> "Executor":
+        with plan_path.open() as f:
+            raw = yaml.safe_load(f)
+        plan = MigrationPlan(**raw)
+        return Executor(plan)
+
+    def save_results(self, output: Path) -> None:
+        data = self.plan.model_dump(mode="json")
+        output.write_text(yaml.dump(data, default_flow_style=False, allow_unicode=True))
+        logger.info(f"Results saved to {output}")

redeploy/cli.py

@@ -0,0 +1,279 @@
+"""redeploy CLI — detect | plan | apply | migrate."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+import yaml
+from loguru import logger
+
+from . import __version__
+from .models import DeployStrategy, TargetConfig
+
+
+def _setup_logging(verbose: bool) -> None:
+    logger.remove()
+    level = "DEBUG" if verbose else "INFO"
+    logger.add(sys.stderr, level=level,
+               format="<green>{time:HH:mm:ss}</green> | <level>{level:<7}</level> | {message}")
+
+
+@click.group()
+@click.version_option(__version__)
+@click.option("-v", "--verbose", is_flag=True)
+@click.pass_context
+def cli(ctx, verbose):
+    """redeploy — Infrastructure migration toolkit: detect → plan → apply"""
+    _setup_logging(verbose)
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+
+
+# ── detect ────────────────────────────────────────────────────────────────────
+
+@cli.command()
+@click.option("--host", required=True, help="SSH host (user@ip) or 'local'")
+@click.option("--app", default="c2004", show_default=True, help="Application name")
+@click.option("--domain", default=None, help="Public domain for HTTP health checks")
+@click.option("-o", "--output", default="infra.yaml", show_default=True,
+              type=click.Path(), help="Output file for InfraState")
+@click.pass_context
+def detect(ctx, host, app, domain, output):
+    """Probe infrastructure and produce infra.yaml."""
+    from rich.console import Console
+    from rich.table import Table
+    from .detect import Detector
+
+    console = Console()
+    out_path = Path(output)
+
+    try:
+        d = Detector(host=host, app=app, domain=domain)
+        state = d.run()
+        d.save(state, out_path)
+    except ConnectionError as e:
+        console.print(f"[red]✗ {e}[/red]")
+        sys.exit(1)
+
+    # Print summary
+    console.print(f"\n[bold]Infrastructure: {host}[/bold]")
+
+    t = Table(show_header=False, box=None, padding=(0, 2))
+    t.add_column("key", style="dim")
+    t.add_column("value")
+    t.add_row("App", state.app)
+    t.add_row("Strategy (detected)", state.detected_strategy.value)
+    t.add_row("Version", state.current_version or "unknown")
+    t.add_row("Docker", state.runtime.docker or "—")
+    t.add_row("k3s", state.runtime.k3s or "—")
+    t.add_row("Podman", state.runtime.podman or "—")
+    t.add_row("Open ports", ", ".join(str(p) for p in sorted(state.ports.keys())))
+    console.print(t)
+
+    # Docker services
+    if state.services.get("docker"):
+        console.print("\n[bold]Docker containers:[/bold]")
+        for s in state.services["docker"]:
+            icon = "✅" if s.status == "healthy" else "⚪"
+            console.print(f"  {icon} {s.name}  ({s.status})")
+
+    # k3s pods
+    if state.services.get("k3s"):
+        console.print(f"\n[bold]k3s pods ({len(state.services['k3s'])}):[/bold]")
+        for s in state.services["k3s"]:
+            icon = "✅" if s.status == "running" else "⚪"
+            console.print(f"  {icon} {s.namespace}/{s.name}  ({s.status})")
+
+    # Conflicts
+    if state.conflicts:
+        console.print(f"\n[bold yellow]Conflicts ({len(state.conflicts)}):[/bold yellow]")
+        for c in state.conflicts:
+            color = {"critical": "red", "high": "yellow", "medium": "blue", "low": "dim"}[c.severity.value]
+            console.print(f"  [{color}][{c.severity.upper()}][/{color}] {c.type}: {c.description}")
+            if c.fix_hint:
+                console.print(f"    [dim]hint: {c.fix_hint}[/dim]")
+    else:
+        console.print("\n[green]No conflicts detected.[/green]")
+
+    console.print(f"\n[dim]Saved to {out_path}[/dim]")
+
+
+# ── plan ──────────────────────────────────────────────────────────────────────
+
+@cli.command()
+@click.option("--infra", default="infra.yaml", show_default=True,
+              type=click.Path(exists=True), help="InfraState file (from detect)")
+@click.option("--target", default=None, type=click.Path(),
+              help="Target config YAML (desired state)")
+@click.option("--strategy", default=None,
+              type=click.Choice([s.value for s in DeployStrategy]),
+              help="Override target strategy")
+@click.option("--domain", default=None, help="Public domain for verify step")
+@click.option("--version", "target_version", default=None, help="Target version to verify")
+@click.option("--compose", multiple=True, help="Compose file(s) for docker_full strategy")
+@click.option("--env-file", default=None, help="Env file path")
+@click.option("-o", "--output", default="migration-plan.yaml", show_default=True,
+              type=click.Path(), help="Output migration plan file")
+@click.pass_context
+def plan(ctx, infra, target, strategy, domain, target_version, compose, env_file, output):
+    """Generate migration-plan.yaml from infra.yaml + target config."""
+    from rich.console import Console
+    from rich.table import Table
+    from .plan import Planner
+
+    console = Console()
+    out_path = Path(output)
+    infra_path = Path(infra)
+    target_path = Path(target) if target else None
+
+    planner = Planner.from_files(infra_path, target_path)
+
+    # CLI overrides
+    if strategy:
+        planner.target.strategy = DeployStrategy(strategy)
+    if domain:
+        planner.target.domain = domain
+    if target_version:
+        planner.target.verify_version = target_version
+    if compose:
+        planner.target.compose_files = list(compose)
+    if env_file:
+        planner.target.env_file = env_file
+
+    migration = planner.run()
+    planner.save(migration, out_path)
+
+    console.print(f"\n[bold]Migration plan: {migration.from_strategy.value} → {migration.to_strategy.value}[/bold]")
+    console.print(f"  Risk:             {migration.risk.value}")
+    console.print(f"  Estimated downtime: {migration.estimated_downtime}")
+    console.print(f"  Steps:            {len(migration.steps)}")
+
+    if migration.steps:
+        console.print("\n[bold]Steps:[/bold]")
+        t = Table(show_header=True, box=None, padding=(0, 2))
+        t.add_column("#", style="dim", width=3)
+        t.add_column("ID")
+        t.add_column("Action", style="cyan")
+        t.add_column("Description")
+        t.add_column("Risk", style="dim")
+        for i, step in enumerate(migration.steps, 1):
+            t.add_row(str(i), step.id, step.action.value, step.description, step.risk.value)
+        console.print(t)
+
+    if migration.notes:
+        console.print("\n[bold yellow]Notes:[/bold yellow]")
+        for note in migration.notes:
+            console.print(f"  • {note}")
+
+    console.print(f"\n[dim]Saved to {out_path}[/dim]")
+
+
+# ── apply ─────────────────────────────────────────────────────────────────────
+
+@cli.command()
+@click.option("--plan", "plan_file", default="migration-plan.yaml", show_default=True,
+              type=click.Path(exists=True), help="Migration plan file")
+@click.option("--dry-run", is_flag=True, help="Show steps without executing")
+@click.option("--step", default=None, help="Run only a specific step by ID")
+@click.option("-o", "--output", default=None, type=click.Path(),
+              help="Save results to file after apply")
+@click.pass_context
+def apply(ctx, plan_file, dry_run, step, output):
+    """Execute a migration plan."""
+    from rich.console import Console
+    from .apply import Executor
+
+    console = Console()
+    executor = Executor.from_file(Path(plan_file))
+
+    if step:
+        # Filter to single step
+        matched = [s for s in executor.plan.steps if s.id == step]
+        if not matched:
+            console.print(f"[red]Step '{step}' not found in plan[/red]")
+            ids = ", ".join(s.id for s in executor.plan.steps)
+            console.print(f"Available: {ids}")
+            sys.exit(1)
+        executor.plan.steps = matched
+
+    executor.dry_run = dry_run
+
+    prefix = "[DRY RUN] " if dry_run else ""
+    console.print(f"\n{prefix}[bold]Applying: {executor.plan.from_strategy.value}"
+                  f" → {executor.plan.to_strategy.value}[/bold]  "
+                  f"({len(executor.plan.steps)} steps)")
+
+    ok = executor.run()
+    console.print(f"\n{executor.summary()}")
+
+    if output:
+        executor.save_results(Path(output))
+
+    if not ok:
+        sys.exit(1)
+
+
+# ── migrate (detect + plan + apply) ──────────────────────────────────────────
+
+@cli.command()
+@click.option("--host", required=True, help="SSH host (user@ip) or 'local'")
+@click.option("--app", default="c2004", show_default=True)
+@click.option("--domain", default=None)
+@click.option("--target", default=None, type=click.Path(), help="Target config YAML")
+@click.option("--strategy", default="docker_full", show_default=True,
+              type=click.Choice([s.value for s in DeployStrategy]))
+@click.option("--version", "target_version", default=None)
+@click.option("--compose", multiple=True)
+@click.option("--env-file", default=None)
+@click.option("--dry-run", is_flag=True)
+@click.option("--infra-out", default="infra.yaml", show_default=True, type=click.Path())
+@click.option("--plan-out", default="migration-plan.yaml", show_default=True, type=click.Path())
+@click.pass_context
+def migrate(ctx, host, app, domain, target, strategy, target_version,
+            compose, env_file, dry_run, infra_out, plan_out):
+    """Full pipeline: detect → plan → apply."""
+    from rich.console import Console
+    from .detect import Detector
+    from .plan import Planner
+    from .apply import Executor
+    from .models import TargetConfig
+
+    console = Console()
+
+    # 1. detect
+    console.print(f"\n[bold]Step 1/3 — detect[/bold]")
+    d = Detector(host=host, app=app, domain=domain)
+    state = d.run()
+    d.save(state, Path(infra_out))
+    console.print(f"  Strategy: {state.detected_strategy.value}  "
+                  f"  Version: {state.current_version or '?'}  "
+                  f"  Conflicts: {len(state.conflicts)}")
+
+    # 2. plan
+    console.print(f"\n[bold]Step 2/3 — plan[/bold]")
+    target_path = Path(target) if target else None
+    planner = Planner.from_files(Path(infra_out), target_path)
+    planner.target.strategy = DeployStrategy(strategy)
+    if domain:
+        planner.target.domain = domain
+    if target_version:
+        planner.target.verify_version = target_version
+    if compose:
+        planner.target.compose_files = list(compose)
+    if env_file:
+        planner.target.env_file = env_file
+
+    migration = planner.run()
+    planner.save(migration, Path(plan_out))
+    console.print(f"  Steps: {len(migration.steps)}  Risk: {migration.risk.value}  "
+                  f"Downtime: {migration.estimated_downtime}")
+
+    # 3. apply
+    console.print(f"\n[bold]Step 3/3 — apply{'  (dry-run)' if dry_run else ''}[/bold]")
+    executor = Executor(migration, dry_run=dry_run)
+    ok = executor.run()
+    console.print(f"\n{executor.summary()}")
+
+    if not ok:
+        sys.exit(1)

redeploy/detect/__init__.py

@@ -0,0 +1,4 @@
+"""detect — Probe infrastructure and produce InfraState."""
+from .detector import Detector
+
+__all__ = ["Detector"]

redeploy/detect/detector.py

@@ -0,0 +1,96 @@
+"""Detector — orchestrates all probes and produces InfraState."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from loguru import logger
+
+from ..models import InfraState
+from .probes import (
+    detect_conflicts, detect_strategy, probe_docker_services,
+    probe_health, probe_iptables_dnat, probe_k3s_services,
+    probe_ports, probe_runtime, probe_systemd_services,
+)
+from .remote import RemoteProbe
+
+
+class Detector:
+    """Probe infrastructure and produce InfraState."""
+
+    def __init__(self, host: str, app: str = "c2004", domain: Optional[str] = None):
+        self.host = host
+        self.app = app
+        self.domain = domain
+        self.probe = RemoteProbe(host)
+
+    def run(self) -> InfraState:
+        logger.info(f"Detecting infrastructure on {self.host} (app={self.app})")
+
+        if not self.probe.is_reachable():
+            raise ConnectionError(f"Host {self.host} is not reachable via SSH")
+
+        logger.debug("Probing runtime...")
+        runtime = probe_runtime(self.probe)
+        logger.debug(f"  docker={runtime.docker}, k3s={runtime.k3s}, podman={runtime.podman}")
+
+        logger.debug("Probing ports...")
+        ports = probe_ports(self.probe)
+        logger.debug(f"  listening ports: {sorted(ports.keys())}")
+
+        logger.debug("Probing iptables DNAT...")
+        dnat = probe_iptables_dnat(self.probe, [80, 443, 8000, 8080, 8443])
+
+        logger.debug("Probing Docker services...")
+        docker_svcs = probe_docker_services(self.probe) if runtime.docker else []
+
+        logger.debug("Probing k3s services...")
+        k3s_svcs = probe_k3s_services(self.probe, runtime.k3s_namespaces) if runtime.k3s else []
+
+        logger.debug("Probing systemd services...")
+        systemd_svcs = probe_systemd_services(self.probe, self.app)
+
+        logger.debug("Probing HTTP health...")
+        health = probe_health(self.host, self.app, self.domain)
+
+        logger.debug("Detecting conflicts...")
+        conflicts = detect_conflicts(ports, dnat, runtime, docker_svcs, k3s_svcs)
+
+        strategy = detect_strategy(runtime, docker_svcs, k3s_svcs, systemd_svcs)
+        logger.info(f"Detected strategy: {strategy.value}")
+
+        if conflicts:
+            logger.warning(f"Found {len(conflicts)} conflict(s):")
+            for c in conflicts:
+                logger.warning(f"  [{c.severity.upper()}] {c.type}: {c.description}")
+
+        current_version = None
+        for h in health:
+            if h.version:
+                current_version = h.version
+                break
+
+        state = InfraState(
+            host=self.host,
+            app=self.app,
+            runtime=runtime,
+            ports=ports,
+            services={
+                "docker": docker_svcs,
+                "k3s": k3s_svcs,
+                "systemd": systemd_svcs,
+                "podman": [],
+            },
+            health=health,
+            conflicts=conflicts,
+            detected_strategy=strategy,
+            current_version=current_version,
+            raw={"dnat": [{"port": p, "target": t} for p, t in dnat]},
+        )
+        return state
+
+    def save(self, state: InfraState, output: Path) -> None:
+        data = state.model_dump(mode="json")
+        output.write_text(yaml.dump(data, default_flow_style=False, allow_unicode=True))
+        logger.info(f"InfraState saved to {output}")