199 lines
8.9 KiB
Python
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
|