@push.rocks/smartproxy 3.28.6 → 3.29.1

package/ts/classes.networkproxy.ts

@@ -16,6 +16,10 @@ export interface INetworkProxyOptions {
     allowHeaders?: string;
     maxAge?: number;
   };
+  
+  // New settings for PortProxy integration
+  connectionPoolSize?: number; // Maximum connections to maintain in the pool to each backend
+  portProxyIntegration?: boolean; // Flag to indicate this proxy is used by PortProxy
 }
 
 interface IWebSocketWithHeartbeat extends plugins.wsDefault {
@@ -42,13 +46,25 @@ export class NetworkProxy {
   public requestsServed: number = 0;
   public failedRequests: number = 0;
   
+  // New tracking for PortProxy integration
+  private portProxyConnections: number = 0;
+  private tlsTerminatedConnections: number = 0;
+  
   // Timers and intervals
   private heartbeatInterval: NodeJS.Timeout;
   private metricsInterval: NodeJS.Timeout;
+  private connectionPoolCleanupInterval: NodeJS.Timeout;
   
   // Certificates
   private defaultCertificates: { key: string; cert: string };
   private certificateCache: Map<string, { key: string; cert: string; expires?: Date }> = new Map();
+  
+  // New connection pool for backend connections
+  private connectionPool: Map<string, Array<{
+    socket: plugins.net.Socket;
+    lastUsed: number;
+    isIdle: boolean;
+  }>> = new Map();
 
   /**
    * Creates a new NetworkProxy instance
@@ -66,7 +82,10 @@ export class NetworkProxy {
         allowMethods: 'GET, POST, PUT, DELETE, OPTIONS',
         allowHeaders: 'Content-Type, Authorization',
         maxAge: 86400
-      }
+      },
+      // New defaults for PortProxy integration
+      connectionPoolSize: optionsArg.connectionPoolSize || 50,
+      portProxyIntegration: optionsArg.portProxyIntegration || false
     };
     
     this.loadDefaultCertificates();
@@ -104,6 +123,213 @@ export class NetworkProxy {
     }
   }
 
+  /**
+   * Returns the port number this NetworkProxy is listening on
+   * Useful for PortProxy to determine where to forward connections
+   */
+  public getListeningPort(): number {
+    return this.options.port;
+  }
+
+  /**
+   * Updates the server capacity settings
+   * @param maxConnections Maximum number of simultaneous connections
+   * @param keepAliveTimeout Keep-alive timeout in milliseconds
+   * @param connectionPoolSize Size of the connection pool per backend
+   */
+  public updateCapacity(maxConnections?: number, keepAliveTimeout?: number, connectionPoolSize?: number): void {
+    if (maxConnections !== undefined) {
+      this.options.maxConnections = maxConnections;
+      this.log('info', `Updated max connections to ${maxConnections}`);
+    }
+    
+    if (keepAliveTimeout !== undefined) {
+      this.options.keepAliveTimeout = keepAliveTimeout;
+      
+      if (this.httpsServer) {
+        this.httpsServer.keepAliveTimeout = keepAliveTimeout;
+        this.log('info', `Updated keep-alive timeout to ${keepAliveTimeout}ms`);
+      }
+    }
+    
+    if (connectionPoolSize !== undefined) {
+      this.options.connectionPoolSize = connectionPoolSize;
+      this.log('info', `Updated connection pool size to ${connectionPoolSize}`);
+      
+      // Cleanup excess connections in the pool if the size was reduced
+      this.cleanupConnectionPool();
+    }
+  }
+
+  /**
+   * Returns current server metrics
+   * Useful for PortProxy to determine which NetworkProxy to use for load balancing
+   */
+  public getMetrics(): any {
+    return {
+      activeConnections: this.connectedClients,
+      totalRequests: this.requestsServed,
+      failedRequests: this.failedRequests,
+      portProxyConnections: this.portProxyConnections,
+      tlsTerminatedConnections: this.tlsTerminatedConnections,
+      connectionPoolSize: Array.from(this.connectionPool.entries()).reduce((acc, [host, connections]) => {
+        acc[host] = connections.length;
+        return acc;
+      }, {} as Record<string, number>),
+      uptime: Math.floor((Date.now() - this.startTime) / 1000),
+      memoryUsage: process.memoryUsage(),
+      activeWebSockets: this.wsServer?.clients.size || 0
+    };
+  }
+
+  /**
+   * Cleanup the connection pool by removing idle connections
+   * or reducing pool size if it exceeds the configured maximum
+   */
+  private cleanupConnectionPool(): void {
+    const now = Date.now();
+    const idleTimeout = this.options.keepAliveTimeout || 120000; // 2 minutes default
+    
+    for (const [host, connections] of this.connectionPool.entries()) {
+      // Sort by last used time (oldest first)
+      connections.sort((a, b) => a.lastUsed - b.lastUsed);
+      
+      // Remove idle connections older than the idle timeout
+      let removed = 0;
+      while (connections.length > 0) {
+        const connection = connections[0];
+        
+        // Remove if idle and exceeds timeout, or if pool is too large
+        if ((connection.isIdle && now - connection.lastUsed > idleTimeout) ||
+            connections.length > this.options.connectionPoolSize!) {
+          
+          try {
+            if (!connection.socket.destroyed) {
+              connection.socket.end();
+              connection.socket.destroy();
+            }
+          } catch (err) {
+            this.log('error', `Error destroying pooled connection to ${host}`, err);
+          }
+          
+          connections.shift(); // Remove from pool
+          removed++;
+        } else {
+          break; // Stop removing if we've reached active or recent connections
+        }
+      }
+      
+      if (removed > 0) {
+        this.log('debug', `Removed ${removed} idle connections from pool for ${host}, ${connections.length} remaining`);
+      }
+      
+      // Update the pool with the remaining connections
+      if (connections.length === 0) {
+        this.connectionPool.delete(host);
+      } else {
+        this.connectionPool.set(host, connections);
+      }
+    }
+  }
+
+  /**
+   * Get a connection from the pool or create a new one
+   */
+  private getConnectionFromPool(host: string, port: number): Promise<plugins.net.Socket> {
+    return new Promise((resolve, reject) => {
+      const poolKey = `${host}:${port}`;
+      const connectionList = this.connectionPool.get(poolKey) || [];
+      
+      // Look for an idle connection
+      const idleConnectionIndex = connectionList.findIndex(c => c.isIdle);
+      
+      if (idleConnectionIndex >= 0) {
+        // Get existing connection from pool
+        const connection = connectionList[idleConnectionIndex];
+        connection.isIdle = false;
+        connection.lastUsed = Date.now();
+        this.log('debug', `Reusing connection from pool for ${poolKey}`);
+        
+        // Update the pool
+        this.connectionPool.set(poolKey, connectionList);
+        
+        resolve(connection.socket);
+        return;
+      }
+      
+      // No idle connection available, create a new one if pool isn't full
+      if (connectionList.length < this.options.connectionPoolSize!) {
+        this.log('debug', `Creating new connection to ${host}:${port}`);
+        
+        try {
+          const socket = plugins.net.connect({
+            host,
+            port,
+            keepAlive: true,
+            keepAliveInitialDelay: 30000 // 30 seconds
+          });
+          
+          socket.once('connect', () => {
+            // Add to connection pool
+            const connection = {
+              socket,
+              lastUsed: Date.now(),
+              isIdle: false
+            };
+            
+            connectionList.push(connection);
+            this.connectionPool.set(poolKey, connectionList);
+            
+            // Setup cleanup when the connection is closed
+            socket.once('close', () => {
+              const idx = connectionList.findIndex(c => c.socket === socket);
+              if (idx >= 0) {
+                connectionList.splice(idx, 1);
+                this.connectionPool.set(poolKey, connectionList);
+                this.log('debug', `Removed closed connection from pool for ${poolKey}`);
+              }
+            });
+            
+            resolve(socket);
+          });
+          
+          socket.once('error', (err) => {
+            this.log('error', `Error creating connection to ${host}:${port}`, err);
+            reject(err);
+          });
+        } catch (err) {
+          this.log('error', `Failed to create connection to ${host}:${port}`, err);
+          reject(err);
+        }
+      } else {
+        // Pool is full, wait for an idle connection or reject
+        this.log('warn', `Connection pool for ${poolKey} is full (${connectionList.length})`);
+        reject(new Error(`Connection pool for ${poolKey} is full`));
+      }
+    });
+  }
+
+  /**
+   * Return a connection to the pool for reuse
+   */
+  private returnConnectionToPool(socket: plugins.net.Socket, host: string, port: number): void {
+    const poolKey = `${host}:${port}`;
+    const connectionList = this.connectionPool.get(poolKey) || [];
+    
+    // Find this connection in the pool
+    const connectionIndex = connectionList.findIndex(c => c.socket === socket);
+    
+    if (connectionIndex >= 0) {
+      // Mark as idle and update last used time
+      connectionList[connectionIndex].isIdle = true;
+      connectionList[connectionIndex].lastUsed = Date.now();
+      
+      this.log('debug', `Returned connection to pool for ${poolKey}`);
+    } else {
+      this.log('warn', `Attempted to return unknown connection to pool for ${poolKey}`);
+    }
+  }
+
   /**
    * Starts the proxy server
    */
@@ -131,6 +357,9 @@ export class NetworkProxy {
     
     // Start metrics collection
     this.setupMetricsCollection();
+    
+    // Setup connection pool cleanup interval
+    this.setupConnectionPoolCleanup();
 
     // Start the server
     return new Promise((resolve) => {
@@ -156,13 +385,31 @@ export class NetworkProxy {
       // Add connection to tracking
       this.socketMap.add(connection);
       this.connectedClients = this.socketMap.getArray().length;
-      this.log('debug', `New connection. Currently ${this.connectedClients} active connections`);
+      
+      // Check for connection from PortProxy by inspecting the source port
+      // This is a heuristic - in a production environment you might use a more robust method
+      const localPort = connection.localPort;
+      const remotePort = connection.remotePort;
+      
+      // If this connection is from a PortProxy (usually indicated by it coming from localhost)
+      if (this.options.portProxyIntegration && connection.remoteAddress?.includes('127.0.0.1')) {
+        this.portProxyConnections++;
+        this.log('debug', `New connection from PortProxy (local: ${localPort}, remote: ${remotePort})`);
+      } else {
+        this.log('debug', `New direct connection (local: ${localPort}, remote: ${remotePort})`);
+      }
       
       // Setup connection cleanup handlers
       const cleanupConnection = () => {
         if (this.socketMap.checkForObject(connection)) {
           this.socketMap.remove(connection);
           this.connectedClients = this.socketMap.getArray().length;
+          
+          // If this was a PortProxy connection, decrement the counter
+          if (this.options.portProxyIntegration && connection.remoteAddress?.includes('127.0.0.1')) {
+            this.portProxyConnections--;
+          }
+          
           this.log('debug', `Connection closed. ${this.connectedClients} connections remaining`);
         }
       };
@@ -178,6 +425,12 @@ export class NetworkProxy {
         cleanupConnection();
       });
     });
+    
+    // Track TLS handshake completions
+    this.httpsServer.on('secureConnection', (tlsSocket) => {
+      this.tlsTerminatedConnections++;
+      this.log('debug', 'TLS handshake completed, connection secured');
+    });
   }
 
   /**
@@ -228,14 +481,35 @@ export class NetworkProxy {
         activeConnections: this.connectedClients,
         totalRequests: this.requestsServed,
         failedRequests: this.failedRequests,
+        portProxyConnections: this.portProxyConnections,
+        tlsTerminatedConnections: this.tlsTerminatedConnections,
         activeWebSockets: this.wsServer?.clients.size || 0,
         memoryUsage: process.memoryUsage(),
-        activeContexts: Array.from(this.activeContexts)
+        activeContexts: Array.from(this.activeContexts),
+        connectionPool: Object.fromEntries(
+          Array.from(this.connectionPool.entries()).map(([host, connections]) => [
+            host, 
+            {
+              total: connections.length, 
+              idle: connections.filter(c => c.isIdle).length
+            }
+          ])
+        )
       };
       
       this.log('debug', 'Proxy metrics', metrics);
     }, 60000); // Log metrics every minute
   }
+  
+  /**
+   * Sets up connection pool cleanup
+   */
+  private setupConnectionPoolCleanup(): void {
+    // Clean up idle connections every minute
+    this.connectionPoolCleanupInterval = setInterval(() => {
+      this.cleanupConnectionPool();
+    }, 60000); // 1 minute
+  }
 
   /**
    * Handles an incoming WebSocket connection
@@ -410,12 +684,27 @@ export class NetworkProxy {
         }
       }
       
+      // Determine if we should use connection pooling
+      const useConnectionPool = this.options.portProxyIntegration && 
+                                originRequest.socket.remoteAddress?.includes('127.0.0.1');
+      
       // Construct destination URL
       const destinationUrl = `http://${destinationConfig.destinationIp}:${destinationConfig.destinationPort}${originRequest.url}`;
-      this.log('debug', `[${reqId}] Proxying to ${destinationUrl}`);
       
-      // Forward the request
-      await this.forwardRequest(reqId, originRequest, originResponse, destinationUrl);
+      if (useConnectionPool) {
+        this.log('debug', `[${reqId}] Proxying to ${destinationUrl} (using connection pool)`);
+        await this.forwardRequestUsingConnectionPool(
+          reqId, 
+          originRequest, 
+          originResponse, 
+          destinationConfig.destinationIp, 
+          destinationConfig.destinationPort,
+          originRequest.url
+        );
+      } else {
+        this.log('debug', `[${reqId}] Proxying to ${destinationUrl}`);
+        await this.forwardRequest(reqId, originRequest, originResponse, destinationUrl);
+      }
       
       const processingTime = Date.now() - startTime;
       this.log('debug', `[${reqId}] Request completed in ${processingTime}ms`);
@@ -488,7 +777,105 @@ export class NetworkProxy {
   }
 
   /**
-   * Forwards a request to the destination
+   * Forwards a request to the destination using connection pool
+   * for optimized connection reuse from PortProxy
+   */
+  private async forwardRequestUsingConnectionPool(
+    reqId: string,
+    originRequest: plugins.http.IncomingMessage,
+    originResponse: plugins.http.ServerResponse,
+    host: string,
+    port: number,
+    path: string
+  ): Promise<void> {
+    try {
+      // Try to get a connection from the pool
+      const socket = await this.getConnectionFromPool(host, port);
+      
+      // Create an HTTP client request using the pooled socket
+      const reqOptions = {
+        createConnection: () => socket,
+        host,
+        port,
+        path,
+        method: originRequest.method,
+        headers: this.prepareForwardHeaders(originRequest),
+        timeout: 30000 // 30 second timeout
+      };
+      
+      const proxyReq = plugins.http.request(reqOptions);
+      
+      // Handle timeouts
+      proxyReq.on('timeout', () => {
+        this.log('warn', `[${reqId}] Request to ${host}:${port}${path} timed out`);
+        proxyReq.destroy();
+      });
+      
+      // Handle errors
+      proxyReq.on('error', (err) => {
+        this.log('error', `[${reqId}] Error in proxy request to ${host}:${port}${path}`, err);
+        
+        // Check if the client response is still writable
+        if (!originResponse.writableEnded) {
+          this.sendErrorResponse(originResponse, 502, 'Bad Gateway: Error communicating with upstream server');
+        }
+        
+        // Don't return the socket to the pool on error
+        try {
+          if (!socket.destroyed) {
+            socket.destroy();
+          }
+        } catch (socketErr) {
+          this.log('error', `[${reqId}] Error destroying socket after request error`, socketErr);
+        }
+      });
+      
+      // Forward request body
+      originRequest.pipe(proxyReq);
+      
+      // Handle response
+      proxyReq.on('response', (proxyRes) => {
+        // Copy status and headers
+        originResponse.statusCode = proxyRes.statusCode;
+        
+        for (const [name, value] of Object.entries(proxyRes.headers)) {
+          if (value !== undefined) {
+            originResponse.setHeader(name, value);
+          }
+        }
+        
+        // Forward the response body
+        proxyRes.pipe(originResponse);
+        
+        // Return connection to pool when the response completes
+        proxyRes.on('end', () => {
+          if (!socket.destroyed) {
+            this.returnConnectionToPool(socket, host, port);
+          }
+        });
+        
+        proxyRes.on('error', (err) => {
+          this.log('error', `[${reqId}] Error in proxy response from ${host}:${port}${path}`, err);
+          
+          // Don't return the socket to the pool on error
+          try {
+            if (!socket.destroyed) {
+              socket.destroy();
+            }
+          } catch (socketErr) {
+            this.log('error', `[${reqId}] Error destroying socket after response error`, socketErr);
+          }
+        });
+      });
+    } catch (error) {
+      this.log('error', `[${reqId}] Error setting up pooled connection to ${host}:${port}`, error);
+      this.sendErrorResponse(originResponse, 502, 'Bad Gateway: Unable to reach upstream server');
+      throw error;
+    }
+  }
+
+  /**
+   * Forwards a request to the destination (standard method)
    */
   private async forwardRequest(
     reqId: string,
@@ -532,6 +919,11 @@ export class NetworkProxy {
     // Add proxy-specific headers
     safeHeaders['X-Proxy-Id'] = `NetworkProxy-${this.options.port}`;
     
+    // If this is coming from PortProxy, add a header to indicate that
+    if (this.options.portProxyIntegration && req.socket.remoteAddress?.includes('127.0.0.1')) {
+      safeHeaders['X-PortProxy-Forwarded'] = 'true';
+    }
+    
     // Remove sensitive headers we don't want to forward
     const sensitiveHeaders = ['connection', 'upgrade', 'http2-settings'];
     for (const header of sensitiveHeaders) {
@@ -778,6 +1170,10 @@ export class NetworkProxy {
       clearInterval(this.metricsInterval);
     }
     
+    if (this.connectionPoolCleanupInterval) {
+      clearInterval(this.connectionPoolCleanupInterval);
+    }
+    
     // Close WebSocket server if exists
     if (this.wsServer) {
       for (const client of this.wsServer.clients) {
@@ -798,6 +1194,20 @@ export class NetworkProxy {
       }
     }
     
+    // Close all connection pool connections
+    for (const [host, connections] of this.connectionPool.entries()) {
+      for (const connection of connections) {
+        try {
+          if (!connection.socket.destroyed) {
+            connection.socket.destroy();
+          }
+        } catch (error) {
+          this.log('error', `Error destroying pooled connection to ${host}`, error);
+        }
+      }
+    }
+    this.connectionPool.clear();
+    
     // Close the HTTPS server
     return new Promise((resolve) => {
       this.httpsServer.close(() => {