@takaro/gameserver 0.0.1

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

@@ -0,0 +1,82 @@
+import { Axios, AxiosResponse } from 'axios';
+import axios from 'axios';
+import { SdtdConnectionInfo } from './connectionInfo.js';
+import {
+  CommandResponse,
+  InventoryResponse,
+  OnlinePlayerResponse,
+  PlayerLocation,
+  StatsResponse,
+} from './apiResponses.js';
+import { addCounterToAxios, errors } from '@takaro/util';
+
+export class SdtdApiClient {
+  private client: Axios;
+
+  constructor(private config: SdtdConnectionInfo) {
+    this.client = axios.create({
+      baseURL: this.url,
+    });
+
+    addCounterToAxios(this.client, {
+      name: 'sdtd_api_requests_total',
+      help: 'Total number of requests to the 7D2D API',
+    });
+
+    this.client.interceptors.request.use((req) => {
+      req.headers['X-SDTD-API-TOKENNAME'] = config.adminUser;
+      req.headers['X-SDTD-API-SECRET'] = config.adminToken;
+
+      return req;
+    });
+
+    this.client.interceptors.response.use(
+      function (response) {
+        return response;
+      },
+      function (error) {
+        // Any status codes that falls outside the range of 2xx cause this function to trigger
+        if (error.response) {
+          const simplifiedError = new errors.BadRequestError('Axios error', {
+            extra: 'A request to the 7D2D server failed',
+            status: error.response.status,
+            statusText: error.response.statusText,
+            url: error.config.url,
+          });
+          return Promise.reject(simplifiedError);
+        } else {
+          const simplifiedError = new errors.BadRequestError('Axios error', {
+            extra: 'A request to the 7D2D server failed',
+            message: error.message,
+            url: error.config.url,
+          });
+          return Promise.reject(simplifiedError);
+        }
+      }
+    );
+  }
+
+  private get url() {
+    return `${this.config.useTls ? 'https' : 'http'}://${this.config.host}`;
+  }
+
+  async getStats(): Promise<AxiosResponse<StatsResponse>> {
+    return this.client.get('/api/getstats');
+  }
+
+  async executeConsoleCommand(command: string): Promise<AxiosResponse<CommandResponse>> {
+    return this.client.get(`/api/executeconsolecommand?command=${command}`);
+  }
+
+  async getPlayersLocation(): Promise<AxiosResponse<Array<PlayerLocation>>> {
+    return this.client.get('/api/getplayerslocation');
+  }
+
+  async getOnlinePlayers(): Promise<AxiosResponse<Array<OnlinePlayerResponse>>> {
+    return this.client.get('/api/getplayersonline');
+  }
+
+  async getPlayerInventory(id: string): Promise<AxiosResponse<InventoryResponse>> {
+    return this.client.get(`/api/getplayerinventory?userid=${id}`);
+  }
+}

package/src/gameservers/mock/connectionInfo.ts

@@ -0,0 +1,25 @@
+import { IsString } from 'class-validator';
+import { TakaroDTO } from '@takaro/util';
+
+export class MockConnectionInfo extends TakaroDTO<MockConnectionInfo> {
+  @IsString()
+  public host!: string;
+  @IsString()
+  public name!: string;
+}
+
+export const mockJsonSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'MockConnectionInfo',
+  type: 'object',
+  properties: {
+    host: {
+      type: 'string',
+    },
+    name: {
+      type: 'string',
+      default: 'mock',
+    },
+  },
+  required: ['host'],
+};

package/src/gameservers/mock/emitter.ts

@@ -0,0 +1,37 @@
+import { logger } from '@takaro/util';
+import { MockConnectionInfo } from './connectionInfo.js';
+import { TakaroEmitter } from '../../TakaroEmitter.js';
+import { Socket } from 'socket.io-client';
+import { EventMapping, GameEventTypes } from '@takaro/modules';
+
+const log = logger('Mock');
+export class MockEmitter extends TakaroEmitter {
+  private scopedListener = this.listener.bind(this);
+
+  constructor(private config: MockConnectionInfo, private io: Socket) {
+    super();
+  }
+
+  async start(): Promise<void> {
+    this.io.onAny(this.scopedListener);
+  }
+
+  async stop(): Promise<void> {
+    this.io.offAny(this.scopedListener);
+  }
+
+  private async listener(event: GameEventTypes, args: any) {
+    if (this.config.name !== args.name) {
+      // This event is not for us
+      return;
+    }
+    log.debug(`Transmitting event ${event}`);
+    const dto = EventMapping[event];
+
+    if (dto) {
+      this.emit(event, new dto(args));
+    } else {
+      this.emit(event, args);
+    }
+  }
+}

package/src/gameservers/mock/index.ts

@@ -0,0 +1,156 @@
+import { logger, traceableClass } from '@takaro/util';
+import { IGamePlayer, IPosition } from '@takaro/modules';
+import {
+  BanDTO,
+  CommandOutput,
+  IGameServer,
+  IItemDTO,
+  IMessageOptsDTO,
+  IPlayerReferenceDTO,
+  TestReachabilityOutputDTO,
+} from '../../interfaces/GameServer.js';
+import { MockEmitter } from './emitter.js';
+import { Socket, io } from 'socket.io-client';
+import assert from 'assert';
+import { MockConnectionInfo } from './connectionInfo.js';
+import { Settings } from '@takaro/apiclient';
+
+@traceableClass('game:mock')
+export class Mock implements IGameServer {
+  private logger = logger('Mock');
+  connectionInfo: MockConnectionInfo;
+  emitter: MockEmitter;
+  io: Socket;
+
+  constructor(config: MockConnectionInfo, private settings: Partial<Settings> = {}) {
+    this.connectionInfo = config;
+    if (!this.connectionInfo.name) this.connectionInfo.name = 'default';
+    this.io = io(this.connectionInfo.host, {
+      query: {
+        name: config.name,
+      },
+    });
+    this.emitter = new MockEmitter(this.connectionInfo, this.io);
+  }
+
+  getEventEmitter() {
+    return this.emitter;
+  }
+
+  private async getClient(timeout = 2500): Promise<Socket> {
+    if (this.io.connected) {
+      return this.io;
+    }
+
+    return Promise.race([
+      new Promise<Socket>((resolve, reject) => {
+        const onConnect = () => {
+          this.io.off('connect_error', onConnectError);
+          resolve(this.io);
+        };
+
+        const onConnectError = (err: Error) => {
+          this.io.off('connect', onConnect);
+          reject(err);
+        };
+
+        this.io.on('connect', onConnect);
+        this.io.on('connect_error', onConnectError);
+      }),
+      new Promise<Socket>((_, reject) => {
+        setTimeout(() => {
+          this.io.off('connect');
+          this.io.off('connect_error');
+          reject(new Error(`Connection timed out after ${timeout}ms`));
+        }, timeout);
+      }),
+    ]);
+  }
+
+  private async requestFromServer(event: string, ...args: any[]) {
+    const client = await this.getClient();
+    return client.timeout(30000).emitWithAck(event, this.connectionInfo.name, ...args);
+  }
+
+  async getPlayer(player: IPlayerReferenceDTO): Promise<IGamePlayer | null> {
+    return this.requestFromServer('getPlayer', player);
+  }
+
+  async getPlayers(): Promise<IGamePlayer[]> {
+    return this.requestFromServer('getPlayers');
+  }
+
+  async getPlayerLocation(player: IPlayerReferenceDTO): Promise<IPosition | null> {
+    return this.requestFromServer('getPlayerLocation', player);
+  }
+
+  async testReachability(): Promise<TestReachabilityOutputDTO> {
+    try {
+      const data = await this.requestFromServer('ping');
+      assert(data === 'pong');
+    } catch (error) {
+      if (!error || !(error instanceof Error)) {
+        return new TestReachabilityOutputDTO({
+          connectable: false,
+          reason: 'Unknown error',
+        });
+      }
+
+      if (error.name === 'AssertionError') {
+        return new TestReachabilityOutputDTO({
+          connectable: false,
+          reason: 'Server responded with invalid data',
+        });
+      }
+
+      return new TestReachabilityOutputDTO({
+        connectable: false,
+        reason: 'Unable to connect to server',
+      });
+    }
+
+    return new TestReachabilityOutputDTO({
+      connectable: true,
+    });
+  }
+
+  async executeConsoleCommand(rawCommand: string): Promise<CommandOutput> {
+    return this.requestFromServer('executeConsoleCommand', rawCommand);
+  }
+
+  async sendMessage(message: string, opts: IMessageOptsDTO) {
+    return this.requestFromServer('sendMessage', message, opts);
+  }
+
+  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number) {
+    return this.requestFromServer('teleportPlayer', player, x, y, z);
+  }
+
+  async kickPlayer(player: IGamePlayer, reason: string) {
+    return this.requestFromServer('kickPlayer', player, reason);
+  }
+
+  async banPlayer(options: BanDTO) {
+    return this.requestFromServer('banPlayer', options);
+  }
+
+  async unbanPlayer(player: IGamePlayer) {
+    return this.requestFromServer('unbanPlayer', player);
+  }
+
+  async listBans(): Promise<BanDTO[]> {
+    return this.requestFromServer('listBans');
+  }
+
+  async giveItem(player: IPlayerReferenceDTO, item: string, amount: number): Promise<void> {
+    return this.requestFromServer('giveItem', player, item, amount);
+  }
+
+  async listItems(): Promise<IItemDTO[]> {
+    return this.requestFromServer('listItems');
+  }
+
+  async getPlayerInventory(player: IPlayerReferenceDTO): Promise<IItemDTO[]> {
+    return this.requestFromServer('getPlayerInventory', player);
+  }
+}

package/src/gameservers/rust/__tests__/rustActions.unit.test.ts

@@ -0,0 +1,140 @@
+import { expect, sandbox } from '@takaro/test';
+
+import { RustConnectionInfo } from '../connectionInfo.js';
+import { CommandOutput } from '../../../interfaces/GameServer.js';
+import { Rust } from '../index.js';
+import { IGamePlayer } from '@takaro/modules';
+
+const MOCK_PLAYER = new IGamePlayer({
+  ip: '169.169.169.80',
+  name: 'brunkel',
+  gameId: '76561198021481871',
+  steamId: '76561198021481871',
+});
+
+const testData = {
+  oneBan: '\'1 76561198028175941 "" "no reason" -1\n\'',
+  oneBanWithTime: '\'1 76561198028175941 "cata" "naughty" 1688173252\n\'',
+  twoBans: '1 76561198028175941 "" "stout" 1688173252\n2 76561198035925898 "Emiel" "filthy hacker >:(" -1\n',
+  noBans: '',
+};
+
+const mockRustConnectionInfo = new RustConnectionInfo({
+  host: 'localhost',
+  rconPassword: 'aaa',
+  rconPort: '28016',
+});
+
+describe('rust actions', () => {
+  describe('listBans', () => {
+    it('Can parse ban list with a single ban', async () => {
+      sandbox.stub(Rust.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.oneBan,
+          success: true,
+        })
+      );
+
+      const result = await new Rust(await mockRustConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].player.gameId).to.equal('76561198028175941');
+      expect(result[0].expiresAt).to.equal(null);
+    });
+
+    it('Can parse expiry time', async () => {
+      sandbox.stub(Rust.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.oneBanWithTime,
+          success: true,
+        })
+      );
+
+      const result = await new Rust(await mockRustConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].player.gameId).to.equal('76561198028175941');
+      expect(result[0].expiresAt).to.equal('2023-07-01T01:00:52.000Z');
+    });
+
+    it('Can parse ban list with two bans', async () => {
+      sandbox.stub(Rust.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.twoBans,
+          success: true,
+        })
+      );
+
+      const result = await new Rust(await mockRustConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(2);
+
+      expect(result[0].player.gameId).to.equal('76561198028175941');
+      expect(result[0].expiresAt).to.equal('2023-07-01T01:00:52.000Z');
+
+      expect(result[1].player.gameId).to.equal('76561198035925898');
+      expect(result[1].expiresAt).to.equal(null);
+    });
+
+    it('Can parse ban list with no bans', async () => {
+      sandbox.stub(Rust.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.noBans,
+          success: true,
+        })
+      );
+
+      const result = await new Rust(await mockRustConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(0);
+    });
+  });
+
+  describe('[getPlayerLocation]', () => {
+    it('Works for a single player', async () => {
+      const res = new CommandOutput({
+        rawResult: `SteamID           DisplayName POS                    ROT               \n${
+          (await MOCK_PLAYER).gameId
+        } Catalysm    (-770.0, 1.0, -1090.7) (1.0, -0.1, -0.1) \n`,
+        success: undefined,
+        errorMessage: undefined,
+      });
+
+      const rustInstance = new Rust({} as RustConnectionInfo);
+      sandbox.stub(rustInstance, 'executeConsoleCommand').resolves(res);
+
+      const location = await rustInstance.getPlayerLocation(await MOCK_PLAYER);
+
+      expect(location).to.deep.equal({
+        x: -770.0,
+        y: 1.0,
+        z: -1090,
+      });
+    });
+
+    it('When output has multiple players', async () => {
+      const res = new CommandOutput({
+        rawResult: `SteamID           DisplayName POS                    ROT               \nfake_steam_id Catalysm    (-123.0, 1.0, -1090.7) (1.0, -0.1, -0.1) \n${
+          (await MOCK_PLAYER).gameId
+        } Player2    (-780.0, 2.0, -1100.7) (1.1, -0.2, -0.2) \n76561198028175943 Player3    (-790.0, 3.0, -1110.7) (1.2, -0.3, -0.3) \n`,
+        success: undefined,
+        errorMessage: undefined,
+      });
+
+      const rustInstance = new Rust({} as RustConnectionInfo);
+      sandbox.stub(rustInstance, 'executeConsoleCommand').resolves(res);
+
+      const location = await rustInstance.getPlayerLocation(await MOCK_PLAYER);
+
+      expect(location).to.deep.equal({
+        x: -780.0,
+        y: 2.0,
+        z: -1100,
+      });
+    });
+  });
+});

package/src/gameservers/rust/connectionInfo.ts

@@ -0,0 +1,35 @@
+import { IsString, IsNumber, IsBoolean } from 'class-validator';
+import { TakaroDTO } from '@takaro/util';
+
+export class RustConnectionInfo extends TakaroDTO<RustConnectionInfo> {
+  @IsString()
+  public readonly host!: string;
+  @IsNumber()
+  public readonly rconPort!: string;
+  @IsString()
+  public readonly rconPassword!: string;
+  @IsBoolean()
+  public readonly useTls!: boolean;
+}
+
+export const rustJsonSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'RustConnectionInfo',
+  type: 'object',
+  properties: {
+    host: {
+      type: 'string',
+    },
+    rconPort: {
+      type: 'number',
+    },
+    rconPassword: {
+      type: 'string',
+    },
+    useTls: {
+      type: 'boolean',
+      default: false,
+    },
+  },
+  required: ['host', 'rconPort', 'rconPassword', 'useTls'],
+};

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');
+
+  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', (m: Buffer) => {
+      this.listener(m.toString());
+    });
+  }
+
+  async stop(): Promise<void> {
+    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, unknown>): Promise<EventChatMessage> {
+    delete data.channel;
+    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);
+    }
+  }
+}