@push.rocks/smartproxy 19.5.4 → 19.5.6

package/dist_ts/core/utils/enhanced-connection-pool.js

@@ -0,0 +1,320 @@
+import { LifecycleComponent } from './lifecycle-component.js';
+import { BinaryHeap } from './binary-heap.js';
+import { AsyncMutex } from './async-utils.js';
+import { EventEmitter } from 'events';
+/**
+ * Enhanced connection pool with priority queue, backpressure, and lifecycle management
+ */
+export class EnhancedConnectionPool extends LifecycleComponent {
+    constructor(options) {
+        super();
+        this.availableConnections = [];
+        this.activeConnections = new Map();
+        this.mutex = new AsyncMutex();
+        this.eventEmitter = new EventEmitter();
+        this.connectionIdCounter = 0;
+        this.requestIdCounter = 0;
+        this.isClosing = false;
+        // Metrics
+        this.metrics = {
+            connectionsCreated: 0,
+            connectionsDestroyed: 0,
+            connectionsAcquired: 0,
+            connectionsReleased: 0,
+            acquireTimeouts: 0,
+            validationFailures: 0,
+            queueHighWaterMark: 0,
+        };
+        this.options = {
+            minSize: 0,
+            maxSize: 10,
+            acquireTimeout: 30000,
+            idleTimeout: 300000, // 5 minutes
+            maxUseCount: Infinity,
+            validateOnAcquire: true,
+            validateOnReturn: false,
+            queueTimeout: 60000,
+            ...options,
+        };
+        // Initialize priority queue (higher priority = extracted first)
+        this.waitQueue = new BinaryHeap((a, b) => b.priority - a.priority || a.timestamp - b.timestamp, (item) => item.id);
+        // Start maintenance cycle
+        this.startMaintenance();
+        // Initialize minimum connections
+        this.initializeMinConnections();
+    }
+    /**
+     * Initialize minimum number of connections
+     */
+    async initializeMinConnections() {
+        const promises = [];
+        for (let i = 0; i < this.options.minSize; i++) {
+            promises.push(this.createConnection()
+                .then(conn => {
+                this.availableConnections.push(conn);
+            })
+                .catch(err => {
+                if (this.options.onConnectionError) {
+                    this.options.onConnectionError(err);
+                }
+            }));
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Start maintenance timer for idle connection cleanup
+     */
+    startMaintenance() {
+        this.setInterval(() => {
+            this.performMaintenance();
+        }, 30000); // Every 30 seconds
+    }
+    /**
+     * Perform maintenance tasks
+     */
+    async performMaintenance() {
+        await this.mutex.runExclusive(async () => {
+            const now = Date.now();
+            const toRemove = [];
+            // Check for idle connections beyond minimum size
+            for (let i = this.availableConnections.length - 1; i >= 0; i--) {
+                const conn = this.availableConnections[i];
+                // Keep minimum connections
+                if (this.availableConnections.length <= this.options.minSize) {
+                    break;
+                }
+                // Remove idle connections
+                if (now - conn.lastUsedAt > this.options.idleTimeout) {
+                    toRemove.push(conn);
+                    this.availableConnections.splice(i, 1);
+                }
+            }
+            // Destroy idle connections
+            for (const conn of toRemove) {
+                await this.destroyConnection(conn);
+            }
+        });
+    }
+    /**
+     * Acquire a connection from the pool
+     */
+    async acquire(priority = 0, timeout) {
+        if (this.isClosing) {
+            throw new Error('Connection pool is closing');
+        }
+        return this.mutex.runExclusive(async () => {
+            // Try to get an available connection
+            const connection = await this.tryAcquireConnection();
+            if (connection) {
+                return connection;
+            }
+            // Check if we can create a new connection
+            const totalConnections = this.availableConnections.length + this.activeConnections.size;
+            if (totalConnections < this.options.maxSize) {
+                try {
+                    const newConnection = await this.createConnection();
+                    return this.checkoutConnection(newConnection);
+                }
+                catch (err) {
+                    // Fall through to queue if creation fails
+                }
+            }
+            // Add to wait queue
+            return this.queueAcquireRequest(priority, timeout);
+        });
+    }
+    /**
+     * Try to acquire an available connection
+     */
+    async tryAcquireConnection() {
+        while (this.availableConnections.length > 0) {
+            const connection = this.availableConnections.shift();
+            // Check if connection exceeded max use count
+            if (connection.useCount >= this.options.maxUseCount) {
+                await this.destroyConnection(connection);
+                continue;
+            }
+            // Validate connection if required
+            if (this.options.validateOnAcquire && this.options.connectionValidator) {
+                try {
+                    const isValid = await this.options.connectionValidator(connection.connection);
+                    if (!isValid) {
+                        this.metrics.validationFailures++;
+                        await this.destroyConnection(connection);
+                        continue;
+                    }
+                }
+                catch (err) {
+                    this.metrics.validationFailures++;
+                    await this.destroyConnection(connection);
+                    continue;
+                }
+            }
+            return this.checkoutConnection(connection);
+        }
+        return null;
+    }
+    /**
+     * Checkout a connection for use
+     */
+    checkoutConnection(connection) {
+        connection.inUse = true;
+        connection.lastUsedAt = Date.now();
+        connection.useCount++;
+        this.activeConnections.set(connection.id, connection);
+        this.metrics.connectionsAcquired++;
+        this.eventEmitter.emit('acquire', connection);
+        return connection;
+    }
+    /**
+     * Queue an acquire request
+     */
+    queueAcquireRequest(priority, timeout) {
+        return new Promise((resolve, reject) => {
+            const request = {
+                id: `req-${this.requestIdCounter++}`,
+                priority,
+                timestamp: Date.now(),
+                resolve,
+                reject,
+            };
+            // Set timeout
+            const timeoutMs = timeout || this.options.queueTimeout;
+            request.timeoutHandle = this.setTimeout(() => {
+                if (this.waitQueue.extractByKey(request.id)) {
+                    this.metrics.acquireTimeouts++;
+                    reject(new Error(`Connection acquire timeout after ${timeoutMs}ms`));
+                }
+            }, timeoutMs);
+            this.waitQueue.insert(request);
+            this.metrics.queueHighWaterMark = Math.max(this.metrics.queueHighWaterMark, this.waitQueue.size);
+            this.eventEmitter.emit('enqueue', { queueSize: this.waitQueue.size });
+        });
+    }
+    /**
+     * Release a connection back to the pool
+     */
+    async release(connection) {
+        return this.mutex.runExclusive(async () => {
+            if (!connection.inUse || !this.activeConnections.has(connection.id)) {
+                throw new Error('Connection is not active');
+            }
+            this.activeConnections.delete(connection.id);
+            connection.inUse = false;
+            connection.lastUsedAt = Date.now();
+            this.metrics.connectionsReleased++;
+            // Check if connection should be destroyed
+            if (connection.useCount >= this.options.maxUseCount) {
+                await this.destroyConnection(connection);
+                return;
+            }
+            // Validate on return if required
+            if (this.options.validateOnReturn && this.options.connectionValidator) {
+                try {
+                    const isValid = await this.options.connectionValidator(connection.connection);
+                    if (!isValid) {
+                        await this.destroyConnection(connection);
+                        return;
+                    }
+                }
+                catch (err) {
+                    await this.destroyConnection(connection);
+                    return;
+                }
+            }
+            // Check if there are waiting requests
+            const request = this.waitQueue.extract();
+            if (request) {
+                this.clearTimeout(request.timeoutHandle);
+                request.resolve(this.checkoutConnection(connection));
+                this.eventEmitter.emit('dequeue', { queueSize: this.waitQueue.size });
+            }
+            else {
+                // Return to available pool
+                this.availableConnections.push(connection);
+                this.eventEmitter.emit('release', connection);
+            }
+        });
+    }
+    /**
+     * Create a new connection
+     */
+    async createConnection() {
+        const rawConnection = await this.options.connectionFactory();
+        const connection = {
+            id: `conn-${this.connectionIdCounter++}`,
+            connection: rawConnection,
+            createdAt: Date.now(),
+            lastUsedAt: Date.now(),
+            useCount: 0,
+            inUse: false,
+        };
+        this.metrics.connectionsCreated++;
+        this.eventEmitter.emit('create', connection);
+        return connection;
+    }
+    /**
+     * Destroy a connection
+     */
+    async destroyConnection(connection) {
+        try {
+            if (this.options.connectionDestroyer) {
+                await this.options.connectionDestroyer(connection.connection);
+            }
+            this.metrics.connectionsDestroyed++;
+            this.eventEmitter.emit('destroy', connection);
+        }
+        catch (err) {
+            if (this.options.onConnectionError) {
+                this.options.onConnectionError(err, connection.connection);
+            }
+        }
+    }
+    /**
+     * Get current pool statistics
+     */
+    getStats() {
+        return {
+            available: this.availableConnections.length,
+            active: this.activeConnections.size,
+            waiting: this.waitQueue.size,
+            total: this.availableConnections.length + this.activeConnections.size,
+            ...this.metrics,
+        };
+    }
+    /**
+     * Subscribe to pool events
+     */
+    on(event, listener) {
+        this.addEventListener(this.eventEmitter, event, listener);
+    }
+    /**
+     * Close the pool and cleanup resources
+     */
+    async onCleanup() {
+        this.isClosing = true;
+        // Clear the wait queue
+        while (!this.waitQueue.isEmpty()) {
+            const request = this.waitQueue.extract();
+            if (request) {
+                this.clearTimeout(request.timeoutHandle);
+                request.reject(new Error('Connection pool is closing'));
+            }
+        }
+        // Wait for active connections to be released (with timeout)
+        const timeout = 30000;
+        const startTime = Date.now();
+        while (this.activeConnections.size > 0 && Date.now() - startTime < timeout) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Destroy all connections
+        const allConnections = [
+            ...this.availableConnections,
+            ...this.activeConnections.values(),
+        ];
+        await Promise.all(allConnections.map(conn => this.destroyConnection(conn)));
+        this.availableConnections.length = 0;
+        this.activeConnections.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enhanced-connection-pool.js","sourceRoot":"","sources":["../../../ts/core/utils/enhanced-connection-pool.ts"],"names":[],"mappings":"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"}

package/dist_ts/core/utils/fs-utils.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Async filesystem utilities for SmartProxy
+ * Provides non-blocking alternatives to synchronous filesystem operations
+ */
+import * as plugins from '../../plugins.js';
+export declare class AsyncFileSystem {
+    /**
+     * Check if a file or directory exists
+     * @param path - Path to check
+     * @returns Promise resolving to true if exists, false otherwise
+     */
+    static exists(path: string): Promise<boolean>;
+    /**
+     * Ensure a directory exists, creating it if necessary
+     * @param dirPath - Directory path to ensure
+     * @returns Promise that resolves when directory is ensured
+     */
+    static ensureDir(dirPath: string): Promise<void>;
+    /**
+     * Read a file as string
+     * @param filePath - Path to the file
+     * @param encoding - File encoding (default: utf8)
+     * @returns Promise resolving to file contents
+     */
+    static readFile(filePath: string, encoding?: BufferEncoding): Promise<string>;
+    /**
+     * Read a file as buffer
+     * @param filePath - Path to the file
+     * @returns Promise resolving to file buffer
+     */
+    static readFileBuffer(filePath: string): Promise<Buffer>;
+    /**
+     * Write string data to a file
+     * @param filePath - Path to the file
+     * @param data - String data to write
+     * @param encoding - File encoding (default: utf8)
+     * @returns Promise that resolves when file is written
+     */
+    static writeFile(filePath: string, data: string, encoding?: BufferEncoding): Promise<void>;
+    /**
+     * Write buffer data to a file
+     * @param filePath - Path to the file
+     * @param data - Buffer data to write
+     * @returns Promise that resolves when file is written
+     */
+    static writeFileBuffer(filePath: string, data: Buffer): Promise<void>;
+    /**
+     * Remove a file
+     * @param filePath - Path to the file
+     * @returns Promise that resolves when file is removed
+     */
+    static remove(filePath: string): Promise<void>;
+    /**
+     * Remove a directory and all its contents
+     * @param dirPath - Path to the directory
+     * @returns Promise that resolves when directory is removed
+     */
+    static removeDir(dirPath: string): Promise<void>;
+    /**
+     * Read JSON from a file
+     * @param filePath - Path to the JSON file
+     * @returns Promise resolving to parsed JSON
+     */
+    static readJSON<T = any>(filePath: string): Promise<T>;
+    /**
+     * Write JSON to a file
+     * @param filePath - Path to the file
+     * @param data - Data to write as JSON
+     * @param pretty - Whether to pretty-print JSON (default: true)
+     * @returns Promise that resolves when file is written
+     */
+    static writeJSON(filePath: string, data: any, pretty?: boolean): Promise<void>;
+    /**
+     * Copy a file from source to destination
+     * @param source - Source file path
+     * @param destination - Destination file path
+     * @returns Promise that resolves when file is copied
+     */
+    static copyFile(source: string, destination: string): Promise<void>;
+    /**
+     * Move/rename a file
+     * @param source - Source file path
+     * @param destination - Destination file path
+     * @returns Promise that resolves when file is moved
+     */
+    static moveFile(source: string, destination: string): Promise<void>;
+    /**
+     * Get file stats
+     * @param filePath - Path to the file
+     * @returns Promise resolving to file stats or null if doesn't exist
+     */
+    static getStats(filePath: string): Promise<plugins.fs.Stats | null>;
+    /**
+     * List files in a directory
+     * @param dirPath - Directory path
+     * @returns Promise resolving to array of filenames
+     */
+    static listFiles(dirPath: string): Promise<string[]>;
+    /**
+     * List files in a directory with full paths
+     * @param dirPath - Directory path
+     * @returns Promise resolving to array of full file paths
+     */
+    static listFilesFullPath(dirPath: string): Promise<string[]>;
+    /**
+     * Recursively list all files in a directory
+     * @param dirPath - Directory path
+     * @param fileList - Accumulator for file list (used internally)
+     * @returns Promise resolving to array of all file paths
+     */
+    static listFilesRecursive(dirPath: string, fileList?: string[]): Promise<string[]>;
+    /**
+     * Create a read stream for a file
+     * @param filePath - Path to the file
+     * @param options - Stream options
+     * @returns Read stream
+     */
+    static createReadStream(filePath: string, options?: Parameters<typeof plugins.fs.createReadStream>[1]): plugins.fs.ReadStream;
+    /**
+     * Create a write stream for a file
+     * @param filePath - Path to the file
+     * @param options - Stream options
+     * @returns Write stream
+     */
+    static createWriteStream(filePath: string, options?: Parameters<typeof plugins.fs.createWriteStream>[1]): plugins.fs.WriteStream;
+    /**
+     * Ensure a file exists, creating an empty file if necessary
+     * @param filePath - Path to the file
+     * @returns Promise that resolves when file is ensured
+     */
+    static ensureFile(filePath: string): Promise<void>;
+    /**
+     * Check if a path is a directory
+     * @param path - Path to check
+     * @returns Promise resolving to true if directory, false otherwise
+     */
+    static isDirectory(path: string): Promise<boolean>;
+    /**
+     * Check if a path is a file
+     * @param path - Path to check
+     * @returns Promise resolving to true if file, false otherwise
+     */
+    static isFile(path: string): Promise<boolean>;
+}