Bugfixes

- Add reconnecting
- add debug logging for stats updates
- Fix ci naming

.github/workflows/client.yaml

@@ -14,7 +14,7 @@ jobs:
           java-version: "23"
       - uses: gradle/actions/setup-gradle@v4
       - run: ./gradlew client:packageReleaseDistributionForCurrentOS
-      - run: mv client-*.msi client.msi
+      - run: mv GTA.Killer-*.msi client.msi
         working-directory: client/build/compose/binaries/main-release/msi/
       - name: Release
         uses: softprops/action-gh-release@v2

client/build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
     alias(libs.plugins.compose)
 }
 
-version = "1.0.0"
+version = "1.1.0"
 
 repositories {
     mavenCentral()
@@ -20,14 +20,16 @@ dependencies {
     implementation(libs.kotlinx.serialization.json)
     implementation(libs.jnativehook)
     implementation(libs.ktor.serialization.kotlinx.json)
-    implementation(libs.ktor.client.okhttp)
+    implementation(libs.ktor.client.cio)
     implementation(libs.ktor.client.websockets)
     implementation(libs.ktor.client.resources)
     implementation(libs.ktor.client.content.negotiation)
     implementation(libs.ktor.serialization.kotlinx.json)
     implementation(libs.kotlin.logging)
     implementation(libs.logback.classic)
 
+    implementation(libs.kord.gateway)
+
     implementation(compose.desktop.currentOs)
     implementation(compose.foundation)
     implementation(compose.runtime)

client/src/main/kotlin/core/APIClient.kt

@@ -3,11 +3,8 @@ package dev.schlaubi.mastermind.core
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
-import dev.schlaubi.gtakiller.common.Event
-import dev.schlaubi.gtakiller.common.KillGtaEvent
-import dev.schlaubi.gtakiller.common.Route
-import dev.schlaubi.gtakiller.common.Status
-import dev.schlaubi.gtakiller.common.Username
+import dev.kord.gateway.retry.LinearRetry
+import dev.schlaubi.gtakiller.common.*
 import dev.schlaubi.mastermind.core.settings.settings
 import io.github.oshai.kotlinlogging.KotlinLogging
 import io.ktor.client.*
@@ -17,6 +14,7 @@ import io.ktor.client.plugins.contentnegotiation.*
 import io.ktor.client.plugins.resources.*
 import io.ktor.client.plugins.websocket.*
 import io.ktor.http.*
+import io.ktor.serialization.*
 import io.ktor.serialization.kotlinx.*
 import io.ktor.serialization.kotlinx.json.*
 import io.ktor.websocket.*
@@ -25,6 +23,7 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.serialization.json.Json
 import kotlin.coroutines.CoroutineContext
+import kotlin.time.Duration.Companion.seconds
 
 var currentApi by mutableStateOf<APIClient?>(null)
 
@@ -40,6 +39,7 @@ class APIClient(val url: Url) : CoroutineScope {
             json()
         }
         install(WebSockets) {
+            pingInterval = 2.seconds
             contentConverter = KotlinxWebsocketSerializationConverter(Json)
         }
         install(Resources)
@@ -52,38 +52,48 @@ class APIClient(val url: Url) : CoroutineScope {
     private var webSocketSession: DefaultClientWebSocketSession? = null
     private val _events = MutableSharedFlow<Event>()
     val events = _events.asSharedFlow()
+    private val retry = LinearRetry(2.seconds, 20.seconds, 10)
 
-    suspend fun connectToWebSocket() {
+    suspend fun connectToWebSocket(isRetry: Boolean = false) {
         webSocketSession?.close()
-        val session = client.webSocketSession {
-            url {
-                url.takeFrom(this@APIClient.url)
-                protocol = if (url.protocol.isSecure()) {
-                    URLProtocol.WSS
-                } else {
-                    URLProtocol.WS
+        val session = try {
+            client.webSocketSession {
+                url {
+                    url.takeFrom(this@APIClient.url)
+                    protocol = if (url.protocol.isSecure()) {
+                        URLProtocol.WSS
+                    } else {
+                        URLProtocol.WS
+                    }
+
+                    client.href(Route.Events(), this)
                 }
 
-                client.href(Route.Events(), this)
+                headers.append(HttpHeaders.Username, settings.userName)
             }
-
-            headers.append(HttpHeaders.Username, settings.userName)
+        } catch (e: Exception) {
+            LOG.error(e) { "Could not connect to websocket" }
+            if (isRetry) {
+                retry.retry()
+                LOG.warn { "Retrying ..." }
+                connectToWebSocket(isRetry = true)
+            }
+            return
         }
+        retry.reset()
 
         webSocketSession = session
 
         session.launch {
-            launch {
-                while (isActive) {
-                    val event = session.receiveDeserialized<Event>()
+            for (message in session.incoming) {
+                val event = client.plugin(WebSockets).contentConverter!!.deserialize<Event>(message)
                     LOG.debug { "Received event: $event" }
                     _events.emit(event)
                     handleEvent(event)
                 }
-            }
 
-            val reason = session.closeReason.await()
-            LOG.info { "Lost connection to websocket: ${reason?.message}" }
+            LOG.info { "Lost connection to websocket" }
+            connectToWebSocket(isRetry = true)
         }
     }
 

gradle/libs.versions.toml

@@ -17,7 +17,7 @@ kotlinx-io-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-io-core", v
 ktor-resources = { group = "io.ktor", name = "ktor-resources", version.ref = "ktor" }
 ktor-http = { group = "io.ktor", name = "ktor-http", version.ref = "ktor" }
 ktor-serialization-kotlinx-json = { group = "io.ktor", name = "ktor-serialization-kotlinx-json", version.ref = "ktor" }
-ktor-client-okhttp = { group = "io.ktor", name = "ktor-client-okhttp", version.ref = "ktor" }
+ktor-client-cio = { group = "io.ktor", name = "ktor-client-cio", version.ref = "ktor" }
 ktor-client-resources = { group = "io.ktor", name = "ktor-client-resources", version.ref = "ktor" }
 ktor-client-websockets = { group = "io.ktor", name = "ktor-client-websockets", version.ref = "ktor" }
 ktor-client-content-negotiation = { group = "io.ktor", name = "ktor-client-content-negotiation", version.ref = "ktor" }
@@ -33,6 +33,8 @@ compose-navigation = { group = "org.jetbrains.androidx.navigation", name = "navi
 kotlin-logging = { group = "io.github.oshai", name = "kotlin-logging", version = "7.0.4" }
 logback-classic = { group = "ch.qos.logback", name = "logback-classic", version = "1.5.16" }
 
+kord-gateway = { group = "dev.kord", name = "kord-gateway", version = "0.15.0" }
+
 [plugins]
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }

server/src/main/kotlin/Server.kt

@@ -1,14 +1,14 @@
 package dev.schlaubi.gtakiller
 
 import dev.schlaubi.gtakiller.common.*
+import dev.schlaubi.gtakiller.common.Route
 import dev.schlaubi.gtakiller.util.hashIpAddress
 import io.github.oshai.kotlinlogging.KotlinLogging
 import io.ktor.http.*
 import io.ktor.serialization.kotlinx.*
 import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.application.*
 import io.ktor.server.engine.*
-import io.ktor.server.routing.Route as KtorRoute
 import io.ktor.server.netty.*
 import io.ktor.server.plugins.*
 import io.ktor.server.plugins.contentnegotiation.*
@@ -24,6 +24,7 @@ import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import kotlinx.serialization.json.Json
 import kotlin.time.Duration.Companion.seconds
+import io.ktor.server.routing.Route as KtorRoute
 
 private val LOG = KotlinLogging.logger { }
 
@@ -79,7 +80,9 @@ private fun KtorRoute.websocketHandler() {
                 }
 
                 sessions.forEach {
-                    it.send(event)
+                    if (it != this@websocketHandler) {
+                        it.send(event)
+                    }
                 }
 
                 if (event is KillGtaEvent) {
@@ -92,6 +95,8 @@ private fun KtorRoute.websocketHandler() {
                                 count = stats.count + 1
                             )
                         )
+                    } else {
+                        LOG.debug { "Ignoring kill, last kill was $timeSinceLastKill ago" }
                     }
                     sessions.forEach {
                         it.send(UpdateKillCounterEvent(stats.count, kill))