BIG BIG BIG BIG BIG UPDATES

Co-authored-by: Copilot <[email protected]>

backend/app/integrations/docker/__init__.py

@@ -0,0 +1,15 @@
+from integrations.docker.compose import (
+    find_docker_compose,
+    get_all_services_in_dir,
+    get_services,
+)
+from integrations.docker.editor import change_port
+from integrations.docker.models import DockerContainer
+
+__all__ = [
+    "DockerContainer",
+    "find_docker_compose",
+    "get_services",
+    "get_all_services_in_dir",
+    "change_port",
+]

backend/app/integrations/docker/compose.py

@@ -0,0 +1,98 @@
+import asyncio
+from pathlib import Path
+
+import yaml
+from integrations.docker.models import DockerContainer
+from integrations.docker.ports import _get_service_port
+
+COMPOSE_NAMES = (
+    "compose.yml",
+    "compose.yaml",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+)
+
+
+def _get_visible_folders(directory: Path) -> list[Path]:
+    return [
+        p
+        for p in Path(directory).iterdir()
+        if p.is_dir() and not p.name.startswith(".")
+    ]
+
+
+def find_docker_compose(path: Path) -> tuple[dict, Path] | None:
+    if not path or not path.is_dir():
+        return None
+
+    for name in COMPOSE_NAMES:
+        file = path / name
+        if file.is_file():
+            content = yaml.safe_load(file.read_text()) or {}
+            return content, file
+
+    return None
+
+
+def get_services(folder: Path) -> list[DockerContainer] | None:
+    services: list[DockerContainer] = []
+    compose_data = find_docker_compose(folder)
+    if compose_data is None:
+        return None
+
+    docker_compose, _ = compose_data
+    compose_services = docker_compose.get("services") or {}
+    if not compose_services:
+        return None
+
+    for service_name, config in compose_services.items():
+        mappings = config.get("ports") if isinstance(config, dict) else None
+        if not isinstance(mappings, list) or not mappings:
+            continue
+
+        ports = [
+            p
+            for p in (_get_service_port(mapping) for mapping in mappings)
+            if p is not None
+        ]
+        if not ports:
+            continue
+
+        services.append({"name": service_name, "ports": ports, "folder": folder})
+
+    return services
+
+
+def get_all_services_in_dir(directory: str | Path) -> list[DockerContainer]:
+    path = Path(directory)
+    if not path.is_dir():
+        return []
+
+    services: list[DockerContainer] = []
+    for sub_folder in _get_visible_folders(path):
+        sub_services = get_services(sub_folder)
+        if sub_services:
+            services.extend(sub_services)
+
+    return services
+
+
+async def run_docker_command(file: Path, command: list[str]) -> dict | None:
+    if not command:
+        return None
+
+    full_command = ["docker", "compose", "-f", f"{file}", *command]
+
+    process = await asyncio.create_subprocess_exec(
+        *full_command,
+        cwd=str(file.parent),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+
+    stdout, stderr = await process.communicate()
+
+    if process.returncode == 0:
+        return {"status": "success", "output": stdout.decode()}
+    else:
+        return {"status": "error", "reason": stderr.decode()}

backend/app/integrations/docker/editor.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+
+import yaml
+from integrations.docker.compose import find_docker_compose, run_docker_command
+from integrations.docker.ports import _get_port_index, _replace_port_in_mapping
+
+
+def _backup_path_for(compose_path: Path) -> Path:
+    if compose_path.suffix in {".yml", ".yaml"}:
+        return compose_path.with_name(f"{compose_path.stem}.bak{compose_path.suffix}")
+    return compose_path.with_name(f"{compose_path.name}.bak")
+
+
+async def change_port(
+    service_name: str,
+    folder: Path,
+    port_from: int,
+    port_to: int,
+) -> bool:
+    compose_data = find_docker_compose(folder)
+    if compose_data is None:
+        return False
+
+    docker_compose, compose_path = compose_data
+    compose_services = docker_compose.get("services") or {}
+    if not compose_services:
+        return False
+
+    service_config = compose_services.get(service_name)
+    if not isinstance(service_config, dict):
+        return False
+
+    mappings = service_config.get("ports")
+    if not isinstance(mappings, list):
+        return False
+
+    idx = _get_port_index(mappings, port_from)
+    if idx is None:
+        return False
+
+    mappings[idx] = _replace_port_in_mapping(mappings[idx], port_from, port_to)
+
+    backup_path = _backup_path_for(compose_path)
+    original_text = compose_path.read_text()
+
+    backup_path.write_text(compose_path.read_text())
+    compose_path.write_text(
+        yaml.dump(docker_compose, default_flow_style=False, sort_keys=False)
+    )
+
+    result = await run_docker_command(
+        compose_path,
+        ["up", "-d", service_name],
+    )
+
+    if result is None or result.get("status") != "success":
+        compose_path.write_text(original_text)
+        return False
+
+    return True

backend/app/integrations/docker/models.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+from typing import TypedDict
+
+
+class DockerContainer(TypedDict):
+    name: str
+    ports: list[int]
+    folder: Path

backend/app/integrations/docker/ports.py

@@ -0,0 +1,80 @@
+import socket
+from collections.abc import Mapping
+
+
+def get_random_port() -> int:
+    # Binding to port 0 asks the OS for an available ephemeral port.
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            port = s.getsockname()[1]
+            return port
+    except Exception as e:
+        raise RuntimeError(f"Could not find an available port: {e}") from e
+
+
+def _get_service_port(mapping: str | int | Mapping[str, object]) -> int | None:
+    if isinstance(mapping, int):
+        return mapping
+
+    if isinstance(mapping, Mapping):
+        published = mapping.get("published")
+        if published is None:
+            return None
+        try:
+            return int(published)
+        except TypeError, ValueError:
+            return None
+
+    parts = str(mapping).split(":")
+    match parts:
+        case [""]:
+            return None
+        case [port] | [port, _]:
+            try:
+                return int(port)
+            except ValueError:
+                return None
+        case ["localhost" | "127.0.0.1", _, _]:
+            return None
+        case [_, port, _]:
+            try:
+                return int(port)
+            except ValueError:
+                return None
+        case _:
+            return None
+
+
+def _replace_port_in_mapping(
+    mapping: str | int | Mapping[str, object],
+    port_from: int,
+    port_to: int,
+) -> str | dict[str, object]:
+    if isinstance(mapping, Mapping):
+        updated = dict(mapping)
+        if _get_service_port(updated) == port_from:
+            updated["published"] = str(port_to)
+        return updated
+
+    parts = str(mapping).split(":")
+    match parts:
+        case [_]:
+            return str(port_to)
+        case [_, container_port]:
+            return f"{port_to}:{container_port}"
+        case [ip, _, container_port]:
+            return f"{ip}:{port_to}:{container_port}"
+        case _:
+            return str(port_to)
+
+
+def _get_port_index(
+    mappings: list[str | int | Mapping[str, object]],
+    port: int,
+) -> int | None:
+    for i, mapping in enumerate(mappings):
+        if _get_service_port(mapping) == port:
+            return i
+    return None