#!/usr/bin/env python3 """A TCP relay that delays mission WebSocket traffic, to simulate a slow link. The hosted smoke runs the page through this so a travel round trip costs a known number of milliseconds. Only connections whose first request is the mission socket are delayed; static files and HTTP calls pass straight through. Usage: scripts/latency-proxy.py --listen 4132 --target 4131 --delay-ms 150 A one-way delay of 150 ms makes a request and its reply cost about 300 ms. The relay does not parse WebSocket frames; it delays each read in each direction. """ import argparse import asyncio import signal import sys async def relay(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, delay: float) -> None: """Reads at once and writes each chunk `delay` after it arrived. Scheduling from arrival time keeps a stream of small messages spaced as they were sent; a queue that slept between writes would add up. """ loop = asyncio.get_running_loop() queue: asyncio.Queue[tuple[float | None, bytes | None]] = asyncio.Queue() async def read_loop() -> None: try: while True: data = await reader.read(65536) if not data: break queue.put_nowait((loop.time(), data)) except (ConnectionError, asyncio.CancelledError): pass finally: queue.put_nowait((None, None)) async def write_loop() -> None: try: while True: arrived, data = await queue.get() if arrived is None or data is None: break pause = arrived + delay - loop.time() if pause > 0: await asyncio.sleep(pause) writer.write(data) await writer.drain() except (ConnectionError, asyncio.CancelledError): pass finally: writer.close() await asyncio.gather(read_loop(), write_loop()) async def handle( client_reader: asyncio.StreamReader, client_writer: asyncio.StreamWriter, target: tuple[str, int], delay: float, ) -> None: try: server_reader, server_writer = await asyncio.open_connection(*target) except OSError as error: print(f"latency-proxy: cannot reach {target[0]}:{target[1]}: {error}", file=sys.stderr) client_writer.close() return # The browser opens a separate connection for the mission socket. Delay # only that one, so loading the bundle is not slowed chunk by chunk. first = await client_reader.read(65536) if not first: server_writer.close() client_writer.close() return request_line = first.split(b"\r\n", 1)[0] socket_delay = delay if b"/ws " in request_line else 0.0 if socket_delay > 0: print(f"latency-proxy: delayed {request_line.decode(errors='replace')}", flush=True) server_writer.write(first) await server_writer.drain() await asyncio.gather( relay(client_reader, server_writer, socket_delay), relay(server_reader, client_writer, socket_delay), ) async def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--listen", type=int, required=True) parser.add_argument("--target", type=int, required=True) parser.add_argument("--host", default="127.0.0.1") parser.add_argument("--delay-ms", type=float, default=150.0) args = parser.parse_args() delay = args.delay_ms / 1000.0 server = await asyncio.start_server( lambda reader, writer: handle(reader, writer, (args.host, args.target), delay), args.host, args.listen, ) print( f"latency-proxy: {args.listen} -> {args.target}, mission sockets delayed " f"{args.delay_ms} ms each way", flush=True, ) loop = asyncio.get_running_loop() stop = loop.create_future() for signum in (signal.SIGINT, signal.SIGTERM): loop.add_signal_handler(signum, lambda: stop.done() or stop.set_result(None)) async with server: await stop if __name__ == "__main__": try: asyncio.run(main()) except KeyboardInterrupt: pass