From 633a7d1cd7955c87e57d76da1ba97e27a1eca991 Mon Sep 17 00:00:00 2001 From: Paddy Byers Date: Mon, 30 Mar 2026 22:27:37 +0100 Subject: [PATCH] Add test proxy framework for integration testing Add a Go-based test proxy that intercepts and manipulates WebSocket and HTTP traffic between SDK clients and the Ably service. Includes: - Programmable proxy server with rule-based request/response manipulation - WebSocket and HTTP proxy handlers with protocol-level inspection - Session management and action framework for fault injection - Integration test specs for connection failures, resume, heartbeats, channel faults, and REST faults using the proxy - Proxy helper spec for UTS integration test authors - Updated write-test-spec skill with proxy test patterns --- uts/.claude/skills/write-test-spec.md | 201 ++- uts/completion-status.md | 25 + uts/proxy/IMPLEMENTATION.md | 710 +++++++++++ uts/proxy/PROPOSAL.md | 461 +++++++ uts/proxy/action.go | 129 ++ uts/proxy/go.mod | 9 + uts/proxy/go.sum | 6 + uts/proxy/http_proxy.go | 205 +++ uts/proxy/listener.go | 71 ++ uts/proxy/log.go | 54 + uts/proxy/main.go | 47 + uts/proxy/protocol.go | 234 ++++ uts/proxy/proxy_test.go | 1118 +++++++++++++++++ uts/proxy/rule.go | 110 ++ uts/proxy/server.go | 245 ++++ uts/proxy/session.go | 286 +++++ uts/proxy/session_store.go | 64 + uts/proxy/test-proxy | Bin 0 -> 8660002 bytes uts/proxy/ws_proxy.go | 500 ++++++++ uts/realtime/integration/helpers/proxy.md | 233 ++++ .../integration/proxy/channel_faults.md | 553 ++++++++ .../proxy/connection_open_failures.md | 495 ++++++++ .../integration/proxy/connection_resume.md | 586 +++++++++ uts/realtime/integration/proxy/heartbeat.md | 174 +++ uts/realtime/integration/proxy/rest_faults.md | 364 ++++++ 25 files changed, 6879 insertions(+), 1 deletion(-) create mode 100644 uts/proxy/IMPLEMENTATION.md create mode 100644 uts/proxy/PROPOSAL.md create mode 100644 uts/proxy/action.go create mode 100644 uts/proxy/go.mod create mode 100644 uts/proxy/go.sum create mode 100644 uts/proxy/http_proxy.go create mode 100644 uts/proxy/listener.go create mode 100644 uts/proxy/log.go create mode 100644 uts/proxy/main.go create mode 100644 uts/proxy/protocol.go create mode 100644 uts/proxy/proxy_test.go create mode 100644 uts/proxy/rule.go create mode 100644 uts/proxy/server.go create mode 100644 uts/proxy/session.go create mode 100644 uts/proxy/session_store.go create mode 100755 uts/proxy/test-proxy create mode 100644 uts/proxy/ws_proxy.go create mode 100644 uts/realtime/integration/helpers/proxy.md create mode 100644 uts/realtime/integration/proxy/channel_faults.md create mode 100644 uts/realtime/integration/proxy/connection_open_failures.md create mode 100644 uts/realtime/integration/proxy/connection_resume.md create mode 100644 uts/realtime/integration/proxy/heartbeat.md create mode 100644 uts/realtime/integration/proxy/rest_faults.md diff --git a/uts/.claude/skills/write-test-spec.md b/uts/.claude/skills/write-test-spec.md index 0dac235e2..d5a05404d 100644 --- a/uts/.claude/skills/write-test-spec.md +++ b/uts/.claude/skills/write-test-spec.md @@ -22,6 +22,12 @@ This skill provides comprehensive guidance for writing portable test specificati - Provision apps via `POST /apps` with body from `ably-common/test-resources/test-app-setup.json` - Use `endpoint: "sandbox"` in ClientOptions +### Proxy Integration Tests (Ably Sandbox via Proxy) +- Run against Ably Sandbox through a programmable proxy (`uts/test/proxy/`) +- Proxy transparently forwards traffic but can inject faults via rules +- Use for testing fault behaviour: connection failures, token renewal under errors, heartbeat starvation, channel error injection +- See `uts/test/realtime/integration/helpers/proxy.md` for the full proxy infrastructure spec + ## Mock Infrastructure Patterns ### HTTP Mock Infrastructure @@ -229,6 +235,189 @@ mock_ws.active_connection.send_to_client(ProtocolMessage( mock_ws.active_connection.simulate_disconnect() ``` +## Proxy Integration Tests + +For detailed proxy infrastructure documentation, see `uts/test/realtime/integration/helpers/proxy.md`. + +### When to Use Proxy Tests + +| Test type | When to use | +|-----------|-------------| +| **Unit test** (mock HTTP/WebSocket) | Client-side logic, state machines, request formation, error parsing. Fast, deterministic. | +| **Direct sandbox integration** | Happy-path behaviour: connect, publish, subscribe. No fault injection needed. | +| **Proxy integration test** | Fault behaviour against real backend: connection failures, resume, heartbeat starvation, token renewal under network errors, channel error injection. | + +### Proxy Test Structure + +```markdown +# Feature Name Proxy Integration Tests + +Spec points: `RTN14a`, `RTN14b`, ... + +## Test Type +Proxy integration test against Ably Sandbox endpoint + +## Proxy Infrastructure +See `uts/test/realtime/integration/helpers/proxy.md` for proxy infrastructure specification. + +## Corresponding Unit Tests +- `uts/test/realtime/unit/connection/connection_failures_test.md` — RTN15a, RTN15b + +## Sandbox Setup +[standard app provisioning — same as direct sandbox tests] + +--- + +## RTN14a - Test name + +| Spec | Requirement | +|------|-------------| +| RTN14a | ... | + +**Corresponding unit test:** `connection_open_failures_test.md` RTN14a + +Tests that [behaviour] when the proxy injects [fault]. + +### Setup + +```pseudo +session = create_proxy_session( + target: TargetConfig(realtimeHost: "sandbox-realtime.ably.io", restHost: "sandbox-rest.ably.io"), + port: allocated_port, + rules: [{ + "match": { ... }, + "action": { ... }, + "times": 1, + "comment": "description" + }] +) + +client = Realtime(options: ClientOptions( + key: api_key, + endpoint: "localhost", + port: session.proxy_port, + tls: false, + useBinaryProtocol: false, + autoConnect: false +)) +``` + +### Test Steps + +```pseudo +state_changes = [] +client.connection.on(change => state_changes.append(change.current)) + +client.connect() +AWAIT_STATE client.connection.state == ConnectionState.failed + WITH timeout: 15 seconds +``` + +### Assertions + +```pseudo +ASSERT client.connection.state == ConnectionState.failed +ASSERT client.connection.errorReason.code == 40005 +``` +``` + +### Common Proxy Rule Patterns + +**Replace server response with error:** +```json +{ + "match": { "type": "ws_frame_to_client", "action": "CONNECTED" }, + "action": { + "type": "replace", + "message": { "action": 9, "error": { "code": 40005, "statusCode": 400, "message": "Error" } } + }, + "times": 1 +} +``` + +**Refuse connection (one-shot):** +```json +{ + "match": { "type": "ws_connect", "count": 1 }, + "action": { "type": "refuse_connection" }, + "times": 1 +} +``` + +**Suppress frame (cause timeout):** +```json +{ + "match": { "type": "ws_frame_to_server", "action": "ATTACH" }, + "action": { "type": "suppress" } +} +``` + +**Temporal trigger (timed fault injection):** +```json +{ + "match": { "type": "delay_after_ws_connect", "delayMs": 2000 }, + "action": { "type": "suppress_onwards" }, + "times": 1 +} +``` + +**Inject message to client:** +```json +{ + "match": { "type": "delay_after_ws_connect", "delayMs": 1000 }, + "action": { + "type": "inject_to_client_and_close", + "message": { "action": 6, "error": { "code": 40142, "statusCode": 401, "message": "Token expired" } } + }, + "times": 1 +} +``` + +**HTTP fault (return custom response):** +```json +{ + "match": { "type": "http_request", "pathContains": "/channels/" }, + "action": { + "type": "http_respond", + "status": 401, + "body": { "error": { "code": 40142, "statusCode": 401, "message": "Token expired" } } + }, + "times": 1 +} +``` + +### Proxy Test Conventions + +1. Each test references the spec point AND the corresponding unit test +2. Tests use `create_proxy_session()` with rules, then connect SDK through the proxy +3. Tests use `AWAIT_STATE` for state assertions and record state changes for sequence verification +4. Tests verify behaviour via SDK state AND proxy event log where useful +5. All tests use `useBinaryProtocol: false` (SDK doesn't implement msgpack) +6. All tests use `endpoint: "localhost"` which auto-disables fallback hosts (REC2c2) +7. Timeouts are generous (10-30s) since real network is involved +8. Each test file provisions a sandbox app in `BEFORE ALL TESTS` and cleans up in `AFTER ALL TESTS` +9. Each test creates its own proxy session and cleans it up after +10. Use imperative actions (`session.trigger_action()`) when you need to disconnect at a specific point in the test flow, rather than timing-based rules +11. Use `add_rules()` to add rules dynamically during a test (e.g., after channel attach succeeds, add a rule to suppress DETACH) + +### Proxy Event Log Assertions + +```pseudo +# Verify resume was attempted on reconnection +log = session.get_log() +ws_connects = log.filter(e => e.type == "ws_connect") +ASSERT ws_connects.length >= 2 +ASSERT ws_connects[1].queryParams["resume"] IS NOT null + +# Verify heartbeats=true in connection URL +ASSERT ws_connects[0].queryParams["heartbeats"] == "true" + +# Verify specific frames were sent +frames = log.filter(e => e.type == "ws_frame" AND e.direction == "client_to_server") +attach_frames = frames.filter(f => f.message.action == 10) # ATTACH = 10 +ASSERT attach_frames.length == 1 +``` + ## Spec Requirement Summaries **Every test must include a spec requirement summary immediately after the heading.** @@ -777,7 +966,17 @@ uts/test/ │ │ ├── connection_open_failures_test.md │ │ └── ... │ └── integration/ -│ └── (future Realtime integration tests) +│ ├── helpers/ +│ │ └── proxy.md # Proxy infrastructure spec +│ ├── proxy/ +│ │ ├── connection_open_failures.md # RTN14 tests via proxy +│ │ ├── connection_resume.md # RTN15 tests via proxy +│ │ ├── heartbeat.md # RTN23 tests via proxy +│ │ ├── channel_faults.md # RTL4, RTL5, RTL13, RTL14 via proxy +│ │ ├── rest_faults.md # RSC10, RSC15 via proxy +│ │ └── end_to_end.md # RTL6 publish + history via proxy +│ ├── connection_lifecycle_test.md # Direct sandbox tests +│ └── ... └── README.md ``` diff --git a/uts/completion-status.md b/uts/completion-status.md index 9909eb07b..43a27031c 100644 --- a/uts/completion-status.md +++ b/uts/completion-status.md @@ -386,6 +386,31 @@ This matrix lists all spec items from the [Ably features spec](../../specificati --- +### Proxy Integration Tests + +| Spec item | Description | UTS test spec | +|-----------|-------------|---------------| +| RTN14a | Fatal error during connection open → FAILED | Yes — `realtime/integration/proxy/connection_open_failures.md` | +| RTN14b | Token error during connection → renew and retry | Yes — `realtime/integration/proxy/connection_open_failures.md` | +| RTN14c | Connection timeout (no CONNECTED received) | Yes — `realtime/integration/proxy/connection_open_failures.md` | +| RTN14d | Retry after connection refused | Yes — `realtime/integration/proxy/connection_open_failures.md` | +| RTN14g | Connection-level ERROR during open → FAILED | Yes — `realtime/integration/proxy/connection_open_failures.md` | +| RTN15a | Unexpected disconnect triggers resume | Yes — `realtime/integration/proxy/connection_resume.md` | +| RTN15b/c6 | Resume preserves connectionId | Yes — `realtime/integration/proxy/connection_resume.md` | +| RTN15c7 | Failed resume gets new connectionId | Yes — `realtime/integration/proxy/connection_resume.md` | +| RTN15h1 | DISCONNECTED with token error, non-renewable → FAILED | Yes — `realtime/integration/proxy/connection_resume.md` | +| RTN15h3 | DISCONNECTED with non-token error → reconnect | Yes — `realtime/integration/proxy/connection_resume.md` | +| RTN23a | Heartbeat starvation causes disconnect | Yes — `realtime/integration/proxy/heartbeat.md` | +| RTN23a | heartbeats=true in connection URL | Yes — `realtime/integration/proxy/heartbeat.md` | +| RTL4f | Attach timeout (server doesn't respond) | Yes — `realtime/integration/proxy/channel_faults.md` | +| RTL4h | Server responds with ERROR to ATTACH | Yes — `realtime/integration/proxy/channel_faults.md` | +| RTL5f | Detach timeout (server doesn't respond) | Yes — `realtime/integration/proxy/channel_faults.md` | +| RTL13a | Server sends unsolicited DETACHED → reattach | Yes — `realtime/integration/proxy/channel_faults.md` | +| RTL14 | Server sends channel ERROR → FAILED | Yes — `realtime/integration/proxy/channel_faults.md` | +| RSC10 | Token renewal on HTTP 401 | Yes — `realtime/integration/proxy/rest_faults.md` | +| RSC15a | HTTP 503 error (no fallback) | Yes — `realtime/integration/proxy/rest_faults.md` | +| RTL6 | End-to-end publish and history | Yes — `realtime/integration/proxy/rest_faults.md` | + ## Summary | Area | Spec groups | With UTS spec | Coverage | diff --git a/uts/proxy/IMPLEMENTATION.md b/uts/proxy/IMPLEMENTATION.md new file mode 100644 index 000000000..02a266181 --- /dev/null +++ b/uts/proxy/IMPLEMENTATION.md @@ -0,0 +1,710 @@ +# Ably Test Proxy — Go Implementation Plan + +## Project structure + +``` +uts/test/proxy/ +├── PROPOSAL.md # API and design proposal +├── IMPLEMENTATION.md # This file +├── go.mod # module: ably.io/test-proxy +├── go.sum +├── main.go # Entry point, flag parsing, server startup +├── server.go # Control API HTTP server, routing +├── session.go # Session lifecycle (create, get, delete, timeout) +├── session_store.go # Thread-safe session storage +├── rule.go # Rule types, matching logic, action types +├── ws_proxy.go # WebSocket proxy (client↔server frame relay) +├── http_proxy.go # HTTP reverse proxy with rule interception +├── protocol.go # Ably protocol message parsing (JSON + msgpack) +├── log.go # Event log (per-session traffic capture) +├── action.go # Imperative action dispatch +├── listener.go # Per-session TCP listener management +└── proxy_test.go # Tests +``` + +## Design decisions + +1. **Port-per-session routing.** The SDK constructs URLs with standard paths (`/channels/...`, `/?key=...`). It cannot prepend a session path prefix. Therefore, each session gets its own TCP listener on a dedicated port. The test process assigns a port from a pool (e.g., 10000–11023, 1024 ports) and passes it in the session creation request. The proxy binds that port and maps all traffic on it to the session. The SDK connects to `ws://localhost:{sessionPort}/...` and `http://localhost:{sessionPort}/...` with normal paths. + +2. **No TLS between client and proxy.** The proxy serves plain HTTP/WS to the SDK. Upstream connections to the Ably sandbox use TLS (`wss://`, `https://`). The SDK is configured with `tls: false`. + +3. **Msgpack support.** The proxy decodes both JSON (text frames) and msgpack (binary frames) for rule matching. Go has good msgpack libraries. Both formats are decoded into the same `ProtocolMessage` struct for matching, then the original raw bytes are forwarded unchanged (the proxy never re-encodes). + +## Dependencies + +| Package | Purpose | +|---------|---------| +| `github.com/gorilla/websocket` | WebSocket client and server | +| `github.com/vmihailenco/msgpack/v5` | Msgpack decoding for binary protocol frames | +| `net/http` | Control API server | +| `net/http/httputil` | `ReverseProxy` for HTTP passthrough | +| `encoding/json` | JSON protocol message parsing, API request/response | +| `sync` | Mutex for session store and rule list | +| `net` | TCP listener management for per-session ports | + +## Phases + +### Phase 1: Skeleton and control API + +Build the control API HTTP server, session CRUD, per-session listener management, and health check. No proxying yet. + +**Files:** `main.go`, `server.go`, `session.go`, `session_store.go`, `rule.go`, `log.go`, `listener.go` + +#### `main.go` + +- Parse `--control-port` flag (default 9100) +- Start the control API HTTP server on the control port +- Handle SIGINT/SIGTERM for graceful shutdown (close all session listeners) + +#### `server.go` + +Control API mux routing: + +| Method | Path | Handler | +|--------|------|---------| +| `GET` | `/health` | Return `{"ok": true}` | +| `POST` | `/sessions` | Create session | +| `GET` | `/sessions/{id}` | Get session metadata | +| `POST` | `/sessions/{id}/rules` | Add rules | +| `POST` | `/sessions/{id}/actions` | Trigger imperative action | +| `GET` | `/sessions/{id}/log` | Get event log | +| `DELETE` | `/sessions/{id}` | Teardown session | + +Use `net/http.ServeMux` (Go 1.22 has method-aware routing with `{id}` wildcards). No framework needed. + +#### `listener.go` + +Per-session TCP listener management: + +```go +// StartSessionListener binds to the given port, starts an HTTP server +// that routes all WS and HTTP traffic to the session's handlers. +// Returns an error immediately if the port cannot be bound. +func StartSessionListener(session *Session, port int) error + +// StopSessionListener closes the listener and shuts down the HTTP server. +func StopSessionListener(session *Session) +``` + +On session creation: +1. Caller provides `port` in the request body +2. Proxy calls `net.Listen("tcp", fmt.Sprintf(":%d", port))` +3. If listen fails (port in use, permission denied), return HTTP 409 with error message +4. Start `http.Serve` on the listener in a goroutine +5. The per-session HTTP server routes: + - WebSocket upgrade requests → `ws_proxy` handler + - All other HTTP requests → `http_proxy` handler + +On session deletion: +1. Close the TCP listener (stops accepting new connections) +2. Close all active WS connections +3. Shut down the per-session HTTP server + +#### `session.go` + +```go +type CreateSessionRequest struct { + Target TargetConfig `json:"target"` + Rules []Rule `json:"rules,omitempty"` + TimeoutMs int `json:"timeoutMs,omitempty"` // default 30000 + Port int `json:"port"` // required — caller-assigned +} + +type CreateSessionResponse struct { + SessionID string `json:"sessionId"` + Proxy ProxyConfig `json:"proxy"` +} + +type ProxyConfig struct { + Host string `json:"host"` // "localhost:{port}" + Port int `json:"port"` +} +``` + +Session creation flow: +1. Validate request (port is required, target has at least one host) +2. Generate session ID (random 8-char hex) +3. Create `Session` struct with rules, empty event log +4. Attempt to bind the requested port — fail fast with 409 if it can't +5. Start the per-session HTTP server +6. Start timeout timer (`time.AfterFunc`) +7. Store session in `SessionStore` +8. Return session ID and proxy host/port + +#### `session_store.go` + +Thread-safe `map[string]*Session` with `sync.RWMutex`. + +```go +type SessionStore struct { + sessions map[string]*Session + mu sync.RWMutex +} + +func (s *SessionStore) Create(session *Session) error +func (s *SessionStore) Get(id string) (*Session, bool) +func (s *SessionStore) Delete(id string) (*Session, bool) +func (s *SessionStore) All() []*Session +``` + +#### `rule.go` + +Rule, MatchConfig, ActionConfig structs with JSON tags. Matching logic is a method on Session: + +```go +// FindMatchingRule iterates rules in order and returns the first match. +// Returns nil if no rule matches (passthrough). +func (s *Session) FindMatchingRule(event MatchEvent) *Rule +``` + +`MatchEvent` is a tagged union representing the thing being matched: + +```go +type MatchEvent struct { + Type string // "ws_connect", "ws_frame_to_server", "ws_frame_to_client", "http_request" + Action string // protocol message action name (for frame matches) + Channel string // protocol message channel (for frame matches) + Method string // HTTP method + Path string // HTTP request path + QueryParams map[string]string // WS connection query params +} +``` + +#### `log.go` + +Append-only event log with mutex. + +```go +type EventLog struct { + events []Event + mu sync.Mutex +} + +func (l *EventLog) Append(event Event) +func (l *EventLog) Events() []Event // returns a copy +``` + +### Phase 2: WebSocket proxy — passthrough + +Implement transparent WebSocket proxying with no rules applied. + +**Files:** `ws_proxy.go`, `protocol.go` + +#### WebSocket proxy flow + +1. Client connects to `ws://localhost:{sessionPort}/?key=...&heartbeats=true&...` +2. Per-session HTTP server detects WebSocket upgrade, hands off to `WsProxyHandler` +3. Increment `session.WsConnectCount` +4. Log `ws_connect` event with URL and query params +5. Build upstream URL: `wss://{target.realtimeHost}/?key=...&heartbeats=true&...` + - Copy all query params from client request + - Scheme is always `wss` (TLS to upstream) +6. Dial upstream WebSocket +7. If dial fails, return error to client (502) +8. Accept the client WebSocket upgrade +9. Start two goroutines: + - **client→server relay**: `readFromClient()` → log → `writeToServer()` + - **server→client relay**: `readFromServer()` → log → `writeToClient()` +10. When either side closes or errors, close the other side +11. Log `ws_disconnect` event + +#### `protocol.go` + +Parse protocol messages for rule matching. Support both JSON and msgpack. + +```go +// ParseProtocolMessage attempts to decode a WebSocket frame into a ProtocolMessage. +// For text frames, parses as JSON. +// For binary frames, parses as msgpack. +// Returns the parsed message and nil error on success. +// On parse failure, returns a zero ProtocolMessage and error (frame is still forwarded). +func ParseProtocolMessage(data []byte, messageType int) (ProtocolMessage, error) +``` + +The `ProtocolMessage` struct: + +```go +type ProtocolMessage struct { + Action int // numeric action code (always normalized to int) + Channel string + Error *ErrorInfo +} +``` + +Action name↔number mapping (subset needed for matching): + +| Name | Number | +|------|--------| +| HEARTBEAT | 0 | +| ACK | 1 | +| NACK | 2 | +| CONNECT | 3 | +| CONNECTED | 4 | +| DISCONNECT | 5 | +| DISCONNECTED | 6 | +| CLOSE | 7 | +| CLOSED | 8 | +| ERROR | 9 | +| ATTACH | 10 | +| ATTACHED | 11 | +| DETACH | 12 | +| DETACHED | 13 | +| PRESENCE | 14 | +| MESSAGE | 15 | +| SYNC | 16 | +| AUTH | 17 | + +Rule matching accepts either name (`"ATTACH"`) or number (`10`) in the match config. Internally normalized to int. + +**Msgpack decoding:** + +Ably msgpack protocol messages are arrays where the first element is the action number. Use `github.com/vmihailenco/msgpack/v5` to decode into a `[]interface{}` and extract the action and channel fields by position. The field positions follow the Ably protocol: + +| Index | Field | +|-------|-------| +| 0 | action | +| 1 | channel | +| ... | (other fields — not needed for matching) | + +Alternatively, decode as a map if the server uses map encoding. Try map first, fall back to array. Log a warning if neither works but still forward the raw frame. + +#### Connection tracking + +```go +type WsConnection struct { + ClientConn *websocket.Conn + ServerConn *websocket.Conn + ConnNumber int // which connection attempt this is (1-based) + timers []*time.Timer // for delay_after_ws_connect cleanup + mu sync.Mutex +} +``` + +Session tracks `activeWsConn *WsConnection` (most recent). When a new WS connection arrives, any previous one should already be closed (the SDK doesn't multiplex WS connections). But track it as a list for safety. + +### Phase 3: WebSocket proxy — rule matching + +Apply rules to WebSocket frames and connection events. + +**Files:** `ws_proxy.go`, `rule.go` + +#### Rule evaluation points + +**On WS connection attempt** (before dialing upstream): +1. Build `MatchEvent{Type: "ws_connect", QueryParams: ...}` +2. Find matching rule +3. If rule action is `refuse_connection`: return HTTP 502 to client, don't dial upstream +4. If rule action is `accept_and_close`: accept WS upgrade, send close frame, don't dial upstream +5. Otherwise: proceed to dial upstream + +**On frame from client** (before forwarding to server): +1. Parse protocol message +2. Build `MatchEvent{Type: "ws_frame_to_server", Action: ..., Channel: ...}` +3. Check `session.suppressClientToServer` flag — if set, drop frame +4. Find matching rule +5. Execute action (suppress, delay, replace, etc.) +6. If no rule matched: forward frame + +**On frame from server** (before forwarding to client): +1. Parse protocol message +2. Build `MatchEvent{Type: "ws_frame_to_client", Action: ..., Channel: ...}` +3. Check `session.suppressServerToClient` flag — if set, drop frame +4. Find matching rule +5. Execute action +6. If no rule matched: forward frame + +#### Count tracking + +The `count` match field means "only match the Nth occurrence of this event type." Counters are per-session: + +- `session.wsConnectCount` — incremented on each WS connection attempt +- `session.wsFrameToServerCount` — incremented on each frame from client +- `session.wsFrameToClientCount` — incremented on each frame from server + +A rule with `count: 2` matches when the counter equals 2 at evaluation time. + +Optionally, counters can be scoped per-action (e.g., "the 2nd ATTACH frame"). Implementation: the rule's `fired` counter tracks how many times the rule's match condition has been checked against a matching event. If `count` is set, the rule only fires when `fired + 1 == count`. + +**Simpler approach (recommended):** `count` is a per-rule occurrence counter. The rule tracks how many times its match condition (type + action + channel) has been satisfied. It only fires when that count equals the specified value. This is more intuitive: `{ "type": "ws_connect", "count": 2 }` means "the 2nd connection attempt that would otherwise match this rule." + +#### `times` handling + +```go +func (s *Session) FireRule(rule *Rule) { + rule.fired++ + if rule.Times > 0 && rule.fired >= rule.Times { + s.removeRule(rule) + } +} +``` + +### Phase 4: HTTP proxy — passthrough and rules + +Implement HTTP reverse proxying for REST API calls. + +**Files:** `http_proxy.go` + +#### HTTP proxy flow + +1. Client sends HTTP request to `http://localhost:{sessionPort}/channels/test/messages` +2. Per-session HTTP server routes non-WebSocket requests to `HttpProxyHandler` +3. Increment `session.HttpReqCount` +4. Log `http_request` event +5. Build `MatchEvent{Type: "http_request", Method: ..., Path: ...}` +6. Find matching rule +7. Execute action: + - `passthrough` (or no match): forward to upstream + - `http_respond`: return specified response immediately + - `http_delay`: sleep then forward + - `http_drop`: hijack connection and close + - `http_replace_response`: forward, discard response, return specified response +8. If forwarding: use `httputil.ReverseProxy` with upstream `https://{target.restHost}` +9. Log `http_response` event + +#### Forwarding details + +- Copy all request headers, body, query params +- Set `Host` header to target host +- Scheme is `https` (TLS to upstream) +- Response headers and body are copied back to client +- Content-Type, status code, etc. are preserved + +#### HTTP count tracking + +`session.httpReqCount` increments on each request. Per-rule `count` matching works the same as for WS: per-rule occurrence counter. + +### Phase 5: Imperative actions + +Implement `POST /sessions/{id}/actions`. + +**Files:** `action.go` + +```go +type ActionRequest struct { + Type string `json:"type"` + Message json.RawMessage `json:"message,omitempty"` + CloseCode int `json:"closeCode,omitempty"` +} +``` + +Handler: +1. Parse request body +2. Find session +3. Find active WS connection(s) +4. Execute action on the connection: + - `disconnect`: `conn.ClientConn.UnderlyingConn().Close()` (raw TCP close) + - `close`: `conn.ClientConn.WriteMessage(websocket.CloseMessage, ...)` + - `inject_to_client`: `conn.ClientConn.WriteMessage(websocket.TextMessage, message)` + - `inject_to_client_and_close`: write message then close +5. Log the action as an event +6. Return 200 OK (or 404/409 on errors) + +### Phase 6: Temporal triggers + +Implement `delay_after_ws_connect` match type. + +**Files:** `ws_proxy.go` + +After upstream WS connection is established: + +1. Lock session mutex +2. Iterate rules looking for `delay_after_ws_connect` type +3. For each matching rule, schedule `time.AfterFunc`: + ```go + timer := time.AfterFunc(time.Duration(rule.Match.DelayMs)*time.Millisecond, func() { + executeAction(session, wsConn, rule.Action) + session.FireRule(rule) + }) + wsConn.timers = append(wsConn.timers, timer) + ``` +4. On WS connection close, cancel all pending timers: + ```go + for _, t := range wsConn.timers { + t.Stop() + } + ``` +5. On session delete, cancel all timers on all connections + +### Phase 7: Tests + +**Files:** `proxy_test.go` + +Test infrastructure: each test starts a local mock upstream server (HTTP + WS echo/scripted), creates the proxy, creates a session pointing at the mock upstream, and connects a client through the proxy. + +```go +// Helper: start a mock upstream WS server that sends CONNECTED then echoes frames +func startMockUpstream(t *testing.T) (wsURL string, httpURL string, cleanup func()) + +// Helper: start the proxy control API +func startProxy(t *testing.T) (controlURL string, cleanup func()) + +// Helper: create a session and return proxy host:port +func createSession(t *testing.T, controlURL string, req CreateSessionRequest) CreateSessionResponse +``` + +#### Test cases + +**Control API:** +1. Health check returns 200 +2. Create session succeeds, returns valid port +3. Create session with port already in use returns 409 +4. Get session returns metadata +5. Delete session returns event log, frees port +6. Session auto-deleted after timeout +7. Add rules dynamically + +**WebSocket proxy:** +8. WS passthrough — frames forwarded both directions +9. WS connection refusal — first connection refused, second passes through +10. WS disconnect action — abrupt close mid-stream +11. WS frame suppression — client ATTACH suppressed, server never sees it +12. WS inject_to_client — proxy injects a frame, original also forwarded +13. WS inject_to_client_and_close — proxy injects then closes +14. WS frame replacement — original frame replaced with different one +15. WS suppress_onwards — all subsequent server frames dropped +16. WS count matching — rule only fires on Nth connection/frame +17. WS one-shot rule (times=1) — fires once then removed + +**HTTP proxy:** +18. HTTP passthrough — request forwarded, response returned +19. HTTP respond — fake 401 returned for first request, second passes through +20. HTTP delay — response delayed by specified duration +21. HTTP drop — connection dropped, no response +22. HTTP replace_response — upstream response discarded, fake one returned +23. HTTP count matching + +**Imperative actions:** +24. Disconnect via actions API +25. Inject message via actions API +26. Action on session with no active WS returns error + +**Temporal triggers:** +27. delay_after_ws_connect fires and disconnects +28. delay_after_ws_connect cancelled if connection closes first +29. delay_after_ws_connect cancelled on session delete + +**Event log:** +30. Log captures WS connect, frames, disconnect events +31. Log captures HTTP request/response events +32. Log records which rule matched (or null for passthrough) + +**Concurrent sessions:** +33. Two sessions on different ports with different rules don't interfere + +**Msgpack:** +34. Binary (msgpack) frames parsed and matched by action +35. Binary frames forwarded unchanged (no re-encoding) + +## Data types + +### Session + +```go +type Session struct { + ID string + Target TargetConfig + Port int + Rules []*Rule + EventLog *EventLog + TimeoutTimer *time.Timer + Listener net.Listener + Server *http.Server + + activeWsConns []*WsConnection + wsConnectCount int + httpReqCount int + + suppressServerToClient bool + suppressClientToServer bool + + mu sync.Mutex +} + +type TargetConfig struct { + RealtimeHost string `json:"realtimeHost"` + RestHost string `json:"restHost"` +} +``` + +### Rule + +```go +type Rule struct { + Match MatchConfig `json:"match"` + Action ActionConfig `json:"action"` + Times int `json:"times,omitempty"` // 0 = unlimited + Comment string `json:"comment,omitempty"` + + matchCount int // how many times the match condition was satisfied +} + +type MatchConfig struct { + Type string `json:"type"` + Count int `json:"count,omitempty"` + Action string `json:"action,omitempty"` + Channel string `json:"channel,omitempty"` + Method string `json:"method,omitempty"` + PathContains string `json:"pathContains,omitempty"` + QueryContains map[string]string `json:"queryContains,omitempty"` + DelayMs int `json:"delayMs,omitempty"` +} + +type ActionConfig struct { + Type string `json:"type"` + CloseCode int `json:"closeCode,omitempty"` + DelayMs int `json:"delayMs,omitempty"` + Message json.RawMessage `json:"message,omitempty"` + Status int `json:"status,omitempty"` + Body json.RawMessage `json:"body,omitempty"` + Headers map[string]string `json:"headers,omitempty"` +} +``` + +### Event log + +```go +type Event struct { + Timestamp time.Time `json:"timestamp"` + Type string `json:"type"` + Direction string `json:"direction,omitempty"` + URL string `json:"url,omitempty"` + QueryParams map[string]string `json:"queryParams,omitempty"` + Message json.RawMessage `json:"message,omitempty"` + Method string `json:"method,omitempty"` + Path string `json:"path,omitempty"` + Status int `json:"status,omitempty"` + Initiator string `json:"initiator,omitempty"` + CloseCode int `json:"closeCode,omitempty"` + RuleMatched *string `json:"ruleMatched"` + Headers map[string]string `json:"headers,omitempty"` +} + +type EventLog struct { + events []Event + mu sync.Mutex +} +``` + +### Protocol message (minimal parsing) + +```go +type ProtocolMessage struct { + Action int + Channel string + Error *ErrorInfo +} + +type ErrorInfo struct { + Code int `json:"code"` + StatusCode int `json:"statusCode"` + Message string `json:"message"` +} + +// Action name constants +const ( + ActionHeartbeat = 0 + ActionAck = 1 + ActionNack = 2 + ActionConnect = 3 + ActionConnected = 4 + ActionDisconnect = 5 + ActionDisconnected = 6 + ActionClose = 7 + ActionClosed = 8 + ActionError = 9 + ActionAttach = 10 + ActionAttached = 11 + ActionDetach = 12 + ActionDetached = 13 + ActionPresence = 14 + ActionMessage = 15 + ActionSync = 16 + ActionAuth = 17 +) + +// actionNames maps name strings to int for rule matching +var actionNames = map[string]int{ + "HEARTBEAT": 0, + "ACK": 1, + // ... +} +``` + +### WsConnection + +```go +type WsConnection struct { + ClientConn *websocket.Conn + ServerConn *websocket.Conn + ConnNumber int + timers []*time.Timer + closed bool + mu sync.Mutex +} +``` + +## Build and run + +```bash +cd uts/test/proxy +go mod init ably.io/test-proxy +go get github.com/gorilla/websocket +go get github.com/vmihailenco/msgpack/v5 +go build -o test-proxy . + +# Run (control API on port 9100) +./test-proxy --port 9100 + +# Run tests +go test ./... -v +``` + +## Integration with Dart test runner + +The Dart test harness will: + +1. Spawn the proxy process: `Process.start('test-proxy', ['--port', '9100'])` +2. Wait for `GET http://localhost:9100/health` to return 200 +3. Maintain a port pool (e.g., 10000–11023) +4. For each test (or test group): + a. Allocate a port from the pool + b. Create a session: `POST http://localhost:9100/sessions` with `{"port": 10042, "target": {...}, "rules": [...]}` + c. If 409 (port conflict), try another port + d. Configure the SDK: + ```dart + ClientOptions( + realtimeHost: 'localhost:10042', + restHost: 'localhost:10042', + tls: false, + key: sandboxKey, + ) + ``` + e. Run the test + f. Delete the session: `DELETE http://localhost:9100/sessions/{id}` + g. Return port to pool +5. After all tests, kill the proxy process + +## Port pool design (Dart side) + +```dart +class PortPool { + final Set _available; + final Set _inUse = {}; + + PortPool({int start = 10000, int count = 1024}) + : _available = Set.from(List.generate(count, (i) => start + i)); + + int allocate() { + if (_available.isEmpty) throw StateError('No ports available'); + final port = _available.first; + _available.remove(port); + _inUse.add(port); + return port; + } + + void release(int port) { + _inUse.remove(port); + _available.add(port); + } +} +``` diff --git a/uts/proxy/PROPOSAL.md b/uts/proxy/PROPOSAL.md new file mode 100644 index 000000000..29f49ba17 --- /dev/null +++ b/uts/proxy/PROPOSAL.md @@ -0,0 +1,461 @@ +# Ably Test Proxy — Proposal + +## Overview + +A programmable HTTP/WebSocket proxy that sits between an Ably SDK under test and the real Ably sandbox backend. The proxy transparently forwards traffic by default, but can be configured with **rules** to inject faults — dropped connections, modified responses, injected protocol messages, delayed frames, etc. + +This enables **integration tests for fault behaviour** that would otherwise require mocking. The proxy gives tests the realism of talking to the actual Ably sandbox while retaining the ability to simulate network and protocol faults. + +## Motivation + +The existing UTS unit tests use mock HTTP/WebSocket clients to test fault handling (connection failures, token expiry, heartbeat starvation, channel errors, etc.). These are valuable but have limitations: + +- They test against synthetic responses, not the real server protocol +- They cannot verify that resume actually works end-to-end with a real server +- They require the test to script every server response, including the "happy path" ones + +A proxy-based approach lets tests rely on the real sandbox for normal behaviour and only inject specific faults. This increases confidence that the SDK handles real-world failure modes correctly. + +## Architecture + +``` + ┌────────────────────────────────────────────┐ + │ Ably Test Proxy (single process) │ + │ │ +┌──────────┐ │ ┌──────────────────┐ │ ┌───────────────┐ +│ SDK │────WS──▶│ │ :10042 (session1)│───wss──────────────▶│──────│ Ably Sandbox │ +│ under │◀───────▶│ │ :10043 (session2)│◀──────────────────▶│ │◀────│ (real backend) │ +│ test │──HTTP──▶│ │ ... │───https─────────────│──────│ │ +└──────────┘ │ └──────────────────┘ │ └───────────────┘ + │ │ + │ ┌──────────────────┐ │ + │ │ :9100 control API │ │ + │ └──────────────────┘ │ + └────────────────────────────────────────────┘ + ▲ + │ HTTP control API + ┌────────┴────────────┐ + │ Test process │ + │ (creates sessions, │ + │ assigns ports, │ + │ adds rules, │ + │ triggers actions) │ + └─────────────────────┘ +``` + +- **Single proxy process** serves multiple concurrent test sessions +- **Control API** (HTTP on a dedicated port, e.g. `:9100`) manages sessions and rules +- **Per-session ports** (assigned by the test process from a port pool) handle proxied WS and HTTP traffic. Each session binds its own TCP listener so the SDK can connect with standard URL paths. +- **No TLS between client and proxy.** The proxy serves plain HTTP/WS to the SDK. Upstream connections to the Ably sandbox use TLS (`wss://`, `https://`). +- **Default behaviour** is transparent passthrough to the real Ably sandbox +- **Protocol-aware for both JSON and msgpack.** The proxy decodes frames in both formats for rule matching. Raw bytes are forwarded unchanged (no re-encoding). + +## Control API + +Base URL: `http://localhost:{CONTROL_PORT}` + +### Create session + +The test process assigns a port from its port pool and passes it in the request. The proxy binds that port immediately — if the bind fails, the request fails with 409. + +``` +POST /sessions +Content-Type: application/json + +{ + "target": { + "realtimeHost": "sandbox-realtime.ably.io", + "restHost": "sandbox-rest.ably.io" + }, + "rules": [ ...rules... ], + "timeoutMs": 30000, + "port": 10042 +} + +Response 201: +{ + "sessionId": "abc123", + "proxy": { + "host": "localhost:10042", + "port": 10042 + } +} + +Response 409 (port unavailable): +{ + "error": "failed to bind port 10042: address already in use" +} +``` + +The SDK under test connects to the proxy port with standard URLs: +- WebSocket: `ws://localhost:10042/?key=...&heartbeats=true` +- REST: `http://localhost:10042/channels/test/messages` + +### Add rules dynamically + +``` +POST /sessions/{sessionId}/rules +Content-Type: application/json + +{ + "rules": [ ...additional rules... ], + "position": "append" // or "prepend" +} + +Response 200: +{ + "ruleCount": 5 +} +``` + +### Trigger an imperative action + +For cases where timed rules are awkward (e.g., "drop the connection NOW"): + +``` +POST /sessions/{sessionId}/actions +Content-Type: application/json + +{ "type": "disconnect" } + +Response 200: +{ "ok": true } +``` + +### Get captured traffic log + +``` +GET /sessions/{sessionId}/log +Response 200: +{ + "events": [ ...see event format below... ] +} +``` + +### Teardown session + +``` +DELETE /sessions/{sessionId} +Response 200: +{ + "events": [ ...final captured traffic log... ] +} +``` + +Teardown closes all active connections, stops the per-session listener, and frees the port. + +### Health check + +``` +GET /health +Response 200: { "ok": true } +``` + +## Rule format + +Each rule has a **match** condition, an **action** to perform, and an optional **times** limit: + +```jsonc +{ + "match": { ... }, + "action": { ... }, + "times": 1, // optional: remove rule after N matches (default: unlimited) + "comment": "..." // optional: for readability +} +``` + +Rules are evaluated in order. The first matching rule wins. Unmatched traffic is passed through unchanged. + +### Match conditions + +#### WebSocket connection attempt + +```jsonc +{ "type": "ws_connect" } +{ "type": "ws_connect", "count": 2 } // only the 2nd connection attempt +{ "type": "ws_connect", "queryContains": { "resume": "*" } } // has resume param +``` + +#### WebSocket frame from client → server + +```jsonc +{ "type": "ws_frame_to_server" } +{ "type": "ws_frame_to_server", "action": "ATTACH" } +{ "type": "ws_frame_to_server", "action": "ATTACH", "channel": "my-channel" } +{ "type": "ws_frame_to_server", "action": "MESSAGE" } +``` + +#### WebSocket frame from server → client + +```jsonc +{ "type": "ws_frame_to_client" } +{ "type": "ws_frame_to_client", "action": "CONNECTED" } +{ "type": "ws_frame_to_client", "action": "ATTACHED", "channel": "my-channel" } +{ "type": "ws_frame_to_client", "action": "HEARTBEAT" } +``` + +#### HTTP request + +```jsonc +{ "type": "http_request" } +{ "type": "http_request", "method": "POST" } +{ "type": "http_request", "pathContains": "/channels/" } +{ "type": "http_request", "pathContains": "/keys/" } +``` + +#### Temporal trigger + +```jsonc +{ "type": "delay_after_ws_connect", "delayMs": 5000 } +``` + +Fires once, `delayMs` after the WebSocket connection is established. Used for timed fault injection (e.g., heartbeat starvation, timed disconnection). + +### Actions + +#### Passthrough (default) + +```jsonc +{ "type": "passthrough" } +``` + +Forward unchanged. + +#### Connection-level faults + +```jsonc +// Refuse the WebSocket connection at TCP level +{ "type": "refuse_connection" } + +// Accept WebSocket handshake but immediately close +{ "type": "accept_and_close", "closeCode": 1011 } + +// Disconnect abruptly (no close frame) +{ "type": "disconnect" } + +// Close cleanly with code +{ "type": "close", "closeCode": 1000 } +``` + +#### Frame manipulation + +```jsonc +// Suppress (swallow) the frame — don't forward it +{ "type": "suppress" } + +// Delay before forwarding +{ "type": "delay", "delayMs": 2000 } + +// Inject a frame to the client (as if from server), in addition to the matched frame +{ "type": "inject_to_client", "message": { "action": 6, ... } } + +// Inject a frame to the client then close the WebSocket +{ "type": "inject_to_client_and_close", "message": { "action": 6, ... }, "closeCode": 1000 } + +// Replace the frame with a different one +{ "type": "replace", "message": { "action": 4, ... } } + +// Suppress all subsequent frames in the same direction (for heartbeat starvation) +{ "type": "suppress_onwards" } +``` + +#### HTTP faults + +```jsonc +// Return a specific HTTP response instead of forwarding +{ "type": "http_respond", "status": 503, "body": { ... }, "headers": { ... } } + +// Delay the HTTP response +{ "type": "http_delay", "delayMs": 5000 } + +// Drop the HTTP connection (no response) +{ "type": "http_drop" } + +// Forward but replace the response +{ "type": "http_replace_response", "status": 401, "body": { ... } } +``` + +## Event log format + +All traffic through a session is recorded: + +```jsonc +{ + "events": [ + { + "timestamp": "2026-02-23T10:00:00.123Z", + "type": "ws_connect", + "url": "ws://...", + "queryParams": { "key": "...", "heartbeats": "true" } + }, + { + "timestamp": "2026-02-23T10:00:00.200Z", + "type": "ws_frame", + "direction": "server_to_client", + "message": { "action": 4, "connectionId": "...", ... }, + "ruleMatched": null + }, + { + "timestamp": "2026-02-23T10:00:01.500Z", + "type": "ws_frame", + "direction": "client_to_server", + "message": { "action": 15, "channel": "test", ... }, + "ruleMatched": "rule-2" + }, + { + "timestamp": "2026-02-23T10:00:02.000Z", + "type": "ws_disconnect", + "initiator": "proxy", + "closeCode": 1006 + }, + { + "timestamp": "2026-02-23T10:00:02.100Z", + "type": "http_request", + "direction": "client_to_server", + "method": "GET", + "path": "/channels/test/messages", + "headers": { ... } + }, + { + "timestamp": "2026-02-23T10:00:02.300Z", + "type": "http_response", + "direction": "server_to_client", + "status": 200, + "ruleMatched": null + } + ] +} +``` + +## Usage patterns + +### Pattern 1: Imperative disconnect (RTN15a equivalent) + +``` +# Create passthrough session on port 10042 +POST /sessions {"port": 10042, "target": SANDBOX} + +# Connect SDK: Realtime(realtimeHost: "localhost:10042", tls: false) +# Wait for CONNECTED + +# Trigger disconnect +POST /sessions/{id}/actions {"type": "disconnect"} + +# SDK reconnects through proxy (passthrough), resumes +# Wait for CONNECTED again + +# Verify from log +GET /sessions/{id}/log +→ expect two ws_connect events +→ expect second ws_connect has queryParams.resume +``` + +### Pattern 2: One-shot connection refusal (RTN14d equivalent) + +```json +{ + "port": 10042, + "target": {"realtimeHost": "sandbox-realtime.ably.io"}, + "rules": [{ + "match": {"type": "ws_connect", "count": 1}, + "action": {"type": "refuse_connection"}, + "times": 1 + }] +} +``` + +First connection attempt is refused. SDK retries. Second passes through to sandbox. + +### Pattern 3: Injected DISCONNECTED with token error (RTN15h1 equivalent) + +```json +{ + "port": 10042, + "target": {"realtimeHost": "sandbox-realtime.ably.io"}, + "rules": [{ + "match": {"type": "delay_after_ws_connect", "delayMs": 1000}, + "action": { + "type": "inject_to_client_and_close", + "message": { + "action": 6, + "error": {"code": 40142, "statusCode": 401, "message": "Token expired"} + } + }, + "times": 1 + }] +} +``` + +### Pattern 4: REST 401 for token renewal (RSA4b4 equivalent) + +```json +{ + "port": 10042, + "target": {"restHost": "sandbox-rest.ably.io"}, + "rules": [{ + "match": {"type": "http_request", "pathContains": "/channels/"}, + "action": { + "type": "http_respond", + "status": 401, + "body": {"error": {"code": 40142, "statusCode": 401, "message": "Token expired"}} + }, + "times": 1 + }] +} +``` + +First channel request gets fake 401. Client renews token, retries. Second request passes through to real sandbox. + +### Pattern 5: Heartbeat starvation (RTN23 equivalent) + +```json +{ + "port": 10042, + "target": {"realtimeHost": "sandbox-realtime.ably.io"}, + "rules": [{ + "match": {"type": "delay_after_ws_connect", "delayMs": 2000}, + "action": {"type": "suppress_onwards"}, + "times": 1 + }] +} +``` + +SDK connects, gets CONNECTED from real server. After 2s, proxy starts swallowing all server→client frames. Client heartbeat timer expires. Client disconnects and reconnects. + +### Pattern 6: Channel attach suppression (RTL4f timeout equivalent) + +```json +{ + "port": 10042, + "target": {"realtimeHost": "sandbox-realtime.ably.io"}, + "rules": [{ + "match": {"type": "ws_frame_to_server", "action": "ATTACH", "channel": "test"}, + "action": {"type": "suppress"}, + "times": 1 + }] +} +``` + +Client sends ATTACH, proxy swallows it. Server never sees it, never responds. Client's attach timeout fires. + +## Scope and non-goals + +### In scope + +- WebSocket proxying with Ably protocol message awareness (JSON and msgpack) +- HTTP proxying for REST API calls +- Rule-based fault injection (connection, frame, and HTTP levels) +- Imperative actions (disconnect, close) +- Traffic capture and logging +- Concurrent sessions on separate ports for parallel tests + +### Not in scope + +- Fake timers / time advancement (integration tests use real time with short configured timeouts) +- Mock authUrl server (tests can spin up their own if needed) +- TLS between client and proxy (proxy serves plain HTTP/WS; TLS is used only upstream to sandbox) +- Modifying the SDK's internal state + +## Implementation + +The proxy is implemented in Go. See `IMPLEMENTATION.md` for the implementation plan. diff --git a/uts/proxy/action.go b/uts/proxy/action.go new file mode 100644 index 000000000..d66972bda --- /dev/null +++ b/uts/proxy/action.go @@ -0,0 +1,129 @@ +package main + +import ( + "encoding/json" + "fmt" + + "github.com/gorilla/websocket" +) + +// ExecuteImperativeAction executes an immediate action on the session's active WS connection(s). +func ExecuteImperativeAction(session *Session, req ActionRequest) error { + session.EventLog.Append(Event{ + Type: "action", + Initiator: "proxy", + Message: mustMarshal(req), + }) + + switch req.Type { + case "disconnect": + return imperativeDisconnect(session) + case "close": + return imperativeClose(session, req.CloseCode) + case "inject_to_client": + return imperativeInjectToClient(session, req.Message, false) + case "inject_to_client_and_close": + return imperativeInjectToClient(session, req.Message, true) + default: + return fmt.Errorf("unknown action type: %s", req.Type) + } +} + +func imperativeDisconnect(session *Session) error { + wc := session.GetActiveWsConn() + if wc == nil { + return fmt.Errorf("no active WebSocket connection") + } + + session.EventLog.Append(Event{ + Type: "ws_disconnect", + Initiator: "proxy", + }) + + // Abrupt close — close the underlying TCP connection + if conn, ok := wc.ClientConn.(*websocket.Conn); ok { + conn.UnderlyingConn().Close() + } + if conn, ok := wc.ServerConn.(*websocket.Conn); ok { + conn.UnderlyingConn().Close() + } + + wc.MarkClosed() + return nil +} + +func imperativeClose(session *Session, closeCode int) error { + wc := session.GetActiveWsConn() + if wc == nil { + return fmt.Errorf("no active WebSocket connection") + } + + if closeCode <= 0 { + closeCode = websocket.CloseNormalClosure + } + + session.EventLog.Append(Event{ + Type: "ws_disconnect", + Initiator: "proxy", + CloseCode: closeCode, + }) + + if conn, ok := wc.ClientConn.(*websocket.Conn); ok { + msg := websocket.FormatCloseMessage(closeCode, "") + conn.WriteMessage(websocket.CloseMessage, msg) + conn.UnderlyingConn().Close() + } + if conn, ok := wc.ServerConn.(*websocket.Conn); ok { + conn.UnderlyingConn().Close() + } + + wc.MarkClosed() + return nil +} + +func imperativeInjectToClient(session *Session, message json.RawMessage, andClose bool) error { + wc := session.GetActiveWsConn() + if wc == nil { + return fmt.Errorf("no active WebSocket connection") + } + + if conn, ok := wc.ClientConn.(*websocket.Conn); ok { + if err := conn.WriteMessage(websocket.TextMessage, message); err != nil { + return fmt.Errorf("failed to inject message: %w", err) + } + + session.EventLog.Append(Event{ + Type: "ws_frame", + Direction: "server_to_client", + Message: message, + Initiator: "proxy", + }) + } + + if andClose { + if conn, ok := wc.ClientConn.(*websocket.Conn); ok { + msg := websocket.FormatCloseMessage(websocket.CloseNormalClosure, "") + conn.WriteMessage(websocket.CloseMessage, msg) + conn.UnderlyingConn().Close() + } + if conn, ok := wc.ServerConn.(*websocket.Conn); ok { + conn.UnderlyingConn().Close() + } + wc.MarkClosed() + + session.EventLog.Append(Event{ + Type: "ws_disconnect", + Initiator: "proxy", + }) + } + + return nil +} + +func mustMarshal(v interface{}) json.RawMessage { + b, err := json.Marshal(v) + if err != nil { + return json.RawMessage(`{}`) + } + return b +} diff --git a/uts/proxy/go.mod b/uts/proxy/go.mod new file mode 100644 index 000000000..536c3d0e3 --- /dev/null +++ b/uts/proxy/go.mod @@ -0,0 +1,9 @@ +module ably.io/test-proxy + +go 1.22.3 + +require ( + github.com/gorilla/websocket v1.5.3 // indirect + github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect + github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect +) diff --git a/uts/proxy/go.sum b/uts/proxy/go.sum new file mode 100644 index 000000000..ec57b9bf5 --- /dev/null +++ b/uts/proxy/go.sum @@ -0,0 +1,6 @@ +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8= +github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok= +github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g= +github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= diff --git a/uts/proxy/http_proxy.go b/uts/proxy/http_proxy.go new file mode 100644 index 000000000..f85db1c16 --- /dev/null +++ b/uts/proxy/http_proxy.go @@ -0,0 +1,205 @@ +package main + +import ( + "crypto/tls" + "encoding/json" + "fmt" + "io" + "log" + "net" + "net/http" + "net/http/httputil" + "net/url" + "time" +) + +// HandleHttpProxy handles an HTTP request from the SDK client, +// proxying it to the upstream Ably REST host. +func HandleHttpProxy(session *Session, w http.ResponseWriter, r *http.Request) { + reqCount := session.IncrementHttpReqCount() + _ = reqCount + + // Log request headers (subset for readability) + headers := make(map[string]string) + for _, key := range []string{"Authorization", "Content-Type", "Accept", "X-Ably-Version", "X-Ably-Lib"} { + if v := r.Header.Get(key); v != "" { + headers[key] = v + } + } + + // Log http_request event + session.EventLog.Append(Event{ + Type: "http_request", + Direction: "client_to_server", + Method: r.Method, + Path: r.URL.Path, + Headers: headers, + }) + + // Build match event + matchEvent := MatchEvent{ + Type: "http_request", + Action: -1, + Method: r.Method, + Path: r.URL.Path, + } + + rule, ruleIdx := session.FindMatchingRule(matchEvent) + + if rule != nil { + session.FireRule(rule) + + switch rule.Action.Type { + case "http_respond": + ruleLabel := LogRuleMatch(rule, ruleIdx) + respondWithRule(w, session, rule, ruleLabel) + return + + case "http_delay": + time.Sleep(time.Duration(rule.Action.DelayMs) * time.Millisecond) + // Fall through to proxy + + case "http_drop": + ruleLabel := LogRuleMatch(rule, ruleIdx) + session.EventLog.Append(Event{ + Type: "http_response", + Direction: "server_to_client", + Status: 0, + RuleMatched: ruleLabel, + }) + // Hijack the connection and close it without responding + hj, ok := w.(http.Hijacker) + if ok { + conn, _, err := hj.Hijack() + if err == nil { + conn.Close() + } + } + return + + case "http_replace_response": + // Forward to upstream, discard response, return specified response + proxyToUpstreamAndDiscard(session, r) + ruleLabel := LogRuleMatch(rule, ruleIdx) + respondWithRule(w, session, rule, ruleLabel) + return + + case "passthrough": + // Fall through to proxy + } + } + + // Proxy to upstream + if session.Target.RestHost == "" { + writeError(w, http.StatusBadGateway, "no REST host configured") + return + } + + scheme := "https" + if session.Target.Insecure { + scheme = "http" + } + upstreamURL := &url.URL{ + Scheme: scheme, + Host: session.Target.RestHost, + } + + transport := &http.Transport{ + DialContext: (&net.Dialer{ + Timeout: 10 * time.Second, + }).DialContext, + } + if !session.Target.Insecure { + transport.TLSClientConfig = &tls.Config{} + } + + proxy := &httputil.ReverseProxy{ + Director: func(req *http.Request) { + req.URL.Scheme = upstreamURL.Scheme + req.URL.Host = upstreamURL.Host + req.Host = upstreamURL.Host + }, + Transport: transport, + ModifyResponse: func(resp *http.Response) error { + ruleLabel := LogRuleMatch(rule, ruleIdx) + session.EventLog.Append(Event{ + Type: "http_response", + Direction: "server_to_client", + Status: resp.StatusCode, + RuleMatched: ruleLabel, + }) + return nil + }, + ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) { + log.Printf("session %s: HTTP proxy error: %v", session.ID, err) + writeError(w, http.StatusBadGateway, fmt.Sprintf("upstream error: %v", err)) + }, + } + + proxy.ServeHTTP(w, r) +} + +func respondWithRule(w http.ResponseWriter, session *Session, rule *Rule, ruleLabel *string) { + status := rule.Action.Status + if status <= 0 { + status = 200 + } + + // Set headers + for k, v := range rule.Action.Headers { + w.Header().Set(k, v) + } + + // Default content type + if w.Header().Get("Content-Type") == "" { + w.Header().Set("Content-Type", "application/json") + } + + w.WriteHeader(status) + + if len(rule.Action.Body) > 0 { + w.Write(rule.Action.Body) + } + + session.EventLog.Append(Event{ + Type: "http_response", + Direction: "server_to_client", + Status: status, + RuleMatched: ruleLabel, + }) +} + +func proxyToUpstreamAndDiscard(session *Session, r *http.Request) { + if session.Target.RestHost == "" { + return + } + + scheme := "https" + if session.Target.Insecure { + scheme = "http" + } + upstreamURL := fmt.Sprintf("%s://%s%s", scheme, session.Target.RestHost, r.URL.RequestURI()) + req, err := http.NewRequest(r.Method, upstreamURL, r.Body) + if err != nil { + return + } + req.Header = r.Header.Clone() + + client := &http.Client{Timeout: 10 * time.Second} + if !session.Target.Insecure { + client.Transport = &http.Transport{TLSClientConfig: &tls.Config{}} + } + resp, err := client.Do(req) + if err != nil { + return + } + io.ReadAll(resp.Body) + resp.Body.Close() +} + +// WriteJSONResponse writes a JSON response body with the given status and data. +func WriteJSONResponse(w http.ResponseWriter, status int, data interface{}) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + json.NewEncoder(w).Encode(data) +} diff --git a/uts/proxy/listener.go b/uts/proxy/listener.go new file mode 100644 index 000000000..fca7f843e --- /dev/null +++ b/uts/proxy/listener.go @@ -0,0 +1,71 @@ +package main + +import ( + "context" + "fmt" + "log" + "net" + "net/http" +) + +// StartSessionListener binds the given port and starts an HTTP server +// that routes WebSocket upgrades to WsProxyHandler and other HTTP requests +// to HttpProxyHandler. Returns an error if the port cannot be bound. +func StartSessionListener(session *Session, port int) error { + addr := fmt.Sprintf(":%d", port) + listener, err := net.Listen("tcp", addr) + if err != nil { + return fmt.Errorf("failed to bind port %d: %w", port, err) + } + + session.mu.Lock() + session.listener = listener + session.mu.Unlock() + + mux := http.NewServeMux() + mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + // Check if this is a WebSocket upgrade request + if isWebSocketUpgrade(r) { + HandleWsProxy(session, w, r) + return + } + // Otherwise treat as HTTP proxy + HandleHttpProxy(session, w, r) + }) + + server := &http.Server{Handler: mux} + + go func() { + if err := server.Serve(listener); err != nil && err != http.ErrServerClosed { + log.Printf("session %s listener on port %d closed: %v", session.ID, port, err) + } + }() + + // Store server reference so we can shut it down later + session.mu.Lock() + session.Server = server + session.mu.Unlock() + + return nil +} + +// StopSessionListener gracefully shuts down the per-session HTTP server and closes the listener. +func StopSessionListener(session *Session) { + session.mu.Lock() + server := session.Server + session.Server = nil + session.mu.Unlock() + + if server != nil { + server.Shutdown(context.Background()) + } +} + +func isWebSocketUpgrade(r *http.Request) bool { + for _, v := range r.Header["Upgrade"] { + if v == "websocket" { + return true + } + } + return false +} diff --git a/uts/proxy/log.go b/uts/proxy/log.go new file mode 100644 index 000000000..111cb2064 --- /dev/null +++ b/uts/proxy/log.go @@ -0,0 +1,54 @@ +package main + +import ( + "encoding/json" + "sync" + "time" +) + +// Event represents a single logged event in a session's traffic log. +type Event struct { + Timestamp time.Time `json:"timestamp"` + Type string `json:"type"` // ws_connect, ws_frame, ws_disconnect, http_request, http_response, action + Direction string `json:"direction,omitempty"` // client_to_server, server_to_client + URL string `json:"url,omitempty"` + QueryParams map[string]string `json:"queryParams,omitempty"` + Message json.RawMessage `json:"message,omitempty"` + Method string `json:"method,omitempty"` + Path string `json:"path,omitempty"` + Status int `json:"status,omitempty"` + Initiator string `json:"initiator,omitempty"` // client, server, proxy + CloseCode int `json:"closeCode,omitempty"` + RuleMatched *string `json:"ruleMatched"` + Headers map[string]string `json:"headers,omitempty"` +} + +// EventLog is an append-only, thread-safe event log. +type EventLog struct { + events []Event + mu sync.Mutex +} + +// NewEventLog creates a new empty event log. +func NewEventLog() *EventLog { + return &EventLog{} +} + +// Append adds an event to the log. +func (l *EventLog) Append(event Event) { + l.mu.Lock() + defer l.mu.Unlock() + if event.Timestamp.IsZero() { + event.Timestamp = time.Now().UTC() + } + l.events = append(l.events, event) +} + +// Events returns a copy of all events. +func (l *EventLog) Events() []Event { + l.mu.Lock() + defer l.mu.Unlock() + out := make([]Event, len(l.events)) + copy(out, l.events) + return out +} diff --git a/uts/proxy/main.go b/uts/proxy/main.go new file mode 100644 index 000000000..9899bbd6c --- /dev/null +++ b/uts/proxy/main.go @@ -0,0 +1,47 @@ +package main + +import ( + "flag" + "fmt" + "log" + "net/http" + "os" + "os/signal" + "syscall" +) + +func main() { + port := flag.Int("port", 9100, "control API port") + flag.Parse() + + store := NewSessionStore() + server := NewServer(store) + + addr := fmt.Sprintf(":%d", *port) + httpServer := &http.Server{ + Addr: addr, + Handler: server, + } + + // Graceful shutdown on signal + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + + go func() { + <-sigCh + log.Println("shutting down...") + + // Clean up all sessions + for _, session := range store.All() { + StopSessionListener(session) + session.Close() + } + + httpServer.Close() + }() + + log.Printf("Ably test proxy control API listening on %s", addr) + if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { + log.Fatalf("failed to start server: %v", err) + } +} diff --git a/uts/proxy/protocol.go b/uts/proxy/protocol.go new file mode 100644 index 000000000..24eaac388 --- /dev/null +++ b/uts/proxy/protocol.go @@ -0,0 +1,234 @@ +package main + +import ( + "encoding/json" + "fmt" + "strconv" + "strings" + + "github.com/gorilla/websocket" + "github.com/vmihailenco/msgpack/v5" +) + +// Ably protocol message action constants. +const ( + ActionHeartbeat = 0 + ActionAck = 1 + ActionNack = 2 + ActionConnect = 3 + ActionConnected = 4 + ActionDisconnect = 5 + ActionDisconnected = 6 + ActionClose = 7 + ActionClosed = 8 + ActionError = 9 + ActionAttach = 10 + ActionAttached = 11 + ActionDetach = 12 + ActionDetached = 13 + ActionPresence = 14 + ActionMessage = 15 + ActionSync = 16 + ActionAuth = 17 +) + +var actionNames = map[string]int{ + "HEARTBEAT": ActionHeartbeat, + "ACK": ActionAck, + "NACK": ActionNack, + "CONNECT": ActionConnect, + "CONNECTED": ActionConnected, + "DISCONNECT": ActionDisconnect, + "DISCONNECTED": ActionDisconnected, + "CLOSE": ActionClose, + "CLOSED": ActionClosed, + "ERROR": ActionError, + "ATTACH": ActionAttach, + "ATTACHED": ActionAttached, + "DETACH": ActionDetach, + "DETACHED": ActionDetached, + "PRESENCE": ActionPresence, + "MESSAGE": ActionMessage, + "SYNC": ActionSync, + "AUTH": ActionAuth, +} + +var actionNumbers = map[int]string{} + +func init() { + for name, num := range actionNames { + actionNumbers[num] = name + } +} + +// ActionFromString converts an action name (e.g. "ATTACH") or numeric string (e.g. "10") to an int. +// Returns -1 if the string is not recognized. +func ActionFromString(s string) int { + // Try as name first + if n, ok := actionNames[strings.ToUpper(s)]; ok { + return n + } + // Try as number + if n, err := strconv.Atoi(s); err == nil { + return n + } + return -1 +} + +// ActionName returns the name for an action number, or the number as a string. +func ActionName(action int) string { + if name, ok := actionNumbers[action]; ok { + return name + } + return strconv.Itoa(action) +} + +// ProtocolMessage is a minimal representation of an Ably protocol message, +// containing only the fields needed for rule matching. +type ProtocolMessage struct { + Action int + Channel string + Error *ErrorInfo +} + +// ErrorInfo is a minimal representation of an Ably error. +type ErrorInfo struct { + Code int `json:"code"` + StatusCode int `json:"statusCode"` + Message string `json:"message"` +} + +// ParseProtocolMessage decodes a WebSocket frame into a ProtocolMessage. +// For text frames (JSON) and binary frames (msgpack). +// Returns the parsed message. On failure, returns a message with Action=-1. +func ParseProtocolMessage(data []byte, messageType int) ProtocolMessage { + if messageType == websocket.TextMessage { + return parseJSON(data) + } + if messageType == websocket.BinaryMessage { + return parseMsgpack(data) + } + return ProtocolMessage{Action: -1} +} + +func parseJSON(data []byte) ProtocolMessage { + var raw map[string]json.RawMessage + if err := json.Unmarshal(data, &raw); err != nil { + return ProtocolMessage{Action: -1} + } + + pm := ProtocolMessage{Action: -1} + + if actionRaw, ok := raw["action"]; ok { + // Action can be int or string + var actionInt int + if err := json.Unmarshal(actionRaw, &actionInt); err == nil { + pm.Action = actionInt + } else { + var actionStr string + if err := json.Unmarshal(actionRaw, &actionStr); err == nil { + pm.Action = ActionFromString(actionStr) + } + } + } + + if channelRaw, ok := raw["channel"]; ok { + json.Unmarshal(channelRaw, &pm.Channel) + } + + if errorRaw, ok := raw["error"]; ok { + var ei ErrorInfo + if err := json.Unmarshal(errorRaw, &ei); err == nil { + pm.Error = &ei + } + } + + return pm +} + +func parseMsgpack(data []byte) ProtocolMessage { + // Ably msgpack can be either a map or an array. + // Try map first (the common wire format). + var rawMap map[string]interface{} + if err := msgpack.Unmarshal(data, &rawMap); err == nil { + return parseMsgpackMap(rawMap) + } + + // Fall back to array format. + var rawArray []interface{} + if err := msgpack.Unmarshal(data, &rawArray); err == nil { + return parseMsgpackArray(rawArray) + } + + return ProtocolMessage{Action: -1} +} + +func parseMsgpackMap(m map[string]interface{}) ProtocolMessage { + pm := ProtocolMessage{Action: -1} + + if action, ok := m["action"]; ok { + pm.Action = toInt(action) + } + if channel, ok := m["channel"]; ok { + if s, ok := channel.(string); ok { + pm.Channel = s + } + } + if errObj, ok := m["error"]; ok { + if errMap, ok := errObj.(map[string]interface{}); ok { + pm.Error = &ErrorInfo{ + Code: toInt(errMap["code"]), + StatusCode: toInt(errMap["statusCode"]), + Message: fmt.Sprintf("%v", errMap["message"]), + } + } + } + + return pm +} + +func parseMsgpackArray(a []interface{}) ProtocolMessage { + pm := ProtocolMessage{Action: -1} + + if len(a) > 0 { + pm.Action = toInt(a[0]) + } + if len(a) > 1 { + if s, ok := a[1].(string); ok { + pm.Channel = s + } + } + + return pm +} + +func toInt(v interface{}) int { + switch n := v.(type) { + case int: + return n + case int8: + return int(n) + case int16: + return int(n) + case int32: + return int(n) + case int64: + return int(n) + case uint: + return int(n) + case uint8: + return int(n) + case uint16: + return int(n) + case uint32: + return int(n) + case uint64: + return int(n) + case float32: + return int(n) + case float64: + return int(n) + default: + return -1 + } +} diff --git a/uts/proxy/proxy_test.go b/uts/proxy/proxy_test.go new file mode 100644 index 000000000..385dd44a6 --- /dev/null +++ b/uts/proxy/proxy_test.go @@ -0,0 +1,1118 @@ +package main + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "net" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/gorilla/websocket" + "github.com/vmihailenco/msgpack/v5" +) + +// -- Test helpers -- + +// startControlServer starts the control API server on a random port, returns its URL and cleanup func. +func startControlServer(t *testing.T) (string, *SessionStore, func()) { + t.Helper() + store := NewSessionStore() + server := NewServer(store) + ts := httptest.NewServer(server) + return ts.URL, store, ts.Close +} + +// freePort returns an available TCP port. +func freePort(t *testing.T) int { + t.Helper() + l, err := net.Listen("tcp", ":0") + if err != nil { + t.Fatalf("failed to get free port: %v", err) + } + port := l.Addr().(*net.TCPAddr).Port + l.Close() + return port +} + +// createSession creates a session via the control API, returns the response. +func createSession(t *testing.T, controlURL string, req CreateSessionRequest) CreateSessionResponse { + t.Helper() + body, _ := json.Marshal(req) + resp, err := http.Post(controlURL+"/sessions", "application/json", bytes.NewReader(body)) + if err != nil { + t.Fatalf("failed to create session: %v", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusCreated { + b, _ := io.ReadAll(resp.Body) + t.Fatalf("create session returned %d: %s", resp.StatusCode, string(b)) + } + + var result CreateSessionResponse + json.NewDecoder(resp.Body).Decode(&result) + return result +} + +// deleteSession deletes a session via the control API. +func deleteSession(t *testing.T, controlURL, sessionID string) map[string]interface{} { + t.Helper() + req, _ := http.NewRequest("DELETE", controlURL+"/sessions/"+sessionID, nil) + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatalf("failed to delete session: %v", err) + } + defer resp.Body.Close() + var result map[string]interface{} + json.NewDecoder(resp.Body).Decode(&result) + return result +} + +// getLog fetches the event log for a session. +func getLog(t *testing.T, controlURL, sessionID string) []Event { + t.Helper() + resp, err := http.Get(controlURL + "/sessions/" + sessionID + "/log") + if err != nil { + t.Fatalf("failed to get log: %v", err) + } + defer resp.Body.Close() + var result struct { + Events []Event `json:"events"` + } + json.NewDecoder(resp.Body).Decode(&result) + return result.Events +} + +// triggerAction sends an imperative action. +func triggerAction(t *testing.T, controlURL, sessionID string, action ActionRequest) { + t.Helper() + body, _ := json.Marshal(action) + resp, err := http.Post(controlURL+"/sessions/"+sessionID+"/actions", "application/json", bytes.NewReader(body)) + if err != nil { + t.Fatalf("failed to trigger action: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + b, _ := io.ReadAll(resp.Body) + t.Fatalf("trigger action returned %d: %s", resp.StatusCode, string(b)) + } +} + +// addRules adds rules to a session dynamically. +func addRules(t *testing.T, controlURL, sessionID string, rules []json.RawMessage, position string) { + t.Helper() + rulesJSON, _ := json.Marshal(rules) + reqBody, _ := json.Marshal(map[string]interface{}{ + "rules": json.RawMessage(rulesJSON), + "position": position, + }) + resp, err := http.Post(controlURL+"/sessions/"+sessionID+"/rules", "application/json", bytes.NewReader(reqBody)) + if err != nil { + t.Fatalf("failed to add rules: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + b, _ := io.ReadAll(resp.Body) + t.Fatalf("add rules returned %d: %s", resp.StatusCode, string(b)) + } +} + +// startMockWsServer starts a simple WS server that sends a CONNECTED message then echoes frames. +func startMockWsServer(t *testing.T) (string, func()) { + t.Helper() + upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }} + + handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + conn, err := upgrader.Upgrade(w, r, nil) + if err != nil { + return + } + defer conn.Close() + + // Send CONNECTED + connected := map[string]interface{}{ + "action": ActionConnected, + "connectionId": "mock-conn-1", + "connectionDetails": map[string]interface{}{ + "connectionKey": "mock-key-1", + "maxIdleInterval": 15000, + "connectionStateTtl": 120000, + }, + } + connJSON, _ := json.Marshal(connected) + conn.WriteMessage(websocket.TextMessage, connJSON) + + // Echo loop + for { + msgType, data, err := conn.ReadMessage() + if err != nil { + return + } + conn.WriteMessage(msgType, data) + } + }) + + server := httptest.NewServer(handler) + + // Convert http URL to ws host + host := strings.TrimPrefix(server.URL, "http://") + return host, server.Close +} + +// startMockHttpServer starts a simple HTTP server that returns 200 with a JSON body. +func startMockHttpServer(t *testing.T) (string, func()) { + t.Helper() + handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + json.NewEncoder(w).Encode(map[string]string{"status": "ok", "path": r.URL.Path}) + }) + server := httptest.NewServer(handler) + host := strings.TrimPrefix(server.URL, "http://") + return host, server.Close +} + +// connectWs connects a WebSocket client to the given host. +func connectWs(t *testing.T, host string, queryParams ...string) *websocket.Conn { + t.Helper() + u := fmt.Sprintf("ws://%s/", host) + if len(queryParams) > 0 { + u += "?" + strings.Join(queryParams, "&") + } + conn, _, err := websocket.DefaultDialer.Dial(u, nil) + if err != nil { + t.Fatalf("failed to connect WS to %s: %v", host, err) + } + return conn +} + +// readWsMessage reads a text message from a WS connection with timeout. +func readWsMessage(t *testing.T, conn *websocket.Conn, timeout time.Duration) map[string]interface{} { + t.Helper() + conn.SetReadDeadline(time.Now().Add(timeout)) + _, data, err := conn.ReadMessage() + if err != nil { + t.Fatalf("failed to read WS message: %v", err) + } + conn.SetReadDeadline(time.Time{}) + var msg map[string]interface{} + json.Unmarshal(data, &msg) + return msg +} + +// -- Tests -- + +func TestHealthCheck(t *testing.T) { + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + resp, err := http.Get(controlURL + "/health") + if err != nil { + t.Fatalf("health check failed: %v", err) + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + t.Fatalf("expected 200, got %d", resp.StatusCode) + } + + var result map[string]bool + json.NewDecoder(resp.Body).Decode(&result) + if !result["ok"] { + t.Fatal("expected ok: true") + } +} + +func TestSessionLifecycle(t *testing.T) { + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: "localhost:1234"}, + Port: port, + }) + + if session.SessionID == "" { + t.Fatal("expected session ID") + } + if session.Proxy.Port != port { + t.Fatalf("expected port %d, got %d", port, session.Proxy.Port) + } + + // Get session + resp, err := http.Get(controlURL + "/sessions/" + session.SessionID) + if err != nil { + t.Fatalf("get session failed: %v", err) + } + resp.Body.Close() + if resp.StatusCode != 200 { + t.Fatalf("expected 200, got %d", resp.StatusCode) + } + + // Delete session + result := deleteSession(t, controlURL, session.SessionID) + if result["events"] == nil { + t.Fatal("expected events in delete response") + } + + // Verify port is freed + l, err := net.Listen("tcp", fmt.Sprintf(":%d", port)) + if err != nil { + t.Fatalf("port %d should be free after session delete: %v", port, err) + } + l.Close() +} + +func TestSessionPortConflict(t *testing.T) { + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + + // Create first session on the port + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: "localhost:1234"}, + Port: port, + }) + + // Try to create second session on same port — should fail with 409 + body, _ := json.Marshal(CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: "localhost:1234"}, + Port: port, + }) + resp, err := http.Post(controlURL+"/sessions", "application/json", bytes.NewReader(body)) + if err != nil { + t.Fatalf("failed to make request: %v", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusConflict { + t.Fatalf("expected 409, got %d", resp.StatusCode) + } + + deleteSession(t, controlURL, session.SessionID) +} + +func TestWsPassthrough(t *testing.T) { + upstreamHost, upstreamCleanup := startMockWsServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: upstreamHost, Insecure: true}, + Port: port, + }) + defer deleteSession(t, controlURL, session.SessionID) + + // Connect through proxy + conn := connectWs(t, fmt.Sprintf("localhost:%d", port), "key=test.key:secret") + defer conn.Close() + + // Should receive CONNECTED from mock upstream + msg := readWsMessage(t, conn, 2*time.Second) + action, _ := msg["action"].(float64) + if int(action) != ActionConnected { + t.Fatalf("expected CONNECTED (4), got %v", msg["action"]) + } + + // Send a frame — should be echoed back + testMsg := map[string]interface{}{"action": float64(ActionMessage), "channel": "test"} + testJSON, _ := json.Marshal(testMsg) + conn.WriteMessage(websocket.TextMessage, testJSON) + + echo := readWsMessage(t, conn, 2*time.Second) + echoAction, _ := echo["action"].(float64) + if int(echoAction) != ActionMessage { + t.Fatalf("expected echo of MESSAGE, got %v", echo["action"]) + } + + // Check event log + events := getLog(t, controlURL, session.SessionID) + hasConnect := false + frameCount := 0 + for _, e := range events { + if e.Type == "ws_connect" { + hasConnect = true + } + if e.Type == "ws_frame" { + frameCount++ + } + } + if !hasConnect { + t.Fatal("expected ws_connect event in log") + } + if frameCount < 2 { + t.Fatalf("expected at least 2 ws_frame events, got %d", frameCount) + } +} + +func TestHttpPassthrough(t *testing.T) { + upstreamHost, upstreamCleanup := startMockHttpServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RestHost: upstreamHost, Insecure: true}, + Port: port, + }) + defer deleteSession(t, controlURL, session.SessionID) + + // Make HTTP request through proxy + resp, err := http.Get(fmt.Sprintf("http://localhost:%d/channels/test/messages", port)) + if err != nil { + t.Fatalf("HTTP request failed: %v", err) + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + t.Fatalf("expected 200, got %d", resp.StatusCode) + } + + var body map[string]string + json.NewDecoder(resp.Body).Decode(&body) + if body["path"] != "/channels/test/messages" { + t.Fatalf("expected path /channels/test/messages, got %s", body["path"]) + } + + // Check event log + events := getLog(t, controlURL, session.SessionID) + hasRequest := false + hasResponse := false + for _, e := range events { + if e.Type == "http_request" { + hasRequest = true + } + if e.Type == "http_response" { + hasResponse = true + } + } + if !hasRequest { + t.Fatal("expected http_request event in log") + } + if !hasResponse { + t.Fatal("expected http_response event in log") + } +} + +func TestWsConnectionRefusal(t *testing.T) { + upstreamHost, upstreamCleanup := startMockWsServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + rulesJSON, _ := json.Marshal([]Rule{{ + Match: MatchConfig{Type: "ws_connect"}, + Action: ActionConfig{Type: "refuse_connection"}, + Times: 1, + }}) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: upstreamHost, Insecure: true}, + Port: port, + Rules: rulesJSON, + }) + defer deleteSession(t, controlURL, session.SessionID) + + // First connection should be refused + u := fmt.Sprintf("ws://localhost:%d/", port) + _, resp, err := websocket.DefaultDialer.Dial(u, nil) + if err == nil { + t.Fatal("expected connection to be refused") + } + if resp != nil && resp.StatusCode != http.StatusBadGateway { + t.Fatalf("expected 502, got %d", resp.StatusCode) + } + + // Second connection should succeed (rule was one-shot) + conn := connectWs(t, fmt.Sprintf("localhost:%d", port)) + defer conn.Close() + msg := readWsMessage(t, conn, 2*time.Second) + action, _ := msg["action"].(float64) + if int(action) != ActionConnected { + t.Fatalf("expected CONNECTED on second attempt, got %v", msg["action"]) + } +} + +func TestWsFrameSuppression(t *testing.T) { + upstreamHost, upstreamCleanup := startMockWsServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + rulesJSON, _ := json.Marshal([]Rule{{ + Match: MatchConfig{Type: "ws_frame_to_server", Action: "MESSAGE"}, + Action: ActionConfig{Type: "suppress"}, + Times: 1, + }}) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: upstreamHost, Insecure: true}, + Port: port, + Rules: rulesJSON, + }) + defer deleteSession(t, controlURL, session.SessionID) + + conn := connectWs(t, fmt.Sprintf("localhost:%d", port)) + defer conn.Close() + + // Read CONNECTED + readWsMessage(t, conn, 2*time.Second) + + // Send MESSAGE — should be suppressed (not echoed) + msg1 := map[string]interface{}{"action": float64(ActionMessage), "channel": "test"} + msg1JSON, _ := json.Marshal(msg1) + conn.WriteMessage(websocket.TextMessage, msg1JSON) + + // Send another MESSAGE — should pass through (rule was one-shot) + msg2 := map[string]interface{}{"action": float64(ActionMessage), "channel": "test2"} + msg2JSON, _ := json.Marshal(msg2) + conn.WriteMessage(websocket.TextMessage, msg2JSON) + + // Should get echo of second message only + echo := readWsMessage(t, conn, 2*time.Second) + echoChannel, _ := echo["channel"].(string) + if echoChannel != "test2" { + t.Fatalf("expected echo of test2, got channel %s", echoChannel) + } +} + +func TestWsInjectAndClose(t *testing.T) { + upstreamHost, upstreamCleanup := startMockWsServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + injectedMsg, _ := json.Marshal(map[string]interface{}{ + "action": ActionDisconnected, + "error": map[string]interface{}{"code": 40142, "statusCode": 401, "message": "Token expired"}, + }) + rulesJSON, _ := json.Marshal([]Rule{{ + Match: MatchConfig{Type: "ws_frame_to_client", Action: "CONNECTED"}, + Action: ActionConfig{Type: "inject_to_client_and_close", Message: injectedMsg}, + Times: 1, + }}) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: upstreamHost, Insecure: true}, + Port: port, + Rules: rulesJSON, + }) + defer deleteSession(t, controlURL, session.SessionID) + + conn := connectWs(t, fmt.Sprintf("localhost:%d", port)) + defer conn.Close() + + // Should receive the injected DISCONNECTED message + msg := readWsMessage(t, conn, 2*time.Second) + action, _ := msg["action"].(float64) + if int(action) != ActionDisconnected { + t.Fatalf("expected DISCONNECTED (6), got %v", msg["action"]) + } + + // Connection should be closed + conn.SetReadDeadline(time.Now().Add(1 * time.Second)) + _, _, err := conn.ReadMessage() + if err == nil { + t.Fatal("expected connection to be closed after inject_to_client_and_close") + } +} + +func TestWsImperativeDisconnect(t *testing.T) { + upstreamHost, upstreamCleanup := startMockWsServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: upstreamHost, Insecure: true}, + Port: port, + }) + defer deleteSession(t, controlURL, session.SessionID) + + conn := connectWs(t, fmt.Sprintf("localhost:%d", port)) + defer conn.Close() + + // Read CONNECTED + readWsMessage(t, conn, 2*time.Second) + + // Trigger disconnect via control API + triggerAction(t, controlURL, session.SessionID, ActionRequest{Type: "disconnect"}) + + // Connection should be closed + conn.SetReadDeadline(time.Now().Add(2 * time.Second)) + _, _, err := conn.ReadMessage() + if err == nil { + t.Fatal("expected connection to be closed after imperative disconnect") + } +} + +func TestHttpRespond(t *testing.T) { + upstreamHost, upstreamCleanup := startMockHttpServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + rulesJSON, _ := json.Marshal([]Rule{{ + Match: MatchConfig{Type: "http_request", PathContains: "/channels/"}, + Action: ActionConfig{Type: "http_respond", Status: 401, Body: json.RawMessage(`{"error":{"code":40142,"message":"Token expired"}}`)}, + Times: 1, + }}) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RestHost: upstreamHost, Insecure: true}, + Port: port, + Rules: rulesJSON, + }) + defer deleteSession(t, controlURL, session.SessionID) + + // First request to /channels/ should get fake 401 + resp, err := http.Get(fmt.Sprintf("http://localhost:%d/channels/test/messages", port)) + if err != nil { + t.Fatalf("request failed: %v", err) + } + resp.Body.Close() + if resp.StatusCode != 401 { + t.Fatalf("expected 401, got %d", resp.StatusCode) + } + + // Second request should pass through (rule was one-shot) + resp2, err := http.Get(fmt.Sprintf("http://localhost:%d/channels/test/messages", port)) + if err != nil { + t.Fatalf("request failed: %v", err) + } + resp2.Body.Close() + if resp2.StatusCode != 200 { + t.Fatalf("expected 200 on second request, got %d", resp2.StatusCode) + } +} + +func TestWsTemporalTrigger(t *testing.T) { + upstreamHost, upstreamCleanup := startMockWsServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + rulesJSON, _ := json.Marshal([]Rule{{ + Match: MatchConfig{Type: "delay_after_ws_connect", DelayMs: 200}, + Action: ActionConfig{Type: "disconnect"}, + Times: 1, + }}) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: upstreamHost, Insecure: true}, + Port: port, + Rules: rulesJSON, + }) + defer deleteSession(t, controlURL, session.SessionID) + + conn := connectWs(t, fmt.Sprintf("localhost:%d", port)) + defer conn.Close() + + // Read CONNECTED + readWsMessage(t, conn, 2*time.Second) + + // Wait for temporal trigger to fire (200ms + margin) + conn.SetReadDeadline(time.Now().Add(2 * time.Second)) + _, _, err := conn.ReadMessage() + if err == nil { + t.Fatal("expected connection to be closed by temporal trigger") + } + + // Verify disconnect logged + time.Sleep(100 * time.Millisecond) + events := getLog(t, controlURL, session.SessionID) + hasDisconnect := false + for _, e := range events { + if e.Type == "ws_disconnect" && e.Initiator == "proxy" { + hasDisconnect = true + } + } + if !hasDisconnect { + t.Fatal("expected ws_disconnect event from proxy in log") + } +} + +func TestWsSuppressOnwards(t *testing.T) { + upstreamHost, upstreamCleanup := startMockWsServer(t) + defer upstreamCleanup() + + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + rulesJSON, _ := json.Marshal([]Rule{{ + Match: MatchConfig{Type: "delay_after_ws_connect", DelayMs: 200}, + Action: ActionConfig{Type: "suppress_onwards"}, + Times: 1, + }}) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: upstreamHost, Insecure: true}, + Port: port, + Rules: rulesJSON, + }) + defer deleteSession(t, controlURL, session.SessionID) + + conn := connectWs(t, fmt.Sprintf("localhost:%d", port)) + defer conn.Close() + + // Read CONNECTED (arrives before suppress_onwards fires) + readWsMessage(t, conn, 2*time.Second) + + // Wait for suppress_onwards to take effect + time.Sleep(400 * time.Millisecond) + + // Send a MESSAGE — the echo from server should be suppressed + testMsg := map[string]interface{}{"action": float64(ActionMessage), "channel": "test"} + testJSON, _ := json.Marshal(testMsg) + conn.WriteMessage(websocket.TextMessage, testJSON) + + // Should NOT receive a response (server echoes but proxy suppresses) + conn.SetReadDeadline(time.Now().Add(500 * time.Millisecond)) + _, _, err := conn.ReadMessage() + if err == nil { + t.Fatal("expected no message after suppress_onwards") + } +} + +// Tests that exercise the rule matching logic without needing a real upstream. + +func TestRuleMatching(t *testing.T) { + rule := &Rule{ + Match: MatchConfig{ + Type: "ws_frame_to_server", + Action: "ATTACH", + }, + Action: ActionConfig{Type: "suppress"}, + } + + // Should match + event := MatchEvent{Type: "ws_frame_to_server", Action: ActionAttach} + if !rule.Matches(event) { + t.Fatal("expected rule to match ATTACH frame") + } + + // Should not match different action + event2 := MatchEvent{Type: "ws_frame_to_server", Action: ActionDetach} + if rule.Matches(event2) { + t.Fatal("expected rule to NOT match DETACH frame") + } + + // Should not match different type + event3 := MatchEvent{Type: "ws_frame_to_client", Action: ActionAttach} + if rule.Matches(event3) { + t.Fatal("expected rule to NOT match client-direction frame") + } +} + +func TestRuleMatchingWithChannel(t *testing.T) { + rule := &Rule{ + Match: MatchConfig{ + Type: "ws_frame_to_server", + Action: "ATTACH", + Channel: "my-channel", + }, + Action: ActionConfig{Type: "suppress"}, + } + + event := MatchEvent{Type: "ws_frame_to_server", Action: ActionAttach, Channel: "my-channel"} + if !rule.Matches(event) { + t.Fatal("expected rule to match") + } + + event2 := MatchEvent{Type: "ws_frame_to_server", Action: ActionAttach, Channel: "other-channel"} + if rule.Matches(event2) { + t.Fatal("expected rule to NOT match different channel") + } +} + +func TestRuleMatchingWsConnect(t *testing.T) { + rule := &Rule{ + Match: MatchConfig{ + Type: "ws_connect", + QueryContains: map[string]string{"resume": "*"}, + }, + Action: ActionConfig{Type: "refuse_connection"}, + } + + // Should match when resume is present + event := MatchEvent{Type: "ws_connect", Action: -1, QueryParams: map[string]string{"resume": "key-1", "key": "abc"}} + if !rule.Matches(event) { + t.Fatal("expected rule to match when resume param present") + } + + // Should not match when resume is absent + event2 := MatchEvent{Type: "ws_connect", Action: -1, QueryParams: map[string]string{"key": "abc"}} + if rule.Matches(event2) { + t.Fatal("expected rule to NOT match when resume param absent") + } +} + +func TestRuleMatchingHttpRequest(t *testing.T) { + rule := &Rule{ + Match: MatchConfig{ + Type: "http_request", + Method: "POST", + PathContains: "/channels/", + }, + Action: ActionConfig{Type: "http_respond", Status: 401}, + } + + event := MatchEvent{Type: "http_request", Action: -1, Method: "POST", Path: "/channels/test/messages"} + if !rule.Matches(event) { + t.Fatal("expected rule to match") + } + + event2 := MatchEvent{Type: "http_request", Action: -1, Method: "GET", Path: "/channels/test/messages"} + if rule.Matches(event2) { + t.Fatal("expected rule to NOT match GET") + } + + event3 := MatchEvent{Type: "http_request", Action: -1, Method: "POST", Path: "/time"} + if rule.Matches(event3) { + t.Fatal("expected rule to NOT match /time") + } +} + +func TestSessionFindMatchingRuleWithCount(t *testing.T) { + session := &Session{ + Rules: []*Rule{ + { + Match: MatchConfig{Type: "ws_connect", Count: 2}, + Action: ActionConfig{Type: "refuse_connection"}, + }, + }, + EventLog: NewEventLog(), + } + + event := MatchEvent{Type: "ws_connect", Action: -1} + + // First attempt — count=1, rule wants count=2, should not fire + rule1, _ := session.FindMatchingRule(event) + if rule1 != nil { + t.Fatal("expected no match on first ws_connect") + } + + // Second attempt — count=2, should fire + rule2, _ := session.FindMatchingRule(event) + if rule2 == nil { + t.Fatal("expected match on second ws_connect") + } +} + +func TestRuleTimesLimit(t *testing.T) { + session := &Session{ + Rules: []*Rule{ + { + Match: MatchConfig{Type: "ws_frame_to_server", Action: "ATTACH"}, + Action: ActionConfig{Type: "suppress"}, + Times: 1, + }, + }, + EventLog: NewEventLog(), + } + + event := MatchEvent{Type: "ws_frame_to_server", Action: ActionAttach} + + // First match — should fire + rule, _ := session.FindMatchingRule(event) + if rule == nil { + t.Fatal("expected match") + } + session.FireRule(rule) + + // Rule should be removed (times=1, fired once) + if len(session.Rules) != 0 { + t.Fatalf("expected 0 rules, got %d", len(session.Rules)) + } + + // Second match — no rule + rule2, _ := session.FindMatchingRule(event) + if rule2 != nil { + t.Fatal("expected no match after rule exhausted") + } +} + +func TestProtocolParseJSON(t *testing.T) { + msg := `{"action":10,"channel":"test-channel"}` + pm := ParseProtocolMessage([]byte(msg), websocket.TextMessage) + if pm.Action != ActionAttach { + t.Fatalf("expected action %d, got %d", ActionAttach, pm.Action) + } + if pm.Channel != "test-channel" { + t.Fatalf("expected channel test-channel, got %s", pm.Channel) + } +} + +func TestProtocolParseJSONWithError(t *testing.T) { + msg := `{"action":9,"error":{"code":40142,"statusCode":401,"message":"Token expired"}}` + pm := ParseProtocolMessage([]byte(msg), websocket.TextMessage) + if pm.Action != ActionError { + t.Fatalf("expected action %d, got %d", ActionError, pm.Action) + } + if pm.Error == nil { + t.Fatal("expected error to be parsed") + } + if pm.Error.Code != 40142 { + t.Fatalf("expected error code 40142, got %d", pm.Error.Code) + } +} + +func TestProtocolParseMsgpack(t *testing.T) { + // Build a msgpack map: {"action": 10, "channel": "test"} + // Using raw msgpack encoding + raw := map[string]interface{}{ + "action": 10, + "channel": "test", + } + data := mustMarshalMsgpack(t, raw) + pm := ParseProtocolMessage(data, websocket.BinaryMessage) + if pm.Action != ActionAttach { + t.Fatalf("expected action %d, got %d", ActionAttach, pm.Action) + } + if pm.Channel != "test" { + t.Fatalf("expected channel test, got %s", pm.Channel) + } +} + +func TestActionFromString(t *testing.T) { + tests := []struct { + input string + want int + }{ + {"ATTACH", ActionAttach}, + {"attach", ActionAttach}, + {"CONNECTED", ActionConnected}, + {"10", ActionAttach}, + {"4", ActionConnected}, + {"unknown", -1}, + } + for _, tt := range tests { + got := ActionFromString(tt.input) + if got != tt.want { + t.Errorf("ActionFromString(%q) = %d, want %d", tt.input, got, tt.want) + } + } +} + +func TestEventLog(t *testing.T) { + log := NewEventLog() + log.Append(Event{Type: "ws_connect"}) + log.Append(Event{Type: "ws_frame", Direction: "client_to_server"}) + + events := log.Events() + if len(events) != 2 { + t.Fatalf("expected 2 events, got %d", len(events)) + } + if events[0].Type != "ws_connect" { + t.Fatalf("expected ws_connect, got %s", events[0].Type) + } + if events[1].Direction != "client_to_server" { + t.Fatalf("expected client_to_server, got %s", events[1].Direction) + } +} + +func TestEventLogConcurrency(t *testing.T) { + el := NewEventLog() + var wg sync.WaitGroup + for i := 0; i < 100; i++ { + wg.Add(1) + go func(i int) { + defer wg.Done() + el.Append(Event{Type: fmt.Sprintf("event-%d", i)}) + }(i) + } + wg.Wait() + + events := el.Events() + if len(events) != 100 { + t.Fatalf("expected 100 events, got %d", len(events)) + } +} + +func TestSessionTimeout(t *testing.T) { + controlURL, store, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: "localhost:1234"}, + Port: port, + TimeoutMs: 200, // 200ms timeout + }) + + // Session should exist + _, ok := store.Get(session.SessionID) + if !ok { + t.Fatal("expected session to exist") + } + + // Wait for timeout + time.Sleep(500 * time.Millisecond) + + // Session should be cleaned up + _, ok = store.Get(session.SessionID) + if ok { + t.Fatal("expected session to be cleaned up after timeout") + } + + // Port should be free + l, err := net.Listen("tcp", fmt.Sprintf(":%d", port)) + if err != nil { + t.Fatalf("port should be free after timeout: %v", err) + } + l.Close() +} + +func TestAddRulesDynamically(t *testing.T) { + controlURL, store, cleanup := startControlServer(t) + defer cleanup() + + port := freePort(t) + session := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: "localhost:1234"}, + Port: port, + }) + defer deleteSession(t, controlURL, session.SessionID) + + // Add a rule + ruleJSON, _ := json.Marshal(Rule{ + Match: MatchConfig{Type: "ws_connect"}, + Action: ActionConfig{Type: "refuse_connection"}, + Times: 1, + }) + addRules(t, controlURL, session.SessionID, []json.RawMessage{ruleJSON}, "append") + + // Verify rule count + sess, _ := store.Get(session.SessionID) + if sess.RuleCount() != 1 { + t.Fatalf("expected 1 rule, got %d", sess.RuleCount()) + } +} + +func TestMultipleRulesOrder(t *testing.T) { + session := &Session{ + Rules: []*Rule{ + { + Match: MatchConfig{Type: "ws_frame_to_server", Action: "ATTACH"}, + Action: ActionConfig{Type: "suppress"}, + Comment: "first", + }, + { + Match: MatchConfig{Type: "ws_frame_to_server"}, + Action: ActionConfig{Type: "passthrough"}, + Comment: "second", + }, + }, + EventLog: NewEventLog(), + } + + // ATTACH should match the first rule (more specific) + event := MatchEvent{Type: "ws_frame_to_server", Action: ActionAttach} + rule, _ := session.FindMatchingRule(event) + if rule == nil || rule.Comment != "first" { + t.Fatal("expected first rule to match") + } + + // MESSAGE should match the second rule (catch-all) + event2 := MatchEvent{Type: "ws_frame_to_server", Action: ActionMessage} + rule2, _ := session.FindMatchingRule(event2) + if rule2 == nil || rule2.Comment != "second" { + t.Fatal("expected second rule to match") + } +} + +func TestConcurrentSessions(t *testing.T) { + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + port1 := freePort(t) + port2 := freePort(t) + + session1 := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: "localhost:1111"}, + Port: port1, + }) + defer deleteSession(t, controlURL, session1.SessionID) + + session2 := createSession(t, controlURL, CreateSessionRequest{ + Target: TargetConfig{RealtimeHost: "localhost:2222"}, + Port: port2, + }) + defer deleteSession(t, controlURL, session2.SessionID) + + if session1.SessionID == session2.SessionID { + t.Fatal("expected different session IDs") + } + if session1.Proxy.Port == session2.Proxy.Port { + t.Fatal("expected different ports") + } +} + +func TestSessionNotFound(t *testing.T) { + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + resp, _ := http.Get(controlURL + "/sessions/nonexistent") + if resp.StatusCode != http.StatusNotFound { + t.Fatalf("expected 404, got %d", resp.StatusCode) + } + resp.Body.Close() + + resp2, _ := http.Get(controlURL + "/sessions/nonexistent/log") + if resp2.StatusCode != http.StatusNotFound { + t.Fatalf("expected 404, got %d", resp2.StatusCode) + } + resp2.Body.Close() +} + +func TestCreateSessionValidation(t *testing.T) { + controlURL, _, cleanup := startControlServer(t) + defer cleanup() + + // Missing port + body, _ := json.Marshal(CreateSessionRequest{Target: TargetConfig{RealtimeHost: "localhost:1234"}}) + resp, _ := http.Post(controlURL+"/sessions", "application/json", bytes.NewReader(body)) + if resp.StatusCode != http.StatusBadRequest { + t.Fatalf("expected 400 for missing port, got %d", resp.StatusCode) + } + resp.Body.Close() + + // Missing target + body2, _ := json.Marshal(CreateSessionRequest{Port: 9999}) + resp2, _ := http.Post(controlURL+"/sessions", "application/json", bytes.NewReader(body2)) + if resp2.StatusCode != http.StatusBadRequest { + t.Fatalf("expected 400 for missing target, got %d", resp2.StatusCode) + } + resp2.Body.Close() +} + +// -- Msgpack test helper -- + +func mustMarshalMsgpack(t *testing.T, v interface{}) []byte { + t.Helper() + data, err := msgpack.Marshal(v) + if err != nil { + t.Fatalf("failed to marshal msgpack: %v", err) + } + return data +} diff --git a/uts/proxy/rule.go b/uts/proxy/rule.go new file mode 100644 index 000000000..53768ed74 --- /dev/null +++ b/uts/proxy/rule.go @@ -0,0 +1,110 @@ +package main + +import ( + "encoding/json" + "strings" +) + +// Rule represents a single proxy rule with match condition, action, and optional firing limit. +type Rule struct { + Match MatchConfig `json:"match"` + Action ActionConfig `json:"action"` + Times int `json:"times,omitempty"` // 0 = unlimited + Comment string `json:"comment,omitempty"` + + matchCount int // how many times the match condition was satisfied (for count matching) +} + +// MatchConfig describes when a rule fires. +type MatchConfig struct { + Type string `json:"type"` // ws_connect, ws_frame_to_server, ws_frame_to_client, http_request, delay_after_ws_connect + Count int `json:"count,omitempty"` // only match the Nth occurrence (1-based) + Action string `json:"action,omitempty"` // protocol message action name or number + Channel string `json:"channel,omitempty"` // channel name must equal this + Method string `json:"method,omitempty"` // HTTP method + PathContains string `json:"pathContains,omitempty"` // request path must contain this + QueryContains map[string]string `json:"queryContains,omitempty"` // query params that must be present ("*" = any value) + DelayMs int `json:"delayMs,omitempty"` // for delay_after_ws_connect +} + +// ActionConfig describes what happens when a rule fires. +type ActionConfig struct { + Type string `json:"type"` // passthrough, refuse_connection, accept_and_close, disconnect, close, suppress, delay, inject_to_client, inject_to_client_and_close, replace, suppress_onwards, http_respond, http_delay, http_drop, http_replace_response + CloseCode int `json:"closeCode,omitempty"` + DelayMs int `json:"delayMs,omitempty"` + Message json.RawMessage `json:"message,omitempty"` + Status int `json:"status,omitempty"` + Body json.RawMessage `json:"body,omitempty"` + Headers map[string]string `json:"headers,omitempty"` +} + +// MatchEvent is the context passed to rule matching. +type MatchEvent struct { + Type string // ws_connect, ws_frame_to_server, ws_frame_to_client, http_request + Action int // protocol message action (normalized to int), -1 if not applicable + ActionStr string // original action string for logging + Channel string // protocol message channel + Method string // HTTP method + Path string // HTTP request path + QueryParams map[string]string // WS connection query params +} + +// Matches checks whether this rule's match config matches the given event. +// It does NOT check the count — that is handled by FindMatchingRule. +func (r *Rule) Matches(event MatchEvent) bool { + m := r.Match + + if m.Type != event.Type { + return false + } + + // Action filter (for frame matches) + if m.Action != "" && event.Action >= 0 { + // Try matching by name or number + wantAction := ActionFromString(m.Action) + if wantAction < 0 { + return false // unknown action name + } + if wantAction != event.Action { + return false + } + } + + // Channel filter + if m.Channel != "" && m.Channel != event.Channel { + return false + } + + // HTTP method filter + if m.Method != "" && !strings.EqualFold(m.Method, event.Method) { + return false + } + + // HTTP path filter + if m.PathContains != "" && !strings.Contains(event.Path, m.PathContains) { + return false + } + + // Query param filter (for ws_connect) + if len(m.QueryContains) > 0 { + for k, v := range m.QueryContains { + actual, ok := event.QueryParams[k] + if !ok { + return false + } + if v != "*" && v != actual { + return false + } + } + } + + return true +} + +// ruleLabel returns a human-readable label for logging which rule matched. +func ruleLabel(rule *Rule, index int) string { + if rule.Comment != "" { + return rule.Comment + } + return "rule-" + strings.Repeat("0", 1) + string(rune('0'+index)) +} diff --git a/uts/proxy/server.go b/uts/proxy/server.go new file mode 100644 index 000000000..0849f6d24 --- /dev/null +++ b/uts/proxy/server.go @@ -0,0 +1,245 @@ +package main + +import ( + "encoding/json" + "fmt" + "io" + "log" + "net/http" + "strings" + "time" +) + +// Server is the control API server. +type Server struct { + store *SessionStore + mux *http.ServeMux +} + +// NewServer creates a new control API server. +func NewServer(store *SessionStore) *Server { + s := &Server{store: store} + s.mux = http.NewServeMux() + s.mux.HandleFunc("GET /health", s.handleHealth) + s.mux.HandleFunc("POST /sessions", s.handleCreateSession) + s.mux.HandleFunc("GET /sessions/{id}", s.handleGetSession) + s.mux.HandleFunc("POST /sessions/{id}/rules", s.handleAddRules) + s.mux.HandleFunc("POST /sessions/{id}/actions", s.handleAction) + s.mux.HandleFunc("GET /sessions/{id}/log", s.handleGetLog) + s.mux.HandleFunc("DELETE /sessions/{id}", s.handleDeleteSession) + return s +} + +// ServeHTTP implements http.Handler. +func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { + s.mux.ServeHTTP(w, r) +} + +func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, map[string]bool{"ok": true}) +} + +func (s *Server) handleCreateSession(w http.ResponseWriter, r *http.Request) { + body, err := io.ReadAll(r.Body) + if err != nil { + writeError(w, http.StatusBadRequest, "failed to read request body") + return + } + + var req CreateSessionRequest + if err := json.Unmarshal(body, &req); err != nil { + writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error()) + return + } + + if req.Port <= 0 { + writeError(w, http.StatusBadRequest, "port is required and must be positive") + return + } + + if req.Target.RealtimeHost == "" && req.Target.RestHost == "" { + writeError(w, http.StatusBadRequest, "target must have at least one of realtimeHost or restHost") + return + } + + timeoutMs := req.TimeoutMs + if timeoutMs <= 0 { + timeoutMs = 30000 + } + + // Parse rules + var rules []*Rule + if len(req.Rules) > 0 { + if err := json.Unmarshal(req.Rules, &rules); err != nil { + writeError(w, http.StatusBadRequest, "invalid rules: "+err.Error()) + return + } + } + + session := &Session{ + ID: GenerateID(), + Target: req.Target, + Port: req.Port, + Rules: rules, + EventLog: NewEventLog(), + timeoutMs: timeoutMs, + } + + // Attempt to bind the port + if err := StartSessionListener(session, req.Port); err != nil { + writeError(w, http.StatusConflict, err.Error()) + return + } + + // Set up auto-cleanup timer + session.timeoutTimer = time.AfterFunc(time.Duration(timeoutMs)*time.Millisecond, func() { + log.Printf("session %s timed out after %dms, cleaning up", session.ID, timeoutMs) + s.cleanupSession(session.ID) + }) + + s.store.Create(session) + + resp := CreateSessionResponse{ + SessionID: session.ID, + Proxy: ProxyConfig{ + Host: fmt.Sprintf("localhost:%d", req.Port), + Port: req.Port, + }, + } + + log.Printf("created session %s on port %d (timeout %dms, %d rules)", + session.ID, req.Port, timeoutMs, len(rules)) + + writeJSON(w, http.StatusCreated, resp) +} + +func (s *Server) handleGetSession(w http.ResponseWriter, r *http.Request) { + id := r.PathValue("id") + session, ok := s.store.Get(id) + if !ok { + writeError(w, http.StatusNotFound, "session not found") + return + } + + writeJSON(w, http.StatusOK, map[string]interface{}{ + "sessionId": session.ID, + "port": session.Port, + "target": session.Target, + "ruleCount": session.RuleCount(), + }) +} + +func (s *Server) handleAddRules(w http.ResponseWriter, r *http.Request) { + id := r.PathValue("id") + session, ok := s.store.Get(id) + if !ok { + writeError(w, http.StatusNotFound, "session not found") + return + } + + body, err := io.ReadAll(r.Body) + if err != nil { + writeError(w, http.StatusBadRequest, "failed to read request body") + return + } + + var req AddRulesRequest + if err := json.Unmarshal(body, &req); err != nil { + writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error()) + return + } + + var rules []*Rule + if err := json.Unmarshal(req.Rules, &rules); err != nil { + writeError(w, http.StatusBadRequest, "invalid rules: "+err.Error()) + return + } + + prepend := strings.EqualFold(req.Position, "prepend") + session.AddRules(rules, prepend) + session.ResetTimeout() + + writeJSON(w, http.StatusOK, map[string]int{"ruleCount": session.RuleCount()}) +} + +func (s *Server) handleAction(w http.ResponseWriter, r *http.Request) { + id := r.PathValue("id") + session, ok := s.store.Get(id) + if !ok { + writeError(w, http.StatusNotFound, "session not found") + return + } + + body, err := io.ReadAll(r.Body) + if err != nil { + writeError(w, http.StatusBadRequest, "failed to read request body") + return + } + + var req ActionRequest + if err := json.Unmarshal(body, &req); err != nil { + writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error()) + return + } + + session.ResetTimeout() + + if err := ExecuteImperativeAction(session, req); err != nil { + writeError(w, http.StatusConflict, err.Error()) + return + } + + writeJSON(w, http.StatusOK, map[string]bool{"ok": true}) +} + +func (s *Server) handleGetLog(w http.ResponseWriter, r *http.Request) { + id := r.PathValue("id") + session, ok := s.store.Get(id) + if !ok { + writeError(w, http.StatusNotFound, "session not found") + return + } + + writeJSON(w, http.StatusOK, map[string]interface{}{ + "events": session.EventLog.Events(), + }) +} + +func (s *Server) handleDeleteSession(w http.ResponseWriter, r *http.Request) { + id := r.PathValue("id") + events := s.cleanupSession(id) + if events == nil { + writeError(w, http.StatusNotFound, "session not found") + return + } + + writeJSON(w, http.StatusOK, map[string]interface{}{ + "events": events, + }) +} + +func (s *Server) cleanupSession(id string) []Event { + session, ok := s.store.Delete(id) + if !ok { + return nil + } + + log.Printf("cleaning up session %s on port %d", session.ID, session.Port) + + StopSessionListener(session) + session.Close() + + return session.EventLog.Events() +} + +// -- helpers -- + +func writeJSON(w http.ResponseWriter, status int, v interface{}) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + json.NewEncoder(w).Encode(v) +} + +func writeError(w http.ResponseWriter, status int, msg string) { + writeJSON(w, status, map[string]string{"error": msg}) +} diff --git a/uts/proxy/session.go b/uts/proxy/session.go new file mode 100644 index 000000000..8d554610b --- /dev/null +++ b/uts/proxy/session.go @@ -0,0 +1,286 @@ +package main + +import ( + "encoding/json" + "fmt" + "net" + "net/http" + "sync" + "time" +) + +// TargetConfig specifies the upstream Ably hosts. +type TargetConfig struct { + RealtimeHost string `json:"realtimeHost,omitempty"` + RestHost string `json:"restHost,omitempty"` + Insecure bool `json:"insecure,omitempty"` // if true, use ws:// and http:// upstream (for testing) +} + +// Session represents a single test session with its own port, rules, and state. +type Session struct { + ID string `json:"id"` + Target TargetConfig `json:"target"` + Port int `json:"port"` + Rules []*Rule `json:"-"` + EventLog *EventLog `json:"-"` + + listener net.Listener + Server *http.Server + timeoutTimer *time.Timer + timeoutMs int + + activeWsConns []*WsConnection + wsConnectCount int + httpReqCount int + + suppressServerToClient bool + suppressClientToServer bool + + mu sync.Mutex +} + +// WsConnection tracks an active proxied WebSocket connection. +type WsConnection struct { + ClientConn interface{} // *websocket.Conn — set during ws_proxy + ServerConn interface{} // *websocket.Conn — set during ws_proxy + ConnNumber int + timers []*time.Timer + closed bool + closeCh chan struct{} // closed when connection is torn down + mu sync.Mutex +} + +// NewWsConnection creates a new WsConnection. +func NewWsConnection(connNumber int) *WsConnection { + return &WsConnection{ + ConnNumber: connNumber, + closeCh: make(chan struct{}), + } +} + +// MarkClosed marks this connection as closed and signals the closeCh. +func (wc *WsConnection) MarkClosed() { + wc.mu.Lock() + defer wc.mu.Unlock() + if !wc.closed { + wc.closed = true + close(wc.closeCh) + } +} + +// IsClosed returns whether this connection has been closed. +func (wc *WsConnection) IsClosed() bool { + wc.mu.Lock() + defer wc.mu.Unlock() + return wc.closed +} + +// CancelTimers stops all pending timers for this connection. +func (wc *WsConnection) CancelTimers() { + wc.mu.Lock() + defer wc.mu.Unlock() + for _, t := range wc.timers { + t.Stop() + } + wc.timers = nil +} + +// AddTimer adds a timer to this connection's timer list. +func (wc *WsConnection) AddTimer(t *time.Timer) { + wc.mu.Lock() + defer wc.mu.Unlock() + wc.timers = append(wc.timers, t) +} + +// FindMatchingRule iterates rules in order and returns the first match. +// It handles count tracking: increments the rule's matchCount when the +// base condition matches, and only returns the rule if count is satisfied. +// Returns the rule and its index, or nil/-1 if no rule matches. +func (s *Session) FindMatchingRule(event MatchEvent) (*Rule, int) { + s.mu.Lock() + defer s.mu.Unlock() + + for i, rule := range s.Rules { + if !rule.Matches(event) { + continue + } + + // Base condition matches — increment match count + rule.matchCount++ + + // Check count constraint + if rule.Match.Count > 0 && rule.matchCount != rule.Match.Count { + continue + } + + return rule, i + } + return nil, -1 +} + +// FireRule records that a rule has fired and removes it if times is exhausted. +func (s *Session) FireRule(rule *Rule) { + s.mu.Lock() + defer s.mu.Unlock() + s.fireRuleLocked(rule) +} + +func (s *Session) fireRuleLocked(rule *Rule) { + if rule.Times > 0 { + rule.Times-- + if rule.Times <= 0 { + s.removeRuleLocked(rule) + } + } +} + +func (s *Session) removeRuleLocked(rule *Rule) { + for i, r := range s.Rules { + if r == rule { + s.Rules = append(s.Rules[:i], s.Rules[i+1:]...) + return + } + } +} + +// AddRules appends or prepends rules to the session. +func (s *Session) AddRules(rules []*Rule, prepend bool) { + s.mu.Lock() + defer s.mu.Unlock() + if prepend { + s.Rules = append(rules, s.Rules...) + } else { + s.Rules = append(s.Rules, rules...) + } +} + +// RuleCount returns the current number of rules. +func (s *Session) RuleCount() int { + s.mu.Lock() + defer s.mu.Unlock() + return len(s.Rules) +} + +// GetActiveWsConn returns the most recently added active WS connection, or nil. +func (s *Session) GetActiveWsConn() *WsConnection { + s.mu.Lock() + defer s.mu.Unlock() + for i := len(s.activeWsConns) - 1; i >= 0; i-- { + if !s.activeWsConns[i].IsClosed() { + return s.activeWsConns[i] + } + } + return nil +} + +// AddWsConn registers a new WS connection and increments the connect count. +func (s *Session) AddWsConn(wc *WsConnection) { + s.mu.Lock() + defer s.mu.Unlock() + s.wsConnectCount++ + wc.ConnNumber = s.wsConnectCount + s.activeWsConns = append(s.activeWsConns, wc) +} + +// RemoveWsConn removes a WS connection from the active list. +func (s *Session) RemoveWsConn(wc *WsConnection) { + s.mu.Lock() + defer s.mu.Unlock() + for i, c := range s.activeWsConns { + if c == wc { + s.activeWsConns = append(s.activeWsConns[:i], s.activeWsConns[i+1:]...) + return + } + } +} + +// IncrementHttpReqCount increments and returns the HTTP request count. +func (s *Session) IncrementHttpReqCount() int { + s.mu.Lock() + defer s.mu.Unlock() + s.httpReqCount++ + return s.httpReqCount +} + +// ResetTimeout resets the session's auto-cleanup timer. +func (s *Session) ResetTimeout() { + s.mu.Lock() + defer s.mu.Unlock() + if s.timeoutTimer != nil { + s.timeoutTimer.Stop() + } + if s.timeoutMs > 0 { + s.timeoutTimer = time.AfterFunc(time.Duration(s.timeoutMs)*time.Millisecond, func() { + // Auto-cleanup is handled by the session store + }) + } +} + +// Close shuts down the session: closes all WS connections, cancels timers, closes listener. +func (s *Session) Close() { + s.mu.Lock() + defer s.mu.Unlock() + + if s.timeoutTimer != nil { + s.timeoutTimer.Stop() + s.timeoutTimer = nil + } + + for _, wc := range s.activeWsConns { + wc.CancelTimers() + wc.MarkClosed() + } + s.activeWsConns = nil + + if s.listener != nil { + s.listener.Close() + s.listener = nil + } +} + +// LogRuleMatch returns a string pointer for logging which rule matched, or nil. +func LogRuleMatch(rule *Rule, index int) *string { + if rule == nil { + return nil + } + label := fmt.Sprintf("rule-%d", index) + if rule.Comment != "" { + label = rule.Comment + } + return &label +} + +// -- API request/response types -- + +// CreateSessionRequest is the JSON body for POST /sessions. +type CreateSessionRequest struct { + Target TargetConfig `json:"target"` + Rules json.RawMessage `json:"rules,omitempty"` + TimeoutMs int `json:"timeoutMs,omitempty"` + Port int `json:"port"` +} + +// CreateSessionResponse is the JSON response for POST /sessions. +type CreateSessionResponse struct { + SessionID string `json:"sessionId"` + Proxy ProxyConfig `json:"proxy"` +} + +// ProxyConfig describes how to connect to the session's proxy. +type ProxyConfig struct { + Host string `json:"host"` + Port int `json:"port"` +} + +// AddRulesRequest is the JSON body for POST /sessions/{id}/rules. +type AddRulesRequest struct { + Rules json.RawMessage `json:"rules"` + Position string `json:"position,omitempty"` // "append" (default) or "prepend" +} + +// ActionRequest is the JSON body for POST /sessions/{id}/actions. +type ActionRequest struct { + Type string `json:"type"` + Message json.RawMessage `json:"message,omitempty"` + CloseCode int `json:"closeCode,omitempty"` +} diff --git a/uts/proxy/session_store.go b/uts/proxy/session_store.go new file mode 100644 index 000000000..a2028ff27 --- /dev/null +++ b/uts/proxy/session_store.go @@ -0,0 +1,64 @@ +package main + +import ( + "crypto/rand" + "encoding/hex" + "sync" +) + +// SessionStore is a thread-safe store for sessions. +type SessionStore struct { + sessions map[string]*Session + mu sync.RWMutex +} + +// NewSessionStore creates a new empty session store. +func NewSessionStore() *SessionStore { + return &SessionStore{ + sessions: make(map[string]*Session), + } +} + +// Create adds a session to the store. +func (s *SessionStore) Create(session *Session) { + s.mu.Lock() + defer s.mu.Unlock() + s.sessions[session.ID] = session +} + +// Get returns a session by ID. +func (s *SessionStore) Get(id string) (*Session, bool) { + s.mu.RLock() + defer s.mu.RUnlock() + session, ok := s.sessions[id] + return session, ok +} + +// Delete removes a session by ID, returning it if found. +func (s *SessionStore) Delete(id string) (*Session, bool) { + s.mu.Lock() + defer s.mu.Unlock() + session, ok := s.sessions[id] + if ok { + delete(s.sessions, id) + } + return session, ok +} + +// All returns all sessions. +func (s *SessionStore) All() []*Session { + s.mu.RLock() + defer s.mu.RUnlock() + out := make([]*Session, 0, len(s.sessions)) + for _, session := range s.sessions { + out = append(out, session) + } + return out +} + +// GenerateID creates a random 8-character hex session ID. +func GenerateID() string { + b := make([]byte, 4) + rand.Read(b) + return hex.EncodeToString(b) +} diff --git a/uts/proxy/test-proxy b/uts/proxy/test-proxy new file mode 100755 index 0000000000000000000000000000000000000000..a70f75f15ff98c22851d8a3528b1c4af642eedec GIT binary patch literal 8660002 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%0A&|X?g{$3 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%0D&eUj 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