@takaro/gameserver 0.0.0-next.0da151e

package/src/gameservers/rust/emitter.ts

@@ -0,0 +1,198 @@
+import WebSocket from 'ws';
+import { logger, errors } from '@takaro/util';
+import { RustConnectionInfo } from './connectionInfo.js';
+import { TakaroEmitter } from '../../TakaroEmitter.js';
+import {
+  EventChatMessage,
+  EventEntityKilled,
+  EventLogLine,
+  EventPlayerConnected,
+  EventPlayerDeath,
+  EventPlayerDisconnected,
+  GameEvents,
+  GameEventsMapping,
+} from '@takaro/modules';
+import { ValueOf } from 'type-fest';
+
+export enum RustEventType {
+  DEFAULT = 'Generic',
+  WARNING = 'Warning',
+  CHAT = 'Chat',
+}
+
+export interface RustEvent {
+  Message: string;
+  Identifier: number;
+  Type: RustEventType;
+  Stacktrace: string;
+}
+
+enum RustTypesType {
+  PLAYER_CONNECTED = 0,
+  PLAYER_DISCONNECTED = 1,
+  CHAT_MESSAGE = 2,
+  PLAYER_DEATH = 3,
+  ENTITY_KILLED = 4,
+}
+
+export class RustEmitter extends TakaroEmitter {
+  private ws: WebSocket | null = null;
+  private log = logger('rust:ws');
+  private boundListener = (m: Buffer) => this.listener(m.toString());
+
+  constructor(private config: RustConnectionInfo) {
+    super();
+  }
+
+  static async getClient(config: RustConnectionInfo) {
+    const log = logger('rust:ws');
+
+    const protocol = config.useTls ? 'wss' : 'ws';
+    const client = new WebSocket(`${protocol}://${config.host}:${config.rconPort}/${config.rconPassword}`);
+
+    log.debug('getClient', {
+      host: config.host,
+      port: config.rconPort,
+    });
+
+    return Promise.race([
+      new Promise<WebSocket>((resolve, reject) => {
+        client?.on('error', (err) => {
+          log.warn('getClient', err);
+          client?.close();
+          return reject(err);
+        });
+        client?.on('unexpected-response', (req, res) => {
+          log.debug('unexpected-response', {
+            req,
+            res,
+          });
+          reject(new errors.InternalServerError());
+        });
+        client?.on('open', () => {
+          log.debug('Connection opened');
+          if (client) {
+            return resolve(client);
+          }
+        });
+      }),
+      new Promise<WebSocket>((_, reject) => {
+        setTimeout(() => reject(new errors.WsTimeOutError('Timeout')), 5000);
+      }),
+    ]);
+  }
+
+  async start(): Promise<void> {
+    this.ws = await RustEmitter.getClient(this.config);
+
+    this.ws?.on('message', this.boundListener);
+  }
+
+  async stop(): Promise<void> {
+    this.ws?.off('message', this.boundListener);
+    this.ws?.close();
+    this.log.debug('Websocket connection has been closed');
+    return;
+  }
+
+  async parseMessage(e: RustEvent) {
+    if (e.Message.includes('[Hook Parser]')) {
+      const parsed = JSON.parse(e.Message.replace('[Hook Parser]', ''));
+      let dto: InstanceType<ValueOf<typeof GameEventsMapping>> | null = null;
+      switch (parsed.type) {
+        case RustTypesType.PLAYER_CONNECTED:
+          dto = await this.handlePlayerConnected(parsed.data);
+          break;
+        case RustTypesType.PLAYER_DISCONNECTED:
+          dto = await this.handlePlayerDisconnected(parsed.data);
+          break;
+        case RustTypesType.CHAT_MESSAGE:
+          dto = await this.handleChatMessage(parsed.data);
+          break;
+        case RustTypesType.PLAYER_DEATH:
+          dto = await this.handlePlayerDeath(parsed.data);
+          break;
+        case RustTypesType.ENTITY_KILLED:
+          dto = await this.handleEntityKilled(parsed.data);
+          break;
+        default:
+          this.log.warn('Unknown event type', parsed);
+          break;
+      }
+
+      if (!dto) {
+        this.log.warn('dto undefined, could not determine type?', parsed);
+        return;
+      }
+
+      await dto.validate({
+        whitelist: false,
+      });
+      this.emit(dto.type, dto);
+    }
+
+    this.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: e.Message,
+      }),
+    );
+  }
+
+  private async handlePlayerConnected(data: Record<string, unknown>): Promise<EventPlayerConnected> {
+    const event = new EventPlayerConnected(data);
+    if (event.player.steamId) {
+      event.player.gameId = event.player.steamId;
+    }
+    return event;
+  }
+
+  private async handlePlayerDisconnected(data: Record<string, unknown>): Promise<EventPlayerDisconnected> {
+    const event = new EventPlayerDisconnected(data);
+    if (event.player.steamId) {
+      event.player.gameId = event.player.steamId;
+    }
+    return event;
+  }
+
+  private async handleChatMessage(data: Record<string, string>): Promise<EventChatMessage> {
+    data.channel = data.channel.toLowerCase();
+    const event = new EventChatMessage(data);
+    if (event.player) {
+      if (event.player.steamId) {
+        event.player.gameId = event.player.steamId;
+      }
+    }
+
+    return event;
+  }
+
+  private async handlePlayerDeath(data: Record<string, unknown>): Promise<EventPlayerDeath> {
+    const event = new EventPlayerDeath(data);
+    if (event.player.steamId) {
+      event.player.gameId = event.player.steamId;
+    }
+    if (event.attacker && event.attacker.steamId) {
+      event.attacker.gameId = event.attacker.steamId;
+    }
+    return event;
+  }
+
+  private async handleEntityKilled(data: Record<string, unknown>): Promise<EventEntityKilled> {
+    const event = new EventEntityKilled(data);
+    if (event.player.steamId) {
+      event.player.gameId = event.player.steamId;
+    }
+    return event;
+  }
+
+  async listener(data: string) {
+    try {
+      const event = JSON.parse(data);
+      await this.parseMessage(event);
+      this.log.debug('event: ', event);
+    } catch (error) {
+      this.log.error('Error handling message from game server', error);
+    }
+  }
+}

package/src/gameservers/rust/emitter.unit.test.ts

@@ -0,0 +1,95 @@
+import 'reflect-metadata';
+import { RustEmitter } from './emitter.js';
+import { RustConnectionInfo } from './connectionInfo.js';
+import { expect, sandbox } from '@takaro/test';
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import WebSocket from 'ws';
+
+describe('RustEmitter', () => {
+  let emitter: RustEmitter;
+
+  beforeEach(() => {
+    emitter = new RustEmitter(
+      new RustConnectionInfo({
+        host: 'localhost',
+        rconPort: '28016',
+        rconPassword: 'test',
+        useTls: false,
+      }),
+    );
+  });
+
+  afterEach(async () => {
+    if (emitter) {
+      try {
+        await emitter.stop();
+      } catch {
+        // Ignore errors during cleanup
+      }
+    }
+    sandbox.restore();
+  });
+
+  it('Does not accumulate listeners on start/stop/start cycle', async () => {
+    // Mock WebSocket to prevent actual network calls
+    const mockWs = {
+      on: sandbox.spy(),
+      off: sandbox.spy(),
+      close: sandbox.spy(),
+      readyState: WebSocket.OPEN,
+    };
+
+    // Stub getClient to return mock WebSocket
+    sandbox.stub(RustEmitter, 'getClient').resolves(mockWs as any);
+
+    // First start
+    await emitter.start();
+
+    // Verify listener was added once
+    expect(mockWs.on).to.have.been.calledOnce;
+    expect(mockWs.on).to.have.been.calledWith('message');
+
+    const firstAddedListener = mockWs.on.getCall(0).args[1];
+
+    // Stop
+    await emitter.stop();
+
+    // Verify listener was removed
+    expect(mockWs.off).to.have.been.calledOnce;
+    expect(mockWs.off).to.have.been.calledWith('message');
+
+    const removedListener = mockWs.off.getCall(0).args[1];
+
+    // Verify the same function reference was used for on and off
+    expect(firstAddedListener).to.equal(
+      removedListener,
+      'on() and off() must use the same function reference to properly remove the listener',
+    );
+
+    expect(mockWs.close).to.have.been.calledOnce;
+
+    // Reset the mock for second start
+    mockWs.on.resetHistory();
+    mockWs.off.resetHistory();
+
+    // Second start
+    await emitter.start();
+
+    // Verify listener was added again
+    expect(mockWs.on).to.have.been.calledOnce;
+    expect(mockWs.on).to.have.been.calledWith('message');
+
+    const secondAddedListener = mockWs.on.getCall(0).args[1];
+
+    // Verify the same listener reference is reused
+    expect(firstAddedListener).to.equal(
+      secondAddedListener,
+      'The same listener reference must be reused across restarts to prevent accumulation',
+    );
+  });
+
+  it('Uses the same function reference for on and off', () => {
+    // Verify boundListener is defined as a class field
+    expect((emitter as any).boundListener).to.be.a('function');
+  });
+});

package/src/gameservers/rust/index.ts

@@ -0,0 +1,270 @@
+import { errors, logger, traceableClass } from '@takaro/util';
+import WebSocket from 'ws';
+import { IGamePlayer, IPosition } from '@takaro/modules';
+import {
+  BanDTO,
+  CommandOutput,
+  IEntityDTO,
+  IGameServer,
+  IItemDTO,
+  ILocationDTO,
+  IMessageOptsDTO,
+  IPlayerReferenceDTO,
+  MapInfoDTO,
+  TestReachabilityOutputDTO,
+} from '../../interfaces/GameServer.js';
+import { RustConnectionInfo } from './connectionInfo.js';
+import { RustEmitter } from './emitter.js';
+import { Settings } from '@takaro/apiclient';
+
+const itemsJson = (await import('./items-rust.json', { with: { type: 'json' } })).default;
+
+@traceableClass('game:rust')
+export class Rust implements IGameServer {
+  private log = logger('rust');
+  connectionInfo: RustConnectionInfo;
+  private client: WebSocket | null;
+
+  constructor(
+    config: RustConnectionInfo,
+    private settings: Partial<Settings> = {},
+  ) {
+    this.connectionInfo = config;
+  }
+
+  private getRequestId(): number {
+    return Math.floor(Math.random() * 100000000);
+  }
+
+  private async getClient() {
+    if (this.client && this.client.readyState === WebSocket.OPEN) {
+      return this.client;
+    }
+
+    this.client = await RustEmitter.getClient(this.connectionInfo);
+    return this.client;
+  }
+
+  getEventEmitter() {
+    const emitter = new RustEmitter(this.connectionInfo);
+    return emitter;
+  }
+
+  async getPlayer(player: IPlayerReferenceDTO): Promise<IGamePlayer | null> {
+    const players = await this.getPlayers();
+    return players.find((p) => p.gameId === player.gameId) || null;
+  }
+
+  async getPlayers(): Promise<IGamePlayer[]> {
+    const response = await this.executeConsoleCommand('playerlist');
+    const rustPlayers = JSON.parse(response.rawResult);
+    return Promise.all(
+      rustPlayers.map((player: any) => {
+        return new IGamePlayer({
+          gameId: player.SteamID,
+          steamId: player.SteamID,
+          ip: player.Address.split(':')[0],
+          name: player.DisplayName,
+          ping: player.Ping,
+        });
+      }),
+    );
+  }
+
+  async giveItem(player: IPlayerReferenceDTO, item: string, amount: number = 1, _quality?: string): Promise<void> {
+    await this.executeConsoleCommand(`inventory.giveid ${player.gameId} ${item} ${amount}`);
+  }
+
+  async getPlayerLocation(player: IPlayerReferenceDTO): Promise<IPosition | null> {
+    const rawResponse = await this.executeConsoleCommand('playerlistpos');
+    const lines = rawResponse.rawResult.split('\n');
+
+    for (const line of lines) {
+      const matches = /(\d{17}) \w+\s+\(([-\d\.]+), ([-\d\.]+), ([-\d\.]+)\)/.exec(line);
+
+      if (matches) {
+        const steamId = matches[1];
+        const x = matches[2].replace('(', '');
+        const y = matches[3].replace(',', '');
+        const z = matches[4].replace(')', '');
+
+        if (steamId === player.gameId) {
+          return new IPosition({
+            x: parseInt(x, 10),
+            y: parseInt(y, 10),
+            z: parseInt(z, 10),
+          });
+        }
+      }
+    }
+
+    return null;
+  }
+
+  async testReachability(): Promise<TestReachabilityOutputDTO> {
+    const start = Date.now();
+    try {
+      await this.executeConsoleCommand('serverinfo');
+      const end = Date.now();
+      return new TestReachabilityOutputDTO({ connectable: true, latency: end - start });
+    } catch (error) {
+      this.log.warn('testReachability', error);
+      return new TestReachabilityOutputDTO({ connectable: false });
+    }
+  }
+
+  async executeConsoleCommand(rawCommand: string) {
+    const client = await this.getClient();
+    return new Promise<CommandOutput>((resolve, reject) => {
+      const command = rawCommand.trim();
+      const requestId = this.getRequestId();
+
+      const timeout = setTimeout(() => reject(), 5000);
+
+      client.on('message', (data) => {
+        const parsed = JSON.parse(data.toString());
+
+        if (parsed.Identifier !== requestId) {
+          return;
+        }
+
+        const commandResult = parsed.Message;
+        clearTimeout(timeout);
+        return resolve(new CommandOutput({ rawResult: commandResult }));
+      });
+
+      this.log.debug('executeConsoleCommand - sending command', { command });
+      client.send(
+        JSON.stringify({
+          Message: command,
+          Identifier: requestId,
+          Name: 'Takaro',
+        }),
+      );
+    });
+  }
+
+  async sendMessage(message: string, _opts?: IMessageOptsDTO) {
+    // Note: Rust's say command doesn't support custom sender names
+    // The senderNameOverride parameter is ignored for Rust servers
+    await this.executeConsoleCommand(`say "${message}"`);
+  }
+
+  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number, _dimension?: string) {
+    // Rust doesn't support dimensions, so we ignore the dimension parameter
+    await this.executeConsoleCommand(`teleportplayer.pos ${player.gameId} ${x} ${y} ${z}`);
+  }
+
+  async kickPlayer(player: IGamePlayer, reason: string) {
+    await this.executeConsoleCommand(`kick "${player.gameId}" "${reason}"`);
+  }
+
+  async banPlayer(options: BanDTO) {
+    // 'find banid'
+    // Variables: Commands: global.banid( ) banid <steamid> <username> <reason> [optional duration]
+    // This optional duration is an integer, seems to be hours.
+
+    if (!options.expiresAt) {
+      await this.executeConsoleCommand(`banid ${options.player.gameId} "" "${options.reason}"`);
+      return;
+    }
+
+    const timeDiff = new Date(options.expiresAt).valueOf() - Date.now();
+    const hours = Math.floor(timeDiff / 1000 / 60 / 60);
+
+    await this.executeConsoleCommand(`banid ${options.player.gameId} "" "${options.reason}" ${hours}`);
+  }
+
+  async unbanPlayer(player: IPlayerReferenceDTO) {
+    await this.executeConsoleCommand(`unban ${player.gameId}`);
+  }
+
+  async listBans(): Promise<BanDTO[]> {
+    const response = await this.executeConsoleCommand('banlistex');
+
+    if (!response.rawResult) {
+      return [];
+    }
+
+    const lines = response.rawResult.split('\n');
+    const pattern =
+      /(?:'|^)(?<number>\d+)\s+(?<gameId>\d+)\s+"(?<username>.*?)"\s+"(?<reason>.*?)"\s+(?<expiration>-?\d+)\s*(?:'|\n|$)/g;
+    const bans = [];
+
+    for (const line of lines) {
+      let match;
+      while ((match = pattern.exec(line)) !== null) {
+        if (!match.groups) {
+          this.log.warn('listBans - line did not match regex', { match, line });
+          continue;
+        }
+        const { gameId, expiration } = match.groups;
+
+        let expiresAt = null;
+        if (expiration !== '-1') {
+          expiresAt = new Date(parseInt(expiration) * 1000).toISOString();
+        }
+
+        const ban = new BanDTO({
+          reason: match.groups.reason,
+          player: new IGamePlayer({
+            gameId,
+            steamId: gameId,
+          }),
+          expiresAt,
+        });
+
+        bans.push(ban);
+      }
+    }
+
+    return bans;
+  }
+
+  async listItems(): Promise<IItemDTO[]> {
+    return Promise.all(
+      Object.values(itemsJson).map((item) => {
+        return new IItemDTO({
+          code: item.shortname,
+          name: item.Name,
+          description: item.Description,
+        });
+      }),
+    );
+  }
+
+  async getPlayerInventory(player: IPlayerReferenceDTO): Promise<IItemDTO[]> {
+    const res = await this.executeConsoleCommand(`viewinventory ${player.gameId}`);
+    const toParse = res.rawResult.replace('[ViewInventory] ', '');
+    const parsed = JSON.parse(toParse);
+    const items = JSON.parse(parsed.Inventory);
+    return await Promise.all(items.map((i: any) => new IItemDTO({ code: i.itemName, amount: i.amount })));
+  }
+
+  async shutdown(): Promise<void> {
+    await this.executeConsoleCommand('quit');
+  }
+
+  async getMapInfo(): Promise<MapInfoDTO> {
+    return new MapInfoDTO({
+      enabled: false,
+      mapBlockSize: 0,
+      maxZoom: 0,
+      mapSizeX: 0,
+      mapSizeY: 0,
+      mapSizeZ: 0,
+    });
+  }
+
+  async getMapTile(_x: number, _y: number, _z: number): Promise<string> {
+    throw new Error('Not implemented');
+  }
+
+  async listEntities(): Promise<IEntityDTO[]> {
+    throw new errors.NotImplementedError();
+  }
+
+  async listLocations(): Promise<ILocationDTO[]> {
+    throw new errors.NotImplementedError();
+  }
+}