refactor: use the correlation provided by the client for the socket connection instead of generating a random UUID manually

Author: sakethpathike

src/main/kotlin/com/sakethh/linkora/WebSocket.kt

@@ -2,26 +2,51 @@ package com.sakethh.linkora
 
 import com.sakethh.linkora.WebSocketManager.closeWriteChannel
 import com.sakethh.linkora.WebSocketManager.initializeWriteChannel
+import com.sakethh.linkora.domain.dto.Correlation
 import io.ktor.server.application.*
 import io.ktor.server.auth.*
 import io.ktor.server.routing.*
 import io.ktor.server.websocket.*
-import java.util.*
+import io.ktor.websocket.*
+import kotlinx.serialization.json.Json
 
 fun Application.eventsWebSocket() {
     routing {
         authenticate(Security.BEARER.name) {
-            webSocket("/events") {
-                val sessionId = UUID.randomUUID().toString()
-                initializeWriteChannel(sessionId)
+            webSocket(path = "/events") {
+                val correlationParam = call.parameters["correlation"]
+                if (correlationParam == null) {
+                    this.close(
+                        CloseReason(
+                            message = "Expected `correlation` as an encoded JSON string via parameter, but it was not provided.",
+                            code = CloseReason.Codes.CANNOT_ACCEPT
+                        )
+                    )
+                    return@webSocket
+                }
+                val correlation = try {
+                    Json.decodeFromString<Correlation>(correlationParam)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    this.close(
+                        CloseReason(
+                            message = "The schema of the provided JSON does not match the expected format.",
+                            code = CloseReason.Codes.CANNOT_ACCEPT
+                        )
+                    )
+                    return@webSocket
+                }
+                val correlationId = correlation.id
+                initializeWriteChannel(correlationId)
+                println("Established the `events` socket connection with \"${correlation.clientName}\".")
                 try {
                     for (frame in incoming) {
                     }
                 } catch (e: Exception) {
-                    println("WebSocket error: ${e.message}")
+                    println("WebSocket error for \"${correlation.clientName}\": ${e.message}")
                 } finally {
-                    closeWriteChannel(sessionId)
-                    println("WebSocket closed.")
+                    closeWriteChannel(correlationId)
+                    println("WebSocket closed for \"${correlation.clientName}\".")
                 }
             }
         }

src/main/kotlin/com/sakethh/linkora/WebSocketManager.kt

@@ -13,24 +13,24 @@ object WebSocketManager {
         prettyPrint = true
     }
 
-    fun DefaultWebSocketServerSession.initializeWriteChannel(sessionId: String) {
-        writeChannels[sessionId] = this
+    fun DefaultWebSocketServerSession.initializeWriteChannel(correlationId: String) {
+        writeChannels[correlationId] = this
     }
 
     suspend fun sendEvent(notification: WebSocketEvent) {
-        writeChannels.forEach { (sessionId, session) ->
+        writeChannels.forEach { (correlationId, session) ->
             try {
                 session.send(Frame.Text(json.encodeToString(notification)))
-                println("Sent event to the client with sessionId: $sessionId")
+                println("Sent event to the client : $correlationId")
             } catch (e: Exception) {
-                println("removing the client $sessionId due to ${e.message}")
-                closeWriteChannel(sessionId)
+                println("removing the client $correlationId due to ${e.message}")
+                closeWriteChannel(correlationId)
                 e.printStackTrace()
             }
         }
     }
 
-    fun closeWriteChannel(sessionId: String) {
-        writeChannels.remove(sessionId)
+    fun closeWriteChannel(correlationId: String) {
+        writeChannels.remove(correlationId)
     }
 }