@babylonjs-toolkit/server 0.0.0-stage → 9.35.0

package/lib/leaderboards/LeaderboardScheduler.js

@@ -0,0 +1,103 @@
+// The leaderboard scheduler (game-server-leaderboards D17, D21): on the holder of LEADERBOARD_SCHEDULER_LEASE it resets
+// every board whose next reset is due and trims the activity stream. Resets are compare-and-set writes, so two processes
+// never reset a board twice.
+import { getLogger } from "../GameServerLogger.js";
+import { LEADERBOARD_ACTIVITY_KEEP, LEADERBOARD_SCHEDULER_LEASE, LEADERBOARD_SCHEDULER_LEASE_TTL_MS } from "./LeaderboardConstants.js";
+/** Admin store stream of the activity (D21). */
+const ACTIVITY_STREAM = "leaderboardActivity";
+/** Scheduled season resets and activity trimming, run on the lease holder (D17). */
+export class LeaderboardScheduler {
+    /** The service whose boards are reset. */
+    service;
+    /** The admin store (lease and activity). */
+    adminStore;
+    /** The service clock (timers and "now"). */
+    clock;
+    /** This process's id, read lazily (matchMaker.processId). */
+    processId;
+    /** Milliseconds between ticks. */
+    tickMs;
+    /** The interval handle while started, or null. */
+    intervalHandle = null;
+    /** The tick in progress, or null; a tick that comes due meanwhile is skipped. */
+    runningTick = null;
+    /**
+     * Creates the scheduler (nothing runs until start()).
+     * @param service The leaderboard service.
+     * @param adminStore The admin store.
+     * @param clock The service clock.
+     * @param processId This process's id.
+     * @param tickMs Milliseconds between ticks.
+     */
+    constructor(service, adminStore, clock, processId, tickMs) {
+        this.service = service;
+        this.adminStore = adminStore;
+        this.clock = clock;
+        this.processId = processId;
+        this.tickMs = tickMs;
+    }
+    /** Starts ticking every tickMs (a second call does nothing). */
+    start() {
+        if (this.intervalHandle != null)
+            return;
+        this.intervalHandle = this.clock.setInterval(() => void this.tick(), this.tickMs);
+    }
+    /** Stops ticking and waits for a tick in progress. */
+    async stop() {
+        if (this.intervalHandle != null)
+            this.clock.clearInterval(this.intervalHandle);
+        this.intervalHandle = null;
+        if (this.runningTick != null)
+            await this.runningTick;
+    }
+    /**
+     * One tick: when this process holds the lease, resets every due board and trims the activity stream. Never throws;
+     * failures are logged at warn.
+     * @returns Resolves when the tick is done (the running tick when one is in progress).
+     */
+    tick() {
+        if (this.runningTick != null)
+            return this.runningTick;
+        this.runningTick = this.runOnce().finally(() => {
+            this.runningTick = null;
+        });
+        return this.runningTick;
+    }
+    /** The work of one tick. */
+    async runOnce() {
+        try {
+            const holdsLease = await this.adminStore.tryAcquireLease(LEADERBOARD_SCHEDULER_LEASE, this.processId(), LEADERBOARD_SCHEDULER_LEASE_TTL_MS);
+            if (!holdsLease)
+                return;
+            await this.resetDueBoards();
+            await this.adminStore.trimRecordsToCount(ACTIVITY_STREAM, LEADERBOARD_ACTIVITY_KEEP);
+        }
+        catch (error) {
+            getLogger().warn("leaderboard scheduler tick failed", { error: errorText(error) });
+        }
+    }
+    /** Resets every board whose nextResetAt has come; a failing board is logged and the others still run. */
+    async resetDueBoards() {
+        const nowMs = this.clock.now();
+        const boards = await this.service.listBoardRecords();
+        for (const stored of boards) {
+            const nextResetAt = stored.value.nextResetAt;
+            if (nextResetAt == null || Date.parse(nextResetAt) > nowMs)
+                continue;
+            try {
+                await this.service.resetSeason(stored.id, "schedule");
+            }
+            catch (error) {
+                getLogger().warn("leaderboard scheduled reset failed", { boardId: stored.id, error: errorText(error) });
+            }
+        }
+    }
+}
+/**
+ * The message of an error.
+ * @param error Anything thrown.
+ * @returns Its message.
+ */
+function errorText(error) {
+    return (error instanceof Error) ? error.message : String(error);
+}