diff --git a/dashboard/src/vms.rs b/dashboard/src/vms.rs index 0f0ad8ca5dbfab4a5ead9834409e90bfc2b2f5cc..df237b28e34decaa9107dfe6793afa6b9380acf4 100644 --- a/dashboard/src/vms.rs +++ b/dashboard/src/vms.rs @@ -115,19 +115,13 @@ async fn bridge(socket: WebSocket, stream: tokio::net::UnixStream) { }; let downstream = async { let mut buffer = vec![0; 65536]; - let mut heartbeat = tokio::time::interval(Duration::from_secs(15)); - heartbeat.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); loop { - let message = tokio::select! { - result = read.read(&mut buffer) => { - let count = result?; - if count == 0 { break; } - Message::Binary(Bytes::copy_from_slice(&buffer[..count])) - } - _ = heartbeat.tick() => Message::Ping(Bytes::new()), - }; - tokio::time::timeout(Duration::from_secs(5), send.send(message)) - .await.map_err(std::io::Error::other)? + let count = read.read(&mut buffer).await?; + if count == 0 { + break; + } + send.send(Message::Binary(Bytes::copy_from_slice(&buffer[..count]))) + .await .map_err(std::io::Error::other)?; } Ok::<_, std::io::Error>(()) diff --git a/tools/router-stream-test.py b/tools/router-stream-test.py new file mode 100644 index 0000000000000000000000000000000000000000..36df08ec2254eddf65e5245f62b77289e33ea2e8 --- /dev/null +++ b/tools/router-stream-test.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +import argparse +import base64 +import hashlib +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +import os +from pathlib import Path +import socket +import subprocess +import tempfile +import threading +import time + +import router + + +class Echo(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + + def do_GET(self): + self.close_connection = True + key = self.headers["Sec-WebSocket-Key"] + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" + self.send_response(101) + self.send_header("Upgrade", "websocket") + self.send_header("Connection", "Upgrade") + self.send_header("Sec-WebSocket-Accept", base64.b64encode(hashlib.sha1(key.encode()).digest()).decode()) + self.end_headers() + while header := self.rfile.read(2): + if len(header) != 2 or header[0] != 0x81: + break + size = header[1] & 127 + assert header[1] & 128 and size < 126 + mask = self.rfile.read(4) + data = self.rfile.read(size) + self.wfile.write(bytes([0x81, size]) + bytes(value ^ mask[index % 4] for index, value in enumerate(data))) + + def log_message(self, *_): + pass + + +def free_port(): + with socket.socket() as listener: + listener.bind(("127.0.0.1", 0)) + return listener.getsockname()[1] + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--caddy", required=True) + args = parser.parse_args() + with tempfile.TemporaryDirectory(prefix="snowglobe-router-stream-") as temporary, ThreadingHTTPServer(("127.0.0.1", 0), Echo) as backend: + root = Path(temporary) + threading.Thread(target=backend.serve_forever, daemon=True).start() + for keep in (False, True): + port, admin = free_port(), free_port() + config = root / "Caddyfile" + content = "\n".join(["{", f" admin 127.0.0.1:{admin}", " auto_https off", "}", f"http://127.0.0.1:{port} {{", + *router.proxy(f"127.0.0.1:{backend.server_port}", " ", keep_streams=keep), "}"]) + config.write_text(content) + environment = {**os.environ, "XDG_DATA_HOME": str(root / "data"), "XDG_CONFIG_HOME": str(root / "config")} + with (root / "caddy.log").open("w") as log: + process = subprocess.Popen([args.caddy, "run", "--config", str(config)], stdout=log, stderr=log, env=environment) + try: + deadline = time.monotonic() + 10 + while True: + try: + client = socket.create_connection(("127.0.0.1", port), timeout=2) + break + except OSError: + assert process.poll() is None and time.monotonic() < deadline, (root / "caddy.log").read_text() + time.sleep(.05) + with client, client.makefile("rb") as incoming: + client.sendall(f"GET / HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: c3RyZWFtLWZpeHR1cmUtMQ==\r\nSec-WebSocket-Version: 13\r\n\r\n".encode()) + assert b"101" in incoming.readline() + while incoming.readline() != b"\r\n": + pass + client.sendall(b"\x81\x84\0\0\0\0ping") + assert incoming.read(6) == b"\x81\x04ping" + config.write_text(content.replace(" reverse_proxy", " header X-Reload verified\n reverse_proxy")) + subprocess.run([args.caddy, "reload", "--config", str(config), "--address", f"127.0.0.1:{admin}"], check=True, capture_output=True, env=environment) + client.sendall(b"\x81\x84\0\0\0\0pong") + header = incoming.read(2) + assert header == (b"\x81\x04" if keep else b"\x88\x02"), header + if keep: + assert incoming.read(4) == b"pong" + finally: + process.terminate() + process.wait(timeout=5) + backend.shutdown() + print("Caddy reload closes default WebSockets and preserves dashboard streams.") + + +if __name__ == "__main__": + main() diff --git a/tools/router.py b/tools/router.py index c6c02f15078630b0d145a01c38d6355eeb983975..dcf4144029a18ce02ab637f63d01b9738c0fe2b4 100644 --- a/tools/router.py +++ b/tools/router.py @@ -28,13 +28,15 @@ def passive_health(upstreams, indent): return [f"{indent}fail_duration 30s"] if len(upstreams.split()) > 1 else [] -def proxy(upstreams, indent, uncompressed=False, host=None): +def proxy(upstreams, indent, uncompressed=False, host=None, keep_streams=False): lines = [f"{indent}reverse_proxy {upstreams} {{", f"{indent} lb_try_duration 5s", *passive_health(upstreams, indent + " ")] if uncompressed: lines.append(f"{indent} header_up Accept-Encoding identity") if host: lines += [f"{indent} header_up Host {host}", f"{indent} header_up X-Forwarded-Host {host}"] + if keep_streams: + lines.append(f"{indent} stream_close_delay 8h") return [*lines, f"{indent}}}"] @@ -465,7 +467,7 @@ def render(token): lines += [" handle {", " request_header -User-Name", " request_header -User-Groups", f" request_header Snowglobe-Proxy-Token {dashboard_proof}", " request_header X-Snowglobe-Client-IP {remote_host}", - *proxy(f"127.0.0.1:{dashboard_port}", " "), " }", "}"] + *proxy(f"127.0.0.1:{dashboard_port}", " ", keep_streams=True), " }", "}"] internal_port = os.environ.get("SNOWGLOBE_INTERNAL_PORT") if internal_port is not None: internal_host = "dashboard.internal." + os.environ["SNOWGLOBE_DOMAIN"]