feat(jsbattle-server): run league battles in the background

Author: jamro

packages/jsbattle-engine/src/engine/AiDefinition.js

@@ -47,7 +47,7 @@ class AiDefinition {
   fromJSON(data) {
     this._name = data.name;
     this._team = data.team;
-    this._code = data.code;
+    this._code = data.code ? data.code.replace(/importScripts\w*\([^\)]*\)/g, '') : data.code;
     this._initData = data.initData;
     this._useSandbox = data.useSandbox;
     this._executionLimit = data.executionLimit;

packages/jsbattle-engine/test/engine/AiDefinition.test.js

@@ -91,6 +91,21 @@ describe('AiDefinition', function() {
       assert.equal(jsonText1, jsonText2);
     });
 
+    it('should strip importScripts commands', () => {
+      let ai = new AiDefinition();
+      let json = {
+        name: "text_" + Math.round(Math.random()*1000000),
+        team: "text_" + Math.round(Math.random()*1000000),
+        code: "importScripts('whatever')var code = 1;",
+        initData: null,
+        useSandbox: false,
+        executionLimit: 483
+      };
+
+      ai.fromJSON(json);
+      assert.equal("var code = 1;", ai.code);
+    });
+
   });
 
   describe('clone', function() {

packages/jsbattle-server/.eslintignore

@@ -0,0 +1 @@
+app/services/ubdPlayer/www/**/*

packages/jsbattle-server/.eslintrc.js

@@ -149,7 +149,7 @@ module.exports = {
         "no-loop-func": "error",
         "no-magic-numbers": "off",
         "no-misleading-character-class": "error",
-        "no-mixed-operators": "error",
+        "no-mixed-operators": "off",
         "no-mixed-requires": "error",
         "no-multi-assign": "error",
         "no-multi-spaces": "error",

packages/jsbattle-server/app/lib/ConfigBroker.js

@@ -26,6 +26,18 @@ class ConfigBroker extends ServiceBroker {
         "enabled": true,
         "admins": [],
         "providers": []
+      },
+      "league": {
+        "scheduleInterval": 5000,
+        "timeLimit": 30000,
+        "teamSize": 3
+      },
+      "ubdPlayer": {
+        "queueLimit": 3,
+        "queueQueryTime": 1000,
+        "port": 8899,
+        "speed": 5,
+        "timeout": 30000
       }
     };
 
@@ -50,6 +62,7 @@ class ConfigBroker extends ServiceBroker {
 
     config = _.defaultsDeep(config, defaultConfig)
 
+
     this.serviceConfig = config;
 
   }

packages/jsbattle-server/app/services/League.service.js

@@ -5,12 +5,15 @@ const _ = require('lodash');
 const getDbAdapterConfig = require("../lib/getDbAdapterConfig.js");
 const fs = require('fs');
 const path = require('path');
+const selectOpponents = require('./league/selectOpponents.js');
+const updateScores = require('./league/updateScores.js');
 
 class LeagueService extends Service {
 
   constructor(broker) {
     super(broker);
-
+    this.config = broker.serviceConfig.league;
+    this.queueLimit = broker.serviceConfig.ubdPlayer.queueLimit;
     let adapterConfig = getDbAdapterConfig(broker.serviceConfig.data, 'league')
     this.parseServiceSchema({
       ...adapterConfig,
@@ -25,7 +28,6 @@ class LeagueService extends Service {
           "ownerName",
           "scriptId",
           "scriptName",
-          "rank",
           "fights_total",
           "fights_win",
           "fights_lose",
@@ -40,16 +42,19 @@ class LeagueService extends Service {
         ownerName: { type: "string", min: 1, max: 255 },
         scriptId: "string",
         scriptName: { type: "string", min: 1, max: 255 },
-        rank: "number",
         fights_total: "number",
         fights_win: "number",
         fights_lose: "number",
         fights_error: "number",
         score: "number",
         code: { type: "string", min: 0, max: 65536 },
       },
-      dependencies: ['scriptStore'],
+      dependencies: [
+        'scriptStore',
+        'ubdPlayer'
+      ],
       actions: {
+        scheduleBattle: this.scheduleBattle,
         seedLeague: this.seedLeague,
         getUserSubmission: this.getUserSubmission,
         joinLeague: this.joinLeague,
@@ -61,12 +66,11 @@ class LeagueService extends Service {
           create: [
             function addDefaults(ctx) {
               ctx.params.joinedAt = new Date();
-              ctx.params.rank = 0;
               ctx.params.fights_total = 0;
               ctx.params.fights_win = 0;
               ctx.params.fights_lose = 0;
               ctx.params.fights_error = 0;
-              ctx.params.score = 0;
+              ctx.params.score = 1000;
               ctx.params = _.omit(ctx.params, ['id']);
               return ctx;
             }
@@ -76,18 +80,85 @@ class LeagueService extends Service {
       events: {
         "app.seed": async (ctx) => {
           await ctx.call('league.seedLeague', {})
+        },
+        "ubdPlayer.battle.league": async (ctx) => {
+          if(ctx.params.error) {
+            this.logger.warn('Battle failed between: ' + Object.keys(ctx.params.refData).join(' and '));
+            return;
+          }
+          await updateScores(ctx, this.logger);
         }
+      },
+      started: () => {
+        this.loop = setInterval(async () => {
+          try {
+            let queueLength = await broker.call('ubdPlayer.getQueueLength', {});
+            if(queueLength >= this.queueLimit) {
+              return;
+            }
+            await broker.call('league.scheduleBattle', {})
+          } catch(err) {
+            this.logger.warn(err)
+          }
+        }, this.config.scheduleInterval)
+      },
+      stopped: () => {
+        clearInterval(this.loop)
       }
     });
   }
 
+  async scheduleBattle(ctx) {
+    // pick random opponents
+    let opponents = await selectOpponents(ctx);
+
+    // build UBD
+    let ubd = {
+      version: 3,
+      rngSeed: Math.random(),
+      teamMode: true,
+      timeLimit: this.config.timeLimit,
+      aiList: []
+    };
+
+    let i;
+    for(i=0; i < this.config.teamSize; i++) {
+      for(let opponent of opponents) {
+        ubd.aiList.push({
+          name: opponent.ownerName === 'jsbattle' ? opponent.scriptName : opponent.ownerName,
+          team: opponent.ownerName + '/' + opponent.scriptName,
+          code: opponent.code,
+          initData: null,
+          useSandbox: true,
+          executionLimit: 100
+        });
+      }
+    }
+
+    this.logger.debug(`Scheduling battle ${opponents[0].scriptName} vs ${opponents[1].scriptName}`)
+
+    try {
+      let refData = {};
+      refData[opponents[0].ownerName + '/' + opponents[0].scriptName] = opponents[0].id;
+      refData[opponents[1].ownerName + '/' + opponents[1].scriptName] = opponents[1].id;
+      await ctx.call('ubdPlayer.scheduleBattle', {
+        ubd: ubd,
+        event: 'league',
+        refData: refData
+      });
+    } catch(err) {
+      this.logger.debug('Unable to schedule battle due to: ' + err.message)
+    }
+
+  }
+
   async seedLeague(ctx) {
     const seedPath = path.resolve(__dirname, 'league', 'seed');
     const seedFiles = fs.readdirSync(seedPath)
-      .map((filename) => ({
-        ownerId: 0,
+      .map((filename, index) => ({
+        ownerId: 'int-user-0000-1',
         ownerName: 'jsbattle',
-        scriptId: 0,
+        scriptId: 'int-script-0000-' + (index+1),
         scriptName: filename.replace(/\.tank$/, ''),
         code: fs.readFileSync(path.resolve(seedPath, filename), 'utf8')
       }))
@@ -178,10 +249,9 @@ class LeagueService extends Service {
     }
 
     let ranktable = await ctx.call('league.find', {
-      sort: 'rank'
+      sort: '-score'
     });
-    ranktable = ranktable.map((item) => _.pick(item, [
-      "rank",
+    const fields = [
       "ownerId",
       "ownerName",
       "scriptId",
@@ -192,22 +262,11 @@ class LeagueService extends Service {
       "fights_lose",
       "fights_error",
       "score"
-    ]));
+    ]
+    ranktable = ranktable.map((item) => _.pick(item, fields));
 
     let submission = await this.getUserSubmission(ctx)
-    submission = _.pick(submission, [
-      "rank",
-      "ownerId",
-      "ownerName",
-      "scriptId",
-      "scriptName",
-      "joinedAt",
-      "fights_total",
-      "fights_win",
-      "fights_lose",
-      "fights_error",
-      "score"
-    ]);
+    submission = _.pick(submission, fields);
 
     return {
       submission,

packages/jsbattle-server/app/services/UbdPlayer.service.js

@@ -0,0 +1,141 @@
+const Service = require("moleculer").Service;
+const { ValidationError, MoleculerError } = require("moleculer").Errors;
+const express = require('express')
+const path = require('path')
+const puppeteer = require('puppeteer');
+
+class UbdPlayer extends Service {
+
+  constructor(broker) {
+    super(broker);
+    this.app = null;
+    this.server = null;
+    this.loop = null;
+    this.browser = null;
+    this.isBusy = false;
+    this.processingStartTime = 0;
+    this.parseServiceSchema({
+      name: "ubdPlayer",
+      dependencies: ['ubdValidator'],
+      actions: {
+        scheduleBattle: this.scheduleBattle,
+        getQueueLength: this.getQueueLength,
+      },
+      started: async () => {
+        // host frontend
+        this.app = express();
+        const port = broker.serviceConfig.ubdPlayer.port
+        this.app.use(express.static(path.join(__dirname, 'ubdPlayer', 'www')))
+        this.server = this.app.listen(port, 'localhost', () => this.logger.info(`UbdPlayer started at http://localhost:${port}`))
+
+        // start browser
+        this.browser = await puppeteer.launch();
+
+        this.loop = setInterval(async () => {
+          if(this.isBusy) {
+            let processDuration = new Date().getTime() - this.processingStartTime;
+            if(processDuration > 1.5 * broker.serviceConfig.ubdPlayer.timeout) {
+              this.logger.warn('Battle not responding. `Restarting...');
+              try {
+                await this.browser.close();
+              } catch(err) {
+                this.logger.warn('cannot close browser when restarting');
+                this.logger.warn(err);
+              }
+              try {
+                this.browser = await puppeteer.launch();
+                this.isBusy = false;
+              } catch(err) {
+                this.logger.warn('cannot restart');
+                this.logger.warn(err);
+              }
+            }
+            return;
+          }
+          if(this.queue.length === 0) {
+            return;
+          }
+          try {
+            this.processingStartTime = new Date().getTime();
+            this.isBusy = true;
+
+            let task = this.queue.shift();
+            let ubd = task.ubd;
+            let page = await this.browser.newPage();
+            await page.goto('http://localhost:' + port);
+            await page.waitFor('#ubd');
+            await page.$eval('#ubd', (el, ubd) => {
+              el.value = JSON.stringify(ubd)
+            }, ubd);
+            await page.$eval('#speed', (el, speed) => {
+              el.value = speed
+            }, broker.serviceConfig.ubdPlayer.speed);
+
+            this.logger.debug('Battle started');
+            await page.click('#start');
+            await page.waitFor('#output', {timeout: broker.serviceConfig.ubdPlayer.timeout});
+            this.logger.debug('Battle completed');
+            const element = await page.$("#output");
+            const text = await page.evaluate((element) => element.innerHTML, element);
+            await page.close();
+            const jsonResult = JSON.parse(text)
+            if(task.refData) {
+              jsonResult.refData = task.refData;
+            }
+            let eventName = "ubdPlayer.battle";
+            if(task.event) {
+              eventName = eventName + ("." + task.event)
+            } else {
+              eventName = eventName + ".default"
+            }
+            broker.broadcast(eventName, jsonResult);
+            this.isBusy = false;
+            let dt = new Date().getTime() - this.processingStartTime;
+            this.logger.debug(`Battle completed after ${dt}ms`)
+          } catch (err) {
+            this.logger.debug('Unable to finish the battle');
+            this.logger.warn(err);
+            this.isBusy = false;
+          }
+        }, broker.serviceConfig.ubdPlayer.queueQueryTime)
+
+      },
+      stopped: () => {
+        this.server.close();
+        if(this.loop) {
+          clearInterval(this.loop);
+          this.loop = null;
+        }
+        if(this.browser) {
+          this.browser.close();
+          this.browser = null;
+        }
+      }
+    });
+    this.queue = []
+    this.queueLimit = broker.serviceConfig.ubdPlayer.queueLimit
+  }
+
+  getQueueLength() {
+    return this.queue.length;
+  }
+
+  async scheduleBattle(ctx) {
+    let result = await ctx.call('ubdValidator.validate', {ubd: ctx.params.ubd})
+    if(!result.valid) {
+      throw new ValidationError('Invalid ubd to play!')
+    }
+    if(this.queue.length >= this.queueLimit) {
+      throw new MoleculerError('UbdPlayer queue limit exceeded')
+    }
+    this.queue.push({
+      ubd: ctx.params.ubd,
+      event: ctx.params.event || "",
+      refData: ctx.params.refData || undefined,
+    });
+    this.logger.debug('Battle scheduled. Queue length: ' + this.queue.length)
+  }
+
+}
+
+module.exports = UbdPlayer;