feat: troppa roba davvero

backend/app/services/mitmproxy/manager.py

@@ -5,10 +5,15 @@ import signal
 from pathlib import Path
 
 import yaml
-from integrations import docker
-from integrations.docker.ports import get_random_port
-from models.proxy import ProxyDocument
-from services.mitmproxy.options import MitmOptionError, validate_options
+
+from app.integrations.docker import change_port
+from app.integrations.docker.ports import get_random_port
+from app.models.proxy import ProxyDocument
+from app.services.mitmproxy.options import MitmOptionError, validate_options
+from app.services.mitmproxy.runtime_validation import (
+    ReservedProxyPortError,
+    ensure_proxy_port_not_reserved,
+)
 
 
 class MitmdumpError(Exception):
@@ -22,6 +27,7 @@ class MitmdumpManager:
         self.processes: dict[int, asyncio.subprocess.Process] = {}
         self.attached_pids: dict[int, int] = {}
         self.locks: dict[int, asyncio.Lock] = {}
+        self.upstream_port_attempts = 8
 
     async def start(self, proxy: ProxyDocument) -> dict[str, object]:
         async with self.lock_for(proxy.proxy_port):
@@ -31,7 +37,30 @@ class MitmdumpManager:
         async with self.lock_for(proxy.proxy_port):
             return await self.stop_unlocked(proxy)
 
+    def cleanup_runtime_artifacts(self, proxy: ProxyDocument) -> None:
+        script_path = (
+            Path(proxy.script_path)
+            if proxy.script_path
+            else self.script_path_for(proxy)
+        )
+        log_path = Path(proxy.log_path) if proxy.log_path else self.log_path_for(proxy)
+        config_path = (
+            Path(proxy.config_path)
+            if proxy.config_path
+            else self.config_path_for(proxy)
+        )
+
+        self.remove_file(script_path)
+        self.remove_file(log_path)
+        self.remove_file(config_path)
+        self.remove_dir(self.conf_dir_for(proxy))
+
     async def start_unlocked(self, proxy: ProxyDocument) -> dict[str, object]:
+        try:
+            ensure_proxy_port_not_reserved(proxy.proxy_port)
+        except ReservedProxyPortError as error:
+            raise MitmdumpError(str(error)) from error
+
         if await self.status(proxy) == "running":
             raise MitmdumpError("Proxy is already running")
 
@@ -44,9 +73,9 @@ class MitmdumpManager:
         except MitmOptionError as error:
             raise MitmdumpError(str(error)) from error
         upstream_port = await self.prepare_upstream(proxy)
-        script_path = self.write_script(proxy)
-        config_path = self.write_config(proxy)
-        log_path = self.log_path(proxy)
+        script_path = await self.write_script(proxy)
+        config_path = await self.write_config(proxy)
+        log_path = await self.log_path(proxy)
         command = self.build_command(
             command_path,
             proxy,
@@ -64,7 +93,10 @@ class MitmdumpManager:
         failed = await self.exited_early(process)
         if failed:
             await self.restore_upstream(proxy, upstream_port)
-            reason = self.read_log_tail(log_path) or "mitmdump exited during startup"
+            reason = (
+                await self.read_log_tail(log_path)
+                or "mitmdump exited during startup"
+            )
             raise MitmdumpError(reason)
 
         self.processes[proxy.proxy_port] = process
@@ -174,18 +206,22 @@ class MitmdumpManager:
         if proxy.service.name is None or proxy.service.folder is None:
             return proxy.service.port
 
-        upstream_port = get_random_port()
-        changed = await docker.change_port(
-            proxy.service.name,
-            Path(proxy.service.folder),
-            proxy.service.port,
-            upstream_port,
-            host_to="127.0.0.1",
-            rewrite_host=True,
-        )
-        if not changed:
-            raise MitmdumpError("Unable to move Docker service port")
-        return upstream_port
+        attempted_ports: set[int] = {proxy.proxy_port, proxy.service.port}
+        for _attempt in range(self.upstream_port_attempts):
+            upstream_port = self.pick_upstream_port(attempted_ports)
+            attempted_ports.add(upstream_port)
+            changed = await change_port(
+                proxy.service.name,
+                Path(proxy.service.folder),
+                proxy.service.port,
+                upstream_port,
+                host_to="127.0.0.1",
+                rewrite_host=True,
+            )
+            if changed:
+                return upstream_port
+
+        raise MitmdumpError("Unable to move Docker service port after retries")
 
     async def restore_upstream(
         self,
@@ -199,7 +235,7 @@ class MitmdumpManager:
         if upstream_port == proxy.service.port:
             return True
 
-        return await docker.change_port(
+        return await change_port(
             proxy.service.name,
             Path(proxy.service.folder),
             upstream_port,
@@ -257,22 +293,29 @@ class MitmdumpManager:
             return False
         return proxy.mode in {"regular", "socks5", "dns", "transparent"}
 
-    def write_script(self, proxy: ProxyDocument) -> Path:
+    def pick_upstream_port(self, excluded_ports: set[int]) -> int:
+        while True:
+            candidate = get_random_port()
+            if candidate not in excluded_ports:
+                return candidate
+
+    async def write_script(self, proxy: ProxyDocument) -> Path:
         path = self.script_path_for(proxy)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(proxy.code, encoding="utf-8")
+        await asyncio.to_thread(path.parent.mkdir, parents=True, exist_ok=True)
+        await asyncio.to_thread(path.write_text, proxy.code, encoding="utf-8")
         return path
 
-    def write_config(self, proxy: ProxyDocument) -> Path:
+    async def write_config(self, proxy: ProxyDocument) -> Path:
         path = self.config_path_for(proxy)
-        path.parent.mkdir(parents=True, exist_ok=True)
+        await asyncio.to_thread(path.parent.mkdir, parents=True, exist_ok=True)
         options = {"block_global": False, **proxy.mitm_options}
-        path.write_text(yaml.safe_dump(options, sort_keys=True), encoding="utf-8")
+        config_text = yaml.safe_dump(options, sort_keys=True)
+        await asyncio.to_thread(path.write_text, config_text, encoding="utf-8")
         return path
 
-    def log_path(self, proxy: ProxyDocument) -> Path:
+    async def log_path(self, proxy: ProxyDocument) -> Path:
         path = self.log_path_for(proxy)
-        path.parent.mkdir(parents=True, exist_ok=True)
+        await asyncio.to_thread(path.parent.mkdir, parents=True, exist_ok=True)
         return path
 
     async def spawn(self, command: list[str], log_path: Path):
@@ -385,12 +428,30 @@ class MitmdumpManager:
     def log_path_for(self, proxy: ProxyDocument) -> Path:
         return self.work_dir / "logs" / f"{proxy.proxy_port}.log"
 
-    def read_log_tail(self, path: Path, limit: int = 4000) -> str:
-        if not path.exists():
+    async def read_log_tail(self, path: Path, limit: int = 4000) -> str:
+        if not await asyncio.to_thread(path.exists):
             return ""
-        content = path.read_text(encoding="utf-8", errors="replace")
+        content = await asyncio.to_thread(
+            path.read_text,
+            encoding="utf-8",
+            errors="replace",
+        )
         return content[-limit:].strip()
 
+    def remove_file(self, path: Path) -> None:
+        try:
+            path.unlink(missing_ok=True)
+        except OSError:
+            return
+
+    def remove_dir(self, path: Path) -> None:
+        try:
+            shutil.rmtree(path)
+        except FileNotFoundError:
+            return
+        except OSError:
+            return
+
     def lock_for(self, proxy_port: int) -> asyncio.Lock:
         lock = self.locks.get(proxy_port)
         if lock is None: