Merge pull request #3 from jasperkamerling/spectating

Spectating

Author: Tortoaster

.github/workflows/docker.yml

@@ -3,7 +3,7 @@ name: Docker
 on:
   push:
     branches: [ "main" ]
-    tags: [ 'v*.*.*' ]
+    tags: [ 'v*.*.*', 'v*.*' ]
   pull_request:
     branches: [ "main" ]
 

src/main/kotlin/com/alliander/Application.kt

@@ -30,10 +30,11 @@ fun Application.module() {
         anyHost()
         allowHeaders { true }
         allowMethod(HttpMethod.Put)
+        allowMethod(HttpMethod.Delete)
     }
+
     install(WebSockets) {
         pingPeriod = 15.seconds
-        timeout = 30.seconds
         contentConverter = KotlinxWebsocketSerializationConverter(Json)
     }
 

src/main/kotlin/com/alliander/rooms/RoomService.kt

@@ -10,11 +10,14 @@ import org.jetbrains.exposed.sql.SqlExpressionBuilder.less
 import org.jetbrains.exposed.sql.kotlin.datetime.CurrentTimestamp
 import org.jetbrains.exposed.sql.kotlin.datetime.timestamp
 import org.jetbrains.exposed.sql.transactions.transaction
+import org.slf4j.LoggerFactory
 import java.util.*
 import kotlin.time.Duration.Companion.days
 
 
 class RoomService {
+    private val logger = LoggerFactory.getLogger(RoomService::class.java)
+
     object Room : Table() {
         val roomId = uuid("room_id")
         val revealed = bool("revealed")
@@ -129,6 +132,7 @@ class RoomService {
      * Cleanup old rooms after 1 day
      */
     fun pruneOldRooms() = transaction {
-        Room.deleteWhere { created less Clock.System.now().plus(1.days) }
+        Room.deleteWhere { created less Clock.System.now().minus(1.days) }
+            .let { if (it != 0) logger.info("Deleted $it rooms from the database") }
     }
 }

src/main/kotlin/com/alliander/rooms/RoomsRouter.kt

@@ -10,19 +10,27 @@ import io.ktor.websocket.*
 import kotlinx.coroutines.cancel
 import java.util.*
 
-fun Application.configureRooms(roomService: RoomService,stateService: StateService) {
+fun Application.configureRooms(roomService: RoomService, stateService: StateService) {
+    fun String.toUUID(): UUID = UUID.fromString(this)
     routing {
-        webSocket("/api/rooms/{roomId}/ws") {
+        webSocket("/api/rooms/{roomId}/{userId}/ws") {
             val roomId = call.parameters["roomId"]?.toUUID() ?: throw IllegalArgumentException("Invalid Room ID")
+            val userId = call.parameters["userId"]?.toUUID() ?: throw IllegalArgumentException("Invalid User ID")
+
+            try {
+                if (!roomService.roomExists(roomId)) {
+                    close(CloseReason(CloseReason.Codes.INTERNAL_ERROR, "Unknown Room ID"))
+                    cancel()
+                    return@webSocket
+                }
 
-            if (!roomService.roomExists(roomId)) {
-                close(CloseReason(CloseReason.Codes.INTERNAL_ERROR, "Unknown Room ID"))
-                cancel()
-            } else {
                 // Subscribe to the flow
                 stateService.getOrCreateState(roomId).stateFlow.collect { room ->
                     sendSerialized(room)
                 }
+            } catch (e: Throwable) {
+                roomService.deleteRoomUser(roomId, userId)
+                stateService.updateRoom(roomId)
             }
         }
 
@@ -129,4 +137,3 @@ fun Application.configureRooms(roomService: RoomService,stateService: StateServi
     }
 }
 
-fun String.toUUID(): UUID = UUID.fromString(this)

src/main/kotlin/com/alliander/rooms/StateService.kt

@@ -2,13 +2,15 @@ package com.alliander.rooms
 
 import com.alliander.rooms.dto.ExternalRoom
 import kotlinx.coroutines.flow.MutableStateFlow
+import org.slf4j.LoggerFactory
 import java.time.LocalDateTime
 import java.util.UUID
 
 class StateService(private val roomService: RoomService) {
     data class State(val stateFlow: MutableStateFlow<ExternalRoom>, val lastUpdated: LocalDateTime)
 
-    val flows: MutableMap<UUID, State> = mutableMapOf()
+    private val logger = LoggerFactory.getLogger(RoomService::class.java)
+    private val flows: MutableMap<UUID, State> = mutableMapOf()
 
     fun getOrCreateState(roomId: UUID): State {
         if (!flows.containsKey(roomId)) {
@@ -29,5 +31,6 @@ class StateService(private val roomService: RoomService) {
     fun pruneOldRooms() =
         flows.filterValues { it.lastUpdated < LocalDateTime.now().minusHours(1) }
             .keys
+            .also { if(it.isNotEmpty()) logger.info("Deleted $it.size from cache") }
             .forEach { flows.remove(it)?.stateFlow }
 }