Arma Reforger support

Author: Dahlgren

Diff for: app.js

@@ -1,5 +1,6 @@
 var express = require('express')
 var bodyParser = require('body-parser')
+var fs = require('fs.extra')
 var morgan = require('morgan')
 var path = require('path')
 var serveStatic = require('serve-static')
@@ -15,6 +16,15 @@ var Mods = require('./lib/mods')
 var Logs = require('./lib/logs')
 var Settings = require('./lib/settings')
 
+if (config.game === 'reforger') {
+  Logs = require('./lib/reforger/logs')
+  Manager = require('./lib/reforger/manager')
+  Missions = require('./lib/reforger/missions')
+  Mods = require('./lib/reforger/mods')
+
+  fs.mkdirp(config.reforger.profiles) // Needs to be created in advance or game will store profiles elsewhere
+}
+
 var app = express()
 var server = require('http').Server(app)
 var io = require('socket.io')(server)

Diff for: config.js.example

@@ -9,6 +9,12 @@ module.exports = {
     '-noSound',
     '-world=empty'
   ],
+  reforger: {
+    configs: 'path-to-configs-folder', // Folder where server config files will be stored
+    profiles: 'path-to-profiles-folder', // Folder where logs and persistence data will be stored. Each server will create a subfolder.
+    region: 'EU', // Region in which servers will be hosted, https://community.bistudio.com/wiki/Arma_Reforger:Server_Hosting#region
+    workshop: 'path-to-workshop-folder' // Folder where workshop mods will be stored
+  },
   serverMods: [ // Mods used exclusively by server and not shared with clients
     '@mod1',
     '@mod2',

Diff for: lib/mods/index.js

@@ -70,6 +70,7 @@ Mods.prototype.resolveModData = function (modPath, cb) {
     }
 
     cb(null, {
+      id: modPath,
       name: modPath,
       size: results.folderSize,
       formattedSize: filesize(results.folderSize),

Diff for: lib/reforger/logs.js

@@ -0,0 +1,91 @@
+var async = require('async')
+var filesize = require('filesize')
+var fs = require('fs.extra')
+var glob = require('glob')
+var path = require('path')
+
+var Logs = function (config) {
+  this.config = config
+}
+
+Logs.prototype.delete = function (filename, callback) {
+  callback = callback || function () {}
+
+  this.getLogFile(filename, function (err, logFile) {
+    if (err) {
+      return callback(err)
+    } else {
+      if (logFile && logFile.path) {
+        fs.unlink(logFile.path, callback)
+      } else {
+        return callback(new Error('File not found'))
+      }
+    }
+  })
+}
+
+Logs.prototype.logsPath = function () {
+  return this.config.reforger.profiles
+}
+
+Logs.prototype.logFiles = function (callback) {
+  var directory = this.logsPath()
+
+  if (directory === null) {
+    return callback(null, [])
+  }
+
+  glob('**/*.log', { cwd: directory }, function (err, files) {
+    if (err) {
+      callback(err)
+      return
+    }
+
+    files = files.map(function (file) {
+      return {
+        name: file,
+        path: path.join(directory, file)
+      }
+    })
+
+    async.filter(files, function (file, cb) {
+      fs.stat(file.path, function (err, stat) {
+        file.created = stat.birthtime.toISOString()
+        file.modified = stat.mtime.toISOString()
+        file.formattedSize = filesize(stat.size)
+        file.size = stat.size
+        cb(!err && stat.isFile())
+      })
+    }, function (files) {
+      files.sort(function (a, b) {
+        return b.created.localeCompare(a.created) // Descending order
+      })
+
+      callback(null, files)
+    })
+  })
+}
+
+Logs.prototype.getLogFile = function (filename, callback) {
+  this.logFiles(function (err, files) {
+    if (err) {
+      callback(err)
+    } else {
+      var validLogs = files.filter(function (file) {
+        return file.name === filename
+      })
+
+      if (validLogs.length > 0) {
+        callback(null, validLogs[0])
+      } else {
+        callback(null, null)
+      }
+    }
+  })
+}
+
+Logs.prototype.readLogFile = function (filename, callback) {
+  fs.readFile(filename, callback)
+}
+
+module.exports = Logs

Diff for: lib/reforger/manager.js

@@ -0,0 +1,132 @@
+var events = require('events')
+var fs = require('fs')
+
+var Server = require('./server')
+
+var filePath = 'servers.json'
+
+var Manager = function (config, logs) {
+  this.config = config
+  this.logs = logs
+  this.serversArr = []
+  this.serversHash = {}
+}
+
+Manager.prototype = new events.EventEmitter()
+
+Manager.prototype.addServer = function (options) {
+  var server = this._addServer(options)
+  this.save()
+  return server
+}
+
+Manager.prototype.removeServer = function (id) {
+  var server = this.serversHash[id]
+
+  if (!server) {
+    return {}
+  }
+
+  var index = this.serversArr.indexOf(server)
+  if (index > -1) {
+    this.serversArr.splice(index, 1)
+  }
+  this.save()
+
+  if (server.pid) {
+    server.stop()
+  }
+
+  return server
+}
+
+Manager.prototype._addServer = function (data) {
+  var server = new Server(this.config, this.logs, data)
+  this.serversArr.push(server)
+  this.serversArr.sort(function (a, b) {
+    return a.title.localeCompare(b.title)
+  })
+  this.serversHash[server.id] = server
+
+  var self = this
+  var save = function () {
+    self.save()
+  }
+  var statusChanged = function () {
+    self.emit('servers')
+  }
+  server.on('save', save)
+  server.on('state', statusChanged)
+
+  return server
+}
+
+Manager.prototype.getServer = function (id) {
+  return this.serversHash[id]
+}
+
+Manager.prototype.getServers = function () {
+  return this.serversArr
+}
+
+Manager.prototype.load = function () {
+  var self = this
+
+  fs.readFile(filePath, function (err, data) {
+    if (err) {
+      console.log('Could not load any existing servers configuration, starting fresh')
+      return
+    }
+
+    try {
+      JSON.parse(data).forEach(function (server) {
+        self._addServer(server)
+      })
+    } catch (e) {
+      console.error('Manager load error: ' + e)
+    }
+
+    self.getServers().map(function (server) {
+      if (server.auto_start) {
+        server.start()
+      }
+    })
+  })
+}
+
+Manager.prototype.save = function () {
+  var data = []
+  var self = this
+
+  this.serversArr.sort(function (a, b) {
+    return a.title.toLowerCase().localeCompare(b.title.toLowerCase())
+  })
+
+  this.serversHash = {}
+  this.serversArr.forEach(function (server) {
+    data.push({
+      admin_password: server.admin_password,
+      auto_start: server.auto_start,
+      battle_eye: server.battle_eye,
+      dedicatedServerId: server.dedicatedServerId,
+      max_players: server.max_players,
+      missions: server.missions,
+      mods: server.mods,
+      password: server.password,
+      port: server.port,
+      title: server.title
+    })
+
+    self.serversHash[server.id] = server
+  })
+
+  fs.writeFile(filePath, JSON.stringify(data), function (err) {
+    if (err) {
+      console.error('Manager save error: ' + err)
+    } else {
+      self.emit('servers')
+    }
+  })
+}
+
+module.exports = Manager

Diff for: lib/reforger/missions.js

@@ -0,0 +1,99 @@
+var async = require('async')
+var events = require('events')
+var fs = require('fs.extra')
+var glob = require('glob')
+var path = require('path')
+
+function stripBOM (data) {
+  if (data.charCodeAt(0) === 0xFEFF) {
+    return data.slice(1)
+  }
+
+  return data
+}
+
+var Missions = function (config) {
+  this.config = config
+  this.missions = []
+
+  this.updateMissions()
+}
+
+Missions.prototype = new events.EventEmitter()
+
+Missions.prototype.missionsPath = function () {
+  return this.config.reforger.workshop
+}
+
+Missions.prototype.updateMissions = function (cb) {
+  var self = this
+  var workshopFolder = this.missionsPath()
+
+  glob('**/ServerData.json', { cwd: workshopFolder }, function (err, files) {
+    if (err) {
+      console.log(err)
+      return
+    }
+
+    async.map(files, function (filename, cb) {
+      var serverDataFile = path.join(workshopFolder, filename)
+      fs.readFile(serverDataFile, 'utf-8', function (err, data) {
+        if (err) {
+          console.log(err)
+          return cb(err)
+        }
+
+        try {
+          var serverData = JSON.parse(stripBOM(data))
+          fs.stat(serverDataFile, function (err, stat) {
+            if (err) {
+              console.log(err)
+              return cb(err)
+            }
+
+            var missions = serverData.revision.scenarios.map(function (scenario) {
+              return {
+                dateCreated: new Date(stat.ctime),
+                dateModified: new Date(stat.mtime),
+                missionName: scenario.name,
+                name: scenario.gameId,
+                size: 0,
+                sizeFormatted: '',
+                worldName: ''
+              }
+            })
+
+            cb(null, missions)
+          })
+        } catch (err) {
+          console.log(err)
+          return cb(err)
+        }
+      })
+    }, function (err, missions) {
+      if (!err) {
+        missions = missions.flat()
+        self.missions = missions
+        self.emit('missions', missions)
+      }
+
+      if (cb) {
+        cb(err, missions)
+      }
+    })
+  })
+}
+
+Missions.prototype.handleUpload = function (uploadedFile, cb) {
+  cb(new Error('Not implemented'))
+}
+
+Missions.prototype.delete = function (missionName, cb) {
+  cb(new Error('Not implemented'))
+}
+
+Missions.prototype.downloadSteamWorkshop = function (id, cb) {
+  cb(new Error('Not implemented'))
+}
+
+module.exports = Missions