fix(shulker-proxy-agent): crash when LoadBalancer service does not have any ingress in status

packages/shulker-operator/src/reconcilers/minecraft_cluster/proxy_role.rs

@@ -60,7 +60,7 @@ impl<'a> ResourceBuilder<'a> for ProxyRoleBuilder {
                 PolicyRule {
                     api_groups: Some(vec!["".to_string()]),
                     resources: Some(vec!["services".to_string()]),
-                    verbs: vec!["get".to_string()],
+                    verbs: vec!["get".to_string(), "watch".to_string()],
                     ..PolicyRule::default()
                 },
                 PolicyRule {

packages/shulker-operator/src/reconcilers/minecraft_cluster/snapshots/shulker_operator__reconcilers__minecraft_cluster__proxy_role__tests__build_snapshot.snap

@@ -30,6 +30,7 @@ rules:
       - services
     verbs:
       - get
+      - watch
   - apiGroups:
       - ""
     resources:

packages/shulker-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/adapters/kubernetes/ImplKubernetesGatewayAdapter.kt

@@ -2,9 +2,11 @@ package io.shulkermc.proxyagent.adapters.kubernetes
 
 import io.fabric8.kubernetes.api.model.ObjectReference
 import io.fabric8.kubernetes.api.model.ObjectReferenceBuilder
+import io.fabric8.kubernetes.api.model.Service
 import io.fabric8.kubernetes.client.KubernetesClient
 import io.fabric8.kubernetes.client.KubernetesClientBuilder
 import io.fabric8.kubernetes.client.informers.ResourceEventHandler
+import io.fabric8.kubernetes.client.informers.SharedIndexInformer
 import io.fabric8.kubernetes.client.okhttp.OkHttpClientFactory
 import io.shulkermc.proxyagent.Configuration
 import io.shulkermc.proxyagent.adapters.kubernetes.models.AgonesV1GameServer
@@ -16,6 +18,8 @@ class ImplKubernetesGatewayAdapter(proxyNamespace: String, proxyName: String) :
     companion object {
         private const val PROXY_INFORMER_SYNC_MS = 30L * 1000
         private const val SERVER_INFORMER_SYNC_MS = 10L * 1000
+        private const val SERVICE_INFORMER_SYNC_MS = 30L * 1000
+        private const val MINECRAFT_DEFAULT_PORT = 25565
     }
 
     private val kubernetesClient: KubernetesClient =
@@ -48,27 +52,13 @@ class ImplKubernetesGatewayAdapter(proxyNamespace: String, proxyName: String) :
         ).list()
     }
 
-    override fun getFleetServiceAddress(): Optional<InetSocketAddress> {
-        if (Configuration.PROXY_PREFERRED_RECONNECT_ADDRESS.isPresent) {
-            return Configuration.PROXY_PREFERRED_RECONNECT_ADDRESS
-        }
-
-        val service =
+    override fun getExternalAddress(): Optional<InetSocketAddress> {
+        return this.getExternalAddressFromService(
             this.kubernetesClient.services()
                 .inNamespace(Configuration.PROXY_NAMESPACE)
                 .withName(Configuration.PROXY_FLEET_NAME)
-                .get()
-
-        if (service.spec.type != "LoadBalancer") {
-            return Optional.empty()
-        }
-
-        return try {
-            val ingress = service.status.loadBalancer.ingress[0]
-            Optional.of(InetSocketAddress(ingress.ip, ingress.ports[0].port))
-        } catch (_: NullPointerException) {
-            Optional.empty()
-        }
+                .get(),
+        )
     }
 
     override fun watchProxyEvents(
@@ -81,14 +71,7 @@ class ImplKubernetesGatewayAdapter(proxyNamespace: String, proxyName: String) :
                 .withLabel("app.kubernetes.io/component", "proxy")
                 .inform(eventHandler, PROXY_INFORMER_SYNC_MS)
 
-        return proxyInformer.start()
-            .thenApply {
-                object : KubernetesGatewayAdapter.EventWatcher {
-                    override fun stop() {
-                        proxyInformer.stop()
-                    }
-                }
-            }
+        return this.createEventWatcher(proxyInformer)
     }
 
     override fun watchMinecraftServerEvents(
@@ -101,12 +84,32 @@ class ImplKubernetesGatewayAdapter(proxyNamespace: String, proxyName: String) :
                 .withLabel("app.kubernetes.io/component", "minecraft-server")
                 .inform(eventHandler, SERVER_INFORMER_SYNC_MS)
 
-        return minecraftServerInformer.start().thenApply {
-            object : KubernetesGatewayAdapter.EventWatcher {
-                override fun stop() {
-                    minecraftServerInformer.stop()
-                }
+        return this.createEventWatcher(minecraftServerInformer)
+    }
+
+    override fun watchExternalAddressUpdates(
+        callback: (address: Optional<InetSocketAddress>) -> Unit,
+    ): CompletionStage<KubernetesGatewayAdapter.EventWatcher> {
+        val eventHandler =
+            this.createEventHandler<Service> { _, service ->
+                callback(this.getExternalAddressFromService(service))
             }
+
+        val serviceInformer =
+            this.kubernetesClient.services()
+                .inNamespace(Configuration.PROXY_NAMESPACE)
+                .withName(Configuration.PROXY_FLEET_NAME)
+                .inform(eventHandler, SERVICE_INFORMER_SYNC_MS)
+
+        return this.createEventWatcher(serviceInformer)
+    }
+
+    private fun getExternalAddressFromService(service: Service): Optional<InetSocketAddress> {
+        return if (service.spec.type == "LoadBalancer") {
+            Optional.ofNullable(service.status.loadBalancer?.ingress?.firstOrNull())
+                .map { ingress -> InetSocketAddress(ingress.ip, MINECRAFT_DEFAULT_PORT) }
+        } else {
+            Optional.empty()
         }
     }
 
@@ -131,4 +134,14 @@ class ImplKubernetesGatewayAdapter(proxyNamespace: String, proxyName: String) :
             }
         }
     }
+
+    private fun <T> createEventWatcher(informer: SharedIndexInformer<T>): CompletionStage<KubernetesGatewayAdapter.EventWatcher> {
+        return informer.start().thenApply {
+            object : KubernetesGatewayAdapter.EventWatcher {
+                override fun stop() {
+                    informer.stop()
+                }
+            }
+        }
+    }
 }

packages/shulker-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/adapters/kubernetes/KubernetesGatewayAdapter.kt

@@ -16,7 +16,7 @@ interface KubernetesGatewayAdapter {
 
     fun listMinecraftServers(): AgonesV1GameServer.List
 
-    fun getFleetServiceAddress(): Optional<InetSocketAddress>
+    fun getExternalAddress(): Optional<InetSocketAddress>
 
     fun watchProxyEvents(
         callback: (action: WatchAction, proxy: AgonesV1GameServer) -> Unit,
@@ -26,6 +26,10 @@ interface KubernetesGatewayAdapter {
         callback: (action: WatchAction, minecraftServer: AgonesV1GameServer) -> Unit,
     ): CompletionStage<EventWatcher>
 
+    fun watchExternalAddressUpdates(
+        callback: (address: Optional<InetSocketAddress>) -> Unit,
+    ): CompletionStage<EventWatcher>
+
     interface EventWatcher {
         fun stop()
     }

packages/shulker-proxy-agent/src/common/kotlin/io/shulkermc/proxyagent/services/PlayerMovementService.kt

@@ -11,6 +11,7 @@ import io.shulkermc.proxyagent.platform.ProxyPingHookResult
 import io.shulkermc.proxyagent.platform.ServerPreConnectHookResult
 import io.shulkermc.proxyagent.utils.createDisconnectMessage
 import net.kyori.adventure.text.format.NamedTextColor
+import java.net.InetSocketAddress
 import java.util.Optional
 import java.util.UUID
 
@@ -51,26 +52,20 @@ class PlayerMovementService(private val agent: ShulkerProxyAgentCommon) {
             java.util.concurrent.TimeUnit.SECONDS,
         )
 
-    private val externalClusterAddress = this.agent.kubernetesGateway.getFleetServiceAddress()
-
+    private var externalClusterAddress: Optional<InetSocketAddress> = Optional.empty()
     private var isAllocatedByAgones = false
     private var acceptingPlayers = true
 
     init {
-        this.externalClusterAddress.ifPresentOrElse({ addr ->
-            this.agent.logger.info("Found fleet's external address: ${addr.hostName}")
-        }, {
-            this.agent.logger.info(
-                "Fleet external address was not found, transfer capabilities will be disabled",
-            )
-        })
-
         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)
+
+        this.onExternalAddressUpdate(this.agent.kubernetesGateway.getExternalAddress())
+        this.agent.kubernetesGateway.watchExternalAddressUpdates(this::onExternalAddressUpdate)
     }
 
     fun setAcceptingPlayers(acceptingPlayers: Boolean) {
@@ -174,6 +169,18 @@ class PlayerMovementService(private val agent: ShulkerProxyAgentCommon) {
         this.agent.cache.setPlayerPosition(player.uniqueId, Configuration.PROXY_NAME, serverName)
     }
 
+    private fun onExternalAddressUpdate(address: Optional<InetSocketAddress>) {
+        this.externalClusterAddress = address
+
+        if (address.isPresent) {
+            this.agent.logger.info("Updated fleet's external address: ${address.get()}")
+        } else {
+            this.agent.logger.warning(
+                "Fleet external address was not found or removed, transfer capabilities are disabled",
+            )
+        }
+    }
+
     private fun isProxyConsideredFull(): Boolean {
         return this.agent.proxyInterface.getPlayerCount() >= this.maxPlayersWithExclusionDelta
     }