feat: swap to counts and lists for game tracking

Author: ZakShearman

build.gradle.kts

@@ -17,7 +17,7 @@ repositories {
 }
 
 dependencies {
-    api("dev.emortal.minestom:core:7b59658")
+    api("dev.emortal.minestom:core:844abe4")
 }
 
 java {

src/main/java/dev/emortal/minestom/gamesdk/MinestomGameServerImpl.java

@@ -90,11 +90,11 @@ static final class BuilderImpl implements Builder, Builder.EndStep {
 
             MessagingModule messaging = moduleProvider.getModule(MessagingModule.class);
             KubernetesModule kubernetesModule = moduleProvider.getModule(KubernetesModule.class);
-            boolean hasAgones = kubernetesModule != null && kubernetesModule.getSdk() != null;
+            boolean hasAgones = kubernetesModule != null && kubernetesModule.getAgonesSdk() != null;
 
             GameManager gameManager = new GameManager(config);
             if (!TEST_MODE && hasAgones) {
-                gameManager.addGameStatusListener(new AgonesGameStatusListener(config, kubernetesModule.getSdk()));
+                gameManager.addGameStatusListener(new AgonesGameStatusListener(gameManager, kubernetesModule));
             }
 
             if (messaging != null) {

src/main/java/dev/emortal/minestom/gamesdk/config/GameSdkConfig.java

@@ -8,10 +8,9 @@
  * The configuration that the game manager will use to create and manage games.
  *
  * @param minPlayers  the minimum players required for a game to start
- * @param maxGames    the maximum games that may run on the server at one time
  * @param gameCreator a function that can be called to create a game instance
  */
-public record GameSdkConfig(int minPlayers, int maxGames, int minTrackingInterval, int maxTrackingInterval,
+public record GameSdkConfig(int minPlayers, int minTrackingInterval, int maxTrackingInterval,
                             FinishBehaviour finishBehaviour, @NotNull GameCreator gameCreator) {
 
     public static @NotNull Builder builder() {
@@ -20,12 +19,7 @@ public record GameSdkConfig(int minPlayers, int maxGames, int minTrackingInterva
 
     public interface Builder {
 
-        @NotNull MaxGamesStep minPlayers(int minPlayers);
-
-        interface MaxGamesStep {
-
-            @NotNull GameCreatorStep maxGames(int maxGames);
-        }
+        @NotNull GameCreatorStep minPlayers(int minPlayers);
 
         interface GameCreatorStep {
 
@@ -44,27 +38,20 @@ interface EndStep {
         }
     }
 
-    private static final class BuilderImpl implements Builder, Builder.MaxGamesStep, Builder.GameCreatorStep, Builder.EndStep {
+    private static final class BuilderImpl implements Builder, Builder.GameCreatorStep, Builder.EndStep {
 
         private int minPlayers;
-        private int maxGames;
         private int minTrackingInterval = GameTracker.DEFAULT_MIN_UPDATE_INTERVAL;
         private int maxTrackingInterval = GameTracker.DEFAULT_MAX_UPDATE_INTERVAL;
         private FinishBehaviour finishBehaviour = FinishBehaviour.LOBBY;
         private GameCreator gameCreator;
 
         @Override
-        public @NotNull MaxGamesStep minPlayers(int minPlayers) {
+        public @NotNull GameCreatorStep minPlayers(int minPlayers) {
             this.minPlayers = minPlayers;
             return this;
         }
 
-        @Override
-        public @NotNull GameCreatorStep maxGames(int maxGames) {
-            this.maxGames = maxGames;
-            return this;
-        }
-
         @Override
         public @NotNull GameCreatorStep minTrackingInterval(int interval) {
             this.minTrackingInterval = interval;
@@ -91,7 +78,7 @@ private static final class BuilderImpl implements Builder, Builder.MaxGamesStep,
 
         @Override
         public @NotNull GameSdkConfig build() {
-            return new GameSdkConfig(this.minPlayers, this.maxGames, this.minTrackingInterval, this.maxTrackingInterval,
+            return new GameSdkConfig(this.minPlayers, this.minTrackingInterval, this.maxTrackingInterval,
                     this.finishBehaviour, this.gameCreator);
         }
     }

src/main/java/dev/emortal/minestom/gamesdk/game/GameProvider.java

@@ -7,4 +7,6 @@
 public interface GameProvider {
 
     @Nullable Game findGame(@NotNull Player player);
+
+    int getGameCount();
 }

src/main/java/dev/emortal/minestom/gamesdk/internal/GameManager.java

@@ -151,6 +151,11 @@ private void kickAllRemainingPlayers(@NotNull Game game) {
         return null;
     }
 
+    @Override
+    public int getGameCount() {
+        return this.games.size();
+    }
+
     public @NotNull Set<Game> getGames() {
         return this.games;
     }

src/main/java/dev/emortal/minestom/gamesdk/internal/listener/AgonesGameStatusListener.java

@@ -2,12 +2,16 @@
 
 import dev.agones.sdk.AgonesSDKProto;
 import dev.agones.sdk.SDKGrpc;
+import dev.agones.sdk.beta.BetaAgonesSDKProto;
 import dev.emortal.api.agonessdk.IgnoredStreamObserver;
+import dev.emortal.minestom.core.module.kubernetes.KubernetesModule;
 import dev.emortal.minestom.gamesdk.config.GameSdkConfig;
 import dev.emortal.minestom.gamesdk.game.Game;
+
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import dev.emortal.minestom.gamesdk.game.GameProvider;
 import net.minestom.server.MinecraftServer;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
@@ -16,56 +20,26 @@
 public final class AgonesGameStatusListener implements GameStatusListener {
     private static final Logger LOGGER = LoggerFactory.getLogger(AgonesGameStatusListener.class);
 
-    private final @NotNull GameSdkConfig config;
+    private final @NotNull GameProvider gameProvider;
+    private final @NotNull KubernetesModule kubeModule;
     private final @NotNull SDKGrpc.SDKStub sdk;
 
-    private final AtomicInteger gameCount = new AtomicInteger(0);
-    private final AtomicBoolean shouldAllocate = new AtomicBoolean(false);
-
-    public AgonesGameStatusListener(@NotNull GameSdkConfig config, @NotNull SDKGrpc.SDKStub sdk) {
-        this.config = config;
-        this.sdk = sdk;
-    }
-
-    @Override
-    public void onGameAdded(@NotNull Game game) {
-        int newGameCount = this.gameCount.incrementAndGet();
-        this.updateShouldAllocate(newGameCount);
+    public AgonesGameStatusListener(@NotNull GameProvider gameProvider, @NotNull KubernetesModule kubeModule) {
+        this.kubeModule = kubeModule;
+        this.gameProvider = gameProvider;
+        this.sdk = kubeModule.getAgonesSdk();
     }
 
     @Override
     public void onGameRemoved(@NotNull Game game) {
-        int newGameCount = this.gameCount.decrementAndGet();
-        this.updateShouldAllocate(newGameCount);
-        this.updateReadyIfEmpty(newGameCount);
-    }
-
-    private void updateShouldAllocate(int gameCount) {
-        boolean allocate = gameCount < this.config.maxGames();
-
-        boolean changed = this.shouldAllocate.getAndSet(allocate) != allocate;
-        // If the current value is the same as the new value, don't bother updating
-        if (!changed) return;
-
-        LOGGER.info("Updating should allocate to {} (game count: {})", allocate, gameCount);
-
-        AgonesSDKProto.KeyValue keyValue = AgonesSDKProto.KeyValue.newBuilder()
-                .setKey("should-allocate")
-                .setValue(String.valueOf(allocate))
-                .build();
-        Thread.startVirtualThread(() -> this.sdk.setLabel(keyValue, new IgnoredStreamObserver<>()));
-    }
-
-    private void updateReadyIfEmpty(int gameCount) {
-        int playerCount = MinecraftServer.getConnectionManager().getOnlinePlayers().size();
-        if (playerCount > 0) return;
-
-        if (gameCount > 0) {
-            // This is really weird. This would only happen if a game didn't unregister itself properly.
-            LOGGER.warn("No players online, but there are still games running.");
-        }
-
-        LOGGER.info("Marking server as ready as no players are online.");
-        Thread.startVirtualThread(() -> this.sdk.ready(AgonesSDKProto.Empty.getDefaultInstance(), new IgnoredStreamObserver<>()));
+        Thread.startVirtualThread(() -> {
+            this.kubeModule.updateAgonesCounter("games", -1);
+            this.kubeModule.removeFromAgonesList("games", game.getCreationInfo().id());
+
+            if (this.gameProvider.getGameCount() == 0) {
+                LOGGER.info("Marking server as ready as no players are online.");
+                Thread.startVirtualThread(() -> this.sdk.ready(AgonesSDKProto.Empty.getDefaultInstance(), new IgnoredStreamObserver<>()));
+            }
+        });
     }
 }