separate lean server from socket server

2023-12-09 22:42:40 +01:00
parent b239a5d3dc
commit 527f58e3a4
11 changed files with 18 additions and 22 deletions
@@ -0,0 +1,31 @@
+#/bin/bash
+
+ELAN_HOME=$(lake env printenv ELAN_HOME)
+
+# $1 : the game directory
+# $2 : the lean4game folder
+# $3 : the gameserver executable
+
+(exec bwrap\
+  --bind $2 /lean4game \
+  --bind $1 /game \
+  --bind $ELAN_HOME /elan \
+  --bind /usr /usr \
+  --dev /dev \
+  --proc /proc \
+  --symlink usr/lib /lib\
+  --symlink usr/lib64 /lib64\
+  --symlink usr/bin /bin\
+  --symlink usr/sbin /sbin\
+  --clearenv \
+  --setenv PATH "/elan/bin:/bin" \
+  --setenv ELAN_HOME "/elan" \
+  --unshare-user \
+  --unshare-pid  \
+  --unshare-net  \
+  --unshare-uts  \
+  --unshare-cgroup \
+  --die-with-parent \
+  --chdir "/game/.lake/packages/GameServer/server/.lake/build/bin/" \
+  ./gameserver --server /game
+)
@@ -0,0 +1,140 @@
+import { spawn } from 'child_process'
+import fs from 'fs';
+import request from 'request'
+import requestProgress from 'request-progress'
+import { Octokit } from 'octokit';
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TOKEN = process.env.LEAN4GAME_GITHUB_TOKEN
+const USERNAME = process.env.LEAN4GAME_GITHUB_USER
+const octokit = new Octokit({
+  auth: TOKEN
+})
+
+const progress = {}
+
+async function runProcess(id, cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const ls = spawn(cmd, args, {cwd});
+
+    ls.stdout.on('data', (data) => {
+      progress[id].output += data.toString()
+    });
+
+    ls.stderr.on('data', (data) => {
+      progress[id].output += data.toString()
+    });
+
+    ls.on('close', (code) => {
+      resolve()
+    });
+  })
+}
+
+async function download(id, url, dest) {
+  return new Promise((resolve, reject) => {
+    // The options argument is optional so you can omit it
+    requestProgress(request({
+      url,
+      headers: {
+        'accept': 'application/vnd.github+json',
+        'User-Agent': USERNAME,
+        'X-GitHub-Api-Version': '2022-11-28',
+        'Authorization': 'Bearer ' + TOKEN
+      }
+    }))
+    .on('progress', function (state) {
+      progress[id].output += `Downloaded ${Math.round(state.size.transferred/1024/1024)}MB\n`
+    })
+    .on('error', function (err) {
+      reject(err)
+    })
+    .on('end', function () {
+      resolve()
+    })
+    .pipe(fs.createWriteStream(dest));
+  })
+}
+
+async function doImport (owner, repo, id) {
+  progress[id].output += `Import starting in a few seconds...\n`
+  await new Promise(resolve => setTimeout(resolve, 3000))
+  let artifactId = null
+  try {
+    const artifacts = await octokit.request('GET /repos/{owner}/{repo}/actions/artifacts', {
+      owner,
+      repo,
+      headers: {
+        'X-GitHub-Api-Version': '2022-11-28'
+      }
+    })
+    // choose latest artifact
+    const artifact = artifacts.data.artifacts
+      .reduce((acc, cur) => acc.created_at < cur.created_at ? cur : acc)
+    artifactId = artifact.id
+    const url = artifact.archive_download_url
+    // Make sure the download folder exists
+    if (!fs.existsSync(path.join(__dirname, "..", "games"))){
+      fs.mkdirSync(path.join(__dirname, "..", "games"));
+    }
+    if (!fs.existsSync(path.join(__dirname, "..", "games", "tmp"))){
+      fs.mkdirSync(path.join(__dirname, "..", "games", "tmp"));
+    }
+    progress[id].output += `Download from ${url}\n`
+    await download(id, url, path.join(__dirname, "..", "games", "tmp", `${owner.toLowerCase()}_${repo.toLowerCase()}_${artifactId}.zip`))
+    progress[id].output += `Download finished.\n`
+
+    await runProcess(id, "/bin/bash", [path.join(__dirname, "unpack.sh"), artifactId, owner.toLowerCase(), repo.toLowerCase()], path.join(__dirname, ".."))
+
+
+    // let manifest = fs.readFileSync(`tmp/artifact_${artifactId}_inner/manifest.json`);
+    // manifest = JSON.parse(manifest);
+    // if (manifest.length !== 1) {
+    //   throw `Unexpected manifest: ${JSON.stringify(manifest)}`
+    // }
+    // manifest[0].RepoTags = [`g/${owner.toLowerCase()}/${repo.toLowerCase()}:latest`]
+    // fs.writeFileSync(`tmp/artifact_${artifactId}_inner/manifest.json`, JSON.stringify(manifest));
+    // await runProcess(id, "tar", ["-cvf", `../archive_${artifactId}.tar`, "."], `tmp/artifact_${artifactId}_inner/`)
+    // // await runProcess(id, "docker", ["load", "-i", `tmp/archive_${artifactId}.tar`])
+
+    progress[id].done = true
+    progress[id].output += `Done!\n`
+    progress[id].output += `Play the game at: {your website}/#/g/${owner}/${repo}\n`
+  } catch (e) {
+    progress[id].output += `Error: ${e.toString()}\n${e.stack}`
+  } finally {
+    // clean-up temp. files
+    if (artifactId) {
+      fs.rmSync(path.join(__dirname, "..", "games", "tmp", `${owner}_${repo}_${artifactId}.zip`), {force: true, recursive: false});
+      fs.rmSync(path.join(__dirname, "..", "games", "tmp", `${owner}_${repo}_${artifactId}`), {force: true, recursive: true});
+    }
+    progress[id].done = true
+  }
+  await new Promise(resolve => setTimeout(resolve, 10000))
+}
+
+export const importTrigger = (req, res) => {
+  const owner = req.params.owner
+  const repo = req.params.repo
+  const id = req.params.owner + '/' + req.params.repo
+  if(!/^[\w.-]+\/[\w.-]+$/.test(id)) { res.send(`Invalid repo name ${id}`); return }
+
+  if(!progress[id] || progress[id].done) {
+    progress[id] = {output: "", done: false}
+    doImport(owner, repo, id)
+  }
+
+  res.redirect(`/import/status/${owner}/${repo}`)
+}
+
+export const importStatus = (req, res) => {
+  const owner = req.params.owner
+  const repo = req.params.repo
+  const id = req.params.owner + '/' + req.params.repo
+  res.send(`<html><head><meta http-equiv="refresh" content="5"></head><body><pre>${progress[id]?.output ?? "Nothing here."}</pre></body></html>`)
+}
@@ -0,0 +1,203 @@
+import { WebSocketServer } from 'ws';
+import express from 'express'
+import path from 'path'
+import * as cp from 'child_process';
+import * as url from 'url';
+import * as rpc from 'vscode-ws-jsonrpc';
+import * as jsonrpcserver from 'vscode-ws-jsonrpc/server';
+import os from 'os';
+import fs from 'fs';
+import anonymize from 'ip-anonymize';
+import { importTrigger, importStatus } from './import.mjs'
+// import fs from 'fs'
+
+/**
+ * Add a game here if the server should keep a queue of pre-loaded games ready at all times.
+ *
+ * IMPORTANT! Tags here need to be lower case!
+*/
+const queueLength = {
+  "g/hhu-adam/robo": 2,
+  "g/hhu-adam/nng4": 5,
+  "g/djvelleman/stg4": 2,
+}
+
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+const app = express()
+
+const PORT = process.env.PORT || 8080;
+
+var router = express.Router();
+
+router.get('/import/status/:owner/:repo', importStatus)
+router.get('/import/trigger/:owner/:repo', importTrigger)
+
+const server = app
+  .use(express.static(path.join(__dirname, '..', 'client', 'dist'))) // TODO: add a dist folder from inside the game
+  .use('/data/g/:owner/:repo/*', (req, res, next) => {
+    const owner = req.params.owner;
+    const repo = req.params.repo
+    const filename = req.params[0];
+    req.url = filename;
+    express.static(path.join(getGameDir(owner,repo),".lake","gamedata"))(req, res, next);
+  })
+  .use('/', router)
+  .listen(PORT, () => console.log(`Listening on ${PORT}`));
+
+const wss = new WebSocketServer({ server })
+
+var socketCounter = 0
+
+const environment = process.env.NODE_ENV
+const isDevelopment = environment === 'development'
+
+/** We keep queues of started Lean Server processes to be ready when a user arrives */
+const queue = {}
+
+function getTag(owner, repo) {
+  return `g/${owner.toLowerCase()}/${repo.toLowerCase()}`
+}
+
+function getGameDir(owner, repo) {
+  owner = owner.toLowerCase()
+  if (owner == 'local') {
+    if(!isDevelopment) {
+      console.error(`No local games in production mode.`)
+      return ""
+    }
+  } else {
+    if(!fs.existsSync(path.join(__dirname, '..', 'games'))) {
+      console.error(`Did not find the following folder: ${path.join(__dirname, '..', 'games')}`)
+      console.error('Did you already import any games?')
+      return ""
+    }
+  }
+
+  let game_dir = (owner == 'local') ?
+    path.join(__dirname, '..', '..', repo) : // note: here we need `repo` to be case sensitive
+    path.join(__dirname, '..', 'games', `${owner}`, `${repo.toLowerCase()}`)
+
+  if(!fs.existsSync(game_dir)) {
+    console.error(`Game '${game_dir}' does not exist!`)
+    return ""
+  }
+
+  return game_dir;
+}
+
+function startServerProcess(owner, repo) {
+
+  let game_dir = getGameDir(owner, repo)
+  if (!game_dir) return;
+
+  let serverProcess
+  if (isDevelopment) {
+    let args = ["--server", game_dir]
+    let binDir = path.join(game_dir, ".lake", "packages", "GameServer", "server", ".lake", "build", "bin")
+    // Note: `cwd` is important to be the `bin` directory as `Watchdog` calls `./gameserver` again
+    if (fs.existsSync(binDir)) {
+      // Try to use the game's own copy of `gameserver`.
+      serverProcess = cp.spawn("./gameserver", args, { cwd: binDir })
+    } else {
+      // If the game is built with `-Klean4game.local` there is no copy in the lake packages.
+      serverProcess = cp.spawn("./gameserver", args,
+        { cwd: path.join(__dirname, "..", "server", ".lake", "build", "bin") })
+    }
+  } else {
+    serverProcess =  cp.spawn("./bubblewrap.sh",
+      [ game_dir, path.join(__dirname, '..')],
+      { cwd: __dirname })
+  }
+
+  serverProcess.on('error', error =>
+    console.error(`Launching Lean Server failed: ${error}`)
+  )
+  if (serverProcess.stderr !== null) {
+    serverProcess.stderr.on('data', data =>
+      console.error(`Lean Server: ${data}`)
+    )
+  }
+  return serverProcess
+}
+
+/** start Lean Server processes to refill the queue */
+function fillQueue(tag) {
+  while (queue[tag].length < queueLength[tag]) {
+    let serverProcess
+    serverProcess = startServerProcess(tag)
+    if (serverProcess == null) {
+      console.error('serverProcess was undefined/null')
+      return
+    }
+    queue[tag].push(serverProcess)
+  }
+}
+
+// // TODO: We disabled queue for now
+// if (!isDevelopment) { // Don't use queue in development
+//   for (let tag in queueLength) {
+//     queue[tag] = []
+//     fillQueue(tag)
+//   }
+// }
+
+const urlRegEx = /^\/websocket\/g\/([\w.-]+)\/([\w.-]+)$/
+
+wss.addListener("connection", function(ws, req) {
+    const reRes = urlRegEx.exec(req.url)
+    if (!reRes) { console.error(`Connection refused because of invalid URL: ${req.url}`); return; }
+    const owner = reRes[1]
+    const repo = reRes[2]
+
+    const tag = getTag(owner, repo)
+
+    let ps
+    if (!queue[tag] || queue[tag].length == 0) {
+      ps = startServerProcess(owner, repo)
+    } else {
+        console.info('Got process from the queue')
+        ps = queue[tag].shift() // Pick the first Lean process; it's likely to be ready immediately
+        fillQueue(tag)
+    }
+
+    if (ps == null) {
+      console.error('server process is undefined/null')
+      return
+    }
+
+    socketCounter += 1;
+    const ip = anonymize(req.headers['x-forwarded-for'] || req.socket.remoteAddress)
+    console.log(`[${new Date()}] Socket opened - ${ip}`)
+
+    const socket = {
+        onMessage: (cb) => { ws.on("message", cb) },
+        onError: (cb) => { ws.on("error", cb) },
+        onClose: (cb) => { ws.on("close", cb) },
+        send: (data, cb) => { ws.send(data,cb) }
+    }
+    const reader = new rpc.WebSocketMessageReader(socket)
+    const writer = new rpc.WebSocketMessageWriter(socket)
+    const socketConnection = jsonrpcserver.createConnection(reader, writer, () => ws.close())
+    const serverConnection = jsonrpcserver.createProcessStreamConnection(ps)
+    socketConnection.forward(serverConnection, message => {
+        if (isDevelopment) {console.log(`CLIENT: ${JSON.stringify(message)}`)}
+        return message;
+    })
+    serverConnection.forward(socketConnection, message => {
+      if (isDevelopment) {console.log(`SERVER: ${JSON.stringify(message)}`)}
+        return message;
+    });
+
+    console.log(`[${new Date()}] Number of open sockets - ${socketCounter}`)
+    console.log(`[${new Date()}] Free RAM - ${Math.round(os.freemem() / 1024 / 1024)} / ${Math.round(os.totalmem() / 1024 / 1024)} MB`)
+
+    ws.on('close', () => {
+      console.log(`[${new Date()}] Socket closed - ${ip}`)
+      socketCounter -= 1
+    })
+
+    socketConnection.onClose(() => serverConnection.dispose())
+    serverConnection.onClose(() => socketConnection.dispose())
+})
@@ -0,0 +1,30 @@
+#/bin/bash
+
+ARTIFACT_ID=$1
+OWNER=$2
+REPO=$3
+
+# mkdir -p games
+cd games
+
+# mkdir -p tmp
+mkdir -p ${OWNER}
+
+echo "Unpacking ZIP."
+unzip -o tmp/${OWNER}_${REPO}_${ARTIFACT_ID}.zip -d tmp/${OWNER}_${REPO}_${ARTIFACT_ID}
+echo "Unpacking game."
+
+# exit the npm project to avoid reloading. TODO: Where should we actually save these?
+
+
+
+echo "Delete old version of the game"
+rm -rf ${OWNER}/${REPO}
+mkdir -p ${OWNER}/${REPO}
+
+for f in tmp/${OWNER}_${REPO}_${ARTIFACT_ID}/* #Should only be one file
+do
+  echo "Unpacking $f"
+  #tar -xvzf $f -C games/${OWNER}/${REPO}
+  unzip -q -o $f -d ${OWNER}/${REPO}
+done