vantiv.io 1.0.0

package/src/classes/Managers/Networking/CooldownManager.js

@@ -0,0 +1,516 @@
+
+class CooldownManager {
+    constructor() {
+        this.cooldowns = new Map();
+        this.globalCooldowns = new Map();
+        this.groups = new Map();
+        this.stats = {
+            totalChecks: 0,
+            blockedActions: 0,
+            successfulActions: 0,
+            averageCooldownTime: 0
+        };
+    }
+
+    /**
+     * Set a cooldown for a specific key
+     * @param {string} key - Unique identifier (e.g., 'user:command' or 'userId:action')
+     * @param {number} durationMs - Cooldown duration in milliseconds
+     * @param {Object} [metadata] - Optional metadata stored with cooldown
+     * @returns {boolean} - Returns true if cooldown was set, false if already on cooldown
+     */
+    set(key, durationMs, metadata = {}) {
+        const now = Date.now();
+        const expiresAt = now + durationMs;
+
+        
+        if (this.check(key)) {
+            this.stats.blockedActions++;
+            return false;
+        }
+
+        this.cooldowns.set(key, {
+            expiresAt,
+            duration: durationMs,
+            metadata: {
+                ...metadata,
+                setAt: now,
+                key
+            }
+        });
+
+        this.stats.successfulActions++;
+        return true;
+    }
+
+    /**
+     * Check if a key is on cooldown
+     * @param {string} key - Key to check
+     * @param {boolean} [autoCleanup=true] - Automatically remove expired cooldowns
+     * @returns {Object|null} - Cooldown info if active, null if not on cooldown
+     */
+    check(key, autoCleanup = true) {
+        this.stats.totalChecks++;
+
+        if (autoCleanup) {
+            this._cleanupExpired();
+        }
+
+        const cooldown = this.cooldowns.get(key);
+        if (!cooldown) return null;
+
+        const now = Date.now();
+        if (now >= cooldown.expiresAt) {
+            this.cooldowns.delete(key);
+            return null;
+        }
+
+        return {
+            ...cooldown,
+            remainingMs: cooldown.expiresAt - now,
+            remainingSeconds: Math.ceil((cooldown.expiresAt - now) / 1000),
+            progress: 1 - ((cooldown.expiresAt - now) / cooldown.duration)
+        };
+    }
+
+    /**
+     * Get remaining time for a cooldown
+     * @param {string} key - Key to check
+     * @returns {number} - Remaining milliseconds (0 if no cooldown)
+     */
+    getRemaining(key) {
+        const cooldown = this.check(key);
+        return cooldown ? cooldown.remainingMs : 0;
+    }
+
+    /**
+     * Attempt to execute if not on cooldown, otherwise return remaining time
+     * @param {string} key - Key to check
+     * @param {number} durationMs - Cooldown duration if executed
+     * @param {Function} [callback] - Optional callback to execute if not on cooldown
+     * @returns {Object} - Result object
+     */
+    attempt(key, durationMs, callback = null) {
+        const cooldown = this.check(key);
+        
+        if (cooldown) {
+            return {
+                success: false,
+                onCooldown: true,
+                remainingMs: cooldown.remainingMs,
+                remainingSeconds: cooldown.remainingSeconds,
+                data: cooldown.metadata
+            };
+        }
+
+        
+        this.set(key, durationMs);
+
+        
+        let result = null;
+        let error = null;
+        
+        if (callback) {
+            try {
+                result = callback();
+            } catch (err) {
+                error = err;
+            }
+        }
+
+        return {
+            success: true,
+            onCooldown: false,
+            executed: callback !== null,
+            result,
+            error,
+            cooldownSet: true,
+            durationMs
+        };
+    }
+
+    /**
+     * Remove a cooldown
+     * @param {string} key - Key to remove
+     * @returns {boolean} - True if removed, false if not found
+     */
+    remove(key) {
+        return this.cooldowns.delete(key);
+    }
+
+    /**
+     * Clear all cooldowns (or by prefix)
+     * @param {string} [prefix] - Optional prefix to filter keys
+     * @returns {number} - Number of cooldowns cleared
+     */
+    clear(prefix = null) {
+        if (!prefix) {
+            const count = this.cooldowns.size;
+            this.cooldowns.clear();
+            return count;
+        }
+
+        let count = 0;
+        for (const key of this.cooldowns.keys()) {
+            if (key.startsWith(prefix)) {
+                this.cooldowns.delete(key);
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /**
+     * Set a global cooldown (affects all users)
+     * @param {string} action - Action identifier
+     * @param {number} durationMs - Cooldown duration
+     * @returns {boolean} - True if set, false if already active
+     */
+    setGlobal(action, durationMs) {
+        const now = Date.now();
+        
+        if (this.checkGlobal(action)) {
+            return false;
+        }
+
+        this.globalCooldowns.set(action, {
+            expiresAt: now + durationMs,
+            duration: durationMs,
+            setAt: now
+        });
+
+        return true;
+    }
+
+    /**
+     * Check global cooldown
+     * @param {string} action - Action identifier
+     * @returns {Object|null} - Cooldown info if active
+     */
+    checkGlobal(action) {
+        const cooldown = this.globalCooldowns.get(action);
+        if (!cooldown) return null;
+
+        const now = Date.now();
+        if (now >= cooldown.expiresAt) {
+            this.globalCooldowns.delete(action);
+            return null;
+        }
+
+        return {
+            ...cooldown,
+            remainingMs: cooldown.expiresAt - now
+        };
+    }
+
+    /**
+     * Create a cooldown group
+     * @param {string} groupName - Group identifier
+     * @param {Object} config - Group configuration
+     */
+    createGroup(groupName, config = {}) {
+        this.groups.set(groupName, {
+            config: {
+                defaultDuration: config.defaultDuration || 5000,
+                maxConcurrent: config.maxConcurrent || 1,
+                perUserLimit: config.perUserLimit || null,
+                ...config
+            },
+            active: new Map(),
+            usage: []
+        });
+    }
+
+    /**
+     * Check group cooldown with rate limiting
+     * @param {string} groupName - Group identifier
+     * @param {string} userId - User identifier
+     * @returns {Object} - Result object
+     */
+    checkGroup(groupName, userId = null) {
+        const group = this.groups.get(groupName);
+        if (!group) {
+            throw new Error(`Group '${groupName}' not found`);
+        }
+
+        const now = Date.now();
+        const { maxConcurrent, perUserLimit, defaultDuration } = group.config;
+
+        
+        if (group.active.size >= maxConcurrent) {
+            return {
+                allowed: false,
+                reason: 'max_concurrent',
+                message: `Maximum ${maxConcurrent} concurrent actions allowed`
+            };
+        }
+
+        
+        if (userId && perUserLimit) {
+            const userCount = Array.from(group.active.values())
+                .filter(entry => entry.userId === userId).length;
+            
+            if (userCount >= perUserLimit) {
+                return {
+                    allowed: false,
+                    reason: 'user_limit',
+                    message: `User limit of ${perUserLimit} actions reached`
+                };
+            }
+        }
+
+        
+        if (userId) {
+            const userKey = `${groupName}:user:${userId}`;
+            const cooldown = this.check(userKey, false);
+            
+            if (cooldown) {
+                return {
+                    allowed: false,
+                    reason: 'user_cooldown',
+                    remainingMs: cooldown.remainingMs,
+                    message: `Please wait ${cooldown.remainingSeconds}s`
+                };
+            }
+        }
+
+        return {
+            allowed: true,
+            duration: defaultDuration
+        };
+    }
+
+    /**
+     * Start a group action
+     * @param {string} groupName - Group identifier
+     * @param {string} actionId - Unique action identifier
+     * @param {string} [userId] - Optional user identifier
+     * @returns {Object} - Result object
+     */
+    startGroupAction(groupName, actionId, userId = null) {
+        const group = this.groups.get(groupName);
+        if (!group) {
+            throw new Error(`Group '${groupName}' not found`);
+        }
+
+        const check = this.checkGroup(groupName, userId);
+        if (!check.allowed) {
+            return check;
+        }
+
+        const now = Date.now();
+        
+        
+        if (userId) {
+            const userKey = `${groupName}:user:${userId}`;
+            this.set(userKey, group.config.defaultDuration, { group: groupName, userId });
+        }
+
+        
+        group.active.set(actionId, {
+            startedAt: now,
+            userId,
+            actionId
+        });
+
+        
+        group.usage.push({
+            actionId,
+            userId,
+            startedAt: now,
+            group: groupName
+        });
+
+        
+        if (group.usage.length > 1000) {
+            group.usage = group.usage.slice(-500);
+        }
+
+        return {
+            success: true,
+            actionId,
+            startedAt: now,
+            duration: group.config.defaultDuration
+        };
+    }
+
+    /**
+     * End a group action
+     * @param {string} groupName - Group identifier
+     * @param {string} actionId - Action identifier
+     * @returns {boolean} - True if ended
+     */
+    endGroupAction(groupName, actionId) {
+        const group = this.groups.get(groupName);
+        if (!group) return false;
+
+        return group.active.delete(actionId);
+    }
+
+    /**
+     * Get formatted time string
+     * @param {number} ms - Milliseconds
+     * @returns {string} - Formatted time (e.g., "1m 30s")
+     */
+    static formatTime(ms) {
+        if (ms < 1000) return `${ms}ms`;
+        
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+
+        const parts = [];
+        
+        if (days > 0) parts.push(`${days}d`);
+        if (hours % 24 > 0) parts.push(`${hours % 24}h`);
+        if (minutes % 60 > 0) parts.push(`${minutes % 60}m`);
+        if (seconds % 60 > 0) parts.push(`${seconds % 60}s`);
+
+        return parts.join(' ') || '0s';
+    }
+
+    /**
+     * Get user's cooldowns
+     * @param {string} userId - User identifier
+     * @returns {Array} - Array of active cooldowns
+     */
+    getUserCooldowns(userId) {
+        const userCooldowns = [];
+        
+        for (const [key, cooldown] of this.cooldowns) {
+            if (key.includes(`:${userId}:`) || key.endsWith(`:${userId}`)) {
+                const remaining = cooldown.expiresAt - Date.now();
+                if (remaining > 0) {
+                    userCooldowns.push({
+                        key,
+                        remainingMs: remaining,
+                        expiresAt: cooldown.expiresAt,
+                        metadata: cooldown.metadata
+                    });
+                }
+            }
+        }
+
+        return userCooldowns;
+    }
+
+    /**
+     * Get statistics
+     * @returns {Object} - Statistics object
+     */
+    getStats() {
+        const now = Date.now();
+        const activeCooldowns = Array.from(this.cooldowns.values())
+            .filter(c => c.expiresAt > now).length;
+
+        const activeGlobals = Array.from(this.globalCooldowns.values())
+            .filter(c => c.expiresAt > now).length;
+
+        let groupStats = {};
+        for (const [name, group] of this.groups) {
+            groupStats[name] = {
+                active: group.active.size,
+                totalUsage: group.usage.length,
+                config: group.config
+            };
+        }
+
+        return {
+            ...this.stats,
+            activeCooldowns,
+            activeGlobals,
+            groups: groupStats,
+            memoryUsage: this._estimateMemoryUsage()
+        };
+    }
+
+    /**
+     * Estimate memory usage
+     * @private
+     */
+    _estimateMemoryUsage() {
+        
+        const cooldownBytes = this.cooldowns.size * 100;
+        const globalBytes = this.globalCooldowns.size * 80;
+        const groupBytes = Array.from(this.groups.values())
+            .reduce((sum, group) => sum + (group.active.size * 120) + (group.usage.length * 200), 0);
+
+        return {
+            cooldowns: `${Math.round(cooldownBytes / 1024)}KB`,
+            globals: `${Math.round(globalBytes / 1024)}KB`,
+            groups: `${Math.round(groupBytes / 1024)}KB`,
+            total: `${Math.round((cooldownBytes + globalBytes + groupBytes) / 1024)}KB`
+        };
+    }
+
+    /**
+     * Cleanup expired cooldowns
+     * @private
+     */
+    _cleanupExpired() {
+        const now = Date.now();
+        let cleaned = 0;
+
+        for (const [key, cooldown] of this.cooldowns) {
+            if (now >= cooldown.expiresAt) {
+                this.cooldowns.delete(key);
+                cleaned++;
+            }
+        }
+
+        for (const [action, cooldown] of this.globalCooldowns) {
+            if (now >= cooldown.expiresAt) {
+                this.globalCooldowns.delete(action);
+            }
+        }
+
+        return cleaned;
+    }
+
+    /**
+     * Auto-cleanup every minute
+     */
+    startAutoCleanup(intervalMs = 60000) {
+        if (this._cleanupInterval) {
+            clearInterval(this._cleanupInterval);
+        }
+
+        this._cleanupInterval = setInterval(() => {
+            const cleaned = this._cleanupExpired();
+            if (cleaned > 0) {
+                
+            }
+        }, intervalMs);
+
+        return this._cleanupInterval;
+    }
+
+    /**
+     * Stop auto-cleanup
+     */
+    stopAutoCleanup() {
+        if (this._cleanupInterval) {
+            clearInterval(this._cleanupInterval);
+            this._cleanupInterval = null;
+        }
+    }
+
+    /**
+     * Destroy all resources
+     */
+    destroy() {
+        this.stopAutoCleanup();
+        this.cooldowns.clear();
+        this.globalCooldowns.clear();
+        this.groups.clear();
+        this.stats = {
+            totalChecks: 0,
+            blockedActions: 0,
+            successfulActions: 0,
+            averageCooldownTime: 0
+        };
+    }
+}
+
+module.exports = CooldownManager;

package/src/classes/Managers/Networking/EventsManager.js

@@ -0,0 +1,64 @@
+const { 
+    UserLeftHandler,
+    VoiceEventHandler,
+    UserJoinedHandler,
+    TipReactionHandler,
+    DirectEventHandler,
+    MessageEventHandler,
+    UserMovementHandler,
+    RoomModerateHandler,
+    HiddenChannelHandler,
+    SessionMetadataHandler,
+} = require('highrise-core/src/classes/Handlers/EventHandlers');
+
+class EventsManager {
+    constructor(server) {
+        this.server = server;
+        this._handlers = new Map();
+        this._registerDefaultHandlers();
+    }
+
+    _registerDefaultHandlers() {
+        this._handlers.set('VoiceEvent', VoiceEventHandler);
+        this._handlers.set('UserLeftEvent', UserLeftHandler);
+        this._handlers.set('ChatEvent', MessageEventHandler);
+        this._handlers.set('MessageEvent', DirectEventHandler);
+        this._handlers.set('WhisperEvent', MessageEventHandler);
+        this._handlers.set('ChannelEvent', HiddenChannelHandler);
+        this._handlers.set('UserJoinedEvent', UserJoinedHandler);
+        this._handlers.set('UserMovedEvent', UserMovementHandler);
+        this._handlers.set('TipReactionEvent', TipReactionHandler);
+        this._handlers.set('SessionMetadata', SessionMetadataHandler);
+        this._handlers.set('RoomModeratedEvent', RoomModerateHandler);
+    }
+
+    registerHandler(eventType, handler) {
+        this._handlers.set(eventType, handler);
+    }
+
+    unregisterHandler(eventType) {
+        this._handlers.delete(eventType);
+    }
+
+    handleEvent(event) {
+        const eventType = event._type;
+        const handler = this._handlers.get(eventType);
+        
+        if (handler) {
+            handler(this.server, event);
+        } else {
+            this.server.emit('unhandledEvent', eventType, event);
+        }
+    }
+
+    clearHandlers(eventType = null) {
+        if (eventType) {
+            this._handlers.delete(eventType);
+        } else {
+            this._handlers.clear();
+            this._registerDefaultHandlers();
+        }
+    }
+}
+
+module.exports = EventsManager;

package/src/classes/Managers/Networking/KeepAliveManager.js

@@ -0,0 +1,109 @@
+const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+const crypto = require('crypto');
+
+class KeepAliveManager {
+    constructor(connectionManager, logger) {
+        this.connectionManager = connectionManager;
+        this.logger = logger;
+        
+        this.interval = null;
+        this.lastKeepaliveSent = 0;
+        this.lastPongReceived = 0;
+        this.consecutiveNoPong = 0;
+        this.maxConsecutiveNoPong = 3;
+        this.firstKeepaliveSent = false;
+    }
+    
+    start() {
+        this.stop();
+        
+        this.firstKeepaliveSent = false;
+        
+        this._sendKeepAlive();
+        
+        this.interval = setInterval(() => {
+            this._sendKeepAlive();
+        }, WebSocketConstants.KEEPALIVE_INTERVAL);
+        
+        this.logger.info('KeepAliveManager', 'Keep-alive started');
+    }
+    
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        this.consecutiveNoPong = 0;
+        this.firstKeepaliveSent = false;
+    }
+    
+    _sendKeepAlive() {
+        if (!this.connectionManager.isConnected()) {
+            this.logger.debug('KeepAliveManager', 'Skipping keepalive');
+            return;
+        }
+        
+        try {
+            const keepalive = {
+                _type: 'KeepaliveRequest',
+                rid: crypto.randomUUID()
+            };
+            
+            this.connectionManager.send(keepalive);
+            this.lastKeepaliveSent = Date.now();
+            
+            if (!this.firstKeepaliveSent) {
+                this.firstKeepaliveSent = true;
+                this.lastPongReceived = Date.now();
+                return;
+            }
+            
+        } catch (error) {
+            this.logger.error('KeepAliveManager', 'Failed to send keepalive', {
+                error: error.message
+            });
+        }
+    }
+    
+    _forceReconnect() {
+        if (this.connectionManager.isConnected()) {
+            this.connectionManager.disconnect(
+                WebSocketConstants.ERROR_CODES.ABNORMAL_CLOSURE,
+                'Keepalive timeout'
+            );
+        }
+        this.consecutiveNoPong = 0;
+    }
+    
+    handlePong() {
+        this.lastPongReceived = Date.now();
+        this.consecutiveNoPong = 0;
+        
+        const latency = this.lastPongReceived - this.lastKeepaliveSent;
+        if (latency > 10000) {
+            this.logger.warn('KeepAliveManager', `High latency: ${latency}ms`);
+        }
+    }
+    
+    getStats() {
+        const timeSinceLastPong = Date.now() - this.lastPongReceived;
+        const timeSinceLastKeepalive = Date.now() - this.lastKeepaliveSent;
+        
+        return {
+            isActive: this.interval !== null,
+            lastKeepaliveSent: this.lastKeepaliveSent,
+            lastPongReceived: this.lastPongReceived,
+            timeSinceLastPong: timeSinceLastPong,
+            timeSinceLastKeepalive: timeSinceLastKeepalive,
+            consecutiveNoPong: this.consecutiveNoPong,
+            healthStatus: this.firstKeepaliveSent ? (timeSinceLastPong < 45000 ? 'healthy' : 'degraded') : 'initializing'
+        };
+    }
+    
+    forceKeepAlive() {
+        this._sendKeepAlive();
+        this.logger.info('KeepAliveManager', 'Manual keepalive sent');
+    }
+}
+
+module.exports = KeepAliveManager;