use serverId in protocol instead of legacy info object

lib/app.js

@@ -39,24 +39,11 @@ class App {
       client.on('requestHistoryGraph', () => {
         // Send historical graphData built from all serverRegistrations
         const graphData = {}
-        const graphPeaks = {}
 
         this.serverRegistrations.forEach((serverRegistration) => {
-          graphData[serverRegistration.data.name] = serverRegistration.graphData
-
-          // Send current peak, if any
-          const graphPeak = serverRegistration.getGraphPeak()
-          if (graphPeak) {
-            graphPeaks[serverRegistration.data.name] = graphPeak
-          }
+          graphData[serverRegistration.serverId] = serverRegistration.graphData
         })
 
-        // Send current peaks, if any
-        // Emit peaks first since graphData may take a while to receive
-        if (Object.keys(graphPeaks).length > 0) {
-          client.emit('peaks', graphPeaks)
-        }
-
         client.emit('historyGraph', graphData)
       })
     }

lib/ping.js

@@ -107,8 +107,6 @@ class PingController {
   handlePing (serverRegistration, resp, err, version) {
     const timestamp = new Date().getTime()
 
-    this._app.server.broadcast('update', serverRegistration.getUpdate(timestamp, resp, err, version))
-
     serverRegistration.addPing(timestamp, resp)
 
     if (config.logToDatabase) {
@@ -119,24 +117,14 @@ class PingController {
 
       if (serverRegistration.addGraphPoint(resp !== undefined, playerCount, timestamp)) {
         this._app.server.broadcast('updateHistoryGraph', {
-          name: serverRegistration.data.name,
+          serverId: serverRegistration.serverId,
           playerCount: playerCount,
           timestamp: timestamp
         })
       }
-
-      // Update calculated graph peak regardless if the graph is being updated
-      // This can cause a (harmless) desync between live and stored data, but it allows it to be more accurate for long surviving processes
-      if (serverRegistration.findNewGraphPeak()) {
-        const graphPeak = serverRegistration.getGraphPeak()
-
-        this._app.server.broadcast('updatePeak', {
-          name: serverRegistration.data.name,
-          playerCount: graphPeak.playerCount,
-          timestamp: graphPeak.timestamp
-        })
-      }
     }
+
+    this._app.server.broadcast('update', serverRegistration.getUpdate(timestamp, resp, err, version))
   }
 }
 

lib/servers.js

@@ -2,22 +2,22 @@ const config = require('../config')
 const minecraftVersions = require('../minecraft_versions')
 
 class ServerRegistration {
+  serverId
   lastFavicon
   versions = []
   recordData
   graphData = []
 
-  constructor (data) {
+  constructor (serverId, data) {
+    this.serverId = serverId
     this.data = data
     this._pingHistory = []
   }
 
   getUpdate (timestamp, resp, err, version) {
     const update = {
-      info: {
-        name: this.data.name,
-        timestamp: timestamp
-      }
+      serverId: this.serverId,
+      timestamp: timestamp
     }
 
     if (resp) {
@@ -48,6 +48,14 @@ class ServerRegistration {
       update.result = {
         players: resp.players
       }
+
+      if (config.logToDatabase) {
+        // Update calculated graph peak regardless if the graph is being updated
+        // This can cause a (harmless) desync between live and stored data, but it allows it to be more accurate for long surviving processes
+        if (this.findNewGraphPeak()) {
+          update.graphPeakData = this.getGraphPeak()
+        }
+      }
     } else if (err) {
       // Append a filtered copy of err
       // This ensures any unintended data is not leaked
@@ -94,15 +102,21 @@ class ServerRegistration {
       const lastPing = this._pingHistory[this._pingHistory.length - 1]
 
       const payload = {
-        info: {
-          name: this.data.name
-        },
+        serverId: this.serverId,
         timestamp: lastPing.timestamp,
         versions: this.versions,
         recordData: this.recordData,
         favicon: this.lastFavicon
       }
 
+      // Only append graphPeakData if defined
+      // The value is lazy computed and conditional that config->logToDatabase == true
+      const graphPeakData = this.getGraphPeak()
+
+      if (graphPeakData) {
+        payload.graphPeakData = graphPeakData
+      }
+
       // Conditionally append to avoid defining fields with undefined values
       if (lastPing.result) {
         payload.result = lastPing.result
@@ -118,14 +132,12 @@ class ServerRegistration {
     }
 
     return [{
+      serverId: this.serverId,
+      timestamp: new Date().getTime(),
       error: {
         message: 'Waiting...',
         placeholder: true
       },
-      timestamp: new Date().getTime(),
-      info: {
-        name: this.data.name
-      },
       recordData: this.recordData
     }]
   }