| """Carry TCP across the agent sandbox's empty network namespace, over a bound unix socket. |
| |
| The agent sandbox runs with `--net --network=none` (see `solve.py`): it keeps a loopback |
| interface but has no route anywhere else, so the only way in or out is a unix socket bound from |
| the host. `scripts/x2p_anthropic_shim.py` already uses that trick for Anthropic traffic; this is |
| the same idea for the local vLLM judge pool (`scripts/ptb_judge_pool.sbatch`), which the two |
| LLM-graded benchmarks need in order to score anything. |
| |
| Two halves of one pipe, plus a degenerate third mode: |
| |
| host listens on a unix socket, dials the pool over TCP (runs on the compute node) |
| sandbox listens on loopback, dials that unix socket (runs inside the sandbox) |
| balance listens on loopback, dials the pool over TCP (no namespace to cross) |
| |
| `balance` is for the evaluation sandbox, which runs without `--net` and so shares the host's |
| network namespace: nothing has to be smuggled across, but the pool still fronts N independent vLLM |
| servers with no load balancer of its own, and a grading pass is thousands of requests. |
| |
| Unlike the Anthropic shim this does not parse HTTP. It pumps bytes, so keep-alive, chunked |
| responses and SSE streams pass through untouched -- worth having when a grading pass is thousands |
| of requests and a subtly wrong re-framing would only show up as a hang. |
| |
| python3 scripts/ptb_uds_bridge.py host --socket /path/judge.sock --targets h1:8000,h1:8001 |
| python3 scripts/ptb_uds_bridge.py sandbox --socket /run/ptb_judge.sock # prints its port |
| python3 scripts/ptb_uds_bridge.py balance --targets h1:8000,h1:8001 # prints its port |
| """ |
|
|
| import argparse |
| import itertools |
| import os |
| import socket |
| import socketserver |
| import sys |
| import threading |
|
|
|
|
| def pump(src: socket.socket, dst: socket.socket) -> None: |
| """Copy until EOF, then half-close so the peer sees the end of the stream.""" |
| try: |
| while chunk := src.recv(65536): |
| dst.sendall(chunk) |
| except OSError: |
| pass |
| finally: |
| try: |
| dst.shutdown(socket.SHUT_WR) |
| except OSError: |
| pass |
|
|
|
|
| def splice(a: socket.socket, b: socket.socket) -> None: |
| """Run both directions until each has seen EOF.""" |
| upward = threading.Thread(target=pump, args=(a, b), daemon=True) |
| upward.start() |
| pump(b, a) |
| upward.join() |
|
|
|
|
| class ThreadingUnixServer(socketserver.ThreadingMixIn, socketserver.UnixStreamServer): |
| daemon_threads = True |
| allow_reuse_address = True |
|
|
|
|
| class ThreadingTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): |
| daemon_threads = True |
| allow_reuse_address = True |
|
|
|
|
| def pool_handler(targets: list[tuple[str, int]]) -> type: |
| """A handler that hands each connection to the next replica in turn. |
| |
| The pool fronts N independent vLLM servers with no load balancer of its own, so without this |
| every grading call would queue on replica 0 and the other GPUs would idle. |
| """ |
| rotation = itertools.cycle(targets) |
| lock = threading.Lock() |
|
|
| class Handler(socketserver.BaseRequestHandler): |
| def handle(self) -> None: |
| with lock: |
| host, port = next(rotation) |
| try: |
| upstream = socket.create_connection((host, port), timeout=900) |
| except OSError as error: |
| print(f"judge bridge: cannot reach {host}:{port}: {error}", file=sys.stderr, flush=True) |
| return |
| with upstream: |
| splice(self.request, upstream) |
|
|
| return Handler |
|
|
|
|
| def host_side(socket_path: str, targets: list[tuple[str, int]]) -> None: |
| if os.path.exists(socket_path): |
| os.unlink(socket_path) |
| server = ThreadingUnixServer(socket_path, pool_handler(targets)) |
| os.chmod(socket_path, 0o666) |
| print(f"judge bridge: {socket_path} -> {', '.join(f'{h}:{p}' for h, p in targets)}", flush=True) |
| try: |
| server.serve_forever() |
| finally: |
| server.server_close() |
| if os.path.exists(socket_path): |
| os.unlink(socket_path) |
|
|
|
|
| def balance_side(port: int, targets: list[tuple[str, int]]) -> None: |
| server = ThreadingTCPServer(("127.0.0.1", port), pool_handler(targets)) |
| print(server.server_address[1], flush=True) |
| server.serve_forever() |
|
|
|
|
| def sandbox_side(socket_path: str, port: int) -> None: |
| class Handler(socketserver.BaseRequestHandler): |
| def handle(self) -> None: |
| upstream = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) |
| upstream.settimeout(900) |
| try: |
| upstream.connect(socket_path) |
| except OSError as error: |
| print(f"judge shim: cannot reach {socket_path}: {error}", file=sys.stderr, flush=True) |
| upstream.close() |
| return |
| with upstream: |
| splice(self.request, upstream) |
|
|
| server = ThreadingTCPServer(("127.0.0.1", port), Handler) |
| print(server.server_address[1], flush=True) |
| server.serve_forever() |
|
|
|
|
| def parse_targets(raw: str) -> list[tuple[str, int]]: |
| targets = [] |
| for item in raw.replace(",", " ").split(): |
| host, _, port = item.rpartition(":") |
| if not host or not port.isdigit(): |
| sys.exit(f"Bad target {item!r}: expected host:port.") |
| targets.append((host, int(port))) |
| if not targets: |
| sys.exit("No targets given.") |
| return targets |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) |
| parser.add_argument("side", choices=("host", "sandbox", "balance")) |
| parser.add_argument("--socket", help="host/sandbox mode: the unix socket to listen on or dial") |
| parser.add_argument("--targets", help="host/balance mode: comma-separated host:port of the pool replicas") |
| parser.add_argument("--port", type=int, default=0, help="sandbox/balance mode: 0 picks a free port") |
| args = parser.parse_args() |
|
|
| if args.side in ("host", "balance") and not args.targets: |
| sys.exit(f"{args.side} mode needs --targets.") |
| if args.side in ("host", "sandbox") and not args.socket: |
| sys.exit(f"{args.side} mode needs --socket.") |
|
|
| if args.side == "host": |
| host_side(args.socket, parse_targets(args.targets)) |
| elif args.side == "balance": |
| balance_side(args.port, parse_targets(args.targets)) |
| else: |
| sandbox_side(args.socket, args.port) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
