Fix SurfPlayerSyncTask for multiproxy: scope stale eviction to current proxy only and sync current server

gradle.properties

@@ -1,4 +1,4 @@
 kotlin.code.style=official
 kotlin.stdlib.default.dependency=false
 org.gradle.parallel=true
-version=1.21.11-1.2.5-SNAPSHOT
+version=1.21.11-1.2.6-SNAPSHOT

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/server/CommonSurfServer.kt

@@ -29,6 +29,6 @@ sealed interface CommonSurfServer {
     fun isBackend() = this is SurfServer
 
     companion object {
-        operator fun get(name: String) = surfCoreApi.getServerByName(name)
+        operator fun get(name: String) = surfCoreApi.getCommonServerByName(name)
     }
 }

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/server/SurfServer.kt

@@ -20,5 +20,7 @@ data class SurfServer(
 
     companion object {
         fun current() = surfCoreApi.getCurrentServer()
+
+        operator fun get(name: String) = surfCoreApi.getServerByName(name)
     }
 }

surf-core-velocity/src/main/kotlin/dev/slne/surf/core/velocity/VelocityMain.kt

@@ -31,6 +31,7 @@ import dev.slne.surf.core.velocity.listener.VelocityServerListener
 import dev.slne.surf.core.velocity.redis.handler.SendPlayerToProxyHandler
 import dev.slne.surf.core.velocity.redis.handler.SendPlayerToServerHandler
 import dev.slne.surf.core.velocity.redis.listener.VelocityRedisListener
+import dev.slne.surf.core.velocity.task.surfPlayerSyncTask
 import dev.slne.surf.surfapi.core.api.messages.adventure.buildText
 import kotlinx.coroutines.runBlocking
 import net.kyori.adventure.text.format.TextDecoration
@@ -89,10 +90,14 @@ class VelocityMain @Inject constructor(
         eventManager.register(this, VelocityServerListener)
 
         surfServerService.changeState(SurfProxyServer.current(), SurfServerState.RUNNING)
+
+        surfPlayerSyncTask.start()
     }
 
     @Subscribe
     fun onProxyShutdown(event: ProxyShutdownEvent) {
+        surfPlayerSyncTask.stop()
+
         surfEventBus.fire(SurfServerStoppingEvent(surfServerConfig.serverName))
 
         surfCoreApi.getOnlinePlayers().forEach {

surf-core-velocity/src/main/kotlin/dev/slne/surf/core/velocity/listener/ConnectionListener.kt

@@ -8,8 +8,8 @@ import com.velocitypowered.api.event.player.ServerConnectedEvent
 import com.velocitypowered.api.util.GameProfile
 import dev.slne.surf.core.api.common.event.SurfPlayerConnectEvent
 import dev.slne.surf.core.api.common.event.SurfPlayerDisconnectEvent
-import dev.slne.surf.core.api.common.server.CommonSurfServer
 import dev.slne.surf.core.api.common.server.SurfProxyServer
+import dev.slne.surf.core.api.common.server.SurfServer
 import dev.slne.surf.core.core.common.event.surfEventBus
 import dev.slne.surf.core.core.common.player.history.surfPlayerIpAddressHistoryService
 import dev.slne.surf.core.core.common.player.history.surfPlayerNameHistoryService
@@ -122,7 +122,7 @@ object ConnectionListener {
         println("[connection update] $playerName was redirected from '$fromServer' to '$toServer'")
 
 
-        val server = CommonSurfServer[toServer] ?: error("SurfServer '$toServer' not found")
+        val server = SurfServer[toServer] ?: error("SurfServer '$toServer' not found")
         val player =
             surfPlayerService.players.firstOrNull { it.uuid == playerUuid }
                 ?.copy(currentServer = server)

surf-core-velocity/src/main/kotlin/dev/slne/surf/core/velocity/task/SurfPlayerSyncTask.kt

@@ -0,0 +1,56 @@
+package dev.slne.surf.core.velocity.task
+
+import com.github.shynixn.mccoroutine.velocity.launch
+import com.velocitypowered.api.scheduler.ScheduledTask
+import dev.slne.surf.core.api.common.server.SurfProxyServer
+import dev.slne.surf.core.api.common.server.SurfServer
+import dev.slne.surf.core.core.common.player.surfPlayerService
+import dev.slne.surf.core.velocity.plugin
+import dev.slne.surf.core.velocity.proxy
+import java.util.concurrent.TimeUnit
+import kotlin.jvm.optionals.getOrNull
+
+val surfPlayerSyncTask = SurfPlayerSyncTask()
+
+class SurfPlayerSyncTask {
+    private var task: ScheduledTask? = null
+
+    fun start() {
+        task = proxy.scheduler
+            .buildTask(plugin, Runnable { syncPlayers() })
+            .delay(1L, TimeUnit.MINUTES)
+            .repeat(1L, TimeUnit.MINUTES)
+            .schedule()
+    }
+
+    fun stop() {
+        task?.cancel()
+        task = null
+    }
+
+    private fun syncPlayers() {
+        plugin.pluginContainer.launch {
+            val onlinePlayers = proxy.allPlayers.map { velocityPlayer ->
+                val surfPlayer = surfPlayerService.findPlayerByUuid(velocityPlayer.uniqueId)
+                    ?: surfPlayerService.getOrLoadOrCreatePlayerByUuid(velocityPlayer.uniqueId)
+                        .also {
+                            it.currentProxy = SurfProxyServer.current()
+                        }
+                val currentServerName = velocityPlayer.currentServer.getOrNull()?.serverInfo?.name
+                val currentServer = currentServerName?.let { SurfServer[it] }
+                surfPlayer.copy(currentServer = currentServer)
+            }
+
+            val onlineUuids = onlinePlayers.map { it.uuid }.toHashSet()
+
+            SurfProxyServer.current().getPlayers()
+                .filter { it.uuid !in onlineUuids }
+                .forEach {
+                    surfPlayerService.invalidatePlayer(it.uuid)
+                    plugin.logger.info("Found invalid player ${it.uuid} (${it.username}), invalidating cache")
+                }
+
+            onlinePlayers.forEach { surfPlayerService.cachePlayer(it) }
+        }
+    }
+}