packet-events-js 1.0.0 → 1.0.1

package/src/advanced/ConnectionManager.js

@@ -0,0 +1,486 @@
+import { EventEmitter } from '../events/EventEmitter.js';
+
+export const ReconnectStrategy = Object.freeze({
+    IMMEDIATE: 'immediate',
+    LINEAR: 'linear',
+    EXPONENTIAL: 'exponential',
+    FIBONACCI: 'fibonacci'
+});
+
+export const HealthStatus = Object.freeze({
+    HEALTHY: 'healthy',
+    DEGRADED: 'degraded',
+    UNHEALTHY: 'unhealthy',
+    UNKNOWN: 'unknown'
+});
+
+export class AutoReconnect extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.enabled = options.enabled !== false;
+        this.strategy = options.strategy || ReconnectStrategy.EXPONENTIAL;
+        this.maxAttempts = options.maxAttempts || 10;
+        this.baseDelay = options.baseDelay || 1000;
+        this.maxDelay = options.maxDelay || 30000;
+        this.jitter = options.jitter !== false;
+        this.jitterFactor = options.jitterFactor || 0.1;
+        
+        this.attempts = 0;
+        this.isReconnecting = false;
+        this.lastAttempt = null;
+        this.connectFn = null;
+        this.timeoutId = null;
+        
+        this._fibCache = [1, 1];
+    }
+
+    _getFibonacci(n) {
+        while (this._fibCache.length <= n) {
+            this._fibCache.push(this._fibCache[this._fibCache.length - 1] + this._fibCache[this._fibCache.length - 2]);
+        }
+        return this._fibCache[n];
+    }
+
+    getDelay() {
+        let delay;
+        
+        switch (this.strategy) {
+            case ReconnectStrategy.IMMEDIATE:
+                delay = 0;
+                break;
+            case ReconnectStrategy.LINEAR:
+                delay = this.baseDelay * this.attempts;
+                break;
+            case ReconnectStrategy.EXPONENTIAL:
+                delay = this.baseDelay * Math.pow(2, this.attempts - 1);
+                break;
+            case ReconnectStrategy.FIBONACCI:
+                delay = this.baseDelay * this._getFibonacci(this.attempts);
+                break;
+            default:
+                delay = this.baseDelay;
+        }
+
+        if (this.jitter && delay > 0) {
+            const jitterAmount = delay * this.jitterFactor;
+            delay += (Math.random() * jitterAmount * 2) - jitterAmount;
+        }
+
+        return Math.min(Math.max(0, delay), this.maxDelay);
+    }
+
+    async start(connectFn) {
+        if (!this.enabled) return false;
+        if (this.isReconnecting) return false;
+
+        this.connectFn = connectFn;
+        this.isReconnecting = true;
+        this.attempts = 0;
+
+        return this._attemptReconnect();
+    }
+
+    async _attemptReconnect() {
+        if (!this.isReconnecting) return false;
+        if (this.attempts >= this.maxAttempts) {
+            this.isReconnecting = false;
+            this.emit('failed', { attempts: this.attempts });
+            return false;
+        }
+
+        this.attempts++;
+        this.lastAttempt = Date.now();
+        const delay = this.getDelay();
+
+        this.emit('attempt', { 
+            attempt: this.attempts, 
+            maxAttempts: this.maxAttempts,
+            delay,
+            strategy: this.strategy
+        });
+
+        if (delay > 0) {
+            await new Promise(resolve => {
+                this.timeoutId = setTimeout(resolve, delay);
+            });
+        }
+
+        if (!this.isReconnecting) return false;
+
+        try {
+            await this.connectFn();
+            this.isReconnecting = false;
+            this.emit('success', { attempts: this.attempts });
+            return true;
+        } catch (e) {
+            this.emit('error', { attempt: this.attempts, error: e.message });
+            return this._attemptReconnect();
+        }
+    }
+
+    stop() {
+        this.isReconnecting = false;
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+        this.emit('stopped');
+        return this;
+    }
+
+    reset() {
+        this.attempts = 0;
+        this.lastAttempt = null;
+        return this;
+    }
+
+    getStatus() {
+        return {
+            enabled: this.enabled,
+            isReconnecting: this.isReconnecting,
+            attempts: this.attempts,
+            maxAttempts: this.maxAttempts,
+            strategy: this.strategy,
+            nextDelay: this.getDelay(),
+            lastAttempt: this.lastAttempt
+        };
+    }
+}
+
+export class HealthMonitor extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.checkInterval = options.checkInterval || 5000;
+        this.latencyThreshold = options.latencyThreshold || 200;
+        this.packetLossThreshold = options.packetLossThreshold || 0.05;
+        this.healthyStreak = options.healthyStreak || 3;
+        
+        this.status = HealthStatus.UNKNOWN;
+        this.latencyHistory = [];
+        this.packetsSent = 0;
+        this.packetsReceived = 0;
+        this.consecutiveHealthy = 0;
+        this.consecutiveUnhealthy = 0;
+        this.intervalId = null;
+        this.checkFn = null;
+    }
+
+    start(checkFn) {
+        this.checkFn = checkFn;
+        this.intervalId = setInterval(() => this._performCheck(), this.checkInterval);
+        this.emit('start');
+        return this;
+    }
+
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.emit('stop');
+        return this;
+    }
+
+    async _performCheck() {
+        if (!this.checkFn) return;
+
+        const start = Date.now();
+        this.packetsSent++;
+
+        try {
+            await this.checkFn();
+            this.packetsReceived++;
+            
+            const latency = Date.now() - start;
+            this.recordLatency(latency);
+            
+            this._evaluateHealth();
+        } catch (e) {
+            this._evaluateHealth();
+            this.emit('checkFailed', { error: e.message });
+        }
+    }
+
+    recordLatency(ms) {
+        this.latencyHistory.push({ time: Date.now(), latency: ms });
+        if (this.latencyHistory.length > 100) {
+            this.latencyHistory.shift();
+        }
+    }
+
+    _evaluateHealth() {
+        const avgLatency = this.getAverageLatency();
+        const packetLoss = this.getPacketLoss();
+        
+        let newStatus;
+        
+        if (avgLatency > this.latencyThreshold * 2 || packetLoss > this.packetLossThreshold * 2) {
+            newStatus = HealthStatus.UNHEALTHY;
+            this.consecutiveUnhealthy++;
+            this.consecutiveHealthy = 0;
+        } else if (avgLatency > this.latencyThreshold || packetLoss > this.packetLossThreshold) {
+            newStatus = HealthStatus.DEGRADED;
+            this.consecutiveHealthy = 0;
+            this.consecutiveUnhealthy = 0;
+        } else {
+            this.consecutiveHealthy++;
+            this.consecutiveUnhealthy = 0;
+            
+            if (this.consecutiveHealthy >= this.healthyStreak) {
+                newStatus = HealthStatus.HEALTHY;
+            } else {
+                newStatus = this.status === HealthStatus.UNKNOWN ? HealthStatus.HEALTHY : this.status;
+            }
+        }
+
+        if (newStatus !== this.status) {
+            const oldStatus = this.status;
+            this.status = newStatus;
+            this.emit('statusChange', { from: oldStatus, to: newStatus });
+        }
+
+        this.emit('check', this.getReport());
+    }
+
+    getAverageLatency() {
+        if (this.latencyHistory.length === 0) return 0;
+        return this.latencyHistory.reduce((a, b) => a + b.latency, 0) / this.latencyHistory.length;
+    }
+
+    getPacketLoss() {
+        if (this.packetsSent === 0) return 0;
+        return 1 - (this.packetsReceived / this.packetsSent);
+    }
+
+    getReport() {
+        return {
+            status: this.status,
+            latency: {
+                current: this.latencyHistory.length > 0 ? this.latencyHistory[this.latencyHistory.length - 1].latency : 0,
+                average: this.getAverageLatency().toFixed(2),
+                min: this.latencyHistory.length > 0 ? Math.min(...this.latencyHistory.map(l => l.latency)) : 0,
+                max: this.latencyHistory.length > 0 ? Math.max(...this.latencyHistory.map(l => l.latency)) : 0
+            },
+            packets: {
+                sent: this.packetsSent,
+                received: this.packetsReceived,
+                loss: (this.getPacketLoss() * 100).toFixed(2) + '%'
+            },
+            consecutiveHealthy: this.consecutiveHealthy,
+            consecutiveUnhealthy: this.consecutiveUnhealthy
+        };
+    }
+
+    reset() {
+        this.latencyHistory = [];
+        this.packetsSent = 0;
+        this.packetsReceived = 0;
+        this.consecutiveHealthy = 0;
+        this.consecutiveUnhealthy = 0;
+        this.status = HealthStatus.UNKNOWN;
+        return this;
+    }
+}
+
+export class ConnectionPool extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.maxConnections = options.maxConnections || 10;
+        this.connections = new Map();
+        this.roundRobinIndex = 0;
+        this.strategy = options.strategy || 'round-robin';
+    }
+
+    add(id, connection, metadata = {}) {
+        if (this.connections.size >= this.maxConnections) {
+            throw new Error('Connection pool is full');
+        }
+
+        this.connections.set(id, {
+            connection,
+            metadata,
+            activeRequests: 0,
+            totalRequests: 0,
+            createdAt: Date.now()
+        });
+
+        this.emit('add', { id, poolSize: this.connections.size });
+        return this;
+    }
+
+    remove(id) {
+        const entry = this.connections.get(id);
+        if (entry) {
+            this.connections.delete(id);
+            this.emit('remove', { id, poolSize: this.connections.size });
+        }
+        return this;
+    }
+
+    get() {
+        if (this.connections.size === 0) return null;
+
+        const entries = [...this.connections.entries()];
+        let selected;
+
+        switch (this.strategy) {
+            case 'round-robin':
+                this.roundRobinIndex = (this.roundRobinIndex + 1) % entries.length;
+                selected = entries[this.roundRobinIndex];
+                break;
+            
+            case 'least-loaded':
+                selected = entries.reduce((min, entry) => 
+                    entry[1].activeRequests < min[1].activeRequests ? entry : min
+                );
+                break;
+            
+            case 'random':
+                selected = entries[Math.floor(Math.random() * entries.length)];
+                break;
+            
+            default:
+                selected = entries[0];
+        }
+
+        if (selected) {
+            selected[1].activeRequests++;
+            selected[1].totalRequests++;
+        }
+
+        return selected ? { id: selected[0], ...selected[1] } : null;
+    }
+
+    release(id) {
+        const entry = this.connections.get(id);
+        if (entry && entry.activeRequests > 0) {
+            entry.activeRequests--;
+        }
+        return this;
+    }
+
+    getStats() {
+        const stats = {
+            size: this.connections.size,
+            maxConnections: this.maxConnections,
+            strategy: this.strategy,
+            connections: []
+        };
+
+        for (const [id, entry] of this.connections) {
+            stats.connections.push({
+                id,
+                activeRequests: entry.activeRequests,
+                totalRequests: entry.totalRequests,
+                uptime: Date.now() - entry.createdAt,
+                metadata: entry.metadata
+            });
+        }
+
+        return stats;
+    }
+
+    clear() {
+        this.connections.clear();
+        this.roundRobinIndex = 0;
+        this.emit('clear');
+        return this;
+    }
+}
+
+export class CircuitBreaker extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.failureThreshold = options.failureThreshold || 5;
+        this.successThreshold = options.successThreshold || 3;
+        this.timeout = options.timeout || 30000;
+        
+        this.state = 'closed';
+        this.failures = 0;
+        this.successes = 0;
+        this.lastFailure = null;
+        this.timeoutId = null;
+    }
+
+    async execute(fn) {
+        if (this.state === 'open') {
+            if (Date.now() - this.lastFailure > this.timeout) {
+                this._transition('half-open');
+            } else {
+                throw new Error('Circuit breaker is open');
+            }
+        }
+
+        try {
+            const result = await fn();
+            this._onSuccess();
+            return result;
+        } catch (e) {
+            this._onFailure();
+            throw e;
+        }
+    }
+
+    _onSuccess() {
+        this.failures = 0;
+        
+        if (this.state === 'half-open') {
+            this.successes++;
+            if (this.successes >= this.successThreshold) {
+                this._transition('closed');
+            }
+        }
+    }
+
+    _onFailure() {
+        this.failures++;
+        this.lastFailure = Date.now();
+        this.successes = 0;
+
+        if (this.failures >= this.failureThreshold) {
+            this._transition('open');
+        }
+    }
+
+    _transition(newState) {
+        const oldState = this.state;
+        this.state = newState;
+        
+        if (newState === 'closed') {
+            this.failures = 0;
+            this.successes = 0;
+        }
+
+        this.emit('stateChange', { from: oldState, to: newState });
+    }
+
+    force(state) {
+        this._transition(state);
+        return this;
+    }
+
+    getStatus() {
+        return {
+            state: this.state,
+            failures: this.failures,
+            successes: this.successes,
+            failureThreshold: this.failureThreshold,
+            successThreshold: this.successThreshold,
+            lastFailure: this.lastFailure,
+            timeout: this.timeout
+        };
+    }
+}
+
+export default {
+    AutoReconnect,
+    ReconnectStrategy,
+    HealthMonitor,
+    HealthStatus,
+    ConnectionPool,
+    CircuitBreaker
+};