update
This commit is contained in:
341
Connection-Cleanup-Patterns.md
Normal file
341
Connection-Cleanup-Patterns.md
Normal file
@@ -0,0 +1,341 @@
|
||||
# Connection Cleanup Code Patterns
|
||||
|
||||
## Pattern 1: Safe Connection Cleanup
|
||||
|
||||
```typescript
|
||||
public initiateCleanupOnce(record: IConnectionRecord, reason: string = 'normal'): void {
|
||||
// Prevent duplicate cleanup
|
||||
if (record.incomingTerminationReason === null ||
|
||||
record.incomingTerminationReason === undefined) {
|
||||
record.incomingTerminationReason = reason;
|
||||
this.incrementTerminationStat('incoming', reason);
|
||||
}
|
||||
|
||||
this.cleanupConnection(record, reason);
|
||||
}
|
||||
|
||||
public cleanupConnection(record: IConnectionRecord, reason: string = 'normal'): void {
|
||||
if (!record.connectionClosed) {
|
||||
record.connectionClosed = true;
|
||||
|
||||
// Remove from tracking immediately
|
||||
this.connectionRecords.delete(record.id);
|
||||
this.securityManager.removeConnectionByIP(record.remoteIP, record.id);
|
||||
|
||||
// Clear timers
|
||||
if (record.cleanupTimer) {
|
||||
clearTimeout(record.cleanupTimer);
|
||||
record.cleanupTimer = undefined;
|
||||
}
|
||||
|
||||
// Clean up sockets
|
||||
this.cleanupSocket(record, 'incoming', record.incoming);
|
||||
if (record.outgoing) {
|
||||
this.cleanupSocket(record, 'outgoing', record.outgoing);
|
||||
}
|
||||
|
||||
// Clear memory
|
||||
record.pendingData = [];
|
||||
record.pendingDataSize = 0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Pattern 2: Socket Cleanup with Retry
|
||||
|
||||
```typescript
|
||||
private cleanupSocket(
|
||||
record: IConnectionRecord,
|
||||
side: 'incoming' | 'outgoing',
|
||||
socket: plugins.net.Socket
|
||||
): void {
|
||||
try {
|
||||
if (!socket.destroyed) {
|
||||
// Graceful shutdown first
|
||||
socket.end();
|
||||
|
||||
// Force destroy after timeout
|
||||
const socketTimeout = setTimeout(() => {
|
||||
try {
|
||||
if (!socket.destroyed) {
|
||||
socket.destroy();
|
||||
}
|
||||
} catch (err) {
|
||||
console.log(`[${record.id}] Error destroying ${side} socket: ${err}`);
|
||||
}
|
||||
}, 1000);
|
||||
|
||||
// Don't block process exit
|
||||
if (socketTimeout.unref) {
|
||||
socketTimeout.unref();
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
console.log(`[${record.id}] Error closing ${side} socket: ${err}`);
|
||||
// Fallback to destroy
|
||||
try {
|
||||
if (!socket.destroyed) {
|
||||
socket.destroy();
|
||||
}
|
||||
} catch (destroyErr) {
|
||||
console.log(`[${record.id}] Error destroying ${side} socket: ${destroyErr}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Pattern 3: NetworkProxy Bridge Cleanup
|
||||
|
||||
```typescript
|
||||
public async forwardToNetworkProxy(
|
||||
connectionId: string,
|
||||
socket: plugins.net.Socket,
|
||||
record: IConnectionRecord,
|
||||
initialChunk: Buffer,
|
||||
networkProxyPort: number,
|
||||
cleanupCallback: (reason: string) => void
|
||||
): Promise<void> {
|
||||
const proxySocket = new plugins.net.Socket();
|
||||
|
||||
// Connect to NetworkProxy
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
proxySocket.connect(networkProxyPort, 'localhost', () => {
|
||||
resolve();
|
||||
});
|
||||
proxySocket.on('error', reject);
|
||||
});
|
||||
|
||||
// Send initial data
|
||||
if (initialChunk) {
|
||||
proxySocket.write(initialChunk);
|
||||
}
|
||||
|
||||
// Setup bidirectional piping
|
||||
socket.pipe(proxySocket);
|
||||
proxySocket.pipe(socket);
|
||||
|
||||
// Comprehensive cleanup handler
|
||||
const cleanup = (reason: string) => {
|
||||
// Unpipe to prevent data loss
|
||||
socket.unpipe(proxySocket);
|
||||
proxySocket.unpipe(socket);
|
||||
|
||||
// Destroy proxy socket
|
||||
proxySocket.destroy();
|
||||
|
||||
// Notify SmartProxy
|
||||
cleanupCallback(reason);
|
||||
};
|
||||
|
||||
// Setup all cleanup triggers
|
||||
socket.on('end', () => cleanup('socket_end'));
|
||||
socket.on('error', () => cleanup('socket_error'));
|
||||
proxySocket.on('end', () => cleanup('proxy_end'));
|
||||
proxySocket.on('error', () => cleanup('proxy_error'));
|
||||
}
|
||||
```
|
||||
|
||||
## Pattern 4: Error Handler with Cleanup
|
||||
|
||||
```typescript
|
||||
public handleError(side: 'incoming' | 'outgoing', record: IConnectionRecord) {
|
||||
return (err: Error) => {
|
||||
const code = (err as any).code;
|
||||
let reason = 'error';
|
||||
|
||||
// Map error codes to reasons
|
||||
switch (code) {
|
||||
case 'ECONNRESET':
|
||||
reason = 'econnreset';
|
||||
break;
|
||||
case 'ETIMEDOUT':
|
||||
reason = 'etimedout';
|
||||
break;
|
||||
case 'ECONNREFUSED':
|
||||
reason = 'connection_refused';
|
||||
break;
|
||||
case 'EHOSTUNREACH':
|
||||
reason = 'host_unreachable';
|
||||
break;
|
||||
}
|
||||
|
||||
// Log with context
|
||||
const duration = Date.now() - record.incomingStartTime;
|
||||
console.log(
|
||||
`[${record.id}] ${code} on ${side} side from ${record.remoteIP}. ` +
|
||||
`Duration: ${plugins.prettyMs(duration)}`
|
||||
);
|
||||
|
||||
// Track termination reason
|
||||
if (side === 'incoming' && record.incomingTerminationReason === null) {
|
||||
record.incomingTerminationReason = reason;
|
||||
this.incrementTerminationStat('incoming', reason);
|
||||
}
|
||||
|
||||
// Initiate cleanup
|
||||
this.initiateCleanupOnce(record, reason);
|
||||
};
|
||||
}
|
||||
```
|
||||
|
||||
## Pattern 5: Inactivity Check with Cleanup
|
||||
|
||||
```typescript
|
||||
public performInactivityCheck(): void {
|
||||
const now = Date.now();
|
||||
const connectionIds = [...this.connectionRecords.keys()];
|
||||
|
||||
for (const id of connectionIds) {
|
||||
const record = this.connectionRecords.get(id);
|
||||
if (!record) continue;
|
||||
|
||||
// Skip if disabled or immortal
|
||||
if (this.settings.disableInactivityCheck ||
|
||||
(record.hasKeepAlive && this.settings.keepAliveTreatment === 'immortal')) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const inactivityTime = now - record.lastActivity;
|
||||
let effectiveTimeout = this.settings.inactivityTimeout!;
|
||||
|
||||
// Extended timeout for keep-alive
|
||||
if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'extended') {
|
||||
effectiveTimeout *= (this.settings.keepAliveInactivityMultiplier || 6);
|
||||
}
|
||||
|
||||
if (inactivityTime > effectiveTimeout && !record.connectionClosed) {
|
||||
// Warn before closing keep-alive connections
|
||||
if (record.hasKeepAlive && !record.inactivityWarningIssued) {
|
||||
console.log(`[${id}] Warning: Keep-alive connection inactive`);
|
||||
record.inactivityWarningIssued = true;
|
||||
// Grace period
|
||||
record.lastActivity = now - (effectiveTimeout - 600000);
|
||||
} else {
|
||||
// Close the connection
|
||||
console.log(`[${id}] Closing due to inactivity`);
|
||||
this.cleanupConnection(record, 'inactivity');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Pattern 6: Complete Shutdown
|
||||
|
||||
```typescript
|
||||
public clearConnections(): void {
|
||||
const connectionIds = [...this.connectionRecords.keys()];
|
||||
|
||||
// Phase 1: Graceful end
|
||||
for (const id of connectionIds) {
|
||||
const record = this.connectionRecords.get(id);
|
||||
if (record) {
|
||||
try {
|
||||
// Clear timers
|
||||
if (record.cleanupTimer) {
|
||||
clearTimeout(record.cleanupTimer);
|
||||
record.cleanupTimer = undefined;
|
||||
}
|
||||
|
||||
// Graceful socket end
|
||||
if (record.incoming && !record.incoming.destroyed) {
|
||||
record.incoming.end();
|
||||
}
|
||||
if (record.outgoing && !record.outgoing.destroyed) {
|
||||
record.outgoing.end();
|
||||
}
|
||||
} catch (err) {
|
||||
console.log(`Error during graceful end: ${err}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Phase 2: Force destroy after delay
|
||||
setTimeout(() => {
|
||||
for (const id of connectionIds) {
|
||||
const record = this.connectionRecords.get(id);
|
||||
if (record) {
|
||||
try {
|
||||
// Remove all listeners
|
||||
if (record.incoming) {
|
||||
record.incoming.removeAllListeners();
|
||||
if (!record.incoming.destroyed) {
|
||||
record.incoming.destroy();
|
||||
}
|
||||
}
|
||||
if (record.outgoing) {
|
||||
record.outgoing.removeAllListeners();
|
||||
if (!record.outgoing.destroyed) {
|
||||
record.outgoing.destroy();
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
console.log(`Error during forced destruction: ${err}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Clear all tracking
|
||||
this.connectionRecords.clear();
|
||||
this.terminationStats = { incoming: {}, outgoing: {} };
|
||||
}, 100);
|
||||
}
|
||||
```
|
||||
|
||||
## Pattern 7: Safe Event Handler Removal
|
||||
|
||||
```typescript
|
||||
// Store handlers for later removal
|
||||
record.renegotiationHandler = this.tlsManager.createRenegotiationHandler(
|
||||
connectionId,
|
||||
serverName,
|
||||
connInfo,
|
||||
(connectionId, reason) => this.connectionManager.initiateCleanupOnce(record, reason)
|
||||
);
|
||||
|
||||
// Add the handler
|
||||
socket.on('data', record.renegotiationHandler);
|
||||
|
||||
// Remove during cleanup
|
||||
if (record.incoming) {
|
||||
try {
|
||||
record.incoming.removeAllListeners('data');
|
||||
record.renegotiationHandler = undefined;
|
||||
} catch (err) {
|
||||
console.log(`[${record.id}] Error removing data handlers: ${err}`);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Pattern 8: Connection State Tracking
|
||||
|
||||
```typescript
|
||||
interface IConnectionRecord {
|
||||
id: string;
|
||||
connectionClosed: boolean;
|
||||
incomingTerminationReason: string | null;
|
||||
outgoingTerminationReason: string | null;
|
||||
cleanupTimer?: NodeJS.Timeout;
|
||||
renegotiationHandler?: Function;
|
||||
// ... other fields
|
||||
}
|
||||
|
||||
// Check state before operations
|
||||
if (!record.connectionClosed) {
|
||||
// Safe to perform operations
|
||||
}
|
||||
|
||||
// Track cleanup state
|
||||
record.connectionClosed = true;
|
||||
```
|
||||
|
||||
## Key Principles
|
||||
|
||||
1. **Idempotency**: Cleanup operations should be safe to call multiple times
|
||||
2. **State Tracking**: Always track connection and cleanup state
|
||||
3. **Error Resilience**: Handle errors during cleanup gracefully
|
||||
4. **Resource Release**: Clear all references (timers, handlers, buffers)
|
||||
5. **Graceful First**: Try graceful shutdown before forced destroy
|
||||
6. **Comprehensive Coverage**: Handle all possible termination scenarios
|
||||
7. **Logging**: Track termination reasons for debugging
|
||||
8. **Memory Safety**: Clear data structures to prevent leaks
|
||||
Reference in New Issue
Block a user