feat(shulker-operator): add ability to register hook with order

BridgeSplash · Oct 31, 2023 · 76f6730 · 76f6730
1 parent 4ac0c8c
commit 76f6730
Show file tree

Hide file tree

Showing 5 changed files with 79 additions and 38 deletions.
diff --git a/...gent/src/bungeecord/kotlin/io/shulkermc/proxyagent/bungeecord/ProxyInterfaceBungeeCord.kt b/...gent/src/bungeecord/kotlin/io/shulkermc/proxyagent/bungeecord/ProxyInterfaceBungeeCord.kt
@@ -3,6 +3,7 @@
 package io.shulkermc.proxyagent.bungeecord
 
 import io.shulkermc.proxyagent.ProxyInterface
+import io.shulkermc.proxyagent.platform.HookPostOrder
 import io.shulkermc.proxyagent.platform.Player
 import io.shulkermc.proxyagent.platform.PlayerDisconnectHook
 import io.shulkermc.proxyagent.platform.PlayerLoginHook
@@ -45,10 +46,11 @@ class ProxyInterfaceBungeeCord(
         return this.proxy.servers.containsKey(name)
     }
 
-    override fun addProxyPingHook(hook: ProxyPingHook) {
+    override fun addProxyPingHook(hook: ProxyPingHook, postOrder: HookPostOrder) {
         this.proxy.pluginManager.registerListener(
             this.plugin,
             object : Listener {
+                // NOTE: BungeeCord does not support runtime event priority
                 @EventHandler(priority = EventPriority.LOWEST)
                 fun onPreLogin(event: ProxyPingEvent) {
                     val result = hook()
@@ -58,11 +60,12 @@ class ProxyInterfaceBungeeCord(
         )
     }
 
-    override fun addPlayerPreLoginHook(hook: PlayerPreLoginHook) {
+    override fun addPlayerPreLoginHook(hook: PlayerPreLoginHook, postOrder: HookPostOrder) {
         this.proxy.pluginManager.registerListener(
             this.plugin,
             object : Listener {
-                @EventHandler(priority = EventPriority.HIGHEST)
+                // NOTE: BungeeCord does not support runtime event priority
+                @EventHandler(priority = EventPriority.LOWEST)
                 fun onPreLogin(event: PreLoginEvent) {
                     if (event.isCancelled) return
                     val result = hook()
@@ -75,34 +78,37 @@ class ProxyInterfaceBungeeCord(
         )
     }
 
-    override fun addPlayerLoginHook(hook: PlayerLoginHook) {
+    override fun addPlayerLoginHook(hook: PlayerLoginHook, postOrder: HookPostOrder) {
         this.proxy.pluginManager.registerListener(
             this.plugin,
             object : Listener {
-                @EventHandler(priority = EventPriority.HIGHEST)
+                // NOTE: BungeeCord does not support runtime event priority
+                @EventHandler(priority = EventPriority.LOW)
                 fun onLogin(event: PostLoginEvent) {
                     hook(wrapPlayer(event.player))
                 }
             }
         )
     }
 
-    override fun addPlayerDisconnectHook(hook: PlayerDisconnectHook) {
+    override fun addPlayerDisconnectHook(hook: PlayerDisconnectHook, postOrder: HookPostOrder) {
         this.proxy.pluginManager.registerListener(
             this.plugin,
             object : Listener {
-                @EventHandler(priority = EventPriority.LOWEST)
+                // NOTE: BungeeCord does not support runtime event priority
+                @EventHandler(priority = EventPriority.HIGH)
                 fun onPlayerDisconnect(event: PlayerDisconnectEvent) {
                     hook(wrapPlayer(event.player))
                 }
             }
         )
     }
 
-    override fun addServerPreConnectHook(hook: ServerPreConnectHook) {
+    override fun addServerPreConnectHook(hook: ServerPreConnectHook, postOrder: HookPostOrder) {
         this.proxy.pluginManager.registerListener(
             this.plugin,
             object : Listener {
+                // NOTE: BungeeCord does not support runtime event priority
                 @EventHandler(priority = EventPriority.LOWEST)
                 fun onServerConnect(event: ServerConnectEvent) {
                     if (event.isCancelled) return
@@ -116,11 +122,12 @@ class ProxyInterfaceBungeeCord(
         )
     }
 
-    override fun addServerPostConnectHook(hook: ServerPostConnectHook) {
+    override fun addServerPostConnectHook(hook: ServerPostConnectHook, postOrder: HookPostOrder) {
         this.proxy.pluginManager.registerListener(
             this.plugin,
             object : Listener {
-                @EventHandler(priority = EventPriority.LOWEST)
+                // NOTE: BungeeCord does not support runtime event priority
+                @EventHandler(priority = EventPriority.HIGH)
                 fun onServerConnected(event: ServerConnectedEvent) {
                     hook(wrapPlayer(event.player), event.server.info.name)
                 }

diff --git a/packages/shulker-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/ProxyInterface.kt b/packages/shulker-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/ProxyInterface.kt
@@ -1,5 +1,6 @@
 package io.shulkermc.proxyagent
 
+import io.shulkermc.proxyagent.platform.HookPostOrder
 import io.shulkermc.proxyagent.platform.PlayerDisconnectHook
 import io.shulkermc.proxyagent.platform.PlayerLoginHook
 import io.shulkermc.proxyagent.platform.PlayerPreLoginHook
@@ -14,12 +15,12 @@ interface ProxyInterface {
     fun unregisterServer(name: String): Boolean
     fun hasServer(name: String): Boolean
 
-    fun addProxyPingHook(hook: ProxyPingHook)
-    fun addPlayerPreLoginHook(hook: PlayerPreLoginHook)
-    fun addPlayerLoginHook(hook: PlayerLoginHook)
-    fun addPlayerDisconnectHook(hook: PlayerDisconnectHook)
-    fun addServerPreConnectHook(hook: ServerPreConnectHook)
-    fun addServerPostConnectHook(hook: ServerPostConnectHook)
+    fun addProxyPingHook(hook: ProxyPingHook, postOrder: HookPostOrder)
+    fun addPlayerPreLoginHook(hook: PlayerPreLoginHook, postOrder: HookPostOrder)
+    fun addPlayerLoginHook(hook: PlayerLoginHook, postOrder: HookPostOrder)
+    fun addPlayerDisconnectHook(hook: PlayerDisconnectHook, postOrder: HookPostOrder)
+    fun addServerPreConnectHook(hook: ServerPreConnectHook, postOrder: HookPostOrder)
+    fun addServerPostConnectHook(hook: ServerPostConnectHook, postOrder: HookPostOrder)
 
     fun teleportPlayerOnServer(playerName: String, serverName: String)
     fun getPlayerCount(): Int

diff --git a/...s/shulker-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/platform/HookPostOrder.kt b/...s/shulker-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/platform/HookPostOrder.kt
@@ -0,0 +1,5 @@
+package io.shulkermc.proxyagent.platform
+
+enum class HookPostOrder {
+    FIRST, EARLY, NORMAL, LATE, LAST
+}
diff --git a/...r-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/services/PlayerMovementService.kt b/...r-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/services/PlayerMovementService.kt
@@ -3,6 +3,7 @@ package io.shulkermc.proxyagent.services
 import com.google.common.base.Suppliers
 import io.shulkermc.proxyagent.Configuration
 import io.shulkermc.proxyagent.ShulkerProxyAgentCommon
+import io.shulkermc.proxyagent.platform.HookPostOrder
 import io.shulkermc.proxyagent.platform.Player
 import io.shulkermc.proxyagent.platform.PlayerPreLoginHookResult
 import io.shulkermc.proxyagent.platform.ProxyPingHookResult
@@ -37,12 +38,12 @@ class PlayerMovementService(private val agent: ShulkerProxyAgentCommon) {
     private var acceptingPlayers = true
 
     init {
-        this.agent.proxyInterface.addProxyPingHook(this::onProxyPing)
-        this.agent.proxyInterface.addPlayerPreLoginHook(this::onPlayerPreLogin)
-        this.agent.proxyInterface.addPlayerLoginHook(this::onPlayerLogin)
-        this.agent.proxyInterface.addPlayerDisconnectHook(this::onPlayerDisconnect)
-        this.agent.proxyInterface.addServerPreConnectHook(this::onServerPreConnect)
-        this.agent.proxyInterface.addServerPostConnectHook(this::onServerPostConnect)
+        this.agent.proxyInterface.addProxyPingHook(this::onProxyPing, HookPostOrder.FIRST)
+        this.agent.proxyInterface.addPlayerPreLoginHook(this::onPlayerPreLogin, HookPostOrder.FIRST)
+        this.agent.proxyInterface.addPlayerLoginHook(this::onPlayerLogin, HookPostOrder.EARLY)
+        this.agent.proxyInterface.addPlayerDisconnectHook(this::onPlayerDisconnect, HookPostOrder.LATE)
+        this.agent.proxyInterface.addServerPreConnectHook(this::onServerPreConnect, HookPostOrder.EARLY)
+        this.agent.proxyInterface.addServerPostConnectHook(this::onServerPostConnect, HookPostOrder.LATE)
     }
 
     fun setAcceptingPlayers(acceptingPlayers: Boolean) {

diff --git a/...roxy-agent/src/velocity/kotlin/io/shulkermc/proxyagent/velocity/ProxyInterfaceVelocity.kt b/...roxy-agent/src/velocity/kotlin/io/shulkermc/proxyagent/velocity/ProxyInterfaceVelocity.kt
@@ -12,6 +12,7 @@ import com.velocitypowered.api.proxy.ProxyServer
 import com.velocitypowered.api.proxy.server.ServerInfo
 import com.velocitypowered.api.scheduler.ScheduledTask
 import io.shulkermc.proxyagent.ProxyInterface
+import io.shulkermc.proxyagent.platform.HookPostOrder
 import io.shulkermc.proxyagent.platform.PlayerDisconnectHook
 import io.shulkermc.proxyagent.platform.PlayerLoginHook
 import io.shulkermc.proxyagent.platform.PlayerPreLoginHook
@@ -43,15 +44,23 @@ class ProxyInterfaceVelocity(
         return this.proxy.getServer(name).isPresent
     }
 
-    override fun addProxyPingHook(hook: ProxyPingHook) {
-        this.proxy.eventManager.register(this.plugin, ProxyPingEvent::class.java, PostOrder.LAST) { event ->
+    override fun addProxyPingHook(hook: ProxyPingHook, postOrder: HookPostOrder) {
+        this.proxy.eventManager.register(
+            this.plugin,
+            ProxyPingEvent::class.java,
+            this.mapPostOrder(postOrder)
+        ) { event ->
             val result = hook()
             event.ping = event.ping.asBuilder().onlinePlayers(result.playerCount).build()
         }
     }
 
-    override fun addPlayerPreLoginHook(hook: PlayerPreLoginHook) {
-        this.proxy.eventManager.register(this.plugin, PreLoginEvent::class.java, PostOrder.FIRST) { event ->
+    override fun addPlayerPreLoginHook(hook: PlayerPreLoginHook, postOrder: HookPostOrder) {
+        this.proxy.eventManager.register(
+            this.plugin,
+            PreLoginEvent::class.java,
+            this.mapPostOrder(postOrder)
+        ) { event ->
             if (!event.result.isAllowed) return@register
             val result = hook()
 
@@ -61,20 +70,26 @@ class ProxyInterfaceVelocity(
         }
     }
 
-    override fun addPlayerLoginHook(hook: PlayerLoginHook) {
-        this.proxy.eventManager.register(this.plugin, LoginEvent::class.java, PostOrder.FIRST) { event ->
+    override fun addPlayerLoginHook(hook: PlayerLoginHook, postOrder: HookPostOrder) {
+        this.proxy.eventManager.register(this.plugin, LoginEvent::class.java, this.mapPostOrder(postOrder)) { event ->
             hook(wrapPlayer(event.player))
         }
     }
 
-    override fun addPlayerDisconnectHook(hook: PlayerDisconnectHook) {
-        this.proxy.eventManager.register(this.plugin, DisconnectEvent::class.java, PostOrder.LAST) { event ->
-            hook(this.wrapPlayer(event.player))
-        }
+    override fun addPlayerDisconnectHook(hook: PlayerDisconnectHook, postOrder: HookPostOrder) {
+        this.proxy.eventManager.register(
+            this.plugin,
+            DisconnectEvent::class.java,
+            this.mapPostOrder(postOrder)
+        ) { event -> hook(this.wrapPlayer(event.player)) }
     }
 
-    override fun addServerPreConnectHook(hook: ServerPreConnectHook) {
-        this.proxy.eventManager.register(this.plugin, ServerPreConnectEvent::class.java, PostOrder.LAST) { event ->
+    override fun addServerPreConnectHook(hook: ServerPreConnectHook, postOrder: HookPostOrder) {
+        this.proxy.eventManager.register(
+            this.plugin,
+            ServerPreConnectEvent::class.java,
+            this.mapPostOrder(postOrder)
+        ) { event ->
             if (!event.result.isAllowed) return@register
             val result = hook(this.wrapPlayer(event.player), event.originalServer.serverInfo.name)
 
@@ -87,10 +102,12 @@ class ProxyInterfaceVelocity(
     }
 
     @Suppress("UnstableApiUsage")
-    override fun addServerPostConnectHook(hook: ServerPostConnectHook) {
-        this.proxy.eventManager.register(this.plugin, ServerPostConnectEvent::class.java, PostOrder.LAST) { event ->
-            hook(this.wrapPlayer(event.player), event.player.currentServer.get().serverInfo.name)
-        }
+    override fun addServerPostConnectHook(hook: ServerPostConnectHook, postOrder: HookPostOrder) {
+        this.proxy.eventManager.register(
+            this.plugin,
+            ServerPostConnectEvent::class.java,
+            this.mapPostOrder(postOrder)
+        ) { event -> hook(this.wrapPlayer(event.player), event.player.currentServer.get().serverInfo.name) }
     }
 
     override fun teleportPlayerOnServer(playerName: String, serverName: String) {
@@ -147,6 +164,16 @@ class ProxyInterfaceVelocity(
         }
     }
 
+    private fun mapPostOrder(postOrder: HookPostOrder): PostOrder {
+        return when (postOrder) {
+            HookPostOrder.FIRST -> PostOrder.FIRST
+            HookPostOrder.EARLY -> PostOrder.EARLY
+            HookPostOrder.NORMAL -> PostOrder.NORMAL
+            HookPostOrder.LATE -> PostOrder.LATE
+            HookPostOrder.LAST -> PostOrder.LAST
+        }
+    }
+
     private class VelocityScheduledTask(private val velocityTask: ScheduledTask) : ProxyInterface.ScheduledTask {
         override fun cancel() {
             this.velocityTask.cancel()