feat(games): use logsecret to match game events (#1161)

.vscode/settings.json

@@ -0,0 +1,22 @@
+{
+  "cSpell.words": [
+    "Configurator",
+    "Cooldown",
+    "Logsecret",
+    "Logsecrets",
+    "Microtasks",
+    "demoman",
+    "ma",
+    "mały",
+    "mongod",
+    "nestjs",
+    "patreon",
+    "pyro",
+    "rcon",
+    "snakewater",
+    "tftrue",
+    "typegoose",
+    "upsert",
+    "y"
+  ]
+}

package.json

@@ -50,7 +50,6 @@
     "reflect-metadata": "0.1.13",
     "rimraf": "3.0.2",
     "rxjs": "7.3.0",
-    "srcds-log-receiver": "1.0.2",
     "steamid": "2.0.0"
   },
   "devDependencies": {

src/game-servers/diagnostic-checks/log-forwarding.ts

@@ -1,11 +1,16 @@
 import { Environment } from '@/environment/environment';
-import { logAddressAdd, logAddressDel } from '@/games/utils/rcon-commands';
+import {
+  logAddressAdd,
+  logAddressDel,
+  svLogsecret,
+} from '@/games/utils/rcon-commands';
+import { LogReceiverService } from '@/log-receiver/services/log-receiver.service';
 import { Injectable, Scope } from '@nestjs/common';
 import { generate } from 'generate-password';
 import { Rcon } from 'rcon-client/lib';
-import { LogMessage, LogReceiver } from 'srcds-log-receiver';
 import { DiagnosticCheckResult } from '../interfaces/diagnostic-check-result';
 import { DiagnosticCheckRunner } from '../interfaces/diagnostic-check-runner';
+import { generateLogsecret } from '../utils/generate-logsecret';
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -15,7 +20,7 @@ export class LogForwarding implements DiagnosticCheckRunner {
   critical = true;
 
   constructor(
-    private logReceiver: LogReceiver,
+    private logReceiverService: LogReceiverService,
     private environment: Environment,
   ) {}
 
@@ -30,21 +35,25 @@ export class LogForwarding implements DiagnosticCheckRunner {
     }
 
     return new Promise((resolve) => {
+      const logSecret = generateLogsecret();
       const secret = generate({ length: 32, numbers: true });
       const timer = setTimeout(
         () =>
           resolve({
             success: false,
             reportedErrors: [
-              `No logs received over the UDP protocol on port ${this.logReceiver.opts.port}. Check your firewall settings.`,
+              `No logs received over the UDP protocol on port ${this.environment.logRelayPort}. Check your firewall settings.`,
             ],
             reportedWarnings: [],
           }),
         5000,
       );
 
-      this.logReceiver.on('data', (data: LogMessage) => {
-        if (new RegExp(`Console.+say\\s"${secret}"$`).test(data.message)) {
+      const subscription = this.logReceiverService.data.subscribe((data) => {
+        if (
+          data.password === logSecret &&
+          new RegExp(`Console.+say\\s"${secret}"$`).test(data.payload)
+        ) {
           clearTimeout(timer);
           resolve({
             success: true,
@@ -56,10 +65,13 @@ export class LogForwarding implements DiagnosticCheckRunner {
 
       const logAddress = `${this.environment.logRelayAddress}:${this.environment.logRelayPort}`;
       rcon
-        .send(logAddressAdd(logAddress))
+        .send(svLogsecret(logSecret))
+        .then(() => rcon.send(logAddressAdd(logAddress)))
         .then(() => sleep(1000))
         .then(() => rcon.send(`say ${secret}`))
-        .then(() => rcon.send(logAddressDel(logAddress)));
+        .then(() => rcon.send(logAddressDel(logAddress)))
+        .then(() => rcon.send(svLogsecret()))
+        .then(() => subscription.unsubscribe());
     });
   }
 }

src/game-servers/models/game-server.ts

@@ -31,9 +31,6 @@ export class GameServer extends MongooseDocument {
   @Prop({ default: false })
   isOnline?: boolean; // was the server online last we checked
 
-  @Prop({ type: () => [String], index: true })
-  resolvedIpAddresses?: string[]; // for tracing game server logs
-
   @Prop()
   mumbleChannelName?: string;
 

src/game-servers/services/game-servers.service.spec.ts

@@ -142,33 +142,11 @@ describe('GameServersService', () => {
         });
       });
 
-      it('should resolve ip addresses', () => {
-        expect(gameServer.resolvedIpAddresses).toEqual(['1.2.3.4']);
-      });
-
       it('should save the mumble channel', () => {
         expect(gameServer.mumbleChannelName).toEqual('some mumble channel');
       });
     });
 
-    describe('when the address is a raw IP address', () => {
-      let gameServer: GameServer;
-
-      beforeEach(async () => {
-        gameServer = await service.addGameServer({
-          name: 'test game server',
-          address: '151.80.108.144',
-          port: '27017',
-          rconPassword: 'test rcon password',
-          mumbleChannelName: 'some mumble channel name',
-        });
-      });
-
-      it('should store the ip address', () => {
-        expect(gameServer.resolvedIpAddresses).toEqual(['151.80.108.144']);
-      });
-    });
-
     it('should emit the gameServerAdded event', async () =>
       new Promise<void>((resolve) => {
         events.gameServerAdded.subscribe(({ gameServer, adminId }) => {
@@ -315,16 +293,6 @@ describe('GameServersService', () => {
     });
   });
 
-  describe('#getGameServerByEventSource()', () => {
-    it('should return the correct server', async () => {
-      const server = await service.getGameServerByEventSource({
-        address: '127.0.0.1',
-        port: 27015,
-      });
-      expect(server.id).toEqual(testGameServer.id);
-    });
-  });
-
   describe('#checkAllServers()', () => {
     it('should check whether every server is online', async () => {
       const spy = jest.spyOn(isServerOnline, 'isServerOnline');

src/game-servers/services/game-servers.service.ts

@@ -1,7 +1,5 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { GameServer, GameServerDocument } from '../models/game-server';
-import { resolve as resolveCb } from 'dns';
-import { promisify } from 'util';
 import { isServerOnline } from '../utils/is-server-online';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { Mutex } from 'async-mutex';
@@ -11,8 +9,6 @@ import { plainToClass } from 'class-transformer';
 import { InjectModel } from '@nestjs/mongoose';
 import { Model, Error } from 'mongoose';
 
-const resolve = promisify(resolveCb);
-
 @Injectable()
 export class GameServersService {
   private readonly logger = new Logger(GameServersService.name);
@@ -42,21 +38,6 @@ export class GameServersService {
     params: GameServer,
     adminId?: string,
   ): Promise<GameServer> {
-    if (
-      /^(?!0)(?!.*\.$)((1?\d?\d|25[0-5]|2[0-4]\d)(\.|$)){4}$/.test(
-        params.address,
-      )
-    ) {
-      // raw ip address was given
-      params.resolvedIpAddresses = [params.address];
-    } else {
-      const resolvedIpAddresses = await resolve(params.address);
-      this.logger.verbose(
-        `resolved addresses for ${params.address}: ${resolvedIpAddresses}`,
-      );
-      params.resolvedIpAddresses = resolvedIpAddresses;
-    }
-
     if (!params.mumbleChannelName) {
       const latestServer = await this.gameServerModel
         .findOne({ mumbleChannelName: { $ne: null }, deleted: false })
@@ -151,24 +132,6 @@ export class GameServersService {
     return gameServer;
   }
 
-  async getGameServerByEventSource(eventSource: {
-    address: string;
-    port: number;
-  }): Promise<GameServer> {
-    return plainToClass(
-      GameServer,
-      await this.gameServerModel
-        .findOne({
-          deleted: false,
-          resolvedIpAddresses: eventSource.address,
-          port: `${eventSource.port}`,
-        })
-        .orFail()
-        .lean()
-        .exec(),
-    );
-  }
-
   @Cron(CronExpression.EVERY_MINUTE)
   async checkAllServers() {
     this.logger.debug('checking all servers...');

src/game-servers/utils/generate-logsecret.ts

@@ -0,0 +1,13 @@
+import { generate } from 'generate-password';
+
+/**
+ * Generate string that will be used with the sv_logsecret command.
+ */
+export const generateLogsecret = () =>
+  generate({
+    length: 16,
+    numbers: true,
+    symbols: false,
+    lowercase: false,
+    uppercase: false,
+  });

src/games/models/game.ts

@@ -20,6 +20,10 @@ import { GameState } from './game-state';
       if (ret.assignedSkills) {
         delete ret.assignedSkills;
       }
+
+      if (ret.logSecret) {
+        delete ret.logSecret;
+      }
     },
   },
 })
@@ -78,6 +82,9 @@ export class Game {
   @Prop()
   stvConnectString?: string;
 
+  @Prop({ unique: true, sparse: true })
+  logSecret?: string;
+
   findPlayerSlot: (playerId: string) => GameSlot;
   activeSlots: () => GameSlot[];
 }

src/games/services/__mocks__/games.service.ts

@@ -16,6 +16,10 @@ export class GamesService {
     return await this.gameModel.findById(gameId);
   }
 
+  async getByLogSecret(logSecret: string): Promise<GameDocument> {
+    return await this.gameModel.findOne({ logSecret });
+  }
+
   async update(gameId: string, update: Partial<Game>) {
     return await this.gameModel.findByIdAndUpdate(gameId, update, {
       new: true,