feat: rotate static game servers

Author: garrappachc

src/admin/game-servers/views/html/game-servers.page.tsx

@@ -1,10 +1,14 @@
 import type { User } from '../../../../auth/types/user'
 import { Admin } from '../../../views/html/admin'
+import { StaticGameServerList } from './static-game-server-list'
 
-export function GameServersPage(props: { user: User }) {
+export async function GameServersPage(props: { user: User }) {
   return (
     <Admin activePage="game-servers" user={props.user}>
-      <div class="admin-panel-set"></div>
+      <div class="admin-panel-set">
+        <h4 class="pb-4">Static servers</h4>
+        <StaticGameServerList />
+      </div>
     </Admin>
   )
 }

src/admin/game-servers/views/html/static-game-server-list.tsx

@@ -0,0 +1,66 @@
+import { collections } from '../../../../database/collections'
+import type { StaticGameServerModel } from '../../../../database/models/static-game-server.model'
+import { IconCheck, IconX } from '../../../../html/components/icons'
+
+export async function StaticGameServerList() {
+  const staticGameServers = await collections.staticGameServers
+    .find()
+    .sort({ isOnline: -1, lastHeartbeatAt: -1, priority: -1 })
+    .toArray()
+
+  return (
+    <table class="w-full table-auto" id="admin-panel-static-game-server-list">
+      <thead>
+        <tr>
+          <th class="border-b border-ash/50 pb-3 text-left">Name</th>
+          <th class="border-b border-ash/50 pb-3 text-left">IP address</th>
+          <th class="border-b border-ash/50 pb-3 text-left">Internal IP address</th>
+          <th class="border-b border-ash/50 pb-3 text-left">RCON password</th>
+          <th class="border-b border-ash/50 pb-3 text-left">Online</th>
+          <th class="border-b border-ash/50 pb-3 text-left"></th>
+        </tr>
+      </thead>
+
+      <tbody>
+        {staticGameServers.map(gameServer => (
+          <StaticGameServerItem gameServer={gameServer} />
+        ))}
+      </tbody>
+    </table>
+  )
+}
+
+function StaticGameServerItem(props: { gameServer: StaticGameServerModel }) {
+  return (
+    <tr>
+      <td class="border-b border-ash/20 py-4 font-bold" safe>
+        {props.gameServer.name}
+      </td>
+      <td class="border-b border-ash/20 py-4" safe>
+        {props.gameServer.address}:{props.gameServer.port}
+      </td>
+      <td class="border-b border-ash/20 py-4" safe>
+        {props.gameServer.internalIpAddress}:{props.gameServer.port}
+      </td>
+      <td class="border-b border-ash/20 py-4" safe>
+        {props.gameServer.rconPassword}
+      </td>
+      <td class="border-b border-ash/20 py-4">
+        {props.gameServer.isOnline ? (
+          <IconCheck class="text-green-600" />
+        ) : (
+          <IconX class="text-red-600" />
+        )}
+      </td>
+      <td class="min-w-[60px] border-b border-ash/20 py-4">
+        {props.gameServer.game ? (
+          <a href={`/games/${props.gameServer.game}`} safe>
+            #{props.gameServer.game}
+          </a>
+        ) : (
+          <></>
+        )}
+      </td>
+    </tr>
+  )
+}

src/game-servers/assign.ts

@@ -10,30 +10,30 @@ const mutex = new Mutex()
 
 export async function assign(game: GameModel) {
   await mutex.runExclusive(async () => {
-    const freeServer = await staticGameServers.findFree()
-    if (!freeServer) {
+    const staticGameServer = await staticGameServers.assign(game)
+    if (!staticGameServer) {
       throw new Error(`no free servers available for game ${game.number}`)
     }
 
     game = await games.update(game.number, {
       $set: {
         gameServer: {
-          id: freeServer.id,
-          name: freeServer.name,
-          address: freeServer.address,
-          port: freeServer.port,
+          id: staticGameServer.id,
+          name: staticGameServer.name,
+          address: staticGameServer.address,
+          port: staticGameServer.port,
           provider: GameServerProvider.static,
         },
       },
       $push: {
         events: {
           event: GameEventType.gameServerAssigned,
           at: new Date(),
-          gameServerName: freeServer.name,
+          gameServerName: staticGameServer.name,
         },
       },
     })
-    logger.info({ game }, `game ${game.number} assigned to game server ${freeServer.name}`)
+    logger.info({ game }, `game ${game.number} assigned to game server ${staticGameServer.name}`)
     events.emit('game:gameServerAssigned', { game })
   })
 }

src/game-servers/plugins/auto-assign-game-server.ts

@@ -3,16 +3,16 @@ import { events } from '../../events'
 import { assign } from '../assign'
 import { getOrphanedGames } from '../get-orphaned-games'
 import { logger } from '../../logger'
+import { safe } from '../../utils/safe'
 
 export default fp(
   async () => {
-    events.on('game:created', async ({ game }) => {
-      try {
+    events.on(
+      'game:created',
+      safe(async ({ game }) => {
         await assign(game)
-      } catch (error) {
-        logger.error(error)
-      }
-    })
+      }),
+    )
 
     const orphanedGames = await getOrphanedGames()
     for (const game of orphanedGames) {

src/html/components/icons/icon-check.tsx

@@ -0,0 +1,9 @@
+import { makeIcon } from './make-icon'
+
+export const IconCheck = makeIcon(
+  'check',
+  <>
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <path d="M5 12l5 5l10 -10" />
+  </>,
+)

src/html/components/icons/index.ts

@@ -8,6 +8,7 @@ export { IconBrandDiscord } from './icon-brand-discord'
 export { IconChartArrowsVertical } from './icon-chart-arrows-vertical'
 export { IconBrandSteam } from './icon-brand-steam'
 export { IconChartPie } from './icon-chart-pie'
+export { IconCheck } from './icon-check'
 export { IconChevronLeft } from './icon-chevron-left'
 export { IconChevronRight } from './icon-chevron-right'
 export { IconCoffee } from './icon-coffee'

src/static-game-servers/assign.ts

@@ -0,0 +1,26 @@
+import { Mutex } from 'async-mutex'
+import type { GameModel } from '../database/models/game.model'
+import { findFree } from './find-free'
+import { update } from './update'
+
+const mutex = new Mutex()
+
+export async function assign(game: GameModel) {
+  return await mutex.runExclusive(async () => {
+    const before = await findFree()
+    if (!before) {
+      throw new Error(`no free servers available for game ${game.number}`)
+    }
+
+    return await update(
+      {
+        id: before.id,
+      },
+      {
+        $set: {
+          game: game.number,
+        },
+      },
+    )
+  })
+}

src/static-game-servers/index.ts

@@ -4,8 +4,11 @@ import type { ZodTypeProvider } from 'fastify-type-provider-zod'
 import { z } from 'zod'
 import { logger } from '../logger'
 import { heartbeat } from './heartbeat'
+import { resolve } from 'node:path'
+import { assign } from './assign'
 
 export const staticGameServers = {
+  assign,
   findFree,
 } as const
 
@@ -16,7 +19,7 @@ export default fp(
       address: z.string(),
       port: z.string(),
       rconPassword: z.string(),
-      priority: z.coerce.number().optional(),
+      priority: z.coerce.number().default(0),
       internalIpAddress: z.string().optional(),
     })
 
@@ -38,14 +41,16 @@ export default fp(
           address,
           port,
           rconPassword,
-          priority: priority ?? 0,
+          priority: priority,
           internalIpAddress: internalIpAddress ?? req.ip,
         })
         await reply.status(200).send()
       },
     )
 
-    await app.register((await import('./plugins/remove-dead-game-servers')).default)
+    await app.register((await import('@fastify/autoload')).default, {
+      dir: resolve(import.meta.dirname, 'plugins'),
+    })
   },
   { name: 'static game servers' },
 )

src/static-game-servers/plugins/free-game-servers.ts

@@ -0,0 +1,31 @@
+import fp from 'fastify-plugin'
+import { events } from '../../events'
+import { update } from '../update'
+import { tasks } from '../../tasks'
+import { secondsToMilliseconds } from 'date-fns'
+import { whenGameEnds } from '../../games/when-game-ends'
+import { GameServerProvider } from '../../database/models/game.model'
+
+const freeGameServerDelay = secondsToMilliseconds(30)
+
+export default fp(
+  async () => {
+    tasks.register('staticGameServers:free', async ({ id }) => {
+      await update({ id }, { $unset: { game: 1 } })
+    })
+
+    events.on(
+      'game:updated',
+      whenGameEnds(({ after }) => {
+        if (after.gameServer?.provider !== GameServerProvider.static) {
+          return
+        }
+
+        tasks.schedule('staticGameServers:free', freeGameServerDelay, { id: after.gameServer.id })
+      }),
+    )
+  },
+  {
+    name: 'free static game servers',
+  },
+)

src/static-game-servers/plugins/remove-dead-game-servers.ts

@@ -2,25 +2,21 @@ import { subMinutes } from 'date-fns'
 import fp from 'fastify-plugin'
 import { collections } from '../../database/collections'
 import { Cron } from 'croner'
-
-async function removeDeadGameServers() {
-  const fiveMinutesAgo = subMinutes(new Date(), 5)
-  await collections.staticGameServers.updateMany(
-    {
-      isOnline: true,
-      lastHeartbeatAt: { $lt: fiveMinutesAgo },
-    },
-    {
-      $set: {
-        isOnline: false,
-      },
-    },
-  )
-}
+import { update } from '../update'
 
 export default fp(
   // eslint-disable-next-line @typescript-eslint/require-await
   async () => {
+    async function removeDeadGameServers() {
+      const fiveMinutesAgo = subMinutes(new Date(), 5)
+      const dead = await collections.staticGameServers
+        .find({ isOnline: true, lastHeartbeatAt: { $lt: fiveMinutesAgo } })
+        .toArray()
+      for (const server of dead) {
+        await update({ id: server.id }, { $set: { isOnline: false } })
+      }
+    }
+
     // run every minute
     new Cron('* * * * *', removeDeadGameServers)
   },

src/static-game-servers/plugins/sync-clients.ts

@@ -0,0 +1,15 @@
+import fp from 'fastify-plugin'
+import { events } from '../../events'
+import { StaticGameServerList } from '../../admin/game-servers/views/html/static-game-server-list'
+
+export default fp(async app => {
+  events.on('staticGameServer:updated', () => {
+    const list = StaticGameServerList()
+    app.gateway.broadcast(() => list)
+  })
+
+  events.on('staticGameServer:added', () => {
+    const list = StaticGameServerList()
+    app.gateway.broadcast(() => list)
+  })
+})

src/static-game-servers/update.ts

@@ -0,0 +1,29 @@
+import type { StrictFilter, StrictUpdateFilter } from 'mongodb'
+import type { StaticGameServerModel } from '../database/models/static-game-server.model'
+import { Mutex } from 'async-mutex'
+import { collections } from '../database/collections'
+import { events } from '../events'
+
+const mutex = new Mutex()
+
+export async function update(
+  filter: StrictFilter<StaticGameServerModel>,
+  update: StrictUpdateFilter<StaticGameServerModel>,
+): Promise<StaticGameServerModel> {
+  return await mutex.runExclusive(async () => {
+    const before = await collections.staticGameServers.findOne(filter)
+    if (!before) {
+      throw new Error(`static game server (${JSON.stringify(filter)}) not found`)
+    }
+
+    const after = await collections.staticGameServers.findOneAndUpdate(filter, update, {
+      returnDocument: 'after',
+    })
+    if (!after) {
+      throw new Error(`can't update static game server ${JSON.stringify(filter)}`)
+    }
+
+    events.emit('staticGameServer:updated', { before, after })
+    return after
+  })
+}

src/tasks/tasks.ts

@@ -30,6 +30,10 @@ export const tasksSchema = z.discriminatedUnion('name', [
     name: z.literal('queue:unready'),
     args: z.object({}),
   }),
+  z.object({
+    name: z.literal('staticGameServers:free'),
+    args: z.object({ id: z.string() }),
+  }),
 ])
 
 type TasksT = z.infer<typeof tasksSchema>