| """Komut çalıştırıcı: kodu yerel süreçte ya da izole Docker konteynerinde koşar. |
| |
| Ajanın derleyici ve test koşucusuna erişimi yalnızca bu katman üzerinden olur; |
| böylece LLM'in ürettiği kod hiçbir zaman ana sürece doğrudan dokunmaz. |
| """ |
| from __future__ import annotations |
|
|
| import os |
| import shutil |
| import signal |
| import subprocess |
| import time |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
| from ..config import settings |
|
|
|
|
| @dataclass |
| class ExecResult: |
| returncode: int |
| stdout: str |
| stderr: str |
| duration_s: float |
| timed_out: bool = False |
|
|
| @property |
| def combined(self) -> str: |
| return (self.stdout + ("\n" + self.stderr if self.stderr else "")).strip() |
|
|
|
|
| class Executor: |
| """Soyut çalıştırıcı. `node_toolchain` ve `java_lib`, çalışma ortamı içindeki yollardır.""" |
|
|
| mode = "abstract" |
| node_toolchain: str |
| java_lib: str |
|
|
| def run(self, cmd: str, workdir: Path, timeout: int, image: str) -> ExecResult: |
| raise NotImplementedError |
|
|
| def workpath(self, workdir: Path) -> str: |
| """Çalışma dizininin, komutun çalıştığı ortamdaki yolu.""" |
| raise NotImplementedError |
|
|
|
|
| class LocalExecutor(Executor): |
| mode = "local" |
|
|
| def __init__(self) -> None: |
| self.node_toolchain = str(settings.node_toolchain) |
| self.java_lib = str(settings.java_lib_dir) |
|
|
| def workpath(self, workdir: Path) -> str: |
| return str(workdir) |
|
|
| def run(self, cmd: str, workdir: Path, timeout: int, image: str = "") -> ExecResult: |
| env = dict(os.environ) |
| env.update({"CI": "1", "NO_COLOR": "1", "FORCE_COLOR": "0", "PYTHONDONTWRITEBYTECODE": "1"}) |
| env["NODE_PATH"] = str(Path(self.node_toolchain) / "node_modules") |
| start = time.time() |
| proc = subprocess.Popen( |
| ["bash", "-lc", cmd], cwd=workdir, stdout=subprocess.PIPE, stderr=subprocess.PIPE, |
| text=True, env=env, start_new_session=True, |
| ) |
| try: |
| out, err = proc.communicate(timeout=timeout) |
| return ExecResult(proc.returncode, out, err, time.time() - start) |
| except subprocess.TimeoutExpired: |
| try: |
| os.killpg(proc.pid, signal.SIGKILL) |
| except ProcessLookupError: |
| pass |
| out, err = proc.communicate() |
| return ExecResult(-9, out or "", (err or "") + "\n[zaman aşımı]", time.time() - start, True) |
|
|
|
|
| class DockerExecutor(Executor): |
| """Her komut için ağ erişimi kapalı, bellek/CPU sınırlı geçici konteyner.""" |
|
|
| mode = "docker" |
|
|
| def __init__(self) -> None: |
| self.node_toolchain = "/opt/toolchain" |
| self.java_lib = "/opt/java-lib" |
| |
| |
| |
| self.work_volume = os.environ.get("WORK_VOLUME") |
| self.host_work_root = os.environ.get("HOST_WORK_ROOT") |
|
|
| def workpath(self, workdir: Path) -> str: |
| return str(workdir.resolve()) if self.work_volume else "/work" |
|
|
| def _mount_args(self, workdir: Path) -> list[str]: |
| if self.work_volume: |
| root = str(settings.work_root.resolve()) |
| return ["-v", f"{self.work_volume}:{root}", "-w", str(workdir.resolve())] |
| return ["-v", f"{self._host_path(workdir)}:/work", "-w", "/work"] |
|
|
| def _host_path(self, workdir: Path) -> str: |
| if self.host_work_root: |
| rel = workdir.resolve().relative_to(settings.work_root.resolve()) |
| return str(Path(self.host_work_root) / rel) |
| return str(workdir.resolve()) |
|
|
| @staticmethod |
| def _open_permissions(workdir: Path) -> None: |
| |
| for p in [workdir, *workdir.rglob("*")]: |
| try: |
| p.chmod(0o777 if p.is_dir() else 0o666) |
| except OSError: |
| pass |
|
|
| def run(self, cmd: str, workdir: Path, timeout: int, image: str) -> ExecResult: |
| self._open_permissions(workdir) |
| name = f"lta-{workdir.name}-{int(time.time() * 1000) % 100000}" |
| docker_cmd = [ |
| "docker", "run", "--rm", "--name", name, "--network", "none", |
| "--memory", settings.docker_memory, "--cpus", settings.docker_cpus, |
| "--pids-limit", "256", "--security-opt", "no-new-privileges", |
| *self._mount_args(workdir), |
| "-e", "CI=1", "-e", "NO_COLOR=1", |
| image, "bash", "-lc", cmd, |
| ] |
| start = time.time() |
| try: |
| p = subprocess.run(docker_cmd, capture_output=True, text=True, timeout=timeout + 15) |
| return ExecResult(p.returncode, p.stdout, p.stderr, time.time() - start) |
| except subprocess.TimeoutExpired as e: |
| subprocess.run(["docker", "kill", name], capture_output=True) |
| return ExecResult(-9, (e.stdout or b"").decode(errors="ignore") if isinstance(e.stdout, bytes) else (e.stdout or ""), |
| "[zaman aşımı]", time.time() - start, True) |
|
|
|
|
| _executor: Executor | None = None |
|
|
|
|
| def get_executor() -> Executor: |
| global _executor |
| if _executor is None: |
| if settings.sandbox_mode == "docker": |
| if not shutil.which("docker"): |
| raise RuntimeError("SANDBOX_MODE=docker fakat docker komutu bulunamadı") |
| _executor = DockerExecutor() |
| else: |
| _executor = LocalExecutor() |
| return _executor |
|
|
