Backend cleanup (#146)
* Add ServerRegistration, begin refactoring to match frontend * move graphData logic into ServerRegistration * move ping updates/history into ServerRegistration * start updating main app entry methods * fix default rates.updateMojangStatus * fix record loading delays on freshly booted instances * move database loading logic to method + callback * use data in frontend for type lookup instead of ping * cleanup app.js * reorganize methods to improve flow * avoid useless mojang updates, remove legacy fields * rename legacy fields for consistency * finish restructure around App model * ensure versions are sorted by release order * filter errors sent to frontend to avoid data leaks * fix version listing behavior on frontend * 5.1.0
This commit is contained in:
Nick Krecklow
92
lib/app.js
Normal file
92
lib/app.js
Normal file
@ -0,0 +1,92 @@
|
||||
const Database = require('./database')
|
||||
const MojangUpdater = require('./mojang')
|
||||
const PingController = require('./ping')
|
||||
const Server = require('./server')
|
||||
|
||||
const config = require('../config')
|
||||
const minecraftVersions = require('../minecraft_versions')
|
||||
|
||||
class App {
|
||||
serverRegistrations = []
|
||||
|
||||
constructor () {
|
||||
this.mojangUpdater = new MojangUpdater(this)
|
||||
this.pingController = new PingController(this)
|
||||
this.server = new Server(this.handleClientConnection)
|
||||
}
|
||||
|
||||
loadDatabase (callback) {
|
||||
this.database = new Database(this)
|
||||
|
||||
// Setup database instance
|
||||
this.database.ensureIndexes()
|
||||
|
||||
this.database.loadGraphPoints(config.graphDuration, () => {
|
||||
this.database.loadRecords(callback)
|
||||
})
|
||||
}
|
||||
|
||||
handleReady () {
|
||||
this.server.listen(config.site.ip, config.site.port)
|
||||
|
||||
// Allow individual modules to manage their own task scheduling
|
||||
this.mojangUpdater.schedule()
|
||||
this.pingController.schedule()
|
||||
}
|
||||
|
||||
handleClientConnection = (client) => {
|
||||
if (config.logToDatabase) {
|
||||
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
|
||||
}
|
||||
})
|
||||
|
||||
// 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)
|
||||
})
|
||||
}
|
||||
|
||||
client.emit('setPublicConfig', (() => {
|
||||
// Remap minecraftVersion entries into name values
|
||||
const minecraftVersionNames = {}
|
||||
Object.keys(minecraftVersions).forEach(function (key) {
|
||||
minecraftVersionNames[key] = minecraftVersions[key].map(version => version.name)
|
||||
})
|
||||
|
||||
// Send configuration data for rendering the page
|
||||
return {
|
||||
graphDuration: config.graphDuration,
|
||||
servers: this.serverRegistrations.map(serverRegistration => serverRegistration.data),
|
||||
minecraftVersions: minecraftVersionNames,
|
||||
isGraphVisible: config.logToDatabase
|
||||
}
|
||||
})())
|
||||
|
||||
// Send last Mojang update, if any
|
||||
this.mojangUpdater.sendLastUpdate(client)
|
||||
|
||||
// Send pingHistory of all ServerRegistrations
|
||||
client.emit('add', this.serverRegistrations.map(serverRegistration => serverRegistration.getPingHistory()))
|
||||
|
||||
// Always send last
|
||||
// This tells the frontend to do final processing and render
|
||||
client.emit('syncComplete')
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = App
|
||||
134
lib/database.js
134
lib/database.js
@ -1,47 +1,105 @@
|
||||
/**
|
||||
* THIS IS LEGACY, UNMAINTAINED CODE
|
||||
* IT MAY (AND LIKELY DOES) CONTAIN BUGS
|
||||
* USAGE IS NOT RECOMMENDED
|
||||
*/
|
||||
var util = require('./util');
|
||||
const sqlite = require('sqlite3')
|
||||
|
||||
exports.setup = function() {
|
||||
var sqlite = require('sqlite3');
|
||||
class Database {
|
||||
constructor (app) {
|
||||
this._app = app
|
||||
this._sql = new sqlite.Database('database.sql')
|
||||
}
|
||||
|
||||
var db = new sqlite.Database('database.sql');
|
||||
ensureIndexes () {
|
||||
this._sql.serialize(() => {
|
||||
this._sql.run('CREATE TABLE IF NOT EXISTS pings (timestamp BIGINT NOT NULL, ip TINYTEXT, playerCount MEDIUMINT)')
|
||||
this._sql.run('CREATE INDEX IF NOT EXISTS ip_index ON pings (ip, playerCount)')
|
||||
this._sql.run('CREATE INDEX IF NOT EXISTS timestamp_index on PINGS (timestamp)')
|
||||
})
|
||||
}
|
||||
|
||||
db.serialize(function() {
|
||||
db.run('CREATE TABLE IF NOT EXISTS pings (timestamp BIGINT NOT NULL, ip TINYTEXT, playerCount MEDIUMINT)');
|
||||
db.run('CREATE INDEX IF NOT EXISTS ip_index ON pings (ip, playerCount)');
|
||||
db.run('CREATE INDEX IF NOT EXISTS timestamp_index on PINGS (timestamp)');
|
||||
});
|
||||
loadGraphPoints (graphDuration, callback) {
|
||||
// Query recent pings
|
||||
const endTime = new Date().getTime()
|
||||
const startTime = endTime - graphDuration
|
||||
|
||||
exports.log = function(ip, timestamp, playerCount) {
|
||||
var insertStatement = db.prepare('INSERT INTO pings (timestamp, ip, playerCount) VALUES (?, ?, ?)');
|
||||
this.getRecentPings(startTime, endTime, pingData => {
|
||||
const graphPointsByIp = []
|
||||
|
||||
db.serialize(function() {
|
||||
insertStatement.run(timestamp, ip, playerCount);
|
||||
});
|
||||
for (const row of pingData) {
|
||||
// Avoid loading outdated records
|
||||
// This shouldn't happen and is mostly a sanity measure
|
||||
if (startTime - row.timestamp <= graphDuration) {
|
||||
// Load into temporary array
|
||||
// This will be culled prior to being pushed to the serverRegistration
|
||||
let graphPoints = graphPointsByIp[row.ip]
|
||||
if (!graphPoints) {
|
||||
graphPoints = graphPointsByIp[row.ip] = []
|
||||
}
|
||||
|
||||
insertStatement.finalize();
|
||||
};
|
||||
graphPoints.push([row.timestamp, row.playerCount])
|
||||
}
|
||||
}
|
||||
|
||||
exports.getTotalRecord = function(ip, callback) {
|
||||
db.all("SELECT MAX(playerCount), timestamp FROM pings WHERE ip = ?", [
|
||||
ip
|
||||
], function(err, data) {
|
||||
callback(data[0]['MAX(playerCount)'], data[0]['timestamp']);
|
||||
});
|
||||
};
|
||||
Object.keys(graphPointsByIp).forEach(ip => {
|
||||
// Match IPs to serverRegistration object
|
||||
for (const serverRegistration of this._app.serverRegistrations) {
|
||||
if (serverRegistration.data.ip === ip) {
|
||||
const graphPoints = graphPointsByIp[ip]
|
||||
|
||||
exports.queryPings = function(duration, callback) {
|
||||
var currentTime = util.getCurrentTimeMs();
|
||||
// Push the data into the instance and cull if needed
|
||||
serverRegistration.loadGraphPoints(graphPoints)
|
||||
|
||||
db.all("SELECT * FROM pings WHERE timestamp >= ? AND timestamp <= ?", [
|
||||
currentTime - duration,
|
||||
currentTime
|
||||
], function(err, data) {
|
||||
callback(data);
|
||||
});
|
||||
};
|
||||
};
|
||||
break
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
callback()
|
||||
})
|
||||
}
|
||||
|
||||
loadRecords (callback) {
|
||||
let completedTasks = 0
|
||||
|
||||
this._app.serverRegistrations.forEach(serverRegistration => {
|
||||
// Find graphPeaks
|
||||
// This pre-computes the values prior to clients connecting
|
||||
serverRegistration.findNewGraphPeak()
|
||||
|
||||
// Query recordData
|
||||
// When complete increment completeTasks to know when complete
|
||||
this.getRecord(serverRegistration.data.ip, (playerCount, timestamp) => {
|
||||
serverRegistration.recordData = {
|
||||
playerCount: playerCount,
|
||||
timestamp: timestamp
|
||||
}
|
||||
|
||||
// Check if completedTasks hit the finish value
|
||||
// Fire callback since #readyDatabase is complete
|
||||
if (++completedTasks === this._app.serverRegistrations.length) {
|
||||
callback()
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
getRecentPings (startTime, endTime, callback) {
|
||||
this._sql.all('SELECT * FROM pings WHERE timestamp >= ? AND timestamp <= ?', [
|
||||
startTime,
|
||||
endTime
|
||||
], (_, data) => callback(data))
|
||||
}
|
||||
|
||||
getRecord (ip, callback) {
|
||||
this._sql.all('SELECT MAX(playerCount), timestamp FROM pings WHERE ip = ?', [
|
||||
ip
|
||||
], (_, data) => callback(data[0]['MAX(playerCount)'], data[0].timestamp))
|
||||
}
|
||||
|
||||
insertPing (ip, timestamp, playerCount) {
|
||||
const statement = this._sql.prepare('INSERT INTO pings (timestamp, ip, playerCount) VALUES (?, ?, ?)')
|
||||
this._sql.serialize(() => {
|
||||
statement.run(timestamp, ip, playerCount)
|
||||
})
|
||||
statement.finalize()
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Database
|
||||
|
||||
@ -1,23 +1,17 @@
|
||||
/**
|
||||
* THIS IS LEGACY, UNMAINTAINED CODE
|
||||
* IT MAY (AND LIKELY DOES) CONTAIN BUGS
|
||||
* USAGE IS NOT RECOMMENDED
|
||||
*/
|
||||
var winston = require('winston');
|
||||
const winston = require('winston')
|
||||
|
||||
winston.remove(winston.transports.Console);
|
||||
winston.remove(winston.transports.Console)
|
||||
|
||||
winston.add(winston.transports.File, {
|
||||
filename: 'minetrack.log'
|
||||
});
|
||||
winston.add(winston.transports.File, {
|
||||
filename: 'minetrack.log'
|
||||
})
|
||||
|
||||
winston.add(winston.transports.Console, {
|
||||
'timestamp': function() {
|
||||
var date = new Date();
|
||||
timestamp: () => {
|
||||
const date = new Date()
|
||||
return date.toLocaleTimeString() + ' ' + date.getDate() + '/' + (date.getMonth() + 1) + '/' + date.getFullYear().toString().substring(2, 4)
|
||||
},
|
||||
colorize: true
|
||||
})
|
||||
|
||||
return date.toLocaleTimeString() + ' ' + date.getDate() + '/' + (date.getMonth() + 1) + '/' + date.getFullYear().toString().substring(2, 4);
|
||||
},
|
||||
'colorize': true
|
||||
});
|
||||
|
||||
module.exports = winston;
|
||||
module.exports = winston
|
||||
|
||||
96
lib/mojang.js
Normal file
96
lib/mojang.js
Normal file
@ -0,0 +1,96 @@
|
||||
const request = require('request')
|
||||
|
||||
const logger = require('./logger')
|
||||
|
||||
const config = require('../config')
|
||||
|
||||
const SERVICE_URL_LOOKUP = {
|
||||
'sessionserver.mojang.com': 'Sessions',
|
||||
'authserver.mojang.com': 'Auth',
|
||||
'textures.minecraft.net': 'Skins',
|
||||
'api.mojang.com': 'API'
|
||||
}
|
||||
|
||||
const TITLE_BY_MOJANG_COLOR = {
|
||||
red: 'Offline',
|
||||
yellow: 'Unstable',
|
||||
green: 'Online'
|
||||
}
|
||||
|
||||
class MojangUpdater {
|
||||
constructor (app) {
|
||||
this._app = app
|
||||
}
|
||||
|
||||
schedule () {
|
||||
setInterval(this.updateServices, config.rates.updateMojangStatus)
|
||||
|
||||
this.updateServices()
|
||||
}
|
||||
|
||||
updateServices = () => {
|
||||
request({
|
||||
uri: 'https://status.mojang.com/check',
|
||||
method: 'GET',
|
||||
timeout: config.rates.mojangStatusTimeout
|
||||
}, (err, _, body) => {
|
||||
if (err) {
|
||||
logger.log('error', 'Failed to update Mojang services: %s', err.message)
|
||||
|
||||
// Set all services to offline
|
||||
// This may be incorrect, but if mojang.com is offline, it would never otherwise be reflected
|
||||
Object.keys(SERVICE_URL_LOOKUP).forEach(url => {
|
||||
this.handleServiceUpdate(url, 'red')
|
||||
})
|
||||
|
||||
this.pushUpdate()
|
||||
} else {
|
||||
try {
|
||||
JSON.parse(body).forEach(service => {
|
||||
// Each service is formatted as an object with the 0 key being the URL
|
||||
const url = Object.keys(service)[0]
|
||||
this.handleServiceUpdate(url, service[url])
|
||||
})
|
||||
} catch (err) {
|
||||
logger.log('error', 'Failed to parse Mojang response: %s', err.message)
|
||||
}
|
||||
|
||||
this.pushUpdate()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
pushUpdate () {
|
||||
// Only fire callback when previous state is modified
|
||||
if (this._hasUpdated) {
|
||||
this._hasUpdated = false
|
||||
|
||||
this._app.server.broadcast('updateMojangServices', this._services)
|
||||
}
|
||||
}
|
||||
|
||||
sendLastUpdate (client) {
|
||||
if (this._services) {
|
||||
client.emit('updateMojangServices', this._services)
|
||||
}
|
||||
}
|
||||
|
||||
handleServiceUpdate (url, color) {
|
||||
const service = SERVICE_URL_LOOKUP[url]
|
||||
|
||||
if (service) {
|
||||
const requiredTitle = TITLE_BY_MOJANG_COLOR[color]
|
||||
|
||||
if (!this._services) {
|
||||
this._services = {}
|
||||
}
|
||||
|
||||
if (this._services[service] !== requiredTitle) {
|
||||
this._services[service] = requiredTitle
|
||||
this._hasUpdated = true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = MojangUpdater
|
||||
@ -1,85 +0,0 @@
|
||||
/**
|
||||
* THIS IS LEGACY, UNMAINTAINED CODE
|
||||
* IT MAY (AND LIKELY DOES) CONTAIN BUGS
|
||||
* USAGE IS NOT RECOMMENDED
|
||||
*/
|
||||
var request = require('request');
|
||||
|
||||
var logger = require('./logger');
|
||||
var util = require('./util');
|
||||
|
||||
var serviceNameLookup = {
|
||||
'sessionserver.mojang.com': 'Sessions',
|
||||
'authserver.mojang.com': 'Auth',
|
||||
'textures.minecraft.net': 'Skins',
|
||||
'api.mojang.com': 'API'
|
||||
};
|
||||
|
||||
var serviceStates = {
|
||||
// Lazy populated.
|
||||
};
|
||||
|
||||
function updateService(name, status) {
|
||||
// Only update if we need to.
|
||||
if (!(name in serviceStates) || serviceStates[name].status !== status) {
|
||||
var newEntry = {
|
||||
name: serviceNameLookup[name], // Send the clean name, not the URL.
|
||||
status: status
|
||||
};
|
||||
|
||||
// If it's an outage, track when it started.
|
||||
if (status === 'yellow'|| status === 'red') {
|
||||
newEntry.startTime = util.getCurrentTimeMs();
|
||||
}
|
||||
|
||||
// Generate a nice title from the color.
|
||||
if (status === 'green') {
|
||||
newEntry.title = 'Online';
|
||||
} else if (status === 'yellow') {
|
||||
newEntry.title = 'Unstable';
|
||||
} else if (status === 'red') {
|
||||
newEntry.title = 'Offline';
|
||||
} else {
|
||||
throw new Error('Unknown Mojang status: ' + status);
|
||||
}
|
||||
|
||||
// Wipe the old status in favor of the new one.
|
||||
serviceStates[name] = newEntry;
|
||||
}
|
||||
}
|
||||
|
||||
exports.update = function(timeout) {
|
||||
request({
|
||||
uri: 'http://status.mojang.com/check',
|
||||
method: 'GET',
|
||||
timeout: timeout
|
||||
}, function(err, res, body) {
|
||||
if (err) {
|
||||
logger.log('error', 'Failed to update Mojang services: %s', JSON.stringify(err));
|
||||
} else {
|
||||
try {
|
||||
body = JSON.parse(body);
|
||||
|
||||
for (var i = 0; i < body.length; i++) {
|
||||
var service = body[i];
|
||||
var name = Object.keys(service)[0]; // Because they return an array of object, we have to do this :(
|
||||
|
||||
// If it's not in the lookup, we don't care about it.
|
||||
if (name in serviceNameLookup) {
|
||||
updateService(name, service[name]);
|
||||
}
|
||||
}
|
||||
|
||||
logger.log('debug', 'Updated Mojang services: %s', JSON.stringify(serviceStates));
|
||||
} catch(err) {
|
||||
// Catch anything weird that can happen, since things probably will.
|
||||
logger.log('error', 'Failed to parse Mojang\'s response: %s', JSON.stringify(err));
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
exports.toMessage = function() {
|
||||
// This is what we send to the clients.
|
||||
return serviceStates;
|
||||
};
|
||||
202
lib/ping.js
202
lib/ping.js
@ -1,85 +1,143 @@
|
||||
/**
|
||||
* THIS IS LEGACY, UNMAINTAINED CODE
|
||||
* IT MAY (AND LIKELY DOES) CONTAIN BUGS
|
||||
* USAGE IS NOT RECOMMENDED
|
||||
*/
|
||||
var mcpe_ping = require('mcpe-ping-fixed');
|
||||
var mcpc_ping = require('mc-ping-updated');
|
||||
const dns = require('dns')
|
||||
|
||||
var logger = require('./logger');
|
||||
var util = require('./util');
|
||||
const minecraftJavaPing = require('mc-ping-updated')
|
||||
const minecraftBedrockPing = require('mcpe-ping-fixed')
|
||||
|
||||
// This is a wrapper function for mc-ping-updated, mainly used to convert the data structure of the result.
|
||||
function pingMinecraftPC(host, port, timeout, callback, version) {
|
||||
var startTime = util.getCurrentTimeMs();
|
||||
const logger = require('./logger')
|
||||
|
||||
mcpc_ping(host, port, function(err, res) {
|
||||
if (err) {
|
||||
callback(err, null);
|
||||
} else {
|
||||
// Remap our JSON into our custom structure.
|
||||
var favicon;
|
||||
const config = require('../config')
|
||||
|
||||
// Ensure the returned favicon is a data URI
|
||||
if (res.favicon && res.favicon.indexOf('data:image/') === 0) {
|
||||
favicon = res.favicon;
|
||||
}
|
||||
function ping (host, port, type, timeout, callback, version) {
|
||||
switch (type) {
|
||||
case 'PC':
|
||||
unfurlSrv(host, port, (host, port) => {
|
||||
minecraftJavaPing(host, port || 25565, (err, res) => {
|
||||
if (err) {
|
||||
callback(err)
|
||||
} else {
|
||||
const payload = {
|
||||
players: {
|
||||
online: capPlayerCount(host, parseInt(res.players.online))
|
||||
},
|
||||
version: parseInt(res.version.protocol)
|
||||
}
|
||||
|
||||
callback(null, {
|
||||
players: {
|
||||
online: capPlayerCount(host, parseInt(res.players.online)),
|
||||
max: parseInt(res.players.max)
|
||||
},
|
||||
version: parseInt(res.version.protocol),
|
||||
latency: util.getCurrentTimeMs() - startTime,
|
||||
favicon: favicon
|
||||
});
|
||||
}
|
||||
}, timeout, version);
|
||||
// Ensure the returned favicon is a data URI
|
||||
if (res.favicon && res.favicon.startsWith('data:image/')) {
|
||||
payload.favicon = res.favicon
|
||||
}
|
||||
|
||||
callback(null, payload)
|
||||
}
|
||||
}, timeout, version)
|
||||
})
|
||||
break
|
||||
|
||||
case 'PE':
|
||||
minecraftBedrockPing(host, port || 19132, (err, res) => {
|
||||
if (err) {
|
||||
callback(err)
|
||||
} else {
|
||||
callback(null, {
|
||||
players: {
|
||||
online: capPlayerCount(host, parseInt(res.currentPlayers))
|
||||
}
|
||||
})
|
||||
}
|
||||
}, timeout)
|
||||
break
|
||||
|
||||
default:
|
||||
throw new Error('Unsupported type: ' + type)
|
||||
}
|
||||
}
|
||||
|
||||
// This is a wrapper function for mcpe-ping, mainly used to convert the data structure of the result.
|
||||
function pingMinecraftPE(host, port, timeout, callback) {
|
||||
var startTime = util.getCurrentTimeMs();
|
||||
|
||||
mcpe_ping(host, port || 19132, function(err, res) {
|
||||
if (err) {
|
||||
callback(err, null);
|
||||
} else {
|
||||
// Remap our JSON into our custom structure.
|
||||
callback(err, {
|
||||
players: {
|
||||
online: capPlayerCount(host, parseInt(res.currentPlayers)),
|
||||
max: parseInt(res.maxPlayers)
|
||||
},
|
||||
latency: util.getCurrentTimeMs() - startTime
|
||||
});
|
||||
}
|
||||
}, timeout);
|
||||
function unfurlSrv (hostname, port, callback) {
|
||||
dns.resolveSrv('_minecraft._tcp.' + hostname, (_, records) => {
|
||||
if (!records || records.length < 1) {
|
||||
callback(hostname, port)
|
||||
} else {
|
||||
callback(records[0].name, records[0].port)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// player count can be up to 1^32-1, which is a massive scale and destroys browser performance when rendering graphs
|
||||
// Artificially cap and warn to prevent propogating garbage
|
||||
function capPlayerCount(host, playerCount) {
|
||||
const maxPlayerCount = 250000;
|
||||
if (playerCount !== Math.min(playerCount, maxPlayerCount)) {
|
||||
logger.log('warn', '%s returned a player count of %d, Minetrack has capped it to %d to prevent browser performance issues with graph rendering. If this is in error, please edit maxPlayerCount in ping.js!', host, playerCount, maxPlayerCount);
|
||||
return maxPlayerCount;
|
||||
} else if (playerCount !== Math.max(playerCount, 0)) {
|
||||
logger.log('warn', '%s returned an invalid player count of %d, setting to 0.', host, playerCount);
|
||||
return 0;
|
||||
}
|
||||
return playerCount;
|
||||
function capPlayerCount (host, playerCount) {
|
||||
const maxPlayerCount = 250000
|
||||
|
||||
if (playerCount !== Math.min(playerCount, maxPlayerCount)) {
|
||||
logger.log('warn', '%s returned a player count of %d, Minetrack has capped it to %d to prevent browser performance issues with graph rendering. If this is in error, please edit maxPlayerCount in ping.js!', host, playerCount, maxPlayerCount)
|
||||
|
||||
return maxPlayerCount
|
||||
} else if (playerCount !== Math.max(playerCount, 0)) {
|
||||
logger.log('warn', '%s returned an invalid player count of %d, setting to 0.', host, playerCount)
|
||||
|
||||
return 0
|
||||
}
|
||||
return playerCount
|
||||
}
|
||||
|
||||
exports.ping = function(host, port, type, timeout, callback, version) {
|
||||
if (type === 'PC') {
|
||||
util.unfurlSRV(host, port, function(host, port){
|
||||
pingMinecraftPC(host, port || 25565, timeout, callback, version);
|
||||
})
|
||||
} else if (type === 'PE') {
|
||||
pingMinecraftPE(host, port || 19132, timeout, callback);
|
||||
} else {
|
||||
throw new Error('Unsupported type: ' + type);
|
||||
}
|
||||
};
|
||||
class PingController {
|
||||
constructor (app) {
|
||||
this._app = app
|
||||
}
|
||||
|
||||
schedule () {
|
||||
setInterval(this.pingAll, config.rates.pingAll)
|
||||
|
||||
this.pingAll()
|
||||
}
|
||||
|
||||
pingAll = () => {
|
||||
for (const serverRegistration of this._app.serverRegistrations) {
|
||||
const version = serverRegistration.getNextProtocolVersion()
|
||||
|
||||
ping(serverRegistration.data.ip, serverRegistration.data.port, serverRegistration.data.type, config.rates.connectTimeout, (err, resp) => {
|
||||
if (err) {
|
||||
logger.log('error', 'Failed to ping %s: %s', serverRegistration.data.ip, err.message)
|
||||
}
|
||||
|
||||
this.handlePing(serverRegistration, resp, err, version)
|
||||
}, version.protocolId)
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
const playerCount = resp ? resp.players.online : 0
|
||||
|
||||
// Log to database
|
||||
this._app.database.insertPing(serverRegistration.data.ip, timestamp, playerCount)
|
||||
|
||||
if (serverRegistration.addGraphPoint(resp !== undefined, playerCount, timestamp)) {
|
||||
this._app.server.broadcast('updateHistoryGraph', {
|
||||
name: serverRegistration.data.name,
|
||||
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
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = PingController
|
||||
|
||||
@ -1,32 +1,64 @@
|
||||
/**
|
||||
* THIS IS LEGACY, UNMAINTAINED CODE
|
||||
* IT MAY (AND LIKELY DOES) CONTAIN BUGS
|
||||
* USAGE IS NOT RECOMMENDED
|
||||
*/
|
||||
const http = require('http')
|
||||
|
||||
const io = require('socket.io')
|
||||
const finalHandler = require('finalhandler')
|
||||
const finalHttpHandler = require('finalhandler')
|
||||
const serveStatic = require('serve-static')
|
||||
const io = require('socket.io')
|
||||
|
||||
const util = require('./util')
|
||||
const logger = require('./logger')
|
||||
|
||||
const config = require('../config.json')
|
||||
|
||||
const distHandler = serveStatic('dist/')
|
||||
const faviconsHandler = serveStatic('favicons/')
|
||||
|
||||
function onRequest (req, res) {
|
||||
logger.log('info', '%s requested: %s', util.getRemoteAddr(req), req.url)
|
||||
distHandler(req, res, function () {
|
||||
faviconsHandler(req, res, finalHandler(req, res))
|
||||
})
|
||||
function getRemoteAddr (req) {
|
||||
return req.headers['cf-connecting-ip'] || req.headers['x-forwarded-for'] || req.connection.remoteAddress
|
||||
}
|
||||
|
||||
exports.start = function () {
|
||||
const server = http.createServer(onRequest)
|
||||
server.listen(config.site.port, config.site.ip)
|
||||
exports.io = io.listen(server)
|
||||
logger.log('info', 'Started on %s:%d', config.site.ip, config.site.port)
|
||||
class Server {
|
||||
constructor (clientSocketHandler) {
|
||||
this._clientSocketHandler = clientSocketHandler
|
||||
this._connectedSockets = 0
|
||||
|
||||
this._http = http.createServer(this.handleHttpRequest)
|
||||
|
||||
this._distServeStatic = serveStatic('dist/')
|
||||
this._faviconsServeStatic = serveStatic('favicons/')
|
||||
}
|
||||
|
||||
listen (host, port) {
|
||||
this._http.listen(port, host)
|
||||
|
||||
this._io = io.listen(this._http)
|
||||
this._io.on('connect', this.handleClientSocket)
|
||||
|
||||
logger.log('info', 'Started on %s:%d', host, port)
|
||||
}
|
||||
|
||||
broadcast (event, payload) {
|
||||
this._io.sockets.emit(event, payload)
|
||||
}
|
||||
|
||||
handleHttpRequest = (req, res) => {
|
||||
logger.log('info', '%s requested: %s', getRemoteAddr(req), req.url)
|
||||
|
||||
// Attempt to handle req using distServeStatic, otherwise fail over to faviconServeStatic
|
||||
// If faviconServeStatic fails, pass to finalHttpHandler to terminate
|
||||
this._distServeStatic(req, res, () => {
|
||||
this._faviconsServeStatic(req, res, finalHttpHandler(req, res))
|
||||
})
|
||||
}
|
||||
|
||||
handleClientSocket = (client) => {
|
||||
this._connectedSockets++
|
||||
|
||||
logger.log('info', '%s connected, total clients: %d', getRemoteAddr(client.request), this._connectedSockets)
|
||||
|
||||
// Bind disconnect event for logging
|
||||
client.on('disconnect', () => {
|
||||
this._connectedSockets--
|
||||
|
||||
logger.log('info', '%s disconnected, total clients: %d', getRemoteAddr(client.request), this._connectedSockets)
|
||||
})
|
||||
|
||||
// Pass client off to proxy handler
|
||||
this._clientSocketHandler(client)
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Server
|
||||
|
||||
279
lib/servers.js
Normal file
279
lib/servers.js
Normal file
@ -0,0 +1,279 @@
|
||||
const config = require('../config')
|
||||
const minecraftVersions = require('../minecraft_versions')
|
||||
|
||||
class ServerRegistration {
|
||||
lastFavicon
|
||||
versions = []
|
||||
recordData
|
||||
graphData = []
|
||||
|
||||
constructor (data) {
|
||||
this.data = data
|
||||
this._pingHistory = []
|
||||
this._hasInitialRecordData = false
|
||||
}
|
||||
|
||||
getUpdate (timestamp, resp, err, version) {
|
||||
const update = {
|
||||
info: {
|
||||
name: this.data.name,
|
||||
timestamp: timestamp
|
||||
}
|
||||
}
|
||||
|
||||
if (resp) {
|
||||
if (resp.version && this.updateProtocolVersionCompat(resp.version, version.protocolId, version.protocolIndex)) {
|
||||
// Append an updated version listing
|
||||
update.versions = this.versions
|
||||
}
|
||||
|
||||
// Validate that we have logToDatabase enabled otherwise in memory pings
|
||||
// will create a record that's only valid for the runtime duration.
|
||||
if (config.logToDatabase && (!this._hasInitialRecordData || !this.recordData || resp.players.online > this.recordData.playerCount)) {
|
||||
// For instances with existing data, recordData will be defined at boot
|
||||
// This causes initial updates to NOT include recordData since it hasn't changed
|
||||
// This flag force includes it to avoid "late loading"
|
||||
this._hasInitialRecordData = true
|
||||
|
||||
this.recordData = {
|
||||
playerCount: resp.players.online,
|
||||
timestamp: timestamp
|
||||
}
|
||||
|
||||
// Append an updated recordData
|
||||
update.recordData = this.recordData
|
||||
}
|
||||
|
||||
// Compare against this.data.favicon to support favicon overrides
|
||||
const newFavicon = resp.favicon || this.data.favicon
|
||||
if (this.updateFavicon(newFavicon)) {
|
||||
// Append an updated favicon
|
||||
update.favicon = newFavicon
|
||||
}
|
||||
|
||||
// Append a result object
|
||||
// This filters out unwanted data from resp
|
||||
update.result = {
|
||||
players: resp.players
|
||||
}
|
||||
} else if (err) {
|
||||
// Append a filtered copy of err
|
||||
// This ensures any unintended data is not leaked
|
||||
update.error = this.filterError(err)
|
||||
}
|
||||
|
||||
return update
|
||||
}
|
||||
|
||||
addPing (timestamp, resp) {
|
||||
const ping = {
|
||||
timestamp: timestamp
|
||||
}
|
||||
|
||||
if (resp) {
|
||||
// Append a result object
|
||||
// This filters out unwanted data from resp
|
||||
ping.result = {
|
||||
players: {
|
||||
online: resp.players.online
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this._pingHistory.push(ping)
|
||||
|
||||
// Trim pingHistory to avoid memory leaks
|
||||
if (this._pingHistory.length > 72) {
|
||||
this._pingHistory.shift()
|
||||
}
|
||||
}
|
||||
|
||||
getPingHistory () {
|
||||
if (this._pingHistory.length > 0) {
|
||||
const pingHistory = []
|
||||
|
||||
for (let i = 0; i < this._pingHistory.length - 1; i++) {
|
||||
pingHistory[i] = this._pingHistory[i]
|
||||
}
|
||||
|
||||
// Insert the latest update manually into the array
|
||||
// This is a mutated copy of the last update to contain live metadata
|
||||
// The metadata is used by the frontend for rendering
|
||||
const lastPing = this._pingHistory[this._pingHistory.length - 1]
|
||||
|
||||
const payload = {
|
||||
info: {
|
||||
name: this.data.name
|
||||
},
|
||||
timestamp: lastPing.timestamp,
|
||||
versions: this.versions,
|
||||
recordData: this.recordData,
|
||||
favicon: this.lastFavicon
|
||||
}
|
||||
|
||||
// Conditionally append to avoid defining fields with undefined values
|
||||
if (lastPing.result) {
|
||||
payload.result = lastPing.result
|
||||
} else if (lastPing.error) {
|
||||
payload.error = lastPing.error
|
||||
}
|
||||
|
||||
// Insert the reconstructed update as the last entry
|
||||
// pingHistory is already sorted during its copy from _pingHistory
|
||||
pingHistory.push(payload)
|
||||
|
||||
return pingHistory
|
||||
}
|
||||
|
||||
return [{
|
||||
error: {
|
||||
message: 'Waiting...',
|
||||
placeholder: true
|
||||
},
|
||||
timestamp: new Date().getTime(),
|
||||
info: {
|
||||
name: this.data.name
|
||||
},
|
||||
recordData: this.recordData
|
||||
}]
|
||||
}
|
||||
|
||||
loadGraphPoints (points) {
|
||||
// Filter pings so each result is a minute apart
|
||||
const minutePoints = []
|
||||
let lastTimestamp = 0
|
||||
|
||||
for (const point of points) {
|
||||
// 0 is the index of the timestamp
|
||||
if (point[0] - lastTimestamp >= 60 * 1000) {
|
||||
// This check tries to smooth out randomly dropped pings
|
||||
// By default only filter pings that are online (playerCount > 0)
|
||||
// This will keep looking forward until it finds a ping that is online
|
||||
// If it can't find one within a reasonable timeframe, it will select a failed ping
|
||||
if (point[0] - lastTimestamp >= 120 * 1000 || point[1] > 0) {
|
||||
minutePoints.push(point)
|
||||
lastTimestamp = point[0]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (minutePoints.length > 0) {
|
||||
this.graphData = minutePoints
|
||||
|
||||
// Select the last entry to use for lastGraphDataPush
|
||||
this._lastGraphDataPush = minutePoints[minutePoints.length - 1][0]
|
||||
}
|
||||
}
|
||||
|
||||
addGraphPoint (isSuccess, playerCount, timestamp) {
|
||||
// If the ping failed, then to avoid destroying the graph, ignore it
|
||||
// However if it's been too long since the last successful ping, push it anyways
|
||||
if (this._lastGraphDataPush) {
|
||||
const timeSince = timestamp - this._lastGraphDataPush
|
||||
if ((isSuccess && timeSince < 60 * 1000) || (!isSuccess && timeSince < 70 * 1000)) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
this.graphData.push([timestamp, playerCount])
|
||||
this._lastGraphDataPush = timestamp
|
||||
|
||||
// Trim old graphPoints according to graphDuration
|
||||
for (let i = 1; i < this.graphData.length; i++) {
|
||||
// Find a break point where i - 1 is too old and i is new
|
||||
if (timestamp - this.graphData[i - 1][0] > config.graphDuration && timestamp - this.graphData[i] <= config.graphDuration) {
|
||||
this.graphData.splice(0, i)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
findNewGraphPeak () {
|
||||
let index = -1
|
||||
for (let i = 0; i < this.graphData.length; i++) {
|
||||
const point = this.graphData[i]
|
||||
if (index === -1 || point[1] > this.graphData[index][1]) {
|
||||
index = i
|
||||
}
|
||||
}
|
||||
if (index >= 0) {
|
||||
const lastGraphPeakIndex = this._graphPeakIndex
|
||||
this._graphPeakIndex = index
|
||||
return index !== lastGraphPeakIndex
|
||||
} else {
|
||||
this._graphPeakIndex = undefined
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
getGraphPeak () {
|
||||
if (this._graphPeakIndex === undefined) {
|
||||
return
|
||||
}
|
||||
const graphPeak = this.graphData[this._graphPeakIndex]
|
||||
return {
|
||||
playerCount: graphPeak[1],
|
||||
timestamp: graphPeak[0]
|
||||
}
|
||||
}
|
||||
|
||||
updateFavicon (favicon) {
|
||||
if (favicon && favicon !== this.lastFavicon) {
|
||||
this.lastFavicon = favicon
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
updateProtocolVersionCompat (incomingId, outgoingId, protocolIndex) {
|
||||
// If the result version matches the attempted version, the version is supported
|
||||
const isSuccess = incomingId === outgoingId
|
||||
const indexOf = this.versions.indexOf(protocolIndex)
|
||||
|
||||
// Test indexOf to avoid inserting previously recorded protocolIndex values
|
||||
if (isSuccess && indexOf < 0) {
|
||||
this.versions.push(protocolIndex)
|
||||
|
||||
// Sort versions in ascending order
|
||||
// This matches protocol ids to Minecraft versions release order
|
||||
this.versions.sort((a, b) => a - b)
|
||||
|
||||
return true
|
||||
} else if (!isSuccess && indexOf >= 0) {
|
||||
this.versions.splice(indexOf, 1)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
getNextProtocolVersion () {
|
||||
const protocolVersions = minecraftVersions[this.data.type]
|
||||
if (typeof this._nextProtocolIndex === 'undefined' || this._nextProtocolIndex + 1 >= protocolVersions.length) {
|
||||
this._nextProtocolIndex = 0
|
||||
} else {
|
||||
this._nextProtocolIndex++
|
||||
}
|
||||
return {
|
||||
protocolId: protocolVersions[this._nextProtocolIndex].protocolId,
|
||||
protocolIndex: this._nextProtocolIndex
|
||||
}
|
||||
}
|
||||
|
||||
filterError (err) {
|
||||
// Attempt to match to the first possible value
|
||||
for (const key of ['message', 'description', 'errno']) {
|
||||
if (err[key]) {
|
||||
return {
|
||||
message: err[key]
|
||||
}
|
||||
}
|
||||
}
|
||||
return {
|
||||
message: 'Unknown error'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = ServerRegistration
|
||||
174
lib/util.js
174
lib/util.js
@ -1,174 +0,0 @@
|
||||
/**
|
||||
* THIS IS LEGACY, UNMAINTAINED CODE
|
||||
* IT MAY (AND LIKELY DOES) CONTAIN BUGS
|
||||
* USAGE IS NOT RECOMMENDED
|
||||
*/
|
||||
var logger = require('./logger');
|
||||
var dns = require('dns');
|
||||
|
||||
var config = require('../config.json');
|
||||
var servers = require('../servers.json');
|
||||
|
||||
var serverNameLookup = [];
|
||||
|
||||
// Finds a server in servers.json with a matching IP.
|
||||
// If it finds one, it caches the result for faster future lookups.
|
||||
function getServerNameByIp(ip) {
|
||||
var lookupName = serverNameLookup[ip];
|
||||
|
||||
if (lookupName) {
|
||||
return lookupName;
|
||||
}
|
||||
|
||||
for (var i = 0; i < servers.length; i++) {
|
||||
var entry = servers[i];
|
||||
|
||||
if (entry.ip === ip) {
|
||||
serverNameLookup[entry.ip] = entry.name;
|
||||
|
||||
return entry.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Returns a list of configured server IPs from servers.json
|
||||
function getServerIps() {
|
||||
var ips = [];
|
||||
|
||||
for (var i = 0; i < servers.length; i++) {
|
||||
ips.push(servers[i].ip);
|
||||
}
|
||||
|
||||
return ips;
|
||||
}
|
||||
|
||||
// This method is a monstrosity.
|
||||
// Since we loaded ALL pings from the database, we need to filter out the pings so each entry is a minute apart.
|
||||
// This is done by iterating over the list, since the time between each ping can be completely arbitrary.
|
||||
function trimUselessPings(data) {
|
||||
var keys = Object.keys(data);
|
||||
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var listing = data[keys[i]];
|
||||
var lastTimestamp = 0;
|
||||
|
||||
var filteredListing = [];
|
||||
|
||||
for (var x = 0; x < listing.length; x++) {
|
||||
var entry = listing[x];
|
||||
|
||||
// 0 is the index of the timestamp.
|
||||
// See the convertPingsToGraph method.
|
||||
if (entry[0] - lastTimestamp >= 60 * 1000) {
|
||||
// This second check tries to smooth out randomly dropped pings.
|
||||
// By default we only want entries that are online (playerCount > 0).
|
||||
// This way we'll keep looking forward until we find one that is online.
|
||||
// However if we can't find one within a reasonable timeframe, select the sucky one.
|
||||
if (entry[0] - lastTimestamp >= 120 * 1000 || entry[1] > 0) {
|
||||
filteredListing.push(entry);
|
||||
|
||||
lastTimestamp = entry[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
data[keys[i]] = filteredListing;
|
||||
}
|
||||
}
|
||||
|
||||
exports.trimOldPings = function(data) {
|
||||
var keys = Object.keys(data);
|
||||
|
||||
var timeMs = exports.getCurrentTimeMs();
|
||||
|
||||
for (var x = 0; x < keys.length; x++) {
|
||||
var listing = data[keys[x]];
|
||||
var toSplice = [];
|
||||
|
||||
for (var i = 0; i < listing.length; i++) {
|
||||
var entry = listing[i];
|
||||
|
||||
if (timeMs - entry[0] > config.graphDuration) {
|
||||
toSplice.push(i);
|
||||
}
|
||||
}
|
||||
|
||||
for (var i = 0; i < toSplice.length; i++) {
|
||||
listing.splice(toSplice[i], 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
exports.getCurrentTimeMs = function() {
|
||||
return new Date().getTime();
|
||||
};
|
||||
|
||||
exports.stringToColor = function(base) {
|
||||
var hash;
|
||||
|
||||
for (var i = base.length - 1, hash = 0; i >= 0; i--) {
|
||||
hash = base.charCodeAt(i) + ((hash << 5) - hash);
|
||||
}
|
||||
|
||||
color = Math.floor(Math.abs((Math.sin(hash) * 10000) % 1 * 16777216)).toString(16);
|
||||
|
||||
return '#' + Array(6 - color.length + 1).join('0') + color;
|
||||
}
|
||||
|
||||
exports.setIntervalNoDelay = function(func, delay) {
|
||||
var task = setInterval(func, delay);
|
||||
|
||||
func();
|
||||
|
||||
return task;
|
||||
};
|
||||
|
||||
exports.convertServerHistory = function(sqlData) {
|
||||
var serverIps = getServerIps();
|
||||
var graphData = {};
|
||||
|
||||
var startTime = exports.getCurrentTimeMs();
|
||||
|
||||
for (var i = 0; i < sqlData.length; i++) {
|
||||
var entry = sqlData[i];
|
||||
|
||||
if (serverIps.indexOf(entry.ip) === -1) continue;
|
||||
|
||||
var name = getServerNameByIp(entry.ip);
|
||||
|
||||
if (!graphData[name]) graphData[name] = [];
|
||||
graphData[name].push([entry.timestamp, entry.playerCount]);
|
||||
}
|
||||
|
||||
// Break it into minutes.
|
||||
trimUselessPings(graphData);
|
||||
|
||||
// Drop old data.
|
||||
exports.trimOldPings(graphData);
|
||||
|
||||
logger.info('Parsed ' + sqlData.length + ' ping records in ' + (exports.getCurrentTimeMs() - startTime) + 'ms');
|
||||
|
||||
return graphData;
|
||||
};
|
||||
|
||||
/**
|
||||
* Attempts to resolve Minecraft PC SRV records from DNS, otherwise falling back to the old hostname.
|
||||
*
|
||||
* @param hostname hostname to check
|
||||
* @param port port to pass to callback if required
|
||||
* @param callback function with a hostname and port parameter
|
||||
*/
|
||||
exports.unfurlSRV = function(hostname, port, callback) {
|
||||
dns.resolveSrv("_minecraft._tcp."+hostname, function (err, records) {
|
||||
if(!records||records.length<=0) {
|
||||
callback(hostname, port);
|
||||
return;
|
||||
}
|
||||
callback(records[0].name, records[0].port);
|
||||
})
|
||||
};
|
||||
|
||||
exports.getRemoteAddr = function(req) {
|
||||
let remoteAddress = req.headers['cf-connecting-ip'] || req.headers['x-forwarded-for'] || req.connection.remoteAddress;
|
||||
return remoteAddress;
|
||||
};
|
||||
Reference in New Issue
Block a user