aqualink 2.7.1 → 2.7.2

package/build/structures/Aqua.js

@@ -62,8 +62,16 @@ class Aqua extends EventEmitter {
         this._failoverQueue = new Map();
         this._lastFailoverAttempt = new Map();
 
+        this._brokenPlayers = new Map();
+        this._nodeReconnectHandlers = new Map();
+
         this._boundCleanupPlayer = this.cleanupPlayer.bind(this);
         this._boundHandlePlayerDestroy = this._handlePlayerDestroy.bind(this);
+        this._boundHandleNodeReconnect = this._handleNodeReconnect.bind(this);
+        this._boundHandleSocketClosed = this._handleSocketClosed.bind(this);
+
+        this.on('nodeConnect', (node) => this._handleNodeReconnect(node));
+        this.on('nodeDisconnect', (node) => this._handleSocketClosed(node));
     }
 
     defaultSendFunction(packet) {
@@ -128,6 +136,7 @@ class Aqua extends EventEmitter {
         this.destroyNode(nodeId);
 
         const node = new Node(this, options, this.options);
+        node.players = new Set();
         this.nodeMap.set(nodeId, node);
         this._invalidateCache();
 
@@ -144,6 +153,116 @@ class Aqua extends EventEmitter {
         }
     }
 
+    async _handleNodeReconnect(node) {
+        if (!this.autoResume) return;
+
+        const nodeId = node.name || node.host;
+        this.emit("debug", "Aqua", `Node ${nodeId} reconnected, attempting to rebuild broken players`);
+
+        this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false });
+
+        await this._rebuildBrokenPlayers(node);
+    }
+
+    async _handleSocketClosed(node) {
+        if (!this.autoResume) return;
+
+        const nodeId = node.name || node.host;
+        this.emit("debug", "Aqua", `Socket closed for node ${nodeId}, storing broken players`);
+
+        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
+
+        await this._storeBrokenPlayersForNode(node);
+    }
+
+    async _storeBrokenPlayersForNode(node) {
+        const nodeId = node.name || node.host;
+        const affectedPlayers = await this._getPlayersForNode(node);
+
+
+        for (const player of affectedPlayers) {
+            try {
+                const playerState = this._capturePlayerState(player);
+                if (playerState) {
+                    playerState.originalNodeId = nodeId;
+                    playerState.brokenAt = Date.now();
+                    this._brokenPlayers.set(player.guildId, playerState);
+
+                    this.emit("debug", "Aqua", `Stored broken player state for guild ${player.guildId}`);
+                }
+            } catch (error) {
+                this.emit("error", null, new Error(`Failed to store broken player state: ${error.message}`));
+            }
+        }
+    }
+
+    async _getPlayersForNode(node) {
+        const affectedPlayers = [];
+        for (const player of this.players.values()) {
+            if (player.nodes === node || player.nodes?.name === node.name) {
+                affectedPlayers.push(player);
+            }
+        }
+        return affectedPlayers;
+    }
+
+    async _rebuildBrokenPlayers(node) {
+        const nodeId = node.name || node.host;
+        const rebuiltCount = 0;
+
+
+
+        for (const [guildId, brokenState] of this._brokenPlayers.entries()) {
+            if (brokenState.originalNodeId !== nodeId) continue;
+            try {
+                await this._rebuildPlayer(brokenState, node);
+                this._brokenPlayers.delete(guildId);
+                rebuiltCount++;
+
+
+                this.emit("debug", "Aqua", `Successfully rebuilt player for guild ${guildId}`);
+            } catch (error) {
+                this.emit("error", null, new Error(`Failed to rebuild player for guild ${guildId}: ${error.message}`));
+
+                if (Date.now() - brokenState.brokenAt > 300000) {
+                    this._brokenPlayers.delete(guildId);
+                }
+            }
+        }
+
+        if (rebuiltCount > 0) {
+            this.emit("playersRebuilt", node, rebuiltCount);
+        }
+    }
+
+    async _rebuildPlayer(brokenState, targetNode) {
+        const { guildId, textChannel, voiceChannel, current, volume = 65, deaf = true } = brokenState;
+
+        const connectionOptions = { guildId, textChannel, voiceChannel, defaultVolume: volume, deaf };
+        const existingPlayer = this.players.get(guildId);
+
+        if (existingPlayer) {
+            await existingPlayer.destroy();
+        }
+
+        setTimeout(async () => {
+            const newestPlayer = await this.createConnection(connectionOptions);
+            this.players.set(guildId, newestPlayer);
+
+            if (current) {
+                try {
+                    await newestPlayer.queue.add(current);
+                    await newestPlayer.play();
+                } catch (error) {
+                    console.error("Error while playing track:", error);
+                }
+            }
+
+            this.emit("trackStart", newestPlayer, brokenState.current);
+            return newestPlayer;
+        }, 2000);
+    }
+
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
@@ -153,6 +272,11 @@ class Aqua extends EventEmitter {
     }
 
     _cleanupNode(nodeId) {
+        const node = this.nodeMap.get(nodeId);
+        if (node) {
+            node.removeAllListeners();
+        }
+
         this.nodeMap.delete(nodeId);
         this._nodeStates.delete(nodeId);
         this._failoverQueue.delete(nodeId);
@@ -186,7 +310,7 @@ class Aqua extends EventEmitter {
         try {
             this.emit("nodeFailover", failedNode);
 
-            const affectedPlayers = this._getPlayersForNode(failedNode);
+            const affectedPlayers = Array.from(failedNode.players);
             if (affectedPlayers.length === 0) {
                 this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
                 return;
@@ -215,22 +339,6 @@ class Aqua extends EventEmitter {
         }
     }
 
-    _getPlayersForNode(node) {
-        const affectedPlayers = [];
-        for (const player of this.players.values()) {
-            if (player.nodes === node || player.nodes?.name === node.name) {
-                affectedPlayers.push(player);
-            }
-        }
-        return affectedPlayers;
-    }
-
-    _getAvailableNodesForFailover(failedNode) {
-        return this.leastUsedNodes.filter(node =>
-            node !== failedNode && node.name !== failedNode.name
-        );
-    }
-
     async _migratePlayersWithRetry(players, availableNodes) {
         const results = [];
 
@@ -275,7 +383,6 @@ class Aqua extends EventEmitter {
 
                 await this._restorePlayerState(newPlayer, playerState);
 
-                newPlayer.destroy();
                 if (playerState.current) {
                     newPlayer.queue.add(playerState.current);
                 }
@@ -316,13 +423,12 @@ class Aqua extends EventEmitter {
                 position: player.position || 0,
                 current: player.current ? { ...player.current } : null,
                 queue: player.queue?.tracks ? [...player.queue.tracks] : [],
-                repeat: player.repeat,
+                repeat: player.loop,
                 shuffle: player.shuffle,
                 deaf: player.deaf || false,
                 mute: player.mute || false,
-                region: player.region,
-                requester: player.requester,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                connected: player.connected || false,
             };
         } catch (error) {
             return null;
@@ -347,22 +453,18 @@ class Aqua extends EventEmitter {
         if (!newPlayer || !playerState) return;
 
         try {
-            // Batch operations where possible
             const operations = [];
 
             if (playerState.volume !== undefined) {
                 operations.push(newPlayer.setVolume(playerState.volume));
             }
 
-            // Restore queue efficiently
             if (playerState.queue?.length > 0) {
                 newPlayer.queue.add(...playerState.queue);
             }
 
-            // Wait for all operations
             await Promise.all(operations);
 
-            // Handle current track restoration
             if (playerState.current && this.failoverOptions.preservePosition) {
                 newPlayer.queue.unshift(playerState.current);
 
@@ -370,7 +472,7 @@ class Aqua extends EventEmitter {
                     await newPlayer.play();
 
                     if (playerState.position > 0) {
-                        await this._delay(300); // Reduced delay
+                        await this._delay(300);
                         await newPlayer.seek(playerState.position);
                     }
 
@@ -380,7 +482,6 @@ class Aqua extends EventEmitter {
                 }
             }
 
-            // Restore other properties
             Object.assign(newPlayer, {
                 repeat: playerState.repeat,
                 shuffle: playerState.shuffle
@@ -395,7 +496,6 @@ class Aqua extends EventEmitter {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
 
-    // Optimized cleanup
     async cleanupPlayer(player) {
         if (!player) return;
         try {
@@ -434,7 +534,6 @@ class Aqua extends EventEmitter {
             }
         }
 
-        // Optimized sorting with caching
         const loadCache = new Map();
         regionNodes.sort((a, b) => {
             const loadA = loadCache.get(a) ?? (loadCache.set(a, this._calculateLoad(a)), loadCache.get(a));
@@ -469,7 +568,6 @@ class Aqua extends EventEmitter {
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
 
-        // Use pre-bound method for better performance
         player.once("destroy", this._boundHandlePlayerDestroy);
         player.connect(options);
         this.emit("playerCreate", player);
@@ -477,6 +575,10 @@ class Aqua extends EventEmitter {
     }
 
     _handlePlayerDestroy(player) {
+        const node = player.nodes;
+        if (node && node.players) {
+            node.players.delete(player);
+        }
         this.players.delete(player.guildId);
         this.emit("playerDestroy", player);
     }
@@ -714,6 +816,44 @@ class Aqua extends EventEmitter {
         });
     }
 
+    // Auto-resume utility methods
+    getBrokenPlayersCount() {
+        return this._brokenPlayers.size;
+    }
+
+    getBrokenPlayers() {
+        return Array.from(this._brokenPlayers.entries()).map(([guildId, state]) => ({
+            guildId,
+            originalNodeId: state.originalNodeId,
+            brokenAt: state.brokenAt,
+            hasCurrentTrack: !!state.current,
+            queueSize: state.queue?.length || 0
+        }));
+    }
+
+    clearBrokenPlayers() {
+        this._brokenPlayers.clear();
+    }
+
+    async forceBrokenPlayerRebuild(guildId) {
+        const brokenState = this._brokenPlayers.get(guildId);
+        if (!brokenState) return false;
+
+        try {
+            const targetNode = this.nodeMap.get(brokenState.originalNodeId) || this.leastUsedNodes[0];
+            if (!targetNode || !targetNode.connected) {
+                throw new Error("No available nodes for rebuild");
+            }
+
+            await this._rebuildPlayer(brokenState, targetNode);
+            this._brokenPlayers.delete(guildId);
+            return true;
+        } catch (error) {
+            this.emit("error", null, new Error(`Failed to force rebuild player for guild ${guildId}: ${error.message}`));
+            return false;
+        }
+    }
+
     // Utility methods
     resetFailoverAttempts(nodeId) {
         this._failoverQueue.delete(nodeId);

package/build/structures/Node.js

@@ -1,5 +1,4 @@
 "use strict";
-
 const WebSocket = require('ws');
 const Rest = require("./Rest");
 
@@ -30,6 +29,9 @@ class Node {
         this.sessionId = sessionId;
         this.regions = regions;
 
+        this.wsUrl = `ws${this.secure ? "s" : ""}://${this.host}:${this.port}/v4/websocket`;
+        this.rest = new Rest(aqua, this);
+
         const {
             resumeTimeout = 60,
             autoResume = false,
@@ -44,24 +46,19 @@ class Node {
         this.reconnectTries = reconnectTries;
         this.infiniteReconnects = infiniteReconnects;
 
-        this.wsUrl = `ws${this.secure ? "s" : ""}://${this.host}:${this.port}/v4/websocket`;
-        this.rest = new Rest(aqua, this);
-        this._headers = this._constructHeaders();
-
         this.connected = false;
-        this.isDestroyed = false;
         this.info = null;
         this.ws = null;
         this.reconnectAttempted = 0;
         this.reconnectTimeoutId = null;
-        this.lastHealthCheck = Date.now();
+        this.isDestroyed = false;
 
-        // Pre-bind event handlers for efficiency
         this._onOpen = this._onOpen.bind(this);
         this._onError = this._onError.bind(this);
         this._onMessage = this._onMessage.bind(this);
         this._onClose = this._onClose.bind(this);
 
+        this._headers = this._constructHeaders();
         this.initializeStats();
     }
 
@@ -94,11 +91,7 @@ class Node {
     async _onOpen() {
         this.connected = true;
         this.reconnectAttempted = 0;
-        this.lastHealthCheck = Date.now();
         this.aqua.emit("debug", this.name, "WebSocket connection established");
-        
-        clearTimeout(this.reconnectTimeoutId);
-        this.reconnectTimeoutId = null;
 
         if (this.aqua.bypassChecks?.nodeFetchInfo) return;
 
@@ -107,7 +100,7 @@ class Node {
             this.aqua.emit("nodeConnected", this);
 
             if (this.autoResume && this.sessionId) {
-                await this.resumePlayers();
+                await this.aqua.loadPlayers();
             }
         } catch (err) {
             this.info = null;
@@ -131,8 +124,7 @@ class Node {
         const { op, guildId } = payload;
         if (!op) return;
 
-        this.lastHealthCheck = Date.now();
-        
+
         switch (op) {
             case "stats":
                 this._updateStats(payload);
@@ -157,20 +149,22 @@ class Node {
         const reasonStr = reason?.toString() || "No reason provided";
 
         this.aqua.emit("nodeDisconnect", this, { code, reason: reasonStr });
+
         this.aqua.handleNodeFailover(this);
+
         this.scheduleReconnect(code);
     }
 
     scheduleReconnect(code) {
+        this.clearReconnectTimeout();
+
         if (code === Node.WS_CLOSE_NORMAL || this.isDestroyed) {
-            this.aqua.emit("debug", this.name, "WebSocket closed normally, not reconnecting.");
+            this.aqua.emit("debug", this.name, "WebSocket closed normally, not reconnecting");
             return;
         }
 
-        if (this.reconnectTimeoutId) return;
-
         if (this.infiniteReconnects) {
-            this.aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying again in 10 seconds.");
+            this.aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying again in 10 seconds");
             this.reconnectTimeoutId = setTimeout(() => this.connect(), 10000);
             return;
         }
@@ -193,19 +187,26 @@ class Node {
     }
 
     calculateBackoff() {
-        const baseBackoff = this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.reconnectAttempted - 1);
+        const baseBackoff = this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.reconnectAttempted);
         const jitter = Math.random() * Math.min(2000, baseBackoff * 0.2);
         return Math.min(baseBackoff + jitter, Node.MAX_BACKOFF);
     }
 
-    connect() {
+    clearReconnectTimeout() {
+        if (this.reconnectTimeoutId) {
+            clearTimeout(this.reconnectTimeoutId);
+            this.reconnectTimeoutId = null;
+        }
+    }
+
+    async connect() {
         if (this.isDestroyed) return;
 
         if (this.ws && this.ws.readyState === Node.WS_OPEN) {
             this.aqua.emit("debug", this.name, "WebSocket already connected");
             return;
         }
-        
+
         this.cleanupExistingConnection();
 
         this.ws = new WebSocket(this.wsUrl, {
@@ -217,31 +218,28 @@ class Node {
         this.ws.once("error", this._onError);
         this.ws.on("message", this._onMessage);
         this.ws.once("close", this._onClose);
+
     }
 
     cleanupExistingConnection() {
         if (!this.ws) return;
 
         this.ws.removeAllListeners();
-        try {
-            if (this.ws.readyState === Node.WS_OPEN) {
-                this.ws.close(Node.WS_CLOSE_NORMAL, "Manual closure");
+
+        if (this.ws.readyState === Node.WS_OPEN) {
+            try {
+                this.ws.close();
+            } catch (err) {
+                this.emitError(`Failed to close WebSocket: ${err.message}`);
             }
-        } catch (err) {
-            this.emitError(`Failed to close WebSocket: ${err.message}`);
         }
+
         this.ws = null;
     }
 
     destroy(clean = false) {
-        if (this.isDestroyed) return;
         this.isDestroyed = true;
-
-        if (this.reconnectTimeoutId) {
-            clearTimeout(this.reconnectTimeoutId);
-            this.reconnectTimeoutId = null;
-        }
-
+        this.clearReconnectTimeout();
         this.cleanupExistingConnection();
 
         if (!clean) {
@@ -253,29 +251,61 @@ class Node {
         this.aqua.emit("nodeDestroy", this);
         this.info = null;
     }
-    
+
+    async getStats() {
+        if (this.connected && this.stats) {
+            return this.stats;
+        }
+
+        try {
+            const newStats = await this.rest.getStats();
+            if (newStats && this.stats) {
+                this.stats.players = newStats.players ?? this.stats.players;
+                this.stats.playingPlayers = newStats.playingPlayers ?? this.stats.playingPlayers;
+                this.stats.uptime = newStats.uptime ?? this.stats.uptime;
+                this.stats.ping = newStats.ping ?? this.stats.ping;
+
+                if (newStats.memory) {
+                    Object.assign(this.stats.memory, newStats.memory);
+                    this._calculateMemoryPercentages();
+                }
+
+                if (newStats.cpu) {
+                    Object.assign(this.stats.cpu, newStats.cpu);
+                    this._calculateCpuPercentages();
+                }
+
+                if (newStats.frameStats) {
+                    Object.assign(this.stats.frameStats, newStats.frameStats);
+                }
+            }
+            return this.stats;
+        } catch (err) {
+            this.emitError(`Failed to fetch node stats: ${err.message}`);
+            return this.stats;
+        }
+    }
+
     _updateStats(payload) {
         if (!payload) return;
-        
-        const { players, playingPlayers, uptime, memory, cpu, frameStats, ping } = payload;
-        
-        this.stats.players = players;
-        this.stats.playingPlayers = playingPlayers;
-        this.stats.uptime = uptime;
-        this.stats.ping = ping ?? this.stats.ping;
-
-        if (memory) {
-            Object.assign(this.stats.memory, memory);
+
+        this.stats.players = payload.players;
+        this.stats.playingPlayers = payload.playingPlayers;
+        this.stats.uptime = payload.uptime;
+        this.stats.ping = payload.ping;
+
+        if (payload.memory) {
+            Object.assign(this.stats.memory, payload.memory);
             this._calculateMemoryPercentages();
         }
 
-        if (cpu) {
-            Object.assign(this.stats.cpu, cpu);
+        if (payload.cpu) {
+            Object.assign(this.stats.cpu, payload.cpu);
             this._calculateCpuPercentages();
         }
 
-        if (frameStats) {
-            Object.assign(this.stats.frameStats, frameStats);
+        if (payload.frameStats) {
+            Object.assign(this.stats.frameStats, payload.frameStats);
         }
     }
 
@@ -294,16 +324,16 @@ class Node {
         }
     }
 
-    _handleReadyOp({ sessionId }) {
-        if (!sessionId) {
+    _handleReadyOp(payload) {
+        if (!payload.sessionId) {
             this.emitError("Ready payload missing sessionId");
             return;
         }
 
-        this.sessionId = sessionId;
-        this.rest.setSessionId(sessionId);
+        this.sessionId = payload.sessionId;
+        this.rest.setSessionId(payload.sessionId);
         this._headers = this._constructHeaders();
-        this.aqua.emit("nodeReady", this);
+        this.aqua.emit("nodeConnect", this);
     }
 
     async resumePlayers() {
@@ -314,7 +344,6 @@ class Node {
             this.emitError(`Failed to resume session: ${err.message}`);
         }
     }
-
     emitError(error) {
         const errorObj = error instanceof Error ? error : new Error(error);
         console.error(`[Aqua] [${this.name}] Error:`, errorObj);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",