@takaro/gameserver 0.0.0-next.0da151e

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

@@ -0,0 +1,82 @@
+import { Axios, AxiosResponse } from 'axios';
+import { SdtdConnectionInfo } from './connectionInfo.js';
+import {
+  CommandResponse,
+  InventoryResponse,
+  OnlinePlayerResponse,
+  PlayerLocation,
+  StatsResponse,
+} from './apiResponses.js';
+import { addCounterToAxios, createAxios, logger } from '@takaro/util';
+import { MapInfoDTO } from '../../main.js';
+
+export class SdtdApiClient {
+  private client: Axios;
+  private log = logger('7d2d:api');
+
+  constructor(private config: SdtdConnectionInfo) {
+    this.client = createAxios(
+      {
+        baseURL: this.url,
+      },
+      { logger: this.log },
+    );
+
+    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;
+    });
+  }
+
+  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}`);
+  }
+
+  async getMapInfo(): Promise<MapInfoDTO> {
+    const res = await this.client.get('/api/map/config');
+
+    return new MapInfoDTO({
+      enabled: res.data.data.enabled,
+      mapBlockSize: res.data.data.mapBlockSize,
+      maxZoom: res.data.data.maxZoom,
+      mapSizeX: res.data.data.mapSize.x,
+      mapSizeY: res.data.data.mapSize.y,
+      mapSizeZ: res.data.data.mapSize.z,
+    });
+  }
+
+  async getMapTile(x: number, y: number, z: number): Promise<string> {
+    const res = await this.client.get(`/map/${z}/${x}/${y}.png?t=${Date.now() / 1000}`, {
+      responseType: 'arraybuffer',
+    });
+    // Convert to b64
+    return Buffer.from(res.data, 'binary').toString('base64');
+  }
+}

package/src/gameservers/generic/connectionInfo.ts

@@ -0,0 +1,19 @@
+import { IsString } from 'class-validator';
+import { TakaroDTO } from '@takaro/util';
+
+export class GenericConnectionInfo extends TakaroDTO<GenericConnectionInfo> {
+  @IsString()
+  public identityToken: string;
+}
+
+export const genericJsonSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'GenericConnectionInfo',
+  type: 'object',
+  properties: {
+    identityToken: {
+      type: 'string',
+    },
+  },
+  required: ['identityToken'],
+};

package/src/gameservers/generic/connectorClient.ts

@@ -0,0 +1,73 @@
+import { AxiosInstance, isAxiosError } from 'axios';
+import { config } from '../../config.js';
+import { errors, logger, createAxios } from '@takaro/util';
+
+function getConnectorClient() {
+  const log = logger('client:connector');
+
+  const connectorClient = createAxios(
+    {
+      baseURL: config.get('connector.host'),
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'Takaro',
+      },
+    },
+    { logger: log },
+  );
+
+  // Add custom interceptor for operation logging
+  connectorClient.interceptors.request.use((request) => {
+    if (request.data?.operation) {
+      log.debug(`Operation: ${request.data.operation}`);
+    }
+    return request;
+  });
+
+  return connectorClient;
+}
+
+export class TakaroConnector {
+  private client: AxiosInstance;
+  constructor() {
+    this.client = getConnectorClient();
+  }
+
+  async requestFromServer(id: string, operation: string, data: string): Promise<any> {
+    try {
+      const res = await this.client.post(`/gameserver/${id}/request`, { operation, data });
+      return res.data.data;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        if (error.response?.data.meta.error.code === 'ValidationError') {
+          throw new errors.BadRequestError(
+            'The gameserver responded with bad data, please verify that the mod is up to date.',
+          );
+        }
+
+        if (error.response?.status) {
+          if (error.response?.status >= 400 && error.response?.status < 500) {
+            throw new errors.BadRequestError(error.response?.data.meta.error.message);
+          }
+        }
+      }
+      throw error;
+    }
+  }
+
+  async resetConnection(id: string): Promise<any> {
+    try {
+      await this.client.post(`/gameserver/${id}/reset`);
+      return;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        if (error.response?.data.meta.error.code === 'ValidationError') {
+          throw new errors.BadRequestError(
+            'The gameserver responded with bad data, please verify that the mod is up to date.',
+          );
+        }
+      }
+      throw error;
+    }
+  }
+}

package/src/gameservers/generic/emitter.ts

@@ -0,0 +1,36 @@
+import { logger } from '@takaro/util';
+import { GenericConnectionInfo } from './connectionInfo.js';
+import { TakaroEmitter } from '../../TakaroEmitter.js';
+import { EventMapping, GameEventTypes } from '@takaro/modules';
+
+const log = logger('Generic');
+export class GenericEmitter extends TakaroEmitter {
+  private scopedListener = this.privateListener.bind(this);
+
+  constructor(private config: GenericConnectionInfo) {
+    super();
+  }
+
+  async start(): Promise<void> {
+    // No-op, generic connectors initiate the connection
+  }
+
+  async stop(): Promise<void> {
+    // No-op, generic connectors initiate the connection
+  }
+
+  get listener() {
+    return this.scopedListener;
+  }
+
+  private async privateListener(event: GameEventTypes, args: any) {
+    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/generic/index.ts

@@ -0,0 +1,193 @@
+import { errors, logger, traceableClass } from '@takaro/util';
+import { IGamePlayer, IPosition } from '@takaro/modules';
+import {
+  BanDTO,
+  CommandOutput,
+  IEntityDTO,
+  IGameServer,
+  IItemDTO,
+  ILocationDTO,
+  IMessageOptsDTO,
+  IPlayerReferenceDTO,
+  MapInfoDTO,
+  TestReachabilityOutputDTO,
+} from '../../interfaces/GameServer.js';
+import { Settings } from '@takaro/apiclient';
+import { TakaroConnector } from './connectorClient.js';
+import { GenericConnectionInfo } from './connectionInfo.js';
+import { JsonObject } from 'type-fest';
+import { GenericEmitter } from './emitter.js';
+
+@traceableClass('game:generic')
+export class Generic implements IGameServer {
+  private logger = logger('Generic');
+  connectionInfo: GenericConnectionInfo;
+  emitter: GenericEmitter;
+  private takaroConnector = new TakaroConnector();
+
+  constructor(
+    config: GenericConnectionInfo,
+    private settings: Partial<Settings> = {},
+    private gameServerId: string,
+  ) {
+    this.connectionInfo = config;
+    this.emitter = new GenericEmitter(config);
+  }
+
+  getEventEmitter() {
+    return this.emitter;
+  }
+
+  private async requestFromServer(operation: string, data?: JsonObject) {
+    if (!data) data = {};
+    const resp = await this.takaroConnector.requestFromServer(this.gameServerId, operation, JSON.stringify(data));
+
+    if (resp && resp.error) {
+      throw new errors.BadRequestError(`Error from server: ${resp.error}`);
+    }
+
+    return resp;
+  }
+
+  async getPlayer(rawPlayer: IPlayerReferenceDTO): Promise<IGamePlayer | null> {
+    const player = new IPlayerReferenceDTO({ gameId: rawPlayer.gameId });
+    const res = await this.requestFromServer('getPlayer', player.toJSON());
+    if (!res) return null;
+    const dto = new IGamePlayer(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async getPlayers(): Promise<IGamePlayer[]> {
+    const res = await this.requestFromServer('getPlayers');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IGamePlayer[] = res.map((p: any) => new IGamePlayer(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async getPlayerLocation(rawPlayer: IPlayerReferenceDTO): Promise<IPosition | null> {
+    const player = new IPlayerReferenceDTO({ gameId: rawPlayer.gameId });
+    const res = await this.requestFromServer('getPlayerLocation', player.toJSON());
+    if (!res) return null;
+    const dto = new IPosition(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async testReachability(): Promise<TestReachabilityOutputDTO> {
+    try {
+      const response = await this.takaroConnector.requestFromServer(this.gameServerId, 'testReachability', '{}');
+      const dto = new TestReachabilityOutputDTO(response);
+      await dto.validate();
+      return dto;
+    } catch (error) {
+      return new TestReachabilityOutputDTO({
+        connectable: false,
+        reason: error instanceof Error ? error.message : 'Unknown error occurred',
+      });
+    }
+  }
+
+  async executeConsoleCommand(rawCommand: string): Promise<CommandOutput> {
+    const res = await this.requestFromServer('executeConsoleCommand', { command: rawCommand });
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto = new CommandOutput(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async sendMessage(message: string, opts?: IMessageOptsDTO) {
+    if (!opts) opts = new IMessageOptsDTO();
+    await this.requestFromServer('sendMessage', {
+      message,
+      opts: opts.toJSON(),
+    });
+  }
+
+  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number, dimension?: string) {
+    await this.requestFromServer('teleportPlayer', { player: player.toJSON(), x, y, z, dimension });
+  }
+
+  async kickPlayer(player: IGamePlayer, reason: string) {
+    await this.requestFromServer('kickPlayer', { player: player.toJSON(), reason });
+  }
+
+  async banPlayer(options: BanDTO) {
+    await this.requestFromServer('banPlayer', options.toJSON());
+  }
+
+  async unbanPlayer(player: IGamePlayer) {
+    await this.requestFromServer('unbanPlayer', player.toJSON());
+  }
+
+  async listBans(): Promise<BanDTO[]> {
+    const res = await this.requestFromServer('listBans');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: BanDTO[] = res.map((p: any) => new BanDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async giveItem(rawPlayer: IPlayerReferenceDTO, item: string, amount: number, quality: string): Promise<void> {
+    await this.requestFromServer('giveItem', {
+      player: { gameId: rawPlayer.gameId },
+      item,
+      amount,
+      quality,
+    });
+  }
+
+  async listItems(): Promise<IItemDTO[]> {
+    const res = await this.requestFromServer('listItems');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IItemDTO[] = res.map((p: any) => new IItemDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async getPlayerInventory(rawPlayer: IPlayerReferenceDTO): Promise<IItemDTO[]> {
+    const player = new IPlayerReferenceDTO({ gameId: rawPlayer.gameId });
+    const res = await this.requestFromServer('getPlayerInventory', player.toJSON());
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IItemDTO[] = res.map((p: any) => new IItemDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async shutdown(): Promise<void> {
+    await this.requestFromServer('shutdown');
+  }
+
+  async getMapInfo(): Promise<MapInfoDTO> {
+    const res = await this.requestFromServer('getMapInfo');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto = new MapInfoDTO(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async getMapTile(_x: number, _y: number, _z: number): Promise<string> {
+    const res = await this.requestFromServer('getMapTile', { x: _x, y: _y, z: _z });
+    return res;
+  }
+
+  async listEntities(): Promise<IEntityDTO[]> {
+    const res = await this.requestFromServer('listEntities');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IEntityDTO[] = res.map((p: any) => new IEntityDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async listLocations(): Promise<ILocationDTO[]> {
+    throw new errors.NotImplementedError();
+  }
+}

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

@@ -0,0 +1,141 @@
+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';
+import { describe, it } from 'node:test';
+
+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'],
+};