@push.rocks/smartproxy 19.5.19 → 19.5.21

package/ts/routing/router/http-router.ts

@@ -0,0 +1,266 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
+import { DomainMatcher, PathMatcher } from '../../core/routing/matchers/index.js';
+
+/**
+ * Interface for router result with additional metadata
+ */
+export interface RouterResult {
+  route: IRouteConfig;
+  pathMatch?: string;
+  pathParams?: Record<string, string>;
+  pathRemainder?: string;
+}
+
+
+/**
+ * Logger interface for HttpRouter
+ */
+export interface ILogger {
+  debug?: (message: string, data?: any) => void;
+  info: (message: string, data?: any) => void;
+  warn: (message: string, data?: any) => void;
+  error: (message: string, data?: any) => void;
+}
+
+/**
+ * Unified HTTP Router for reverse proxy requests
+ * 
+ * Domain matching patterns:
+ * - Exact matches: "example.com"
+ * - Wildcard subdomains: "*.example.com" (matches any subdomain of example.com)
+ * - TLD wildcards: "example.*" (matches example.com, example.org, etc.)
+ * - Complex wildcards: "*.lossless*" (matches any subdomain of any lossless domain)
+ * - Default fallback: "*" (matches any unmatched domain)
+ * 
+ * Path pattern matching:
+ * - Exact path: "/api/users"
+ * - Wildcard paths: "/api/*" 
+ * - Path parameters: "/users/:id/profile"
+ */
+export class HttpRouter {
+  // Store routes sorted by priority
+  private routes: IRouteConfig[] = [];
+  // Default route to use when no match is found (optional)
+  private defaultRoute?: IRouteConfig;
+  // Logger interface
+  private logger: ILogger;
+
+  constructor(
+    routes?: IRouteConfig[],
+    logger?: ILogger
+  ) {
+    this.logger = logger || {
+      error: console.error.bind(console),
+      warn: console.warn.bind(console),
+      info: console.info.bind(console),
+      debug: console.debug?.bind(console)
+    };
+    
+    if (routes) {
+      this.setRoutes(routes);
+    }
+  }
+
+  /**
+   * Sets a new set of routes
+   * @param routes Array of route configurations
+   */
+  public setRoutes(routes: IRouteConfig[]): void {
+    this.routes = [...routes];
+
+    // Sort routes by priority (higher priority first)
+    this.routes.sort((a, b) => {
+      const priorityA = a.priority ?? 0;
+      const priorityB = b.priority ?? 0;
+      return priorityB - priorityA;
+    });
+
+    // Find default route if any (route with "*" as domain)
+    this.defaultRoute = this.routes.find(route => {
+      const domains = Array.isArray(route.match.domains) 
+        ? route.match.domains 
+        : route.match.domains ? [route.match.domains] : [];
+      return domains.includes('*');
+    });
+
+    const uniqueDomains = this.getHostnames();
+    this.logger.info(`HttpRouter initialized with ${this.routes.length} routes (${uniqueDomains.length} unique hosts)`);
+  }
+
+  /**
+   * Routes a request based on hostname and path
+   * @param req The incoming HTTP request
+   * @returns The matching route or undefined if no match found
+   */
+  public routeReq(req: plugins.http.IncomingMessage): IRouteConfig | undefined {
+    const result = this.routeReqWithDetails(req);
+    return result ? result.route : undefined;
+  }
+
+  /**
+   * Routes a request with detailed matching information
+   * @param req The incoming HTTP request
+   * @returns Detailed routing result including matched route and path information
+   */
+  public routeReqWithDetails(req: plugins.http.IncomingMessage): RouterResult | undefined {
+    // Extract and validate host header
+    const originalHost = req.headers.host;
+    if (!originalHost) {
+      this.logger.error('No host header found in request');
+      return this.defaultRoute ? { route: this.defaultRoute } : undefined;
+    }
+    
+    // Parse URL for path matching
+    const parsedUrl = plugins.url.parse(req.url || '/');
+    const urlPath = parsedUrl.pathname || '/';
+    
+    // Extract hostname without port
+    const hostWithoutPort = originalHost.split(':')[0].toLowerCase();
+    
+    // Find matching route
+    const matchingRoute = this.findMatchingRoute(hostWithoutPort, urlPath);
+    
+    if (matchingRoute) {
+      return matchingRoute;
+    }
+    
+    // Fall back to default route if available
+    if (this.defaultRoute) {
+      this.logger.warn(`No specific route found for host: ${hostWithoutPort}, using default`);
+      return { route: this.defaultRoute };
+    }
+    
+    this.logger.error(`No route found for host: ${hostWithoutPort}`);
+    return undefined;
+  }
+
+  /**
+   * Find the best matching route for a given hostname and path
+   */
+  private findMatchingRoute(hostname: string, path: string): RouterResult | undefined {
+    // Try each route in priority order
+    for (const route of this.routes) {
+      // Skip disabled routes
+      if (route.enabled === false) {
+        continue;
+      }
+
+      // Check domain match
+      if (route.match.domains) {
+        const domains = Array.isArray(route.match.domains) 
+          ? route.match.domains 
+          : [route.match.domains];
+        
+        // Check if any domain pattern matches
+        const domainMatches = domains.some(domain => 
+          DomainMatcher.match(domain, hostname)
+        );
+        
+        if (!domainMatches) {
+          continue;
+        }
+      }
+
+      // Check path match if specified
+      if (route.match.path) {
+        const pathResult = PathMatcher.match(route.match.path, path);
+        if (pathResult.matches) {
+          return {
+            route,
+            pathMatch: path,
+            pathParams: pathResult.params,
+            pathRemainder: pathResult.pathRemainder
+          };
+        }
+      } else {
+        // No path specified, so domain match is sufficient
+        return { route };
+      }
+    }
+    
+    return undefined;
+  }
+
+  /**
+   * Gets all currently active route configurations
+   * @returns Array of all active routes
+   */
+  public getRoutes(): IRouteConfig[] {
+    return [...this.routes];
+  }
+
+  /**
+   * Gets all hostnames that this router is configured to handle
+   * @returns Array of unique hostnames
+   */
+  public getHostnames(): string[] {
+    const hostnames = new Set<string>();
+    for (const route of this.routes) {
+      if (!route.match.domains) continue;
+      
+      const domains = Array.isArray(route.match.domains) 
+        ? route.match.domains 
+        : [route.match.domains];
+      
+      for (const domain of domains) {
+        if (domain !== '*') {
+          hostnames.add(domain.toLowerCase());
+        }
+      }
+    }
+    return Array.from(hostnames);
+  }
+
+  /**
+   * Adds a single new route configuration
+   * @param route The route configuration to add
+   */
+  public addRoute(route: IRouteConfig): void {
+    this.routes.push(route);
+    
+    // Re-sort routes by priority
+    this.routes.sort((a, b) => {
+      const priorityA = a.priority ?? 0;
+      const priorityB = b.priority ?? 0;
+      return priorityB - priorityA;
+    });
+  }
+
+  /**
+   * Removes routes by domain pattern
+   * @param domain The domain pattern to remove routes for
+   * @returns Boolean indicating whether any routes were removed
+   */
+  public removeRoutesByDomain(domain: string): boolean {
+    const initialCount = this.routes.length;
+    
+    // Filter out routes that match the domain
+    this.routes = this.routes.filter(route => {
+      if (!route.match.domains) return true;
+      
+      const domains = Array.isArray(route.match.domains) 
+        ? route.match.domains 
+        : [route.match.domains];
+      
+      return !domains.includes(domain);
+    });
+    
+    return this.routes.length !== initialCount;
+  }
+
+  /**
+   * Remove a specific route by reference
+   * @param route The route to remove
+   * @returns Boolean indicating if the route was found and removed
+   */
+  public removeRoute(route: IRouteConfig): boolean {
+    const index = this.routes.indexOf(route);
+    if (index !== -1) {
+      this.routes.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+
+}

package/ts/routing/router/index.ts

@@ -2,11 +2,6 @@
  * HTTP routing
  */
 
-// Export selectively to avoid ambiguity between duplicate type names
-export { ProxyRouter } from './proxy-router.js';
-export type { IPathPatternConfig } from './proxy-router.js';
-// Re-export the RouterResult and PathPatternConfig from proxy-router.js (legacy names maintained for compatibility)
-export type { PathPatternConfig as ProxyPathPatternConfig, RouterResult as ProxyRouterResult } from './proxy-router.js';
-
-export { RouteRouter } from './route-router.js';
-export type { PathPatternConfig as RoutePathPatternConfig, RouterResult as RouteRouterResult } from './route-router.js';
+// Export the unified HttpRouter
+export { HttpRouter } from './http-router.js';
+export type { RouterResult, ILogger } from './http-router.js';

package/readme.problems.md

@@ -1,170 +0,0 @@
-# SmartProxy Performance Issues Report
-
-## Executive Summary
-This report identifies performance issues and blocking operations in the SmartProxy codebase that could impact scalability and responsiveness under high load.
-
-## Critical Issues
-
-### 1. **Synchronous Filesystem Operations**
-These operations block the event loop and should be replaced with async alternatives:
-
-#### Certificate Management
-- `ts/proxies/http-proxy/certificate-manager.ts:29`: `fs.existsSync()` 
-- `ts/proxies/http-proxy/certificate-manager.ts:30`: `fs.mkdirSync()`
-- `ts/proxies/http-proxy/certificate-manager.ts:49-50`: `fs.readFileSync()` for loading certificates
-
-#### NFTables Proxy
-- `ts/proxies/nftables-proxy/nftables-proxy.ts`: Multiple uses of `execSync()` for system commands
-- `ts/proxies/nftables-proxy/nftables-proxy.ts`: Multiple `fs.writeFileSync()` and `fs.unlinkSync()` operations
-
-#### Certificate Store
-- `ts/proxies/smart-proxy/cert-store.ts:8`: `ensureDirSync()`
-- `ts/proxies/smart-proxy/cert-store.ts:15,31,76`: `fileExistsSync()`
-- `ts/proxies/smart-proxy/cert-store.ts:77`: `removeManySync()`
-
-### 2. **Event Loop Blocking Operations**
-
-#### Busy Wait Loop
-- `ts/proxies/nftables-proxy/nftables-proxy.ts:235-238`: 
-  ```typescript
-  const waitUntil = Date.now() + retryDelayMs;
-  while (Date.now() < waitUntil) {
-    // busy wait - blocks event loop completely
-  }
-  ```
-  This is extremely problematic as it blocks the entire Node.js event loop.
-
-### 3. **Potential Memory Leaks**
-
-#### Timer Management Issues
-Several timers are created without proper cleanup:
-- `ts/proxies/http-proxy/function-cache.ts`: `setInterval()` without storing reference for cleanup
-- `ts/proxies/http-proxy/request-handler.ts`: `setInterval()` for rate limit cleanup without cleanup
-- `ts/core/utils/shared-security-manager.ts`: `cleanupInterval` stored but no cleanup method
-
-#### Event Listener Accumulation
-- Multiple instances of event listeners being added without corresponding cleanup
-- Connection handlers add listeners without always removing them on connection close
-
-### 4. **Connection Pool Management**
-
-#### ConnectionPool (ts/proxies/http-proxy/connection-pool.ts)
-**Good practices observed:**
-- Proper connection lifecycle management
-- Periodic cleanup of idle connections
-- Connection limits enforcement
-
-**Potential issues:**
-- No backpressure mechanism when pool is full
-- Synchronous sorting operation in `cleanupConnectionPool()` could be slow with many connections
-
-### 5. **Resource Management Issues**
-
-#### Socket Cleanup
-- Some error paths don't properly clean up sockets
-- Missing `removeAllListeners()` in some error scenarios could lead to memory leaks
-
-#### Timeout Management
-- Inconsistent timeout handling across different components
-- Some sockets created without timeout settings
-
-### 6. **JSON Operations on Large Objects**
-- `ts/proxies/smart-proxy/cert-store.ts:21`: `JSON.parse()` on certificate metadata
-- `ts/proxies/smart-proxy/cert-store.ts:71`: `JSON.stringify()` with pretty printing
-- `ts/proxies/http-proxy/function-cache.ts:76`: `JSON.stringify()` for cache keys (called frequently)
-
-## Recommendations
-
-### Immediate Actions (High Priority)
-
-1. **Replace Synchronous Operations**
-   ```typescript
-   // Instead of:
-   if (fs.existsSync(path)) { ... }
-   
-   // Use:
-   try {
-     await fs.promises.access(path);
-     // file exists
-   } catch {
-     // file doesn't exist
-   }
-   ```
-
-2. **Fix Busy Wait Loop**
-   ```typescript
-   // Instead of:
-   while (Date.now() < waitUntil) { }
-   
-   // Use:
-   await new Promise(resolve => setTimeout(resolve, retryDelayMs));
-   ```
-
-3. **Add Timer Cleanup**
-   ```typescript
-   class Component {
-     private cleanupTimer?: NodeJS.Timeout;
-     
-     start() {
-       this.cleanupTimer = setInterval(() => { ... }, 60000);
-     }
-     
-     stop() {
-       if (this.cleanupTimer) {
-         clearInterval(this.cleanupTimer);
-         this.cleanupTimer = undefined;
-       }
-     }
-   }
-   ```
-
-### Medium Priority
-
-1. **Optimize JSON Operations**
-   - Cache JSON.stringify results for frequently used objects
-   - Consider using faster hashing for cache keys (e.g., crypto.createHash)
-   - Use streaming JSON parsers for large objects
-
-2. **Improve Connection Pool**
-   - Implement backpressure/queueing when pool is full
-   - Use a heap or priority queue for connection management instead of sorting
-
-3. **Standardize Resource Cleanup**
-   - Create a base class for components with lifecycle management
-   - Ensure all event listeners are removed on cleanup
-   - Add abort controllers for better cancellation support
-
-### Long-term Improvements
-
-1. **Worker Threads**
-   - Move CPU-intensive operations to worker threads
-   - Consider using worker pools for NFTables operations
-
-2. **Monitoring and Metrics**
-   - Add performance monitoring for event loop lag
-   - Track connection pool utilization
-   - Monitor memory usage patterns
-
-3. **Graceful Degradation**
-   - Implement circuit breakers for backend connections
-   - Add request queuing with overflow protection
-   - Implement adaptive timeout strategies
-
-## Impact Assessment
-
-These issues primarily affect:
-- **Scalability**: Blocking operations limit concurrent connection handling
-- **Responsiveness**: Event loop blocking causes latency spikes
-- **Stability**: Memory leaks could cause crashes under sustained load
-- **Resource Usage**: Inefficient resource management increases memory/CPU usage
-
-## Testing Recommendations
-
-1. Load test with high connection counts (10k+ concurrent)
-2. Monitor event loop lag under stress
-3. Test long-running scenarios to detect memory leaks
-4. Benchmark with async vs sync operations to measure improvement
-
-## Conclusion
-
-While SmartProxy has good architectural design and many best practices, the identified blocking operations and resource management issues could significantly impact performance under high load. The most critical issues (busy wait loop and synchronous filesystem operations) should be addressed immediately.