Merge branch 'main' into fix/1339

Merge PR #1651: feat: add WebSocket load testing infrastructure (#1505)

Dockerfile.preview

@@ -0,0 +1,9 @@
+FROM nginx:alpine
+
+RUN rm /etc/nginx/conf.d/default.conf
+COPY preview/nginx.conf /etc/nginx/conf.d/default.conf
+
+COPY *.html *.js *.mjs *.json *.css /usr/share/nginx/html/
+COPY nexus/ /usr/share/nginx/html/nexus/
+
+EXPOSE 3000

app.js

@@ -1253,10 +1253,16 @@ async function updateSovereignHealth() {
   const container = document.getElementById('sovereign-health-content');
   if (!container) return;
 
+  const params = new URLSearchParams(window.location.search);
+  const metricsOverride = params.get('metrics');
+  const metricsUrl = metricsOverride || `${window.location.protocol}//${window.location.host}/metrics`;
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const wsStatusUrl = `${protocol}//${window.location.host}/api/world/ws`;
+
   let metrics = { sovereignty_score: 100, local_sessions: 0, total_sessions: 0 };
   let daemonReachable = false;
   try {
-    const res = await fetch('http://localhost:8082/metrics');
+    const res = await fetch(metricsUrl);
     if (res.ok) {
       metrics = await res.json();
       daemonReachable = true;
@@ -1269,8 +1275,8 @@ async function updateSovereignHealth() {
     { name: 'LOCAL DAEMON', status: daemonReachable ? 'ONLINE' : 'OFFLINE' },
     { name: 'FORGE / GITEA', url: 'https://forge.alexanderwhitestone.com', status: 'ONLINE' },
     { name: 'NEXUS CORE', url: 'https://forge.alexanderwhitestone.com/Timmy_Foundation/the-nexus', status: 'ONLINE' },
-    { name: 'HERMES WS', url: 'ws://143.198.27.163:8765', status: wsConnected ? 'ONLINE' : 'OFFLINE' },
-    { name: 'SOVEREIGNTY', url: 'http://localhost:8082/metrics', status: metrics.sovereignty_score + '%' }
+    { name: 'HERMES WS', url: wsStatusUrl, status: wsConnected ? 'ONLINE' : 'OFFLINE' },
+    { name: 'SOVEREIGNTY', url: metricsUrl, status: metrics.sovereignty_score + '%' }
   ];
 
   container.innerHTML = '';

docker-compose.yml

@@ -1,5 +1,3 @@
-version: "3.9"
-
 services:
   nexus-main:
     build: .
@@ -7,9 +5,21 @@ services:
     restart: unless-stopped
     ports:
       - "8765:8765"
+
   nexus-staging:
     build: .
     container_name: nexus-staging
     restart: unless-stopped
     ports:
-      - "8766:8765"
+      - "8766:8765"
+
+  nexus-preview:
+    build:
+      context: .
+      dockerfile: Dockerfile.preview
+    container_name: nexus-preview
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    depends_on:
+      - nexus-main

docs/preview-deploy.md

@@ -0,0 +1,25 @@
+# Nexus preview deploy
+
+The Nexus frontend must be served over HTTP for ES modules to boot. This repo now includes a preview stack that serves the frontend on a proper URL and proxies `/api/world/ws` back to the existing Nexus WebSocket gateway.
+
+## Quick start
+
+```bash
+docker compose up -d nexus-main nexus-preview
+```
+
+Open:
+- `http://localhost:3000`
+
+The preview service serves the static frontend and proxies WebSocket traffic at:
+- `/api/world/ws`
+
+## Remote preview
+
+If you run the same compose stack on a VPS, the preview URL is:
+- `http://<host>:3000`
+
+## Notes
+- `nexus-main` keeps serving the backend WebSocket gateway on port `8765`
+- `nexus-preview` serves the frontend on port `3000`
+- The browser can stay on a single origin because nginx proxies the WebSocket path

preview/nginx.conf

@@ -0,0 +1,36 @@
+server {
+    listen 3000;
+    server_name _;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    location ~* \.js$ {
+        types { application/javascript js; }
+    }
+
+    location ~* \.mjs$ {
+        types { application/javascript mjs; }
+    }
+
+    location ~* \.css$ {
+        types { text/css css; }
+    }
+
+    location ~* \.json$ {
+        types { application/json json; }
+        add_header Cache-Control "no-cache";
+    }
+
+    location /api/world/ws {
+        proxy_pass http://nexus-main:8765;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_read_timeout 86400;
+    }
+}

tests/load/websocket_load_test.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+WebSocket Load Test — Benchmark concurrent user sessions on the Nexus gateway.
+
+Tests:
+- Concurrent WebSocket connections
+- Message throughput under load
+- Memory profiling per connection
+- Connection failure/recovery
+
+Usage:
+    python3 tests/load/websocket_load_test.py                    # default (50 users)
+    python3 tests/load/websocket_load_test.py --users 200        # 200 concurrent
+    python3 tests/load/websocket_load_test.py --duration 60      # 60 second test
+    python3 tests/load/websocket_load_test.py --json             # JSON output
+
+Ref: #1505
+"""
+
+import asyncio
+import json
+import os
+import sys
+import time
+import argparse
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+WS_URL = os.environ.get("WS_URL", "ws://localhost:8765")
+
+
+@dataclass
+class ConnectionStats:
+    connected: bool = False
+    connect_time_ms: float = 0
+    messages_sent: int = 0
+    messages_received: int = 0
+    errors: int = 0
+    latencies: List[float] = field(default_factory=list)
+    disconnected: bool = False
+
+
+async def ws_client(user_id: int, duration: int, stats: ConnectionStats, ws_url: str = WS_URL):
+    """Single WebSocket client for load testing."""
+    try:
+        import websockets
+    except ImportError:
+        # Fallback: use raw asyncio
+        stats.errors += 1
+        return
+
+    try:
+        start = time.time()
+        async with websockets.connect(ws_url, open_timeout=5) as ws:
+            stats.connect_time_ms = (time.time() - start) * 1000
+            stats.connected = True
+
+            # Send periodic messages for the duration
+            end_time = time.time() + duration
+            msg_count = 0
+            while time.time() < end_time:
+                try:
+                    msg_start = time.time()
+                    message = json.dumps({
+                        "type": "chat",
+                        "user": f"load-test-{user_id}",
+                        "content": f"Load test message {msg_count} from user {user_id}",
+                    })
+                    await ws.send(message)
+                    stats.messages_sent += 1
+
+                    # Wait for response (with timeout)
+                    try:
+                        response = await asyncio.wait_for(ws.recv(), timeout=5.0)
+                        stats.messages_received += 1
+                        latency = (time.time() - msg_start) * 1000
+                        stats.latencies.append(latency)
+                    except asyncio.TimeoutError:
+                        stats.errors += 1
+
+                    msg_count += 1
+                    await asyncio.sleep(0.5)  # 2 messages/sec per user
+
+                except websockets.exceptions.ConnectionClosed:
+                    stats.disconnected = True
+                    break
+                except Exception:
+                    stats.errors += 1
+
+    except Exception as e:
+        stats.errors += 1
+        if "Connection refused" in str(e) or "connect" in str(e).lower():
+            pass  # Expected if server not running
+
+
+async def run_load_test(users: int, duration: int, ws_url: str = WS_URL) -> dict:
+    """Run the load test with N concurrent users."""
+    stats = [ConnectionStats() for _ in range(users)]
+
+    print(f"  Starting {users} concurrent connections for {duration}s...")
+    start = time.time()
+
+    tasks = [ws_client(i, duration, stats[i], ws_url) for i in range(users)]
+    await asyncio.gather(*tasks, return_exceptions=True)
+
+    total_time = time.time() - start
+
+    # Aggregate results
+    connected = sum(1 for s in stats if s.connected)
+    total_sent = sum(s.messages_sent for s in stats)
+    total_received = sum(s.messages_received for s in stats)
+    total_errors = sum(s.errors for s in stats)
+    disconnected = sum(1 for s in stats if s.disconnected)
+
+    all_latencies = []
+    for s in stats:
+        all_latencies.extend(s.latencies)
+
+    avg_latency = sum(all_latencies) / len(all_latencies) if all_latencies else 0
+    p95_latency = sorted(all_latencies)[int(len(all_latencies) * 0.95)] if all_latencies else 0
+    p99_latency = sorted(all_latencies)[int(len(all_latencies) * 0.99)] if all_latencies else 0
+
+    avg_connect_time = sum(s.connect_time_ms for s in stats if s.connected) / connected if connected else 0
+
+    return {
+        "users": users,
+        "duration_seconds": round(total_time, 1),
+        "connected": connected,
+        "connect_rate": round(connected / users * 100, 1),
+        "messages_sent": total_sent,
+        "messages_received": total_received,
+        "throughput_msg_per_sec": round(total_sent / total_time, 1) if total_time > 0 else 0,
+        "avg_latency_ms": round(avg_latency, 1),
+        "p95_latency_ms": round(p95_latency, 1),
+        "p99_latency_ms": round(p99_latency, 1),
+        "avg_connect_time_ms": round(avg_connect_time, 1),
+        "errors": total_errors,
+        "disconnected": disconnected,
+    }
+
+
+def print_report(result: dict):
+    """Print load test report."""
+    print(f"\n{'='*60}")
+    print(f"  WEBSOCKET LOAD TEST REPORT")
+    print(f"{'='*60}\n")
+
+    print(f"  Connections:    {result['connected']}/{result['users']} ({result['connect_rate']}%)")
+    print(f"  Duration:       {result['duration_seconds']}s")
+    print(f"  Messages sent:  {result['messages_sent']}")
+    print(f"  Messages recv:  {result['messages_received']}")
+    print(f"  Throughput:     {result['throughput_msg_per_sec']} msg/s")
+    print(f"  Avg connect:    {result['avg_connect_time_ms']}ms")
+    print()
+    print(f"  Latency:")
+    print(f"    Avg: {result['avg_latency_ms']}ms")
+    print(f"    P95: {result['p95_latency_ms']}ms")
+    print(f"    P99: {result['p99_latency_ms']}ms")
+    print()
+    print(f"  Errors:         {result['errors']}")
+    print(f"  Disconnected:   {result['disconnected']}")
+
+    # Verdict
+    if result['connect_rate'] >= 95 and result['errors'] == 0:
+        print(f"\n  ✅ PASS")
+    elif result['connect_rate'] >= 80:
+        print(f"\n  ⚠️  DEGRADED")
+    else:
+        print(f"\n  ❌ FAIL")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="WebSocket Load Test")
+    parser.add_argument("--users", type=int, default=50, help="Concurrent users")
+    parser.add_argument("--duration", type=int, default=30, help="Test duration in seconds")
+    parser.add_argument("--json", action="store_true", help="JSON output")
+    parser.add_argument("--url", default=WS_URL, help="WebSocket URL")
+    args = parser.parse_args()
+
+    ws_url = args.url
+
+    print(f"\nWebSocket Load Test — {args.users} users, {args.duration}s\n")
+
+    result = asyncio.run(run_load_test(args.users, args.duration, ws_url))
+
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        print_report(result)
+
+
+if __name__ == "__main__":
+    main()

tests/test_preview_deploy.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent.parent
+DOCKERFILE = ROOT / "Dockerfile.preview"
+NGINX_CONF = ROOT / "preview" / "nginx.conf"
+DOC = ROOT / "docs" / "preview-deploy.md"
+COMPOSE = ROOT / "docker-compose.yml"
+
+
+def test_preview_deploy_files_exist():
+    assert DOCKERFILE.exists(), "expected Dockerfile.preview for Nexus preview deployment"
+    assert NGINX_CONF.exists(), "expected preview/nginx.conf for Nexus preview deployment"
+    assert DOC.exists(), "expected docs/preview-deploy.md runbook"
+
+
+def test_preview_nginx_config_proxies_websocket_and_serves_modules():
+    text = NGINX_CONF.read_text(encoding="utf-8")
+    assert "listen 3000;" in text
+    assert "location /api/world/ws" in text
+    assert "proxy_pass http://nexus-main:8765;" in text
+    assert "application/javascript js;" in text
+    assert "try_files $uri $uri/ /index.html;" in text
+
+
+def test_compose_exposes_preview_service():
+    text = COMPOSE.read_text(encoding="utf-8")
+    assert "nexus-preview:" in text
+    assert '"3000:3000"' in text
+    assert "depends_on:" in text
+    assert "nexus-main" in text
+
+
+def test_preview_runbook_documents_preview_url():
+    text = DOC.read_text(encoding="utf-8")
+    assert "http://localhost:3000" in text
+    assert "docker compose up -d nexus-main nexus-preview" in text
+    assert "/api/world/ws" in text
+
+
+def test_app_avoids_hardcoded_preview_breaking_urls():
+    text = (ROOT / "app.js").read_text(encoding="utf-8")
+    assert "ws://143.198.27.163:8765" not in text
+    assert "http://localhost:8082/metrics" not in text
+    assert "const metricsUrl = metricsOverride || `${window.location.protocol}//${window.location.host}/metrics`;" in text
+    assert "const wsStatusUrl = `${protocol}//${window.location.host}/api/world/ws`;" in text