Minetrack/lib/time.js

const config = require('../config.json')

const GRAPH_UPDATE_TIME_GAP = 60 * 1000 // 60 seconds

class TimeTracker {
  constructor (app) {
    this._app = app
    this._serverGraphPoints = []
    this._graphPoints = []
  }

  newPointTimestamp () {
    const timestamp = TimeTracker.getEpochMillis()

    TimeTracker.pushAndShift(this._serverGraphPoints, timestamp, TimeTracker.getMaxServerGraphDataLength())

    // Flag each group as history graph additions each minute
    // This is sent to the frontend for graph updates
    const updateHistoryGraph = config.logToDatabase && (!this._lastHistoryGraphUpdate || timestamp - this._lastHistoryGraphUpdate >= GRAPH_UPDATE_TIME_GAP)

    if (updateHistoryGraph) {
      this._lastHistoryGraphUpdate = timestamp

      // Push into timestamps array to update backend state
      TimeTracker.pushAndShift(this._graphPoints, timestamp, TimeTracker.getMaxGraphDataLength())
    }

    return {
      timestamp,
      updateHistoryGraph
    }
  }

  loadGraphPoints (startTime, timestamps) {
    // This is a copy of ServerRegistration#loadGraphPoints
    // timestamps contains original timestamp data and needs to be filtered into minutes
    this._graphPoints = TimeTracker.everyN(timestamps, startTime, GRAPH_UPDATE_TIME_GAP, (i) => timestamps[i])
  }

  getGraphPointAt (i) {
    return TimeTracker.toSeconds(this._graphPoints[i])
  }

  getServerGraphPoints () {
    return this._serverGraphPoints.map(TimeTracker.toSeconds)
  }

  getGraphPoints () {
    return this._graphPoints.map(TimeTracker.toSeconds)
  }

  static toSeconds = (timestamp) => {
    return Math.floor(timestamp / 1000)
  }

  static getEpochMillis () {
    return new Date().getTime()
  }

  static getMaxServerGraphDataLength () {
    return Math.ceil(config.serverGraphDuration / config.rates.pingAll)
  }

  static getMaxGraphDataLength () {
    return Math.ceil(config.graphDuration / GRAPH_UPDATE_TIME_GAP)
  }

  static everyN (array, start, diff, adapter) {
    const selected = []
    let lastPoint = start

    for (let i = 0; i < array.length; i++) {
      const point = array[i]

      if (point - lastPoint >= diff) {
        lastPoint = point
        selected.push(adapter(i))
      }
    }

    return selected
  }

  static pushAndShift (array, value, maxLength) {
    array.push(value)

    if (array.length > maxLength) {
      array.splice(0, array.length - maxLength)
    }
  }
}

module.exports = {
  GRAPH_UPDATE_TIME_GAP,
  TimeTracker
}