Files

199 lines
8.9 KiB
Python

"""Loopback Chat Completions and SMTP fixtures for dedicated server tests."""
import base64
import json
import re
import socketserver
import socket
import ssl
import threading
import time
import zipfile
from collections import deque
from contextlib import ExitStack, contextmanager
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
class AIHandler(BaseHTTPRequestHandler):
def do_POST(self):
request = json.loads(self.rfile.read(int(self.headers["content-length"])))
text = request["messages"][-1]["content"]
with self.server.lock:
self.server.requests.append({"received": time.time(), "size": len(text)})
self.server.request_count += 1
if "ICG-timeout" in text:
time.sleep(2.5)
if "ICG-offline-pending" in text:
time.sleep(0.75)
if "ICG-move-pending" in text:
self.server.move_requested.set()
deadline = time.monotonic() + 7
def can_respond():
return self.server.move_signal.exists() and (
not self.server.require_reload or self.server.reload_signal.exists())
while not can_respond() and time.monotonic() < deadline:
time.sleep(0.025)
if not can_respond():
self.send_error(503)
return
if "ICG-error" in text:
self.send_error(503)
return
if "ICG-disconnect" in text:
self.close_connection = True
return
blocked = "ICG-denied" in text
review = {"safe": not blocked, "level": "HIGH" if blocked else "LOW", "category": "INSULT" if blocked else "SAFE",
"reason": "loopback fixture", "suggestion": "BLOCK" if blocked else "ALLOW"}
content = "invalid JSON" if "ICG-invalid" in text else json.dumps(review)
response = json.dumps({"choices": [{"message": {"content": content}}]}).encode()
try:
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(response)))
self.end_headers()
self.wfile.write(response)
except ConnectionError:
pass
def log_message(self, fmt, *args):
pass
class SmtpHandler(socketserver.StreamRequestHandler):
def handle(self):
self.connection.settimeout(8)
if self.server.fail_connections:
return
self.wfile.write(b"220 localhost ICG test SMTP\r\n")
encrypted = isinstance(self.connection, ssl.SSLSocket)
if encrypted:
with self.server.lock:
self.server.negotiated.add(self.connection.version())
data = None
while command := self.rfile.readline(70_000):
if data is not None:
if command == b".\r\n":
with self.server.lock:
self.server.messages.append(b"".join(data))
self.server.message_count += 1
self.wfile.write(b"250 queued\r\n")
data = None
else:
data.append(command)
continue
label = command.upper()
if label.startswith((b"EHLO ", b"HELO ")):
if self.server.tls_mode == "starttls" and not encrypted:
self.wfile.write(b"250-localhost\r\n250 STARTTLS\r\n")
elif self.server.authenticate:
self.wfile.write(b"250-localhost\r\n250 AUTH PLAIN\r\n")
else:
self.wfile.write(b"250 localhost\r\n")
elif label.startswith(b"STARTTLS") and self.server.tls_mode == "starttls" and not encrypted:
self.wfile.write(b"220 start TLS\r\n")
self.rfile.close()
self.wfile.close()
self.connection = self.server.ssl_context.wrap_socket(self.connection, server_side=True)
self.rfile = self.connection.makefile("rb")
self.wfile = self.connection.makefile("wb", buffering=0)
encrypted = True
with self.server.lock:
self.server.negotiated.add(self.connection.version())
elif label.startswith(b"AUTH PLAIN "):
try:
received = base64.b64decode(command.strip().split()[2], validate=True).split(b"\0")[-2:]
except ValueError:
received = []
if received == [b"fixture-user", b"fixture-password"]:
self.wfile.write(b"235 authenticated\r\n")
else:
self.wfile.write(b"535 authentication failed\r\n")
elif label.startswith((b"MAIL FROM:", b"RCPT TO:", b"RSET")):
self.wfile.write(b"250 accepted\r\n")
elif label.startswith(b"DATA"):
if self.server.tls_mode == "timeout":
time.sleep(2)
return
self.wfile.write(b"354 send message\r\n")
data = []
elif label.startswith(b"QUIT"):
self.wfile.write(b"221 bye\r\n")
return
else:
self.wfile.write(b"502 unsupported\r\n")
class SmtpServer(socketserver.ThreadingTCPServer):
daemon_threads = True
def get_request(self):
client, endpoint = super().get_request()
if self.tls_mode == "ssl":
client.settimeout(8)
client = self.ssl_context.wrap_socket(client, server_side=True)
return client, endpoint
@contextmanager
def fixtures(plugin: Path, directory: Path, mode="STRICT", smtp_mode="plain", smtp_tls=None,
folia_special=False, require_reload=False):
with ExitStack() as stack:
ai = stack.enter_context(ThreadingHTTPServer(("127.0.0.1", 0), AIHandler))
smtp = stack.enter_context(SmtpServer(("127.0.0.1", 0), SmtpHandler))
ai.lock, ai.requests, ai.request_count = threading.Lock(), deque(maxlen=4096), 0
ai.move_signal = directory / "plugins" / "ICGCompatibilityProbe" / "moved.signal"
ai.require_reload = require_reload
ai.reload_signal = directory / "configuration-reloaded.signal"
ai.move_requested = threading.Event()
smtp.lock, smtp.messages, smtp.message_count = threading.Lock(), deque(maxlen=200), 0
smtp.fail_connections = False
smtp.tls_mode = smtp_mode
smtp.ssl_context = smtp_tls
smtp.authenticate = smtp_mode in ("ssl", "starttls", "auth-error")
smtp.negotiated = set()
smtp_port = smtp.server_address[1]
if smtp_mode == "port-closed":
with socket.socket() as unserved:
unserved.bind(("127.0.0.1", 0))
smtp_port = unserved.getsockname()[1]
# Keep the port reserved without a listening socket for this run.
inherited = unserved.dup()
stack.callback(inherited.close)
for service in (ai, smtp):
thread = threading.Thread(target=service.serve_forever, kwargs={"poll_interval": 0.1}, daemon=True)
thread.start()
stack.callback(thread.join)
stack.callback(service.shutdown)
data = directory / "plugins" / "ItxiaohuiContentGuard"
data.mkdir()
with zipfile.ZipFile(plugin) as archive:
for name, items in (
("ai.yml", {
"mode": mode, "api-key": "fixture-token", "model": "fixture-model",
"base-url": f"http://127.0.0.1:{ai.server_port}/v1", "timeout-ms": 900, "deadline-ms": 1500,
"max-retries": 0, "requests-per-minute": 6000, "circuit-failures": 3, "circuit-cooldown-seconds": 2,
}),
("smtp.yml", {
"enabled": True, "host": "127.0.0.1", "port": smtp_port,
"starttls": smtp_mode == "starttls", "ssl": smtp_mode == "ssl",
"from": "contentguard@example.test", "to": ["admin@example.test"],
"send-interval-ms": 150, "merge-window-ms": 100,
"send-timeout-ms": 600 if smtp_mode == "timeout" else 5000,
"username": "fixture-user" if smtp.authenticate else "",
"password": ("fixture-invalid" if smtp_mode == "auth-error" else "fixture-password")
if smtp.authenticate else "",
}),
):
if folia_special and name == "ai.yml":
items.update({"timeout-ms": 8000, "deadline-ms": 9000})
yaml = archive.read(name).decode("utf-8")
for key, value in items.items():
yaml, count = re.subn(rf"(?m)^{re.escape(key)}:.*$", lambda _: key + ": " + json.dumps(value), yaml)
if count != 1:
raise ValueError(f"Fixture key missing: {name} {key}")
(data / name).write_text(yaml, encoding="utf-8")
yield ai, smtp