@takaro/gameserver 0.0.0-next.0da151e

package/src/gameservers/7d2d/emitter.ts

@@ -0,0 +1,334 @@
+import { logger } from '@takaro/util';
+import EventSource from 'eventsource';
+import { JsonObject } from 'type-fest';
+import {
+  ChatChannel,
+  EventChatMessage,
+  EventEntityKilled,
+  EventLogLine,
+  EventPlayerConnected,
+  EventPlayerDeath,
+  EventPlayerDisconnected,
+  GameEvents,
+  IGamePlayer,
+} from '@takaro/modules';
+import { SdtdConnectionInfo } from './connectionInfo.js';
+import { TakaroEmitter } from '../../TakaroEmitter.js';
+import { SevenDaysToDie } from './index.js';
+import ms from 'ms';
+
+interface I7DaysToDieEvent extends JsonObject {
+  msg: string;
+}
+
+/**
+ * 7d2d servers can get really spammy with bugged vehicles, buggy mods, etc.
+ * This is a list of messages that we don't want to emit events for.
+ */
+const blackListedMessages = [
+  'NullReferenceException',
+  'Infinity or NaN floating point numbers appear when calculating the transform matrix for a Collider',
+  'IsMovementBlocked',
+  'Particle System is trying to spawn on a mesh with zero surface area',
+  'AddDecorationAt',
+  'EntityFactory CreateEntity: unknown type',
+  'DroneManager',
+  'VehicleManager',
+  'kinematic body',
+];
+
+const EventRegexMap = {
+  [GameEvents.PLAYER_CONNECTED]:
+    /PlayerSpawnedInWorld \(reason: (JoinMultiplayer|EnterMultiplayer), position: [-\d]+, [-\d]+, [-\d]+\): EntityID=(?<entityId>[-\d]+), PltfmId='(Steam|XBL)_[\w\d]+', CrossId='EOS_[\w\d]+', OwnerID='(Steam|XBL)_\d+', PlayerName='(?<name>.+)'/,
+  [GameEvents.PLAYER_DISCONNECTED]: /(Player disconnected: )/,
+  [GameEvents.CHAT_MESSAGE]:
+    /Chat \(from '(?<platformId>[\w\d-]+)', entity id '(?<entityId>[-\d]+)', to '(?<channel>\w+)'\): ('(?<playerName>.+)':)?(?<message>.+)/,
+  [GameEvents.PLAYER_DEATH]:
+    /GMSG: Player '(?<name1>.+)' died|\[(?:CSMM_Patrons|PrismaCore)\]playerDied: (?<name2>.+) \((?<steamOrXboxId>.+)\) died @ (?<xCoord>[-\d]+) (?<yCoord>[-\d]+) (?<zCoord>[-\d]+)/,
+  [GameEvents.ENTITY_KILLED]:
+    /\[(?:CSMM_Patrons|PrismaCore)\]entityKilled: (?<killerName>.+) \((?<steamOrXboxId>.+)\) killed (?<entityType>\w+) (?<entityName>[\w\s\u00C0-\u024F\[\]-]+) with (?<weapon>.+)|Entity (?<entityName2>[\w\s\u00C0-\u024F]+) \d+ killed by (?<killerName2>.+) \d+/,
+};
+
+export class SevenDaysToDieEmitter extends TakaroEmitter {
+  private SSERegex = /\d+-\d+-\d+T\d+:\d+:\d+ \d+\.\d+ INF (.+)/;
+  private eventSource!: EventSource;
+  private logger = logger('7D2D:SSE');
+  private sdtd: SevenDaysToDie;
+
+  private recentMessages: Set<string> = new Set(); // To track recent messages
+  private checkInterval: NodeJS.Timeout;
+  private lastMessageTimestamp = Date.now();
+  private keepAliveTimeout = ms('5minutes');
+  private boundListener = (data: MessageEvent) => this.listener(data);
+
+  constructor(private config: SdtdConnectionInfo) {
+    super();
+    this.sdtd = new SevenDaysToDie(config, {});
+  }
+
+  private isModdedFormat(msg: string): boolean {
+    return msg.includes('[CSMM_Patrons]') || msg.includes('[PrismaCore]');
+  }
+
+  get url() {
+    if (this.config.useLegacy) {
+      return `${this.config.useTls ? 'https' : 'http'}://${this.config.host}/sse/log`;
+    }
+    return `${this.config.useTls ? 'https' : 'http'}://${this.config.host}/sse/?events=log`;
+  }
+
+  async start(): Promise<void> {
+    this.checkInterval = setInterval(() => {
+      if (Date.now() - this.lastMessageTimestamp >= this.keepAliveTimeout) {
+        this.logger.warn(`No messages received for ${ms(this.keepAliveTimeout, { long: true })}. Reconnecting...`);
+        this.lastMessageTimestamp = Date.now();
+        this.stop()
+          .then(() => this.start())
+          .catch((err) => this.logger.error('Error during reconnection', err));
+      }
+    }, 5000);
+
+    await Promise.race([
+      new Promise<void>((resolve, reject) => {
+        this.logger.debug(`Connecting to ${this.config.host}`);
+        this.eventSource = new EventSource(this.url, {
+          headers: {
+            'X-SDTD-API-TOKENNAME': this.config.adminUser,
+            'X-SDTD-API-SECRET': this.config.adminToken,
+          },
+        });
+
+        this.eventSource.addEventListener('logLine', this.boundListener);
+
+        this.eventSource.onerror = (e) => {
+          this.logger.error('Event source error', e);
+          return reject(e);
+        };
+        this.eventSource.onopen = () => {
+          this.logger.debug('Opened a SSE channel for server');
+          return resolve();
+        };
+      }),
+      new Promise((_resolve, reject) => {
+        setTimeout(() => {
+          reject(new Error('Timed out'));
+        }, 30000);
+      }),
+    ]);
+  }
+
+  async stop(): Promise<void> {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+    }
+    this.eventSource.removeEventListener('logLine', this.boundListener);
+    this.eventSource.close();
+  }
+
+  async parseMessage(logLine: I7DaysToDieEvent) {
+    this.logger.silly(`Received message from game server: ${logLine.msg}`);
+    if (!logLine.msg || typeof logLine.msg !== 'string') {
+      throw new Error('Invalid logLine');
+    }
+
+    if (blackListedMessages.some((msg) => logLine.msg.includes(msg))) {
+      return;
+    }
+
+    if (EventRegexMap[GameEvents.PLAYER_CONNECTED].test(logLine.msg)) {
+      const data = await this.handlePlayerConnected(logLine);
+      await this.emit(GameEvents.PLAYER_CONNECTED, data);
+    }
+
+    if (EventRegexMap[GameEvents.PLAYER_DISCONNECTED].test(logLine.msg)) {
+      const data = await this.handlePlayerDisconnected(logLine);
+      await this.emit(GameEvents.PLAYER_DISCONNECTED, data);
+    }
+
+    if (EventRegexMap[GameEvents.CHAT_MESSAGE].test(logLine.msg)) {
+      const data = await this.handleChatMessage(logLine);
+      if (data) await this.emit(GameEvents.CHAT_MESSAGE, data);
+    }
+
+    if (EventRegexMap[GameEvents.PLAYER_DEATH].test(logLine.msg)) {
+      const data = await this.handlePlayerDeath(logLine);
+      if (data) await this.emit(GameEvents.PLAYER_DEATH, data);
+    }
+
+    if (EventRegexMap[GameEvents.ENTITY_KILLED].test(logLine.msg)) {
+      const data = await this.handleEntityKilled(logLine);
+      if (data) await this.emit(GameEvents.ENTITY_KILLED, data);
+    }
+
+    await this.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: logLine.msg,
+      }),
+    );
+  }
+
+  private async handlePlayerConnected(logLine: I7DaysToDieEvent) {
+    const nameMatches = /PlayerName='([^']+)/.exec(logLine.msg);
+    const platformIdMatches = /PltfmId='(.+)', CrossId=/.exec(logLine.msg);
+    const crossIdMatches = /CrossId='(.+)', OwnerID/.exec(logLine.msg);
+
+    const name = nameMatches ? nameMatches[1] : 'Unknown name';
+    const platformId = platformIdMatches ? platformIdMatches[1] : null;
+    const epicOnlineServicesId = crossIdMatches ? crossIdMatches[1].replace('EOS_', '') : undefined;
+    const gameId = epicOnlineServicesId;
+
+    const steamId = platformId && platformId.startsWith('Steam_') ? platformId.replace('Steam_', '') : undefined;
+    const xboxLiveId = platformId && platformId.startsWith('XBL_') ? platformId.replace('XBL_', '') : undefined;
+
+    if (!gameId) throw new Error('Could not find gameId');
+
+    return new EventPlayerConnected({
+      msg: logLine.msg,
+      player: new IGamePlayer({
+        name,
+        gameId,
+        steamId,
+        xboxLiveId,
+        epicOnlineServicesId,
+      }),
+    });
+  }
+  private async handlePlayerDisconnected(logLine: I7DaysToDieEvent) {
+    const nameMatch = /PlayerName='([^']+)/.exec(logLine.msg);
+    const platformIdMatches = /PltfmId='(.+)', CrossId=/.exec(logLine.msg);
+    const crossIdMatches = /CrossId='(.+)', OwnerID/.exec(logLine.msg);
+
+    const name = nameMatch ? nameMatch[1] : 'Unknown name';
+    const platformId = platformIdMatches ? platformIdMatches[1] : null;
+
+    const steamId = platformId && platformId.startsWith('Steam_') ? platformId.replace('Steam_', '') : undefined;
+    const xboxLiveId = platformId && platformId.startsWith('XBL_') ? platformId.replace('XBL_', '') : undefined;
+    const epicOnlineServicesId = crossIdMatches ? crossIdMatches[1].replace('EOS_', '') : undefined;
+    const gameId = epicOnlineServicesId;
+
+    if (!gameId) throw new Error('Could not find gameId');
+
+    return new EventPlayerDisconnected({
+      msg: logLine.msg,
+      player: new IGamePlayer({
+        name,
+        gameId,
+        steamId,
+        xboxLiveId,
+      }),
+    });
+  }
+
+  private async handleChatMessage(logLine: I7DaysToDieEvent) {
+    const match = EventRegexMap[GameEvents.CHAT_MESSAGE].exec(logLine.msg);
+    if (!match) throw new Error('Could not parse chat message');
+
+    const { groups } = match;
+    if (!groups) throw new Error('Could not parse chat message');
+
+    const { platformId, name, message, channel } = groups;
+
+    if (platformId === '-non-player-' && name !== 'Server') {
+      return;
+    }
+
+    const trimmedMessage = message.trim();
+    if (this.recentMessages.has(trimmedMessage)) {
+      return; // Ignore if recently processed
+    }
+    this.recentMessages.add(trimmedMessage);
+    setTimeout(() => this.recentMessages.delete(trimmedMessage), 1000);
+
+    const xboxLiveId = platformId.startsWith('XBL_') ? platformId.replace('XBL_', '') : undefined;
+    const steamId = platformId.startsWith('Steam_') ? platformId.replace('Steam_', '') : undefined;
+
+    if (steamId || xboxLiveId) {
+      const id = steamId || xboxLiveId || '';
+      const player = await this.sdtd.steamIdOrXboxToGameId(id);
+
+      let detectedChannel: ChatChannel = ChatChannel.GLOBAL;
+
+      switch (channel) {
+        case 'Global':
+          detectedChannel = ChatChannel.GLOBAL;
+          break;
+        case 'Party':
+          detectedChannel = ChatChannel.TEAM;
+          break;
+        case 'Friends':
+          detectedChannel = ChatChannel.FRIENDS;
+          break;
+        default:
+          break;
+      }
+
+      if (player) {
+        return new EventChatMessage({
+          player,
+          channel: detectedChannel,
+          msg: trimmedMessage.trim(),
+        });
+      }
+    }
+  }
+
+  private async handlePlayerDeath(logLine: I7DaysToDieEvent) {
+    if (this.isModdedFormat(logLine.msg) && !this.config.useCPM) return;
+    if (logLine.msg.includes('GMSG') && this.config.useCPM) return;
+
+    const match = EventRegexMap[GameEvents.PLAYER_DEATH].exec(logLine.msg);
+    if (!match) throw new Error('Could not parse player death message');
+    const { groups } = match;
+    if (!groups) throw new Error('Could not parse player death message');
+
+    const { xCoord, yCoord, zCoord, steamOrXboxId } = groups;
+
+    const player = await this.sdtd.steamIdOrXboxToGameId(steamOrXboxId);
+
+    return new EventPlayerDeath({
+      msg: logLine.msg,
+      player,
+      position: {
+        x: parseFloat(xCoord),
+        y: parseFloat(yCoord),
+        z: parseFloat(zCoord),
+      },
+    });
+  }
+
+  private async handleEntityKilled(logLine: I7DaysToDieEvent) {
+    if (this.isModdedFormat(logLine.msg) && !this.config.useCPM) return;
+    if (logLine.msg.includes('killed by') && this.config.useCPM) return;
+
+    const match = EventRegexMap[GameEvents.ENTITY_KILLED].exec(logLine.msg);
+    if (!match) throw new Error('Could not parse entity killed message');
+    const { groups } = match;
+    if (!groups) throw new Error('Could not parse entity killed message');
+
+    // Extracting the relevant details from the named groups
+    const { entityName, entityName2, weapon, steamOrXboxId } = groups;
+
+    const player = await this.sdtd.steamIdOrXboxToGameId(steamOrXboxId);
+
+    // Constructing the EventEntityKilled object with the parsed data
+    return new EventEntityKilled({
+      msg: logLine.msg,
+      entity: entityName || entityName2,
+      player,
+      weapon: weapon || undefined, // Assuming that 'weapon' might not be present in some log lines
+    });
+  }
+
+  async listener(data: MessageEvent) {
+    this.lastMessageTimestamp = Date.now();
+
+    const parsed = JSON.parse(data.data);
+    const messageMatch = this.SSERegex.exec(parsed.msg);
+    if (messageMatch && messageMatch[1]) {
+      parsed.msg = messageMatch[1];
+    }
+
+    await this.parseMessage(parsed);
+  }
+}

package/src/gameservers/7d2d/emitter.unit.test.ts

@@ -0,0 +1,117 @@
+import 'reflect-metadata';
+import { SevenDaysToDieEmitter } from './emitter.js';
+import { SdtdConnectionInfo } from './connectionInfo.js';
+import { SevenDaysToDie } from './index.js';
+import { expect, sandbox } from '@takaro/test';
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import EventSource from 'eventsource';
+
+describe('SevenDaysToDieEmitter', () => {
+  let emitter: SevenDaysToDieEmitter;
+
+  beforeEach(() => {
+    // Stub the SevenDaysToDie constructor to prevent network calls
+    sandbox.stub(SevenDaysToDie.prototype, 'steamIdOrXboxToGameId').resolves(undefined);
+
+    emitter = new SevenDaysToDieEmitter(
+      new SdtdConnectionInfo({
+        host: 'localhost:8080',
+        adminUser: 'test',
+        adminToken: 'test',
+        useTls: false,
+        useLegacy: false,
+        useCPM: false,
+      }),
+    );
+    // Add error handler to prevent unhandled errors
+    emitter.on('error', () => {
+      // Ignore errors in tests
+    });
+  });
+
+  afterEach(async () => {
+    if (emitter) {
+      try {
+        await emitter.stop();
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+    sandbox.restore();
+  });
+
+  it.skip('Does not accumulate listeners on start/stop/start cycle', async () => {
+    // Track listeners
+    const listeners: Array<(data: any) => void> = [];
+
+    // Create a mock EventSource
+    class MockEventSource {
+      onerror: any = null;
+      onopen: any = null;
+
+      constructor(..._args: any[]) {
+        //No-op constructor - onopen will be set by the emitter
+      }
+
+      addEventListener(event: string, listener: any) {
+        listeners.push(listener);
+      }
+
+      removeEventListener(event: string, listener: any) {
+        const index = listeners.indexOf(listener);
+        if (index > -1) {
+          listeners.splice(index, 1);
+        }
+      }
+
+      close() {
+        // Mock close
+      }
+    }
+
+    // Stub EventSource constructor
+    const OriginalEventSource = EventSource;
+    const MockEventSourceClass = class extends MockEventSource {
+      constructor(...args: any[]) {
+        super(...args);
+        // Immediately trigger onopen to resolve the Promise.race in start()
+        const triggerOpen = () => {
+          if (this.onopen) {
+            this.onopen();
+          }
+        };
+        queueMicrotask(triggerOpen.bind(this));
+      }
+    };
+    (global as any).EventSource = MockEventSourceClass;
+
+    try {
+      // First start
+      await emitter.start();
+      expect(listeners.length).to.equal(1, 'Should have 1 listener after start');
+
+      // Stop
+      await emitter.stop();
+      expect(listeners.length).to.equal(0, 'Should have 0 listeners after stop');
+
+      // Second start (this is where the bug would cause accumulation)
+      await emitter.start();
+      expect(listeners.length).to.equal(1, 'Should have 1 listener after restart (not 2)');
+
+      // Third start/stop cycle to be extra sure
+      await emitter.stop();
+      expect(listeners.length).to.equal(0, 'Should have 0 listeners after second stop');
+
+      await emitter.start();
+      expect(listeners.length).to.equal(1, 'Should have 1 listener after second restart (not 2 or 3)');
+    } finally {
+      // Restore EventSource
+      (global as any).EventSource = OriginalEventSource;
+    }
+  });
+
+  it('Uses the same function reference for addEventListener and removeEventListener', () => {
+    // Verify boundListener is defined as a class field
+    expect((emitter as any).boundListener).to.be.a('function');
+  });
+});