refactor(netty): simplify Velocity secret handling and optimize Bukkit packet listener components

twisti-dev · twisti-dev · commit 21640aa3f2ed · 2025-07-22T11:29:58.000+02:00
diff --git a/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/netty/network/BukkitSpecificPacketListenerExtension.kt b/surf-cloud-bukkit/src/main/kotlin/dev/slne/surf/cloud/bukkit/netty/network/BukkitSpecificPacketListenerExtension.kt
@@ -1,5 +1,6 @@
 package dev.slne.surf.cloud.bukkit.netty.network
 
+import com.github.shynixn.mccoroutine.folia.entityDispatcher
 import com.github.shynixn.mccoroutine.folia.globalRegionDispatcher
 import com.github.shynixn.mccoroutine.folia.launch
 import dev.slne.surf.cloud.api.common.player.teleport.TeleportCause
@@ -17,7 +18,6 @@ import dev.slne.surf.cloud.core.common.netty.network.protocol.running.Serverboun
 import dev.slne.surf.surfapi.bukkit.api.extensions.server
 import dev.slne.surf.surfapi.bukkit.api.nms.NmsUseWithCaution
 import dev.slne.surf.surfapi.bukkit.api.nms.bridges.nmsCommonBridge
-import dev.slne.surf.surfapi.bukkit.api.util.dispatcher
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
@@ -26,28 +26,11 @@ import net.kyori.adventure.text.Component
 import org.bukkit.Bukkit
 import java.net.InetAddress
 import java.net.InetSocketAddress
-import java.nio.charset.StandardCharsets
 import java.util.*
-import kotlin.io.path.Path
-import kotlin.io.path.inputStream
-import kotlin.io.path.notExists
 import org.springframework.stereotype.Component as SpringComponent
 
 @SpringComponent
 class BukkitSpecificPacketListenerExtension : PlatformSpecificPacketListenerExtension {
-    private val properties by lazy {
-        val propertiesPath = Path("server.properties")
-        if (propertiesPath.notExists()) {
-            Properties()
-        } else {
-            Properties().apply {
-                propertiesPath.inputStream().use { inputStream ->
-                    load(inputStream)
-                }
-            }
-        }
-    }
-
     override val playAddress: InetSocketAddress by lazy {
         InetSocketAddress(InetAddress.getByName(server.ip), server.port)
     }
@@ -65,7 +48,7 @@ class BukkitSpecificPacketListenerExtension : PlatformSpecificPacketListenerExte
 
     override fun disconnectPlayer(playerUuid: UUID, reason: Component) {
         val player = Bukkit.getPlayer(playerUuid) ?: return
-        plugin.launch(player.dispatcher()) {
+        plugin.launch(plugin.entityDispatcher(player)) {
             player.kick(reason)
         }
     }
@@ -104,17 +87,6 @@ class BukkitSpecificPacketListenerExtension : PlatformSpecificPacketListenerExte
         return player.teleportAsync(targetPlayer.location).await()
     }
 
-    @OptIn(NmsUseWithCaution::class)
-    override fun setVelocitySecret(secret: ByteArray) {
-//        nmsCommonBridge.setVelocityEnabled(true)
-//        nmsCommonBridge.setVelocitySecret(secret.toString(StandardCharsets.UTF_8))
-//        nmsCommonBridge.setOnlineMode(false)
-
-        BukkitVelocitySecretManager.currentVelocityEnabled = true
-        BukkitVelocitySecretManager.currentVelocitySecret = secret
-        BukkitVelocitySecretManager.currentOnlineMode = false
-    }
-
     override fun triggerShutdown() {
         plugin.launch(plugin.globalRegionDispatcher) {
             Bukkit.shutdown()
@@ -129,6 +101,13 @@ class BukkitSpecificPacketListenerExtension : PlatformSpecificPacketListenerExte
         server.shutdown()
     }
 
+    @OptIn(NmsUseWithCaution::class)
+    override fun setVelocitySecret(secret: ByteArray) {
+        BukkitVelocitySecretManager.currentVelocityEnabled = true
+        BukkitVelocitySecretManager.currentVelocitySecret = secret
+        BukkitVelocitySecretManager.currentOnlineMode = false
+    }
+
     @OptIn(NmsUseWithCaution::class)
     object BukkitVelocitySecretManager {
 
@@ -138,7 +117,7 @@ class BukkitSpecificPacketListenerExtension : PlatformSpecificPacketListenerExte
         @Volatile
         var currentVelocitySecret = nmsCommonBridge
             .getVelocitySecret()
-            .toByteArray(StandardCharsets.UTF_8)
+            .toByteArray()
 
         @Volatile
         var currentOnlineMode = server.onlineMode
@@ -147,22 +126,18 @@ class BukkitSpecificPacketListenerExtension : PlatformSpecificPacketListenerExte
             observingFlow({ nmsCommonBridge.isVelocityEnabled() })
                 .onEach { remote ->
                     if (remote != currentVelocityEnabled) {
-                        println("Updating Velocity enabled state: $remote")
                         nmsCommonBridge.setVelocityEnabled(currentVelocityEnabled)
                     }
                 }
                 .launchIn(CommonObservableScope)
 
 
             observingFlow({ nmsCommonBridge.getVelocitySecret() })
-                .map { it.toByteArray(StandardCharsets.UTF_8) }
+                .map { it.toByteArray() }
                 .onEach { remote ->
                     if (!remote.contentEquals(currentVelocitySecret)) {
-                        println("Updating Velocity secret: ${remote.toString(StandardCharsets.UTF_8)}")
                         nmsCommonBridge.setVelocitySecret(
-                            currentVelocitySecret.toString(
-                                StandardCharsets.UTF_8
-                            )
+                            currentVelocitySecret.decodeToString()
                         )
                     }
                 }
@@ -171,7 +146,6 @@ class BukkitSpecificPacketListenerExtension : PlatformSpecificPacketListenerExte
             observingFlow({ server.onlineMode })
                 .onEach { remote ->
                     if (remote != currentOnlineMode) {
-                        println("Updating online mode: $remote")
                         nmsCommonBridge.setOnlineMode(remote)
                     }
                 }
diff --git a/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/netty/server/ProxySecretHolder.kt b/surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/netty/server/ProxySecretHolder.kt
@@ -4,14 +4,12 @@ import dev.slne.surf.cloud.api.server.netty.packet.broadcast
 import dev.slne.surf.cloud.core.common.netty.network.protocol.common.ClientboundSetVelocitySecretPacket
 import dev.slne.surf.cloud.standalone.config.ProxyConfig.SecretConfig.SecretType
 import dev.slne.surf.cloud.standalone.config.standaloneConfig
-import dev.slne.surf.surfapi.core.api.util.random
+import org.apache.commons.lang3.RandomStringUtils
 
 object ProxySecretHolder {
 
     private var dynamicSecret = randomSecret()
 
-    private fun randomSecret() = ByteArray(128).apply { random.nextBytes(this) }
-
     fun currentSecret(): ByteArray {
         val secretConfig = standaloneConfig.proxy.secretConfig
         return when (secretConfig.type) {
@@ -24,4 +22,6 @@ object ProxySecretHolder {
         dynamicSecret = randomSecret()
         ClientboundSetVelocitySecretPacket(currentSecret()).broadcast()
     }
+
+    private fun randomSecret() = RandomStringUtils.secureStrong().next(128).toByteArray()
 }
diff --git a/surf-cloud-velocity/src/main/kotlin/dev/slne/surf/cloud/velocity/netty/network/VelocitySpecificPacketListenerExtension.kt b/surf-cloud-velocity/src/main/kotlin/dev/slne/surf/cloud/velocity/netty/network/VelocitySpecificPacketListenerExtension.kt
@@ -1,17 +1,20 @@
 package dev.slne.surf.cloud.velocity.netty.network
 
-import com.github.benmanes.caffeine.cache.Caffeine
 import com.velocitypowered.api.proxy.ConnectionRequestBuilder
 import com.velocitypowered.api.proxy.server.ServerInfo
 import dev.slne.surf.cloud.api.common.player.teleport.TeleportCause
 import dev.slne.surf.cloud.api.common.player.teleport.TeleportFlag
 import dev.slne.surf.cloud.api.common.player.teleport.TeleportLocation
+import dev.slne.surf.cloud.api.common.util.observer.observingFlow
 import dev.slne.surf.cloud.core.client.netty.network.PlatformSpecificPacketListenerExtension
 import dev.slne.surf.cloud.core.client.server.ClientCloudServerImpl
+import dev.slne.surf.cloud.core.common.coroutines.CommonObservableScope
 import dev.slne.surf.cloud.core.common.netty.network.protocol.running.RegistrationInfo
 import dev.slne.surf.cloud.core.common.netty.network.protocol.running.ServerboundTransferPlayerPacketResponse.Status
 import dev.slne.surf.cloud.velocity.proxy
 import dev.slne.surf.cloud.velocity.reflection.VelocityConfigurationProxy
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.future.await
 import net.kyori.adventure.text.Component
 import java.net.InetSocketAddress
@@ -21,9 +24,6 @@ import org.springframework.stereotype.Component as SpringComponent
 
 @SpringComponent
 class VelocitySpecificPacketListenerExtension : PlatformSpecificPacketListenerExtension {
-    private val serverInfoCache = Caffeine.newBuilder()
-        .build<Long, ServerInfo>()
-
     override val playAddress: InetSocketAddress
         get() = proxy.boundAddress
 
@@ -67,8 +67,8 @@ class VelocitySpecificPacketListenerExtension : PlatformSpecificPacketListenerEx
         error("Teleporting players is not supported on Velocity")
     }
 
-    override fun registerCloudServersToProxy(servers: Array<RegistrationInfo>) {
-        servers.map { (name, address) -> ServerInfo(name, address) }
+    override fun registerCloudServersToProxy(packets: Array<RegistrationInfo>) {
+        packets.map { (name, address) -> ServerInfo(name, address) }
             .forEach { proxy.registerServer(it) }
     }
 
@@ -77,11 +77,10 @@ class VelocitySpecificPacketListenerExtension : PlatformSpecificPacketListenerEx
         println("Registering server $serverInfo to proxy")
 
         proxy.registerServer(serverInfo)
-        serverInfoCache.put(client.uid, serverInfo)
     }
 
     override fun unregisterCloudServerFromProxy(client: ClientCloudServerImpl) {
-        val info = serverInfoCache.getIfPresent(client.uid) ?: return
+        val info = ServerInfo(client.name, client.playAddress)
         println("Unregistering server $info from proxy")
         proxy.unregisterServer(info)
     }
@@ -93,10 +92,6 @@ class VelocitySpecificPacketListenerExtension : PlatformSpecificPacketListenerEx
         error("Teleporting players is not supported on Velocity")
     }
 
-    override fun setVelocitySecret(secret: ByteArray) {
-        VelocityConfigurationProxy.instance.setForwardingSecret(proxy.configuration, secret)
-    }
-
     override fun triggerShutdown() {
         proxy.shutdown()
     }
@@ -108,4 +103,24 @@ class VelocitySpecificPacketListenerExtension : PlatformSpecificPacketListenerEx
     override fun shutdown() {
         proxy.shutdown()
     }
+
+    override fun setVelocitySecret(secret: ByteArray) {
+        VelocitySecretManager.currentVelocitySecret = secret
+    }
+
+    object VelocitySecretManager {
+        @Volatile
+        var currentVelocitySecret =
+            VelocityConfigurationProxy.instance.getForwardingSecret(proxy.configuration)
+
+        init {
+            observingFlow({ VelocityConfigurationProxy.instance.getForwardingSecret(proxy.configuration) })
+                .onEach { remote ->
+                    if (!remote.contentEquals(currentVelocitySecret)) {
+                        VelocityConfigurationProxy.instance.setForwardingSecret(proxy.configuration, currentVelocitySecret)
+                    }
+                }
+                .launchIn(CommonObservableScope)
+        }
+    }
 }
