fix(socket-handler): Fix socket handler race condition by differentiating between async and sync handlers. Now, async socket handlers complete their setup before initial data is emitted, ensuring that no data is lost. Documentation and tests have been updated to reflect this change.

This commit is contained in:
Philipp Kunz 2025-05-29 00:24:57 +00:00
parent d42fa8b1e9
commit e4aade4a9a
11 changed files with 1338 additions and 6 deletions

View File

@ -1,5 +1,12 @@
# Changelog
## 2025-05-29 - 19.5.1 - fix(socket-handler)
Fix socket handler race condition by differentiating between async and sync handlers. Now, async socket handlers complete their setup before initial data is emitted, ensuring that no data is lost. Documentation and tests have been updated to reflect this change.
- Added detailed explanation in readme.hints.md about the race condition issue, root cause, and solution implementation.
- Provided a code snippet that checks if the socket handler returns a Promise and waits for its resolution before emitting initial data.
- Updated tests (test.socket-handler-race.ts, test.socket-handler.simple.ts, test.socket-handler.ts) to verify correct behavior of async handlers.
## 2025-05-28 - 19.5.0 - feat(socket-handler)
Add socket-handler support for custom socket handling in SmartProxy

View File

@ -155,4 +155,41 @@ Deferred certificate provisioning until after ports are ready:
- `test/test.acme-timing-simple.ts` - Verifies proper timing sequence
### Migration
Update to v19.3.9+, no configuration changes needed.
Update to v19.3.9+, no configuration changes needed.
## Socket Handler Race Condition Fix (v19.5.0)
### Issue
Initial data chunks were being emitted before async socket handlers had completed setup, causing data loss when handlers performed async operations before setting up data listeners.
### Root Cause
The `handleSocketHandlerAction` method was using `process.nextTick` to emit initial chunks regardless of whether the handler was sync or async. This created a race condition where async handlers might not have their listeners ready when the initial data was emitted.
### Solution
Differentiated between sync and async handlers:
```typescript
const result = route.action.socketHandler(socket);
if (result instanceof Promise) {
// Async handler - wait for completion before emitting initial data
result.then(() => {
if (initialChunk && initialChunk.length > 0) {
socket.emit('data', initialChunk);
}
}).catch(/*...*/);
} else {
// Sync handler - use process.nextTick as before
if (initialChunk && initialChunk.length > 0) {
process.nextTick(() => {
socket.emit('data', initialChunk);
});
}
}
```
### Test Coverage
- `test/test.socket-handler-race.ts` - Specifically tests async handlers with delayed listener setup
- Verifies that initial data is received even when handler sets up listeners after async work
### Usage Note
Socket handlers require initial data from the client to trigger routing (not just a TLS handshake). Clients must send at least one byte of data for the handler to be invoked.

View File

@ -1,6 +1,6 @@
# SmartProxy Development Plan
## Implementation Plan: Socket Handler Function Support (Simplified)
## Implementation Plan: Socket Handler Function Support (Simplified) ✅ COMPLETED
### Overview
Add support for custom socket handler functions with the simplest possible API - just pass a function that receives the socket.
@ -286,4 +286,31 @@ Keep it simple. The user just wants to handle a socket.
- ✅ The function is called when a connection matches the route
- ✅ Error handling prevents crashes
- ✅ No performance impact on existing routes
- ✅ Clean, simple API that's easy to understand
- ✅ Clean, simple API that's easy to understand
---
## Implementation Notes (Completed)
### What Was Implemented
1. **Type Definitions** - Added 'socket-handler' to TRouteActionType and TSocketHandler type
2. **Route Handler** - Added socket-handler case in RouteConnectionHandler switch statement
3. **Error Handling** - Both sync and async errors are caught and logged
4. **Initial Data Handling** - Initial chunks are re-emitted to handler's listeners
5. **Helper Functions** - Added createSocketHandlerRoute and pre-built handlers (echo, proxy, etc.)
6. **Full Test Coverage** - All test cases pass including async handlers and error handling
### Key Implementation Details
- Socket handlers require initial data from client to trigger routing (not TLS handshake)
- The handler receives the raw socket after route matching
- Both sync and async handlers are supported
- Errors in handlers terminate the connection gracefully
- Helper utilities provide common patterns (echo server, TCP proxy, line protocol)
### Usage Notes
- Clients must send initial data to trigger the handler (even just a newline)
- The socket is passed directly to the handler function
- Handler has complete control over the socket lifecycle
- No special context object needed - keeps it simple
**Total implementation time: ~3 hours**

764
readme.plan2.md Normal file
View File

@ -0,0 +1,764 @@
# SmartProxy Simplification Plan: Unify Action Types
## Summary
Complete removal of 'redirect', 'block', and 'static' action types, leaving only 'forward' and 'socket-handler'. All old code will be deleted entirely - no migration paths or backwards compatibility. Socket handlers will be enhanced to receive IRouteContext as a second parameter.
## Goal
Create a dramatically simpler SmartProxy with only two action types, where everything is either proxied (forward) or handled by custom code (socket-handler).
## Current State
```typescript
export type TRouteActionType = 'forward' | 'redirect' | 'block' | 'static' | 'socket-handler';
export type TSocketHandler = (socket: plugins.net.Socket) => void | Promise<void>;
```
## Target State
```typescript
export type TRouteActionType = 'forward' | 'socket-handler';
export type TSocketHandler = (socket: plugins.net.Socket, context: IRouteContext) => void | Promise<void>;
```
## Benefits
1. **Simpler API** - Only two action types to understand
2. **Unified handling** - Everything is either forwarding or custom socket handling
3. **More flexible** - Socket handlers can do anything the old types did and more
4. **Less code** - Remove specialized handlers and their dependencies
5. **Context aware** - Socket handlers get access to route context (domain, port, clientIp, etc.)
6. **Clean codebase** - No legacy code or migration paths
---
## Phase 1: Code to Remove
### 1.1 Action Type Handlers
- `RouteConnectionHandler.handleRedirectAction()`
- `RouteConnectionHandler.handleBlockAction()`
- `RouteConnectionHandler.handleStaticAction()`
### 1.2 Handler Classes
- `RedirectHandler` class (http-proxy/handlers/)
- `StaticHandler` class (http-proxy/handlers/)
### 1.3 Type Definitions
- 'redirect', 'block', 'static' from TRouteActionType
- IRouteRedirect interface
- IRouteStatic interface
- Related properties in IRouteAction
### 1.4 Helper Functions
- `createStaticFileRoute()`
- Any other helpers that create redirect/block/static routes
---
## Phase 2: Create Predefined Socket Handlers
### 2.1 Block Handler
```typescript
export const SocketHandlers = {
// ... existing handlers
/**
* Block connection immediately
*/
block: (message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => {
// Can use context for logging or custom messages
const finalMessage = message || `Connection blocked from ${context.clientIp}`;
if (finalMessage) {
socket.write(finalMessage);
}
socket.end();
},
/**
* HTTP block response
*/
httpBlock: (statusCode: number = 403, message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => {
// Can customize message based on context
const defaultMessage = `Access forbidden for ${context.domain || context.clientIp}`;
const finalMessage = message || defaultMessage;
const response = [
`HTTP/1.1 ${statusCode} ${finalMessage}`,
'Content-Type: text/plain',
`Content-Length: ${finalMessage.length}`,
'Connection: close',
'',
finalMessage
].join('\r\n');
socket.write(response);
socket.end();
}
};
```
### 2.2 Redirect Handler
```typescript
export const SocketHandlers = {
// ... existing handlers
/**
* HTTP redirect handler
*/
httpRedirect: (locationTemplate: string, statusCode: number = 301) => (socket: plugins.net.Socket, context: IRouteContext) => {
let buffer = '';
socket.once('data', (data) => {
buffer += data.toString();
// Parse HTTP request
const lines = buffer.split('\r\n');
const requestLine = lines[0];
const [method, path] = requestLine.split(' ');
// Use domain from context (more reliable than Host header)
const domain = context.domain || 'localhost';
const port = context.port;
// Replace placeholders in location using context
let finalLocation = locationTemplate
.replace('{domain}', domain)
.replace('{port}', String(port))
.replace('{path}', path)
.replace('{clientIp}', context.clientIp);
const message = `Redirecting to ${finalLocation}`;
const response = [
`HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
`Location: ${finalLocation}`,
'Content-Type: text/plain',
`Content-Length: ${message.length}`,
'Connection: close',
'',
message
].join('\r\n');
socket.write(response);
socket.end();
});
}
};
```
### 2.3 Benefits of Context in Socket Handlers
With routeContext as a second parameter, socket handlers can:
- Access client IP for logging or rate limiting
- Use domain information for multi-tenant handling
- Check if connection is TLS and what version
- Access route name/ID for metrics
- Build more intelligent responses based on context
Example advanced handler:
```typescript
const rateLimitHandler = (maxRequests: number) => {
const ipCounts = new Map<string, number>();
return (socket: net.Socket, context: IRouteContext) => {
const count = (ipCounts.get(context.clientIp) || 0) + 1;
ipCounts.set(context.clientIp, count);
if (count > maxRequests) {
socket.write(`Rate limit exceeded for ${context.clientIp}\n`);
socket.end();
return;
}
// Process request...
};
};
```
---
## Phase 3: Update Helper Functions
### 3.1 Update createHttpToHttpsRedirect
```typescript
export function createHttpToHttpsRedirect(
domains: string | string[],
httpsPort: number = 443,
options: Partial<IRouteConfig> = {}
): IRouteConfig {
return {
name: options.name || `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
match: {
ports: options.match?.ports || 80,
domains
},
action: {
type: 'socket-handler',
socketHandler: SocketHandlers.httpRedirect(`https://{domain}:${httpsPort}{path}`, 301)
},
...options
};
}
```
### 3.2 Update createSocketHandlerRoute
```typescript
export function createSocketHandlerRoute(
domains: string | string[],
ports: TPortRange,
handler: TSocketHandler,
options: { name?: string; priority?: number; path?: string } = {}
): IRouteConfig {
return {
name: options.name || 'socket-handler-route',
priority: options.priority !== undefined ? options.priority : 50,
match: {
domains,
ports,
...(options.path && { path: options.path })
},
action: {
type: 'socket-handler',
socketHandler: handler
}
};
}
```
---
## Phase 4: Core Implementation Changes
### 4.1 Update Route Connection Handler
```typescript
// Remove these methods:
// - handleRedirectAction()
// - handleBlockAction()
// - handleStaticAction()
// Update switch statement to only have:
switch (route.action.type) {
case 'forward':
return this.handleForwardAction(socket, record, route, initialChunk);
case 'socket-handler':
this.handleSocketHandlerAction(socket, record, route, initialChunk);
return;
default:
logger.log('error', `Unknown action type '${(route.action as any).type}'`);
socket.end();
this.connectionManager.cleanupConnection(record, 'unknown_action');
}
```
### 4.2 Update Socket Handler to Pass Context
```typescript
private async handleSocketHandlerAction(
socket: plugins.net.Socket,
record: IConnectionRecord,
route: IRouteConfig,
initialChunk?: Buffer
): Promise<void> {
const connectionId = record.id;
// Create route context for the handler
const routeContext = this.createRouteContext({
connectionId: record.id,
port: record.localPort,
domain: record.lockedDomain,
clientIp: record.remoteIP,
serverIp: socket.localAddress || '',
isTls: record.isTLS || false,
tlsVersion: record.tlsVersion,
routeName: route.name,
routeId: route.id,
});
try {
// Call the handler with socket AND context
const result = route.action.socketHandler(socket, routeContext);
// Rest of implementation stays the same...
} catch (error) {
// Error handling...
}
}
```
### 4.3 Clean Up Imports and Exports
- Remove imports of deleted handler classes
- Update index.ts files to remove exports
- Clean up any unused imports
---
## Phase 5: Test Updates
### 5.1 Remove Old Tests
- Delete tests for redirect action type
- Delete tests for block action type
- Delete tests for static action type
### 5.2 Add New Socket Handler Tests
- Test block socket handler with context
- Test HTTP redirect socket handler with context
- Test that context is properly passed to all handlers
---
## Phase 6: Documentation Updates
### 6.1 Update README.md
- Remove documentation for redirect, block, static action types
- Document the two remaining action types: forward and socket-handler
- Add examples using socket handlers with context
### 6.2 Update Type Documentation
```typescript
/**
* Route action types
* - 'forward': Proxy the connection to a target host:port
* - 'socket-handler': Pass the socket to a custom handler function
*/
export type TRouteActionType = 'forward' | 'socket-handler';
/**
* Socket handler function
* @param socket - The incoming socket connection
* @param context - Route context with connection information
*/
export type TSocketHandler = (socket: net.Socket, context: IRouteContext) => void | Promise<void>;
```
### 6.3 Example Documentation
```typescript
// Example: Block connections from specific IPs
const ipBlocker = (socket: net.Socket, context: IRouteContext) => {
if (context.clientIp.startsWith('192.168.')) {
socket.write('Internal IPs not allowed\n');
socket.end();
return;
}
// Forward to backend...
};
// Example: Domain-based routing
const domainRouter = (socket: net.Socket, context: IRouteContext) => {
const backend = context.domain === 'api.example.com' ? 'api-server' : 'web-server';
// Forward to appropriate backend...
};
```
---
## Implementation Steps
1. **Update TSocketHandler type** (15 minutes)
- Add IRouteContext as second parameter
- Update type definition in route-types.ts
2. **Update socket handler implementation** (30 minutes)
- Create routeContext in handleSocketHandlerAction
- Pass context to socket handler function
- Update all existing socket handlers in route-helpers.ts
3. **Remove old action types** (30 minutes)
- Remove 'redirect', 'block', 'static' from TRouteActionType
- Remove IRouteRedirect, IRouteStatic interfaces
- Clean up IRouteAction interface
4. **Delete old handlers** (45 minutes)
- Delete handleRedirectAction, handleBlockAction, handleStaticAction methods
- Delete RedirectHandler and StaticHandler classes
- Remove imports and exports
5. **Update route connection handler** (30 minutes)
- Simplify switch statement to only handle 'forward' and 'socket-handler'
- Remove all references to deleted action types
6. **Create new socket handlers** (30 minutes)
- Implement SocketHandlers.block() with context
- Implement SocketHandlers.httpBlock() with context
- Implement SocketHandlers.httpRedirect() with context
7. **Update helper functions** (30 minutes)
- Update createHttpToHttpsRedirect to use socket handler
- Delete createStaticFileRoute entirely
- Update any other affected helpers
8. **Clean up tests** (1.5 hours)
- Delete all tests for removed action types
- Update socket handler tests to verify context parameter
- Add new tests for block/redirect socket handlers
9. **Update documentation** (30 minutes)
- Update README.md
- Update type documentation
- Add examples of context usage
**Total estimated time: ~5 hours**
---
## Considerations
### Benefits
- **Dramatically simpler API** - Only 2 action types instead of 5
- **Consistent handling model** - Everything is either forwarding or custom handling
- **More powerful** - Socket handlers with context can do much more than old static types
- **Less code to maintain** - Removing hundreds of lines of specialized handler code
- **Better extensibility** - Easy to add new socket handlers for any use case
- **Context awareness** - All handlers get full connection context
### Trade-offs
- Static file serving removed (users should use nginx/apache behind proxy)
- HTTP-specific logic (redirects) now in socket handlers (but more flexible)
- Slightly more verbose configuration for simple blocks/redirects
### Why This Approach
1. **Simplicity wins** - Two concepts are easier to understand than five
2. **Power through context** - Socket handlers with context are more capable
3. **Clean break** - No migration paths means cleaner code
4. **Future proof** - Easy to add new handlers without changing core
---
## Code Examples: Before and After
### Block Action
```typescript
// BEFORE
{
action: { type: 'block' }
}
// AFTER
{
action: {
type: 'socket-handler',
socketHandler: SocketHandlers.block()
}
}
```
### HTTP Redirect
```typescript
// BEFORE
{
action: {
type: 'redirect',
redirect: {
to: 'https://{domain}:443{path}',
status: 301
}
}
}
// AFTER
{
action: {
type: 'socket-handler',
socketHandler: SocketHandlers.httpRedirect('https://{domain}:443{path}', 301)
}
}
```
### Custom Handler with Context
```typescript
// NEW CAPABILITY - Access to full context
{
action: {
type: 'socket-handler',
socketHandler: (socket, context) => {
console.log(`Connection from ${context.clientIp} to ${context.domain}:${context.port}`);
// Custom handling based on context...
}
}
}
```
---
## Detailed Implementation Tasks
### Step 1: Update TSocketHandler Type (15 minutes)
- [ ] Open `ts/proxies/smart-proxy/models/route-types.ts`
- [ ] Find line 14: `export type TSocketHandler = (socket: plugins.net.Socket) => void | Promise<void>;`
- [ ] Import IRouteContext at top of file: `import type { IRouteContext } from '../../../core/models/route-context.js';`
- [ ] Update TSocketHandler to: `export type TSocketHandler = (socket: plugins.net.Socket, context: IRouteContext) => void | Promise<void>;`
- [ ] Save file
### Step 2: Update Socket Handler Implementation (30 minutes)
- [ ] Open `ts/proxies/smart-proxy/route-connection-handler.ts`
- [ ] Find `handleSocketHandlerAction` method (around line 790)
- [ ] Add route context creation after line 809:
```typescript
// Create route context for the handler
const routeContext = this.createRouteContext({
connectionId: record.id,
port: record.localPort,
domain: record.lockedDomain,
clientIp: record.remoteIP,
serverIp: socket.localAddress || '',
isTls: record.isTLS || false,
tlsVersion: record.tlsVersion,
routeName: route.name,
routeId: route.id,
});
```
- [ ] Update line 812 from `const result = route.action.socketHandler(socket);`
- [ ] To: `const result = route.action.socketHandler(socket, routeContext);`
- [ ] Save file
### Step 3: Update Existing Socket Handlers in route-helpers.ts (20 minutes)
- [ ] Open `ts/proxies/smart-proxy/utils/route-helpers.ts`
- [ ] Update `echo` handler (line 856):
- From: `echo: (socket: plugins.net.Socket) => {`
- To: `echo: (socket: plugins.net.Socket, context: IRouteContext) => {`
- [ ] Update `proxy` handler (line 864):
- From: `proxy: (targetHost: string, targetPort: number) => (socket: plugins.net.Socket) => {`
- To: `proxy: (targetHost: string, targetPort: number) => (socket: plugins.net.Socket, context: IRouteContext) => {`
- [ ] Update `lineProtocol` handler (line 879):
- From: `lineProtocol: (handler: (line: string, socket: plugins.net.Socket) => void) => (socket: plugins.net.Socket) => {`
- To: `lineProtocol: (handler: (line: string, socket: plugins.net.Socket) => void) => (socket: plugins.net.Socket, context: IRouteContext) => {`
- [ ] Update `httpResponse` handler (line 896):
- From: `httpResponse: (statusCode: number, body: string) => (socket: plugins.net.Socket) => {`
- To: `httpResponse: (statusCode: number, body: string) => (socket: plugins.net.Socket, context: IRouteContext) => {`
- [ ] Save file
### Step 4: Remove Old Action Types from Type Definitions (15 minutes)
- [ ] Open `ts/proxies/smart-proxy/models/route-types.ts`
- [ ] Find line with TRouteActionType (around line 10)
- [ ] Change from: `export type TRouteActionType = 'forward' | 'redirect' | 'block' | 'static' | 'socket-handler';`
- [ ] To: `export type TRouteActionType = 'forward' | 'socket-handler';`
- [ ] Find and delete IRouteRedirect interface (around line 123-126)
- [ ] Find and delete IRouteStatic interface (if exists)
- [ ] Find IRouteAction interface
- [ ] Remove these properties:
- `redirect?: IRouteRedirect;`
- `static?: IRouteStatic;`
- [ ] Save file
### Step 5: Delete Handler Classes (15 minutes)
- [ ] Delete file: `ts/proxies/http-proxy/handlers/redirect-handler.ts`
- [ ] Delete file: `ts/proxies/http-proxy/handlers/static-handler.ts`
- [ ] Open `ts/proxies/http-proxy/handlers/index.ts`
- [ ] Delete all content (the file only exports RedirectHandler and StaticHandler)
- [ ] Save empty file or delete it
### Step 6: Remove Handler Methods from RouteConnectionHandler (30 minutes)
- [ ] Open `ts/proxies/smart-proxy/route-connection-handler.ts`
- [ ] Find and delete entire `handleRedirectAction` method (around line 723)
- [ ] Find and delete entire `handleBlockAction` method (around line 750)
- [ ] Find and delete entire `handleStaticAction` method (around line 773)
- [ ] Remove imports at top:
- `import { RedirectHandler, StaticHandler } from '../http-proxy/handlers/index.js';`
- [ ] Save file
### Step 7: Update Switch Statement (15 minutes)
- [ ] Still in `route-connection-handler.ts`
- [ ] Find switch statement (around line 388)
- [ ] Remove these cases:
- `case 'redirect': return this.handleRedirectAction(...)`
- `case 'block': return this.handleBlockAction(...)`
- `case 'static': this.handleStaticAction(...); return;`
- [ ] Verify only 'forward' and 'socket-handler' cases remain
- [ ] Save file
### Step 8: Add New Socket Handlers to route-helpers.ts (30 minutes)
- [ ] Open `ts/proxies/smart-proxy/utils/route-helpers.ts`
- [ ] Add import at top: `import type { IRouteContext } from '../../../core/models/route-context.js';`
- [ ] Add to SocketHandlers object:
```typescript
/**
* Block connection immediately
*/
block: (message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => {
const finalMessage = message || `Connection blocked from ${context.clientIp}`;
if (finalMessage) {
socket.write(finalMessage);
}
socket.end();
},
/**
* HTTP block response
*/
httpBlock: (statusCode: number = 403, message?: string) => (socket: plugins.net.Socket, context: IRouteContext) => {
const defaultMessage = `Access forbidden for ${context.domain || context.clientIp}`;
const finalMessage = message || defaultMessage;
const response = [
`HTTP/1.1 ${statusCode} ${finalMessage}`,
'Content-Type: text/plain',
`Content-Length: ${finalMessage.length}`,
'Connection: close',
'',
finalMessage
].join('\r\n');
socket.write(response);
socket.end();
},
/**
* HTTP redirect handler
*/
httpRedirect: (locationTemplate: string, statusCode: number = 301) => (socket: plugins.net.Socket, context: IRouteContext) => {
let buffer = '';
socket.once('data', (data) => {
buffer += data.toString();
const lines = buffer.split('\r\n');
const requestLine = lines[0];
const [method, path] = requestLine.split(' ');
const domain = context.domain || 'localhost';
const port = context.port;
let finalLocation = locationTemplate
.replace('{domain}', domain)
.replace('{port}', String(port))
.replace('{path}', path)
.replace('{clientIp}', context.clientIp);
const message = `Redirecting to ${finalLocation}`;
const response = [
`HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
`Location: ${finalLocation}`,
'Content-Type: text/plain',
`Content-Length: ${message.length}`,
'Connection: close',
'',
message
].join('\r\n');
socket.write(response);
socket.end();
});
}
```
- [ ] Save file
### Step 9: Update Helper Functions (20 minutes)
- [ ] Still in `route-helpers.ts`
- [ ] Update `createHttpToHttpsRedirect` function (around line 109):
- Change the action to use socket handler:
```typescript
action: {
type: 'socket-handler',
socketHandler: SocketHandlers.httpRedirect(`https://{domain}:${httpsPort}{path}`, 301)
}
```
- [ ] Delete entire `createStaticFileRoute` function (lines 277-322)
- [ ] Save file
### Step 10: Update Test Files (1.5 hours)
#### 10.1 Update Socket Handler Tests
- [ ] Open `test/test.socket-handler.ts`
- [ ] Update all handler functions to accept context parameter
- [ ] Open `test/test.socket-handler.simple.ts`
- [ ] Update handler to accept context parameter
- [ ] Open `test/test.socket-handler-race.ts`
- [ ] Update handler to accept context parameter
#### 10.2 Find and Update/Delete Redirect Tests
- [ ] Search for files containing `type: 'redirect'` in test directory
- [ ] For each file:
- [ ] If it's a redirect-specific test, delete the file
- [ ] If it's a mixed test, update redirect actions to use socket handlers
- [ ] Files to check:
- [ ] `test/test.route-redirects.ts` - likely delete entire file
- [ ] `test/test.forwarding.ts` - update any redirect tests
- [ ] `test/test.forwarding.examples.ts` - update any redirect tests
- [ ] `test/test.route-config.ts` - update any redirect tests
#### 10.3 Find and Update/Delete Block Tests
- [ ] Search for files containing `type: 'block'` in test directory
- [ ] Update or delete as appropriate
#### 10.4 Find and Delete Static Tests
- [ ] Search for files containing `type: 'static'` in test directory
- [ ] Delete static-specific test files
- [ ] Remove static tests from mixed test files
### Step 11: Clean Up Imports and Exports (20 minutes)
- [ ] Open `ts/proxies/smart-proxy/utils/index.ts`
- [ ] Ensure route-helpers.ts is exported
- [ ] Remove any exports of deleted functions
- [ ] Open `ts/index.ts`
- [ ] Remove any exports of deleted types/interfaces
- [ ] Search for any remaining imports of RedirectHandler or StaticHandler
- [ ] Remove any found imports
### Step 12: Documentation Updates (30 minutes)
- [ ] Update README.md:
- [ ] Remove any mention of redirect, block, static action types
- [ ] Add examples of socket handlers with context
- [ ] Document the two action types: forward and socket-handler
- [ ] Update any JSDoc comments in modified files
- [ ] Add examples showing context usage
### Step 13: Final Verification (15 minutes)
- [ ] Run build: `pnpm build`
- [ ] Fix any compilation errors
- [ ] Run tests: `pnpm test`
- [ ] Fix any failing tests
- [ ] Search codebase for any remaining references to:
- [ ] 'redirect' action type
- [ ] 'block' action type
- [ ] 'static' action type
- [ ] RedirectHandler
- [ ] StaticHandler
- [ ] IRouteRedirect
- [ ] IRouteStatic
### Step 14: Test New Functionality (30 minutes)
- [ ] Create test for block socket handler with context
- [ ] Create test for httpBlock socket handler with context
- [ ] Create test for httpRedirect socket handler with context
- [ ] Verify context is properly passed in all scenarios
---
## Files to be Modified/Deleted
### Files to Modify:
1. `ts/proxies/smart-proxy/models/route-types.ts` - Update types
2. `ts/proxies/smart-proxy/route-connection-handler.ts` - Remove handlers, update switch
3. `ts/proxies/smart-proxy/utils/route-helpers.ts` - Update handlers, add new ones
4. `ts/proxies/http-proxy/handlers/index.ts` - Remove exports
5. Various test files - Update to use socket handlers
### Files to Delete:
1. `ts/proxies/http-proxy/handlers/redirect-handler.ts`
2. `ts/proxies/http-proxy/handlers/static-handler.ts`
3. `test/test.route-redirects.ts` (likely)
4. Any static-specific test files
### Test Files Requiring Updates (15 files found):
- test/test.acme-http01-challenge.ts
- test/test.logger-error-handling.ts
- test/test.port80-management.node.ts
- test/test.route-update-callback.node.ts
- test/test.acme-state-manager.node.ts
- test/test.acme-route-creation.ts
- test/test.forwarding.ts
- test/test.route-redirects.ts
- test/test.forwarding.examples.ts
- test/test.acme-simple.ts
- test/test.acme-http-challenge.ts
- test/test.certificate-provisioning.ts
- test/test.route-config.ts
- test/test.route-utils.ts
- test/test.certificate-simple.ts
---
## Success Criteria
- ✅ Only 'forward' and 'socket-handler' action types remain
- ✅ Socket handlers receive IRouteContext as second parameter
- ✅ All old handler code completely removed
- ✅ Redirect functionality works via context-aware socket handlers
- ✅ Block functionality works via context-aware socket handlers
- ✅ All tests updated and passing
- ✅ Documentation updated with new examples
- ✅ No performance regression
- ✅ Cleaner, simpler codebase

View File

@ -0,0 +1,83 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/index.js';
tap.test('should handle async handler that sets up listeners after delay', async () => {
const proxy = new SmartProxy({
routes: [{
name: 'delayed-setup-handler',
match: { ports: 7777 },
action: {
type: 'socket-handler',
socketHandler: async (socket) => {
// Simulate async work BEFORE setting up listeners
await new Promise(resolve => setTimeout(resolve, 50));
// Now set up the listener - with the race condition, this would miss initial data
socket.on('data', (data) => {
const message = data.toString().trim();
socket.write(`RECEIVED: ${message}\n`);
if (message === 'close') {
socket.end();
}
});
// Send ready message
socket.write('HANDLER READY\n');
}
}
}],
enableDetailedLogging: false
});
await proxy.start();
// Test connection
const client = new net.Socket();
let response = '';
client.on('data', (data) => {
response += data.toString();
});
await new Promise<void>((resolve, reject) => {
client.connect(7777, 'localhost', () => {
// Send initial data immediately - this tests the race condition
client.write('initial-message\n');
resolve();
});
client.on('error', reject);
});
// Wait for handler setup and initial data processing
await new Promise(resolve => setTimeout(resolve, 150));
// Send another message to verify handler is working
client.write('test-message\n');
// Wait for response
await new Promise(resolve => setTimeout(resolve, 50));
// Send close command
client.write('close\n');
// Wait for connection to close
await new Promise(resolve => {
client.on('close', () => resolve(undefined));
});
console.log('Response:', response);
// Should have received the ready message
expect(response).toContain('HANDLER READY');
// Should have received the initial message (this would fail with race condition)
expect(response).toContain('RECEIVED: initial-message');
// Should have received the test message
expect(response).toContain('RECEIVED: test-message');
await proxy.stop();
});
export default tap.start();

View File

@ -0,0 +1,59 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/index.js';
tap.test('simple socket handler test', async () => {
const proxy = new SmartProxy({
routes: [{
name: 'simple-handler',
match: {
ports: 8888
// No domains restriction - will match all connections on this port
},
action: {
type: 'socket-handler',
socketHandler: (socket) => {
console.log('Handler called!');
socket.write('HELLO\n');
socket.end();
}
}
}],
enableDetailedLogging: true
});
await proxy.start();
// Test connection
const client = new net.Socket();
let response = '';
client.on('data', (data) => {
response += data.toString();
});
await new Promise<void>((resolve, reject) => {
client.connect(8888, 'localhost', () => {
console.log('Connected');
// Send some initial data to trigger the handler
client.write('test\n');
resolve();
});
client.on('error', reject);
});
// Wait for response
await new Promise(resolve => {
client.on('close', () => {
console.log('Connection closed');
resolve(undefined);
});
});
console.log('Got response:', response);
expect(response).toEqual('HELLO\n');
await proxy.stop();
});
export default tap.start();

173
test/test.socket-handler.ts Normal file
View File

@ -0,0 +1,173 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/index.js';
import type { IRouteConfig } from '../ts/index.js';
let proxy: SmartProxy;
tap.test('setup socket handler test', async () => {
// Create a simple socket handler route
const routes: IRouteConfig[] = [{
name: 'echo-handler',
match: {
ports: 9999
// No domains restriction - matches all connections
},
action: {
type: 'socket-handler',
socketHandler: (socket) => {
console.log('Socket handler called');
// Simple echo server
socket.write('ECHO SERVER\n');
socket.on('data', (data) => {
console.log('Socket handler received data:', data.toString());
socket.write(`ECHO: ${data}`);
});
socket.on('error', (err) => {
console.error('Socket error:', err);
});
}
}
}];
proxy = new SmartProxy({
routes,
enableDetailedLogging: false
});
await proxy.start();
});
tap.test('should handle socket with custom function', async () => {
const client = new net.Socket();
let response = '';
await new Promise<void>((resolve, reject) => {
client.connect(9999, 'localhost', () => {
console.log('Client connected to proxy');
resolve();
});
client.on('error', reject);
});
// Collect data
client.on('data', (data) => {
console.log('Client received:', data.toString());
response += data.toString();
});
// Wait a bit for connection to stabilize
await new Promise(resolve => setTimeout(resolve, 50));
// Send test data
console.log('Sending test data...');
client.write('Hello World\n');
// Wait for response
await new Promise(resolve => setTimeout(resolve, 200));
console.log('Total response:', response);
expect(response).toContain('ECHO SERVER');
expect(response).toContain('ECHO: Hello World');
client.destroy();
});
tap.test('should handle async socket handler', async () => {
// Update route with async handler
await proxy.updateRoutes([{
name: 'async-handler',
match: { ports: 9999 },
action: {
type: 'socket-handler',
socketHandler: async (socket) => {
// Set up data handler first
socket.on('data', async (data) => {
console.log('Async handler received:', data.toString());
// Simulate async processing
await new Promise(resolve => setTimeout(resolve, 10));
const processed = `PROCESSED: ${data.toString().trim().toUpperCase()}\n`;
console.log('Sending:', processed);
socket.write(processed);
});
// Then simulate async operation
await new Promise(resolve => setTimeout(resolve, 10));
socket.write('ASYNC READY\n');
}
}
}]);
const client = new net.Socket();
let response = '';
// Collect data
client.on('data', (data) => {
response += data.toString();
});
await new Promise<void>((resolve, reject) => {
client.connect(9999, 'localhost', () => {
// Send initial data to trigger the handler
client.write('test data\n');
resolve();
});
client.on('error', reject);
});
// Wait for async processing
await new Promise(resolve => setTimeout(resolve, 200));
console.log('Final response:', response);
expect(response).toContain('ASYNC READY');
expect(response).toContain('PROCESSED: TEST DATA');
client.destroy();
});
tap.test('should handle errors in socket handler', async () => {
// Update route with error-throwing handler
await proxy.updateRoutes([{
name: 'error-handler',
match: { ports: 9999 },
action: {
type: 'socket-handler',
socketHandler: (socket) => {
throw new Error('Handler error');
}
}
}]);
const client = new net.Socket();
let connectionClosed = false;
client.on('close', () => {
connectionClosed = true;
});
await new Promise<void>((resolve, reject) => {
client.connect(9999, 'localhost', () => {
// Connection established - send data to trigger handler
client.write('trigger\n');
resolve();
});
client.on('error', () => {
// Ignore client errors - we expect the connection to be closed
});
});
// Wait a bit
await new Promise(resolve => setTimeout(resolve, 100));
// Socket should be closed due to handler error
expect(connectionClosed).toEqual(true);
});
tap.test('cleanup', async () => {
await proxy.stop();
});
export default tap.start();

View File

@ -3,6 +3,6 @@
*/
export const commitinfo = {
name: '@push.rocks/smartproxy',
version: '19.5.0',
version: '19.5.1',
description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
}

View File

@ -6,7 +6,12 @@ import type { PortRange } from '../../../proxies/nftables-proxy/models/interface
/**
* Supported action types for route configurations
*/
export type TRouteActionType = 'forward' | 'redirect' | 'block' | 'static';
export type TRouteActionType = 'forward' | 'redirect' | 'block' | 'static' | 'socket-handler';
/**
* Socket handler function type
*/
export type TSocketHandler = (socket: plugins.net.Socket) => void | Promise<void>;
/**
* TLS handling modes for route configurations
@ -297,6 +302,9 @@ export interface IRouteAction {
// Handler function for static routes
handler?: (context: IRouteContext) => Promise<IStaticResponse>;
// Socket handler function (when type is 'socket-handler')
socketHandler?: TSocketHandler;
}
/**

View File

@ -399,6 +399,15 @@ export class RouteConnectionHandler {
this.handleStaticAction(socket, record, route, initialChunk);
return;
case 'socket-handler':
logger.log('info', `Handling socket-handler action for route ${route.name}`, {
connectionId,
routeName: route.name,
component: 'route-handler'
});
this.handleSocketHandlerAction(socket, record, route, initialChunk);
return;
default:
logger.log('error', `Unknown action type '${(route.action as any).type}' for connection ${connectionId}`, {
connectionId,
@ -776,6 +785,75 @@ export class RouteConnectionHandler {
}, record, initialChunk);
}
/**
* Handle a socket-handler action for a route
*/
private async handleSocketHandlerAction(
socket: plugins.net.Socket,
record: IConnectionRecord,
route: IRouteConfig,
initialChunk?: Buffer
): Promise<void> {
const connectionId = record.id;
if (!route.action.socketHandler) {
logger.log('error', 'socket-handler action missing socketHandler function', {
connectionId,
routeName: route.name,
component: 'route-handler'
});
socket.destroy();
this.connectionManager.cleanupConnection(record, 'missing_handler');
return;
}
try {
// Call the handler
const result = route.action.socketHandler(socket);
// Handle async handlers properly
if (result instanceof Promise) {
result
.then(() => {
// Emit initial chunk after async handler completes
if (initialChunk && initialChunk.length > 0) {
socket.emit('data', initialChunk);
}
})
.catch(error => {
logger.log('error', 'Socket handler error', {
connectionId,
routeName: route.name,
error: error.message,
component: 'route-handler'
});
if (!socket.destroyed) {
socket.destroy();
}
this.connectionManager.cleanupConnection(record, 'handler_error');
});
} else {
// For sync handlers, emit on next tick
if (initialChunk && initialChunk.length > 0) {
process.nextTick(() => {
socket.emit('data', initialChunk);
});
}
}
} catch (error) {
logger.log('error', 'Socket handler error', {
connectionId,
routeName: route.name,
error: error.message,
component: 'route-handler'
});
if (!socket.destroyed) {
socket.destroy();
}
this.connectionManager.cleanupConnection(record, 'handler_error');
}
}
/**
* Setup improved error handling for the outgoing connection
*/

View File

@ -19,6 +19,7 @@
* - NFTables routes (createNfTablesRoute, createNfTablesTerminateRoute)
*/
import * as plugins from '../../../plugins.js';
import type { IRouteConfig, IRouteMatch, IRouteAction, IRouteTarget, TPortRange, IRouteContext } from '../models/route-types.js';
/**
@ -810,4 +811,99 @@ export function createCompleteNfTablesHttpsServer(
);
return [httpsRoute, httpRedirectRoute];
}
}
/**
* Create a socket handler route configuration
* @param domains Domain(s) to match
* @param ports Port(s) to listen on
* @param handler Socket handler function
* @param options Additional route options
* @returns Route configuration object
*/
export function createSocketHandlerRoute(
domains: string | string[],
ports: TPortRange,
handler: (socket: plugins.net.Socket) => void | Promise<void>,
options: {
name?: string;
priority?: number;
path?: string;
} = {}
): IRouteConfig {
return {
name: options.name || 'socket-handler-route',
priority: options.priority !== undefined ? options.priority : 50,
match: {
domains,
ports,
...(options.path && { path: options.path })
},
action: {
type: 'socket-handler',
socketHandler: handler
}
};
}
/**
* Pre-built socket handlers for common use cases
*/
export const SocketHandlers = {
/**
* Simple echo server handler
*/
echo: (socket: plugins.net.Socket) => {
socket.write('ECHO SERVER READY\n');
socket.on('data', data => socket.write(data));
},
/**
* TCP proxy handler
*/
proxy: (targetHost: string, targetPort: number) => (socket: plugins.net.Socket) => {
const target = plugins.net.connect(targetPort, targetHost);
socket.pipe(target);
target.pipe(socket);
socket.on('close', () => target.destroy());
target.on('close', () => socket.destroy());
target.on('error', (err) => {
console.error('Proxy target error:', err);
socket.destroy();
});
},
/**
* Line-based protocol handler
*/
lineProtocol: (handler: (line: string, socket: plugins.net.Socket) => void) => (socket: plugins.net.Socket) => {
let buffer = '';
socket.on('data', (data) => {
buffer += data.toString();
const lines = buffer.split('\n');
buffer = lines.pop() || '';
lines.forEach(line => {
if (line.trim()) {
handler(line.trim(), socket);
}
});
});
},
/**
* Simple HTTP response handler (for testing)
*/
httpResponse: (statusCode: number, body: string) => (socket: plugins.net.Socket) => {
const response = [
`HTTP/1.1 ${statusCode} ${statusCode === 200 ? 'OK' : 'Error'}`,
'Content-Type: text/plain',
`Content-Length: ${body.length}`,
'Connection: close',
'',
body
].join('\r\n');
socket.write(response);
socket.end();
}
};