Merge remote-tracking branch 'remote/master' into feature/add-xml-support-to-http-monitors

# Conflicts:
#	server/database.js
#	server/model/monitor.js

server/database.js

@@ -65,7 +65,9 @@ class Database {
         "patch-grpc-monitor.sql": true,
         "patch-add-radius-monitor.sql": true,
         "patch-monitor-add-resend-interval.sql": true,
+        "patch-ping-packet-size.sql": true,
         "patch-maintenance-table2.sql": true,
+        "patch-add-gamedig-monitor.sql": true,
         "patch-http-body-encoding.sql": true
     };
 

server/model/monitor.js

@@ -18,6 +18,7 @@ const { CacheableDnsHttpAgent } = require("../cacheable-dns-http-agent");
 const { DockerHost } = require("../docker");
 const Maintenance = require("./maintenance");
 const { UptimeCacheList } = require("../uptime-cache-list");
+const Gamedig = require("gamedig");
 
 /**
  * status:
@@ -86,6 +87,7 @@ class Monitor extends BeanModel {
             expiryNotification: this.isEnabledExpiryNotification(),
             ignoreTls: this.getIgnoreTls(),
             upsideDown: this.isUpsideDown(),
+            packetSize: this.packetSize,
             maxredirects: this.maxredirects,
             accepted_statuscodes: this.getAcceptedStatuscodes(),
             dns_resolve_type: this.dns_resolve_type,
@@ -108,6 +110,7 @@ class Monitor extends BeanModel {
             grpcEnableTls: this.getGrpcEnableTls(),
             radiusCalledStationId: this.radiusCalledStationId,
             radiusCallingStationId: this.radiusCallingStationId,
+            game: this.game,
             httpBodyEncoding: this.httpBodyEncoding
         };
 
@@ -386,7 +389,7 @@ class Monitor extends BeanModel {
                     bean.status = UP;
 
                 } else if (this.type === "ping") {
-                    bean.ping = await ping(this.hostname);
+                    bean.ping = await ping(this.hostname, this.packetSize);
                     bean.msg = "";
                     bean.status = UP;
                 } else if (this.type === "dns") {
@@ -496,13 +499,28 @@ class Monitor extends BeanModel {
                         bean.msg = res.data.response.servers[0].name;
 
                         try {
-                            bean.ping = await ping(this.hostname);
+                            bean.ping = await ping(this.hostname, this.packetSize);
                         } catch (_) { }
                     } else {
                         throw new Error("Server not found on Steam");
                     }
+                } else if (this.type === "gamedig") {
+                    try {
+                        const state = await Gamedig.query({
+                            type: this.game,
+                            host: this.hostname,
+                            port: this.port,
+                            givenPortOnly: true,
+                        });
+
+                        bean.msg = state.name;
+                        bean.status = UP;
+                        bean.ping = state.ping;
+                    } catch (e) {
+                        throw new Error(e.message);
+                    }
                 } else if (this.type === "docker") {
-                    log.debug(`[${this.name}] Prepare Options for Axios`);
+                    log.debug("monitor", `[${this.name}] Prepare Options for Axios`);
 
                     const dockerHost = await R.load("docker_host", this.docker_host);
 
@@ -528,7 +546,7 @@ class Monitor extends BeanModel {
                         options.baseURL = DockerHost.patchDockerURL(dockerHost._dockerDaemon);
                     }
 
-                    log.debug(`[${this.name}] Axios Request`);
+                    log.debug("monitor", `[${this.name}] Axios Request`);
                     let res = await axios.request(options);
                     if (res.data.State.Running) {
                         bean.status = UP;

server/server.js

@@ -689,12 +689,14 @@ let needSetup = false;
                 bean.retryInterval = monitor.retryInterval;
                 bean.resendInterval = monitor.resendInterval;
                 bean.hostname = monitor.hostname;
+                bean.game = monitor.game;
                 bean.maxretries = monitor.maxretries;
                 bean.port = parseInt(monitor.port);
                 bean.keyword = monitor.keyword;
                 bean.ignoreTls = monitor.ignoreTls;
                 bean.expiryNotification = monitor.expiryNotification;
                 bean.upsideDown = monitor.upsideDown;
+                bean.packetSize = monitor.packetSize;
                 bean.maxredirects = monitor.maxredirects;
                 bean.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
                 bean.dns_resolve_type = monitor.dns_resolve_type;

server/socket-handlers/general-socket-handler.js

@@ -2,6 +2,30 @@ const { log } = require("../../src/util");
 const { Settings } = require("../settings");
 const { sendInfo } = require("../client");
 const { checkLogin } = require("../util-server");
+const GameResolver = require("gamedig/lib/GameResolver");
+
+let gameResolver = new GameResolver();
+let gameList = null;
+
+/**
+ * Get a game list via GameDig
+ * @returns {any[]}
+ */
+function getGameList() {
+    if (!gameList) {
+        gameList = gameResolver._readGames().games.sort((a, b) => {
+            if ( a.pretty < b.pretty ) {
+                return -1;
+            }
+            if ( a.pretty > b.pretty ) {
+                return 1;
+            }
+            return 0;
+        });
+    } else {
+        return gameList;
+    }
+}
 
 module.exports.generalSocketHandler = (socket, server) => {
 
@@ -17,4 +41,11 @@ module.exports.generalSocketHandler = (socket, server) => {
         }
     });
 
+    socket.on("getGameList", async (callback) => {
+        callback({
+            ok: true,
+            gameList: getGameList(),
+        });
+    });
+
 };

server/util-server.js

@@ -79,15 +79,16 @@ exports.tcping = function (hostname, port) {
 /**
  * Ping the specified machine
  * @param {string} hostname Hostname / address of machine
+ * @param {number} [size=56] Size of packet to send
  * @returns {Promise<number>} Time for ping in ms rounded to nearest integer
  */
-exports.ping = async (hostname) => {
+exports.ping = async (hostname, size = 56) => {
     try {
-        return await exports.pingAsync(hostname);
+        return await exports.pingAsync(hostname, false, size);
     } catch (e) {
         // If the host cannot be resolved, try again with ipv6
         if (e.message.includes("service not known")) {
-            return await exports.pingAsync(hostname, true);
+            return await exports.pingAsync(hostname, true, size);
         } else {
             throw e;
         }
@@ -98,14 +99,16 @@ exports.ping = async (hostname) => {
  * Ping the specified machine
  * @param {string} hostname Hostname / address of machine to ping
  * @param {boolean} ipv6 Should IPv6 be used?
+ * @param {number} [size = 56] Size of ping packet to send
  * @returns {Promise<number>} Time for ping in ms rounded to nearest integer
  */
-exports.pingAsync = function (hostname, ipv6 = false) {
+exports.pingAsync = function (hostname, ipv6 = false, size = 56) {
     return new Promise((resolve, reject) => {
         ping.promise.probe(hostname, {
             v6: ipv6,
             min_reply: 1,
             deadline: 10,
+            packetSize: size,
         }).then((res) => {
             // If ping failed, it will set field to unknown
             if (res.alive) {