Change how resume reconnect failure is handled

Author: freyacodes

src/main/kotlin/dev/arbjerg/lavalink/client/LavalinkClient.kt

@@ -9,7 +9,6 @@ import dev.arbjerg.lavalink.internal.ReconnectTask
 import dev.arbjerg.lavalink.protocol.v4.VoiceState
 import reactor.core.Disposable
 import reactor.core.publisher.Flux
-import reactor.core.publisher.Mono
 import reactor.core.publisher.Sinks
 import java.io.Closeable
 import java.time.Duration
@@ -172,13 +171,15 @@ class LavalinkClient(val userId: Long) : Closeable, Disposable {
 
         val session = node.cachedSession
         val canResume = session != null && session.resuming && session.timeoutSeconds > 0
-        if (!canResume) {
-            // If canResume is true, onNodeFirstReconnectFailed(node) may do the transfer
+        if (canResume) {
+            // This causes onResumeReconnectFailed(node) to be called if the next reconnect fails
+            node.ws.onResumableConnectionDisconnected()
+        } else {
             transferNodes(node)
         }
     }
 
-    internal fun onNodeFirstReconnectFailed(node: LavalinkNode) {
+    internal fun onResumeReconnectFailed(node: LavalinkNode) {
         transferNodes(node)
     }
 

src/main/kotlin/dev/arbjerg/lavalink/internal/LavalinkSocket.kt

@@ -18,6 +18,7 @@ import java.io.EOFException
 import java.net.ConnectException
 import java.net.SocketException
 import java.net.SocketTimeoutException
+import java.util.concurrent.atomic.AtomicBoolean
 
 class LavalinkSocket(private val node: LavalinkNode) : WebSocketListener(), Closeable {
     private val logger = LoggerFactory.getLogger(LavalinkSocket::class.java)
@@ -27,11 +28,14 @@ class LavalinkSocket(private val node: LavalinkNode) : WebSocketListener(), Clos
     var mayReconnect = true
     var lastReconnectAttempt = 0L
     @Volatile
-    private var connectionsAttempted = 0
+    private var reconnectsAttempted = 0
     val reconnectInterval: Int
-        get() = connectionsAttempted * 2000 - 2000
+        get() = reconnectsAttempted * 2000 - 2000
     var open: Boolean = false
         private set
+    @Volatile
+    private var hasEverConnected = false
+    private val isAttemptingResume = AtomicBoolean(node.sessionId != null)
 
     init {
         connect()
@@ -40,7 +44,9 @@ class LavalinkSocket(private val node: LavalinkNode) : WebSocketListener(), Clos
     override fun onOpen(webSocket: WebSocket, response: Response) {
         logger.info("${node.name} has been connected!")
         open = true
-        connectionsAttempted = 0
+        reconnectsAttempted = 0
+        hasEverConnected = true
+        isAttemptingResume.set(false)
     }
 
     override fun onMessage(webSocket: WebSocket, text: String) {
@@ -190,8 +196,8 @@ class LavalinkSocket(private val node: LavalinkNode) : WebSocketListener(), Clos
             }
         }
 
-        if (connectionsAttempted == 1 && lastReconnectAttempt > 0) {
-            node.lavalink.onNodeFirstReconnectFailed(node)
+        if (hasEverConnected && isAttemptingResume.getAndSet(false)) {
+            node.lavalink.onResumeReconnectFailed(node)
         }
     }
 
@@ -221,6 +227,7 @@ class LavalinkSocket(private val node: LavalinkNode) : WebSocketListener(), Clos
 
     fun attemptReconnect() {
         lastReconnectAttempt = System.currentTimeMillis()
+        reconnectsAttempted++
         connect()
     }
 
@@ -236,14 +243,13 @@ class LavalinkSocket(private val node: LavalinkNode) : WebSocketListener(), Clos
             .addHeader("Client-Name", "Lavalink-Client/${CLIENT_VERSION}")
             .addHeader("User-Id", node.lavalink.userId.toString())
             .apply {
-                if (node.sessionId != null && connectionsAttempted == 0) {
+                if (node.sessionId != null && isAttemptingResume.get()) {
                     addHeader("Session-Id", node.sessionId!!)
                 }
             }
             .build()
 
         mayReconnect = true
-        connectionsAttempted++
         socket = node.httpClient.newWebSocket(request, this)
     }
 
@@ -254,4 +260,8 @@ class LavalinkSocket(private val node: LavalinkNode) : WebSocketListener(), Clos
         socket?.close(1000, "Client shutdown")
         socket?.cancel()
     }
+
+    internal fun onResumableConnectionDisconnected() {
+        isAttemptingResume.set(true)
+    }
 }