feature: record when a server is hibernating

hasura/metadata/databases/default/tables/public_servers.yaml

@@ -124,6 +124,7 @@ select_permissions:
         - enabled
         - game
         - game_server_node_id
+        - hibernating
         - host
         - id
         - is_dedicated
@@ -157,6 +158,7 @@ select_permissions:
         - connected
         - enabled
         - game
+        - hibernating
         - host
         - id
         - label
@@ -190,6 +192,7 @@ select_permissions:
         - enabled
         - game
         - game_server_node_id
+        - hibernating
         - host
         - id
         - is_dedicated

hasura/migrations/default/1890000000720_servers_hibernating/down.sql

@@ -0,0 +1 @@
+ALTER TABLE public.servers DROP COLUMN IF EXISTS hibernating;

hasura/migrations/default/1890000000720_servers_hibernating/up.sql

@@ -0,0 +1 @@
+ALTER TABLE public.servers ADD COLUMN IF NOT EXISTS hibernating boolean NOT NULL DEFAULT false;

src/game-server-node/game-server-node.controller.spec.ts

@@ -70,3 +70,95 @@ describe("GameServerNodeController ping disk alerts", () => {
     expect(notifications.send).not.toHaveBeenCalled();
   });
 });
+
+describe("GameServerNodeController server ping hibernation", () => {
+  let hasura: { query: jest.Mock; mutation: jest.Mock };
+  let controller: GameServerNodeController;
+
+  const server = (hibernating: boolean) => ({
+    plugin_version: "1.0.0",
+    plugin_runtime: "swiftlys2",
+    connected: true,
+    hibernating,
+    enabled: true,
+    steam_relay: null as null,
+    is_dedicated: true,
+    game_server_node_id: null as null,
+    current_match: null as null,
+  });
+
+  const ping = (query: Record<string, string>) =>
+    controller.ping({
+      params: { serverId: "server-1" },
+      query: { map: "de_overpass", pluginVersion: "1.0.0", ...query },
+    } as any);
+
+  const setsHibernating = (hibernating: boolean) =>
+    expect.objectContaining({
+      update_servers_by_pk: expect.objectContaining({
+        __args: expect.objectContaining({ _set: { hibernating } }),
+      }),
+    });
+
+  beforeEach(() => {
+    hasura = {
+      query: jest.fn(),
+      mutation: jest.fn().mockResolvedValue({}),
+    };
+    const queue = { add: jest.fn(), remove: jest.fn() };
+
+    controller = new GameServerNodeController(
+      { warn: jest.fn(), log: jest.fn() } as any,
+      {} as any,
+      { get: jest.fn().mockReturnValue({}) } as any,
+      hasura as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      queue as any,
+      queue as any,
+      {} as any,
+      queue as any,
+      queue as any,
+      {} as any,
+      {} as any,
+    );
+  });
+
+  it("records a server that says it is hibernating", async () => {
+    hasura.query.mockResolvedValue({ servers_by_pk: server(false) });
+
+    await ping({ hibernating: "true" });
+
+    expect(hasura.mutation).toHaveBeenCalledWith(setsHibernating(true));
+  });
+
+  it("clears it once the server wakes", async () => {
+    hasura.query.mockResolvedValue({ servers_by_pk: server(true) });
+
+    await ping({ hibernating: "false" });
+
+    expect(hasura.mutation).toHaveBeenCalledWith(setsHibernating(false));
+  });
+
+  it("writes nothing while the state has not changed", async () => {
+    hasura.query.mockResolvedValue({ servers_by_pk: server(true) });
+
+    await ping({ hibernating: "true" });
+
+    expect(hasura.mutation).not.toHaveBeenCalledWith(setsHibernating(true));
+    expect(hasura.mutation).not.toHaveBeenCalledWith(setsHibernating(false));
+  });
+
+  // Plugins from before the flag existed never send it.
+  it("reads a plugin that does not say as awake", async () => {
+    hasura.query.mockResolvedValue({ servers_by_pk: server(true) });
+
+    await ping({});
+
+    expect(hasura.mutation).toHaveBeenCalledWith(setsHibernating(false));
+  });
+});

src/game-server-node/game-server-node.controller.ts

@@ -852,6 +852,7 @@ UNIT
         plugin_version: true,
         plugin_runtime: true,
         connected: true,
+        hibernating: true,
         enabled: true,
         steam_relay: true,
         is_dedicated: true,
@@ -884,6 +885,7 @@ UNIT
               pk_columns: { id: serverId },
               _set: {
                 connected: false,
+                hibernating: false,
                 offline_at: new Date().toISOString(),
               },
             },
@@ -897,6 +899,26 @@ UNIT
       return;
     }
 
+    // A server sleeping until someone connects is healthy, and says so on its
+    // ping. Plugins from before this never send the flag and read as awake.
+    const hibernating = request.query.hibernating === "true";
+
+    if (server.hibernating !== hibernating) {
+      await this.hasura.mutation({
+        update_servers_by_pk: {
+          __args: {
+            pk_columns: {
+              id: serverId,
+            },
+            _set: {
+              hibernating,
+            },
+          },
+          __typename: true,
+        },
+      });
+    }
+
     if (
       pluginVersion &&
       (server.plugin_version !== pluginVersion ||

src/game-server-node/jobs/MarkDedicatedServerOffline.spec.ts

@@ -70,6 +70,7 @@ describe("MarkDedicatedServerOffline", () => {
 
     expect(offlineWrite()).toEqual({
       connected: false,
+      hibernating: false,
       offline_at: expect.any(String),
     });
     expect(notifications.send).toHaveBeenCalledWith(

src/game-server-node/jobs/MarkDedicatedServerOffline.ts

@@ -57,6 +57,7 @@ export class MarkDedicatedServerOffline extends WorkerHost {
           },
           _set: {
             connected: false,
+            hibernating: false,
             offline_at: server.offline_at ?? new Date().toISOString(),
           },
         },