228 lines
7.7 KiB
Python
228 lines
7.7 KiB
Python
from __future__ import annotations
|
|
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import select
|
|
import socket
|
|
import struct
|
|
import threading
|
|
import time
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from typing import Any
|
|
from urllib.parse import parse_qs, urlparse
|
|
|
|
from core.controller import MicroduckController
|
|
from core.deploy_service import DeployService
|
|
|
|
from .api import (
|
|
build_status_payload,
|
|
dispatch_api_get,
|
|
dispatch_api_post,
|
|
handle_ws_message,
|
|
load_index_html,
|
|
)
|
|
|
|
|
|
WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
|
|
|
|
|
def _ws_encode_frame(opcode: int, payload: bytes) -> bytes:
|
|
header = bytearray([0x80 | (opcode & 0x0F)])
|
|
n = len(payload)
|
|
if n < 126:
|
|
header.append(n)
|
|
elif n < 65536:
|
|
header.append(126)
|
|
header.extend(struct.pack("!H", n))
|
|
else:
|
|
header.append(127)
|
|
header.extend(struct.pack("!Q", n))
|
|
return bytes(header) + payload
|
|
|
|
|
|
def _recv_exact(sock: socket.socket, n: int) -> bytes | None:
|
|
chunks = bytearray()
|
|
while len(chunks) < n:
|
|
chunk = sock.recv(n - len(chunks))
|
|
if not chunk:
|
|
return None
|
|
chunks.extend(chunk)
|
|
return bytes(chunks)
|
|
|
|
|
|
def _ws_read_frame(sock: socket.socket) -> tuple[int, bytes] | None:
|
|
head = _recv_exact(sock, 2)
|
|
if head is None:
|
|
return None
|
|
b1, b2 = head[0], head[1]
|
|
opcode = b1 & 0x0F
|
|
masked = bool(b2 & 0x80)
|
|
length = b2 & 0x7F
|
|
if length == 126:
|
|
ext = _recv_exact(sock, 2)
|
|
if ext is None:
|
|
return None
|
|
length = struct.unpack("!H", ext)[0]
|
|
elif length == 127:
|
|
ext = _recv_exact(sock, 8)
|
|
if ext is None:
|
|
return None
|
|
length = struct.unpack("!Q", ext)[0]
|
|
if length > 1024 * 1024:
|
|
return None
|
|
mask = _recv_exact(sock, 4) if masked else b""
|
|
if masked and mask is None:
|
|
return None
|
|
payload = _recv_exact(sock, length) if length > 0 else b""
|
|
if payload is None:
|
|
return None
|
|
if masked:
|
|
payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
|
|
return opcode, payload
|
|
|
|
|
|
class FallbackWebServer(ThreadingHTTPServer):
|
|
"""Zero-dependency HTTP + RFC6455 WebSocket server (runs on stock Python 3.12)."""
|
|
|
|
allow_reuse_address = True
|
|
daemon_threads = True
|
|
|
|
def __init__(
|
|
self,
|
|
host: str,
|
|
port: int,
|
|
controller: MicroduckController,
|
|
deploy_service: DeployService,
|
|
) -> None:
|
|
self.controller = controller
|
|
self.deploy_service = deploy_service
|
|
super().__init__((host, port), _RequestHandler)
|
|
self.port = int(self.server_address[1])
|
|
|
|
|
|
class _RequestHandler(BaseHTTPRequestHandler):
|
|
protocol_version = "HTTP/1.1"
|
|
|
|
def log_message(self, format: str, *args: Any) -> None: # noqa: A002
|
|
return
|
|
|
|
def _send_cors_headers(self) -> None:
|
|
self.send_header("Access-Control-Allow-Origin", "*")
|
|
self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
|
|
self.send_header("Access-Control-Allow-Headers", "Content-Type")
|
|
self.send_header("Access-Control-Allow-Private-Network", "true")
|
|
|
|
def _send_json(self, status_code: int, payload: dict[str, Any]) -> None:
|
|
raw = json.dumps(payload).encode("utf-8")
|
|
self.send_response(status_code)
|
|
self._send_cors_headers()
|
|
self.send_header("Content-Type", "application/json; charset=utf-8")
|
|
self.send_header("Content-Length", str(len(raw)))
|
|
self.end_headers()
|
|
self.wfile.write(raw)
|
|
|
|
def _send_bytes(self, status_code: int, content_type: str, data: bytes) -> None:
|
|
self.send_response(status_code)
|
|
self._send_cors_headers()
|
|
self.send_header("Content-Type", content_type)
|
|
self.send_header("Content-Length", str(len(data)))
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
|
|
def do_OPTIONS(self) -> None: # noqa: N802
|
|
self.send_response(204)
|
|
self._send_cors_headers()
|
|
self.send_header("Content-Length", "0")
|
|
self.end_headers()
|
|
|
|
def do_GET(self) -> None: # noqa: N802
|
|
parsed = urlparse(self.path)
|
|
if parsed.path == "/ws/control" and self.headers.get("Upgrade", "").lower() == "websocket":
|
|
self._handle_websocket()
|
|
return
|
|
if parsed.path in ("/", "/index.html"):
|
|
self._send_bytes(200, "text/html; charset=utf-8", load_index_html())
|
|
return
|
|
|
|
srv: FallbackWebServer = self.server # type: ignore[assignment]
|
|
code, payload = dispatch_api_get(parsed.path, srv.controller, srv.deploy_service)
|
|
self._send_json(code, payload)
|
|
|
|
def do_POST(self) -> None: # noqa: N802
|
|
parsed = urlparse(self.path)
|
|
length = int(self.headers.get("Content-Length", "0") or "0")
|
|
if length < 0 or length > 160 * 1024 * 1024:
|
|
self._send_json(413, {"ok": False, "error": "Payload too large"})
|
|
return
|
|
body = self.rfile.read(length) if length > 0 else b""
|
|
content_type = self.headers.get("Content-Type", "")
|
|
query = parse_qs(parsed.query)
|
|
srv: FallbackWebServer = self.server # type: ignore[assignment]
|
|
code, payload = dispatch_api_post(
|
|
parsed.path,
|
|
body,
|
|
content_type,
|
|
query,
|
|
srv.controller,
|
|
srv.deploy_service,
|
|
)
|
|
self._send_json(code, payload)
|
|
|
|
def _handle_websocket(self) -> None:
|
|
key = self.headers.get("Sec-WebSocket-Key")
|
|
if not key:
|
|
self.send_error(400, "Missing Sec-WebSocket-Key")
|
|
return
|
|
accept = base64.b64encode(hashlib.sha1((key.strip() + WS_GUID).encode("ascii")).digest()).decode("ascii")
|
|
self.send_response(101, "Switching Protocols")
|
|
self.send_header("Upgrade", "websocket")
|
|
self.send_header("Connection", "Upgrade")
|
|
self.send_header("Sec-WebSocket-Accept", accept)
|
|
self.end_headers()
|
|
|
|
srv: FallbackWebServer = self.server # type: ignore[assignment]
|
|
sock: socket.socket = self.connection
|
|
sock.settimeout(5.0)
|
|
write_lock = threading.Lock()
|
|
last_telemetry = 0.0
|
|
|
|
try:
|
|
while True:
|
|
now = time.monotonic()
|
|
if now - last_telemetry >= 0.1:
|
|
last_telemetry = now
|
|
msg = {"type": "telemetry", **build_status_payload(srv.controller, srv.deploy_service)}
|
|
frame = _ws_encode_frame(0x1, json.dumps(msg).encode("utf-8"))
|
|
with write_lock:
|
|
sock.sendall(frame)
|
|
|
|
readable, _, _ = select.select([sock], [], [], 0.05)
|
|
if not readable:
|
|
continue
|
|
parsed = _ws_read_frame(sock)
|
|
if parsed is None:
|
|
break
|
|
opcode, payload = parsed
|
|
if opcode == 0x8: # close
|
|
with write_lock:
|
|
sock.sendall(_ws_encode_frame(0x8, b""))
|
|
break
|
|
if opcode == 0x9: # ping -> pong
|
|
with write_lock:
|
|
sock.sendall(_ws_encode_frame(0xA, payload))
|
|
continue
|
|
if opcode == 0x1: # text
|
|
try:
|
|
data = json.loads(payload.decode("utf-8"))
|
|
except Exception:
|
|
continue
|
|
ack = handle_ws_message(srv.controller, data)
|
|
if ack is not None:
|
|
with write_lock:
|
|
sock.sendall(_ws_encode_frame(0x1, json.dumps(ack).encode("utf-8")))
|
|
except (BrokenPipeError, ConnectionResetError, TimeoutError, OSError):
|
|
pass
|
|
finally:
|
|
self.close_connection = True
|