@push.rocks/smartproxy 21.1.3 → 21.1.5

package/dist_ts/proxies/smart-proxy/route-orchestrator.js

@@ -0,0 +1,204 @@
+import { logger } from '../../core/utils/logger.js';
+import { RouteValidator } from './utils/route-validator.js';
+import { Mutex } from './utils/mutex.js';
+/**
+ * Orchestrates route updates and coordination between components
+ * Extracted from SmartProxy to reduce class complexity
+ */
+export class RouteOrchestrator {
+    constructor(portManager, routeManager, httpProxyBridge, nftablesManager, certManager, logger) {
+        this.certManager = null;
+        this.portManager = portManager;
+        this.routeManager = routeManager;
+        this.httpProxyBridge = httpProxyBridge;
+        this.nftablesManager = nftablesManager;
+        this.certManager = certManager;
+        this.logger = logger;
+        this.routeUpdateLock = new Mutex();
+    }
+    /**
+     * Set or update certificate manager reference
+     */
+    setCertManager(certManager) {
+        this.certManager = certManager;
+    }
+    /**
+     * Get certificate manager reference
+     */
+    getCertManager() {
+        return this.certManager;
+    }
+    /**
+     * Update routes with validation and coordination
+     */
+    async updateRoutes(oldRoutes, newRoutes, options = {}) {
+        return this.routeUpdateLock.runExclusive(async () => {
+            // Validate route configurations
+            const validation = RouteValidator.validateRoutes(newRoutes);
+            if (!validation.valid) {
+                RouteValidator.logValidationErrors(validation.errors);
+                throw new Error(`Route validation failed: ${validation.errors.size} route(s) have errors`);
+            }
+            // Track port usage before and after updates
+            const oldPortUsage = this.updatePortUsageMap(oldRoutes);
+            const newPortUsage = this.updatePortUsageMap(newRoutes);
+            // Get the lists of currently listening ports and new ports needed
+            const currentPorts = new Set(this.portManager.getListeningPorts());
+            const newPortsSet = new Set(newPortUsage.keys());
+            // Log the port usage for debugging
+            this.logger.debug(`Current listening ports: ${Array.from(currentPorts).join(', ')}`);
+            this.logger.debug(`Ports needed for new routes: ${Array.from(newPortsSet).join(', ')}`);
+            // Find orphaned ports - ports that no longer have any routes
+            const orphanedPorts = this.findOrphanedPorts(oldPortUsage, newPortUsage);
+            // Find new ports that need binding (only ports that we aren't already listening on)
+            const newBindingPorts = Array.from(newPortsSet).filter(p => !currentPorts.has(p));
+            // Check for ACME challenge port to give it special handling
+            const acmePort = options.acmePort || 80;
+            const acmePortNeeded = newPortsSet.has(acmePort);
+            const acmePortListed = newBindingPorts.includes(acmePort);
+            if (acmePortNeeded && acmePortListed) {
+                this.logger.info(`Adding ACME challenge port ${acmePort} to routes`);
+            }
+            // Update NFTables routes
+            await this.updateNfTablesRoutes(oldRoutes, newRoutes);
+            // Update routes in RouteManager
+            this.routeManager.updateRoutes(newRoutes);
+            // Release orphaned ports first to free resources
+            if (orphanedPorts.length > 0) {
+                this.logger.info(`Releasing ${orphanedPorts.length} orphaned ports: ${orphanedPorts.join(', ')}`);
+                await this.portManager.removePorts(orphanedPorts);
+            }
+            // Add new ports if needed
+            if (newBindingPorts.length > 0) {
+                this.logger.info(`Binding to ${newBindingPorts.length} new ports: ${newBindingPorts.join(', ')}`);
+                // Handle port binding with improved error recovery
+                try {
+                    await this.portManager.addPorts(newBindingPorts);
+                }
+                catch (error) {
+                    // Special handling for port binding errors
+                    if (error.code === 'EADDRINUSE') {
+                        const port = error.port || newBindingPorts[0];
+                        const isAcmePort = port === acmePort;
+                        if (isAcmePort) {
+                            this.logger.warn(`Could not bind to ACME challenge port ${port}. It may be in use by another application.`);
+                            // Re-throw with more helpful message
+                            throw new Error(`ACME challenge port ${port} is already in use by another application. ` +
+                                `Configure a different port in settings.acme.port (e.g., 8080) or free up port ${port}.`);
+                        }
+                    }
+                    // Re-throw the original error for other cases
+                    throw error;
+                }
+            }
+            // If HttpProxy is initialized, resync the configurations
+            if (this.httpProxyBridge.getHttpProxy()) {
+                await this.httpProxyBridge.syncRoutesToHttpProxy(newRoutes);
+            }
+            // Update certificate manager if needed
+            let newCertManager;
+            let newChallengeRouteActive = options.globalChallengeRouteActive || false;
+            if (this.certManager && options.createCertificateManager) {
+                const existingAcmeOptions = this.certManager.getAcmeOptions();
+                const existingState = this.certManager.getState();
+                // Store global state before stopping
+                newChallengeRouteActive = existingState.challengeRouteActive;
+                // Keep certificate manager routes in sync before stopping
+                this.certManager.setRoutes(newRoutes);
+                await this.certManager.stop();
+                // Verify the challenge route has been properly removed
+                if (options.verifyChallengeRouteRemoved) {
+                    await options.verifyChallengeRouteRemoved();
+                }
+                // Create new certificate manager with preserved state
+                newCertManager = await options.createCertificateManager(newRoutes, './certs', existingAcmeOptions, { challengeRouteActive: newChallengeRouteActive });
+                this.certManager = newCertManager;
+            }
+            return {
+                portUsageMap: newPortUsage,
+                newChallengeRouteActive,
+                newCertManager
+            };
+        });
+    }
+    /**
+     * Update port usage map based on the provided routes
+     */
+    updatePortUsageMap(routes) {
+        const portUsage = new Map();
+        for (const route of routes) {
+            // Get the ports for this route
+            const portsConfig = Array.isArray(route.match.ports)
+                ? route.match.ports
+                : [route.match.ports];
+            // Expand port range objects to individual port numbers
+            const expandedPorts = [];
+            for (const portConfig of portsConfig) {
+                if (typeof portConfig === 'number') {
+                    expandedPorts.push(portConfig);
+                }
+                else if (typeof portConfig === 'object' && 'from' in portConfig && 'to' in portConfig) {
+                    // Expand the port range
+                    for (let p = portConfig.from; p <= portConfig.to; p++) {
+                        expandedPorts.push(p);
+                    }
+                }
+            }
+            // Use route name if available, otherwise generate a unique ID
+            const routeName = route.name || `unnamed_${Math.random().toString(36).substring(2, 9)}`;
+            // Add each port to the usage map
+            for (const port of expandedPorts) {
+                if (!portUsage.has(port)) {
+                    portUsage.set(port, new Set());
+                }
+                portUsage.get(port).add(routeName);
+            }
+        }
+        // Log port usage for debugging
+        for (const [port, routes] of portUsage.entries()) {
+            this.logger.debug(`Port ${port} is used by ${routes.size} routes: ${Array.from(routes).join(', ')}`);
+        }
+        return portUsage;
+    }
+    /**
+     * Find ports that have no routes in the new configuration
+     */
+    findOrphanedPorts(oldUsage, newUsage) {
+        const orphanedPorts = [];
+        for (const [port, routes] of oldUsage.entries()) {
+            if (!newUsage.has(port) || newUsage.get(port).size === 0) {
+                orphanedPorts.push(port);
+            }
+        }
+        return orphanedPorts;
+    }
+    /**
+     * Update NFTables routes
+     */
+    async updateNfTablesRoutes(oldRoutes, newRoutes) {
+        // Get existing routes that use NFTables and update them
+        const oldNfTablesRoutes = oldRoutes.filter(r => r.action.forwardingEngine === 'nftables');
+        const newNfTablesRoutes = newRoutes.filter(r => r.action.forwardingEngine === 'nftables');
+        // Update existing NFTables routes
+        for (const oldRoute of oldNfTablesRoutes) {
+            const newRoute = newNfTablesRoutes.find(r => r.name === oldRoute.name);
+            if (!newRoute) {
+                // Route was removed
+                await this.nftablesManager.deprovisionRoute(oldRoute);
+            }
+            else {
+                // Route was updated
+                await this.nftablesManager.updateRoute(oldRoute, newRoute);
+            }
+        }
+        // Add new NFTables routes
+        for (const newRoute of newNfTablesRoutes) {
+            const oldRoute = oldNfTablesRoutes.find(r => r.name === newRoute.name);
+            if (!oldRoute) {
+                // New route
+                await this.nftablesManager.provisionRoute(newRoute);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-orchestrator.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/route-orchestrator.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/smart-proxy.d.ts

@@ -43,6 +43,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     private routeUpdateLock;
     acmeStateManager: AcmeStateManager;
     metricsCollector: MetricsCollector;
+    private routeOrchestrator;
     private portUsageMap;
     /**
      * Constructor for SmartProxy
@@ -144,17 +145,6 @@ export declare class SmartProxy extends plugins.EventEmitter {
      * Manually provision a certificate for a route
      */
     provisionCertificate(routeName: string): Promise<void>;
-    /**
-     * Update the port usage map based on the provided routes
-     *
-     * This tracks which ports are used by which routes, allowing us to
-     * detect when a port is no longer needed and can be released.
-     */
-    private updatePortUsageMap;
-    /**
-     * Find ports that have no routes in the new configuration
-     */
-    private findOrphanedPorts;
     /**
      * Force renewal of a certificate
      */