uptime-kuma/server/server.js

819 lines
22 KiB
JavaScript
Raw Normal View History

2021-08-08 09:03:10 -04:00
console.log("Welcome to Uptime Kuma");
console.log("Node Env: " + process.env.NODE_ENV);
2021-07-31 09:57:58 -04:00
const { sleep, debug } = require("../src/util");
console.log("Importing Node libraries")
const fs = require("fs");
2021-07-27 13:47:13 -04:00
const http = require("http");
2021-07-31 09:57:58 -04:00
console.log("Importing 3rd-party libraries")
debug("Importing express");
const express = require("express");
debug("Importing socket.io");
2021-06-25 09:55:49 -04:00
const { Server } = require("socket.io");
2021-07-31 09:57:58 -04:00
debug("Importing dayjs");
2021-06-25 09:55:49 -04:00
const dayjs = require("dayjs");
2021-07-31 09:57:58 -04:00
debug("Importing redbean-node");
2021-07-27 13:47:13 -04:00
const { R } = require("redbean-node");
2021-07-31 09:57:58 -04:00
debug("Importing jsonwebtoken");
2021-07-27 13:47:13 -04:00
const jwt = require("jsonwebtoken");
2021-07-31 09:57:58 -04:00
debug("Importing http-graceful-shutdown");
2021-07-27 13:47:13 -04:00
const gracefulShutdown = require("http-graceful-shutdown");
2021-07-31 09:57:58 -04:00
debug("Importing prometheus-api-metrics");
2021-07-27 13:47:13 -04:00
const prometheusAPIMetrics = require("prometheus-api-metrics");
2021-07-31 09:57:58 -04:00
console.log("Importing this project modules");
debug("Importing Monitor");
const Monitor = require("./model/monitor");
debug("Importing Settings");
2021-08-09 01:34:44 -04:00
const { getSettings, setSettings, setting, initJWTSecret } = require("./util-server");
2021-07-31 09:57:58 -04:00
debug("Importing Notification");
const { Notification } = require("./notification");
debug("Importing Database");
const Database = require("./database");
2021-07-27 12:52:31 -04:00
const { basicAuth } = require("./auth");
2021-07-27 13:47:13 -04:00
const { login } = require("./auth");
2021-07-28 08:35:55 -04:00
const passwordHash = require("./password-hash");
2021-07-31 09:57:58 -04:00
const args = require("args-parser")(process.argv);
2021-07-27 13:47:13 -04:00
const version = require("../package.json").version;
2021-08-10 04:36:21 -04:00
2021-08-10 04:45:37 -04:00
// If host is omitted, the server will accept connections on the unspecified IPv6 address (::) when IPv6 is available and the unspecified IPv4 address (0.0.0.0) otherwise.
// Dual-stack support for (::)
2021-08-10 04:36:21 -04:00
const hostname = process.env.HOST || args.host;
2021-07-29 23:33:44 -04:00
const port = parseInt(process.env.PORT || args.port || 3001);
2021-06-25 09:55:49 -04:00
2021-07-17 17:13:54 -04:00
console.info("Version: " + version)
2021-07-15 13:44:51 -04:00
console.log("Creating express and socket.io instance")
const app = express();
const server = http.createServer(app);
const io = new Server(server);
2021-07-09 07:33:22 -04:00
app.use(express.json())
2021-07-21 14:02:35 -04:00
/**
* Total WebSocket client connected to server currently, no actual use
* @type {number}
*/
2021-06-25 09:55:49 -04:00
let totalClient = 0;
2021-07-21 14:02:35 -04:00
/**
* Use for decode the auth object
* @type {null}
*/
2021-06-25 09:55:49 -04:00
let jwtSecret = null;
2021-07-21 14:02:35 -04:00
/**
* Main monitor list
* @type {{}}
*/
2021-06-25 09:55:49 -04:00
let monitorList = {};
2021-07-21 14:02:35 -04:00
/**
* Show Setup Page
* @type {boolean}
*/
2021-07-11 01:47:57 -04:00
let needSetup = false;
2021-06-25 09:55:49 -04:00
/**
* Cache Index HTML
* @type {string}
*/
let indexHTML = fs.readFileSync("./dist/index.html").toString();
2021-06-25 09:55:49 -04:00
(async () => {
await initDatabase();
2021-07-18 06:51:58 -04:00
console.log("Adding route")
2021-07-27 12:52:31 -04:00
// Normal Router here
2021-08-09 06:16:27 -04:00
// Robots.txt
app.get("/robots.txt", async (_request, response) => {
let txt = "User-agent: *\nDisallow:";
if (! await setting("searchEngineIndex")) {
txt += " /";
}
response.setHeader("Content-Type", "text/plain");
response.send(txt);
});
2021-06-25 09:55:49 -04:00
2021-07-27 12:52:31 -04:00
// Basic Auth Router here
// Prometheus API metrics /metrics
// With Basic Auth using the first user's username/password
2021-08-09 06:16:27 -04:00
app.get("/metrics", basicAuth, prometheusAPIMetrics());
app.use("/", express.static("dist"));
2021-07-22 03:22:15 -04:00
2021-07-27 12:52:31 -04:00
// Universal Route Handler, must be at the end
2021-08-09 06:16:27 -04:00
app.get("*", async (_request, response) => {
response.send(indexHTML);
2021-07-09 02:14:03 -04:00
});
2021-07-18 06:51:58 -04:00
console.log("Adding socket handler")
2021-07-27 13:47:13 -04:00
io.on("connection", async (socket) => {
2021-07-13 06:08:12 -04:00
socket.emit("info", {
version,
})
2021-06-25 09:55:49 -04:00
totalClient++;
2021-07-11 01:47:57 -04:00
if (needSetup) {
console.log("Redirect to setup page")
socket.emit("setup")
}
2021-07-27 13:47:13 -04:00
socket.on("disconnect", () => {
2021-06-25 09:55:49 -04:00
totalClient--;
});
2021-07-29 23:33:44 -04:00
// ***************************
2021-06-25 09:55:49 -04:00
// Public API
2021-07-29 23:33:44 -04:00
// ***************************
2021-06-25 09:55:49 -04:00
socket.on("loginByToken", async (token, callback) => {
try {
let decoded = jwt.verify(token, jwtSecret);
console.log("Username from JWT: " + decoded.username)
let user = await R.findOne("user", " username = ? AND active = 1 ", [
2021-07-27 13:47:13 -04:00
decoded.username,
2021-06-25 09:55:49 -04:00
])
if (user) {
2021-08-03 13:03:40 -04:00
debug("afterLogin")
2021-06-25 09:55:49 -04:00
await afterLogin(socket, user)
2021-08-03 13:03:40 -04:00
debug("afterLogin ok")
2021-06-25 09:55:49 -04:00
callback({
ok: true,
})
} else {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: "The user is inactive or deleted.",
2021-06-25 09:55:49 -04:00
})
}
} catch (error) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: "Invalid token.",
2021-06-25 09:55:49 -04:00
})
}
});
socket.on("login", async (data, callback) => {
console.log("Login")
2021-07-27 12:52:31 -04:00
let user = await login(data.username, data.password)
2021-07-13 10:22:46 -04:00
2021-07-27 12:52:31 -04:00
if (user) {
2021-06-25 09:55:49 -04:00
await afterLogin(socket, user)
callback({
ok: true,
token: jwt.sign({
2021-07-27 13:47:13 -04:00
username: data.username,
}, jwtSecret),
2021-06-25 09:55:49 -04:00
})
} else {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: "Incorrect username or password.",
2021-06-25 09:55:49 -04:00
})
}
});
socket.on("logout", async (callback) => {
socket.leave(socket.userID)
socket.userID = null;
callback();
2021-07-11 01:47:57 -04:00
});
socket.on("needSetup", async (callback) => {
callback(needSetup);
});
socket.on("setup", async (username, password, callback) => {
try {
if ((await R.count("user")) !== 0) {
throw new Error("Uptime Kuma has been setup. If you want to setup again, please delete the database.")
}
let user = R.dispense("user")
user.username = username;
user.password = passwordHash.generate(password)
await R.store(user)
needSetup = false;
callback({
ok: true,
2021-07-27 13:47:13 -04:00
msg: "Added Successfully.",
2021-07-11 01:47:57 -04:00
});
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-07-11 01:47:57 -04:00
});
}
2021-06-25 09:55:49 -04:00
});
2021-07-29 23:33:44 -04:00
// ***************************
2021-06-25 09:55:49 -04:00
// Auth Only API
2021-07-29 23:33:44 -04:00
// ***************************
2021-06-25 09:55:49 -04:00
2021-07-30 07:18:26 -04:00
// Add a new monitor
2021-06-25 09:55:49 -04:00
socket.on("add", async (monitor, callback) => {
try {
checkLogin(socket)
let bean = R.dispense("monitor")
let notificationIDList = monitor.notificationIDList;
delete monitor.notificationIDList;
2021-08-06 14:10:38 -04:00
monitor.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
delete monitor.accepted_statuscodes;
2021-06-25 09:55:49 -04:00
bean.import(monitor)
bean.user_id = socket.userID
await R.store(bean)
await updateMonitorNotification(bean.id, notificationIDList)
2021-06-27 04:10:55 -04:00
await startMonitor(socket.userID, bean.id);
await sendMonitorList(socket);
2021-06-25 09:55:49 -04:00
callback({
ok: true,
msg: "Added Successfully.",
2021-07-27 13:47:13 -04:00
monitorID: bean.id,
2021-06-25 09:55:49 -04:00
});
2021-06-27 04:10:55 -04:00
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-06-27 04:10:55 -04:00
});
}
});
2021-07-30 07:18:26 -04:00
// Edit a monitor
2021-06-27 04:10:55 -04:00
socket.on("editMonitor", async (monitor, callback) => {
try {
checkLogin(socket)
let bean = await R.findOne("monitor", " id = ? ", [ monitor.id ])
if (bean.user_id !== socket.userID) {
throw new Error("Permission denied.")
}
bean.name = monitor.name
bean.type = monitor.type
bean.url = monitor.url
bean.interval = monitor.interval
2021-07-01 02:03:06 -04:00
bean.hostname = monitor.hostname;
bean.maxretries = monitor.maxretries;
2021-07-01 02:03:06 -04:00
bean.port = monitor.port;
2021-07-01 05:19:28 -04:00
bean.keyword = monitor.keyword;
2021-07-30 07:18:26 -04:00
bean.ignoreTls = monitor.ignoreTls;
bean.upsideDown = monitor.upsideDown;
2021-08-08 12:23:51 -04:00
bean.maxredirects = monitor.maxredirects;
bean.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
2021-06-27 04:10:55 -04:00
await R.store(bean)
await updateMonitorNotification(bean.id, monitor.notificationIDList)
2021-06-27 04:10:55 -04:00
if (bean.active) {
await restartMonitor(socket.userID, bean.id)
}
2021-06-25 09:55:49 -04:00
await sendMonitorList(socket);
2021-06-27 04:10:55 -04:00
callback({
ok: true,
msg: "Saved.",
2021-07-27 13:47:13 -04:00
monitorID: bean.id,
2021-06-27 04:10:55 -04:00
});
2021-06-25 09:55:49 -04:00
} catch (e) {
2021-07-17 17:13:54 -04:00
console.error(e)
2021-06-25 09:55:49 -04:00
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-06-25 09:55:49 -04:00
});
}
});
socket.on("getMonitor", async (monitorID, callback) => {
try {
checkLogin(socket)
console.log(`Get Monitor: ${monitorID} User ID: ${socket.userID}`)
let bean = await R.findOne("monitor", " id = ? AND user_id = ? ", [
monitorID,
socket.userID,
])
callback({
ok: true,
monitor: await bean.toJSON(),
2021-06-25 09:55:49 -04:00
});
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-06-25 09:55:49 -04:00
});
}
});
// Start or Resume the monitor
socket.on("resumeMonitor", async (monitorID, callback) => {
try {
checkLogin(socket)
await startMonitor(socket.userID, monitorID);
await sendMonitorList(socket);
callback({
ok: true,
2021-07-27 13:47:13 -04:00
msg: "Resumed Successfully.",
2021-06-25 09:55:49 -04:00
});
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-06-25 09:55:49 -04:00
});
}
});
socket.on("pauseMonitor", async (monitorID, callback) => {
try {
checkLogin(socket)
await pauseMonitor(socket.userID, monitorID)
await sendMonitorList(socket);
callback({
ok: true,
2021-07-27 13:47:13 -04:00
msg: "Paused Successfully.",
2021-06-25 09:55:49 -04:00
});
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-06-25 09:55:49 -04:00
});
}
});
socket.on("deleteMonitor", async (monitorID, callback) => {
try {
checkLogin(socket)
console.log(`Delete Monitor: ${monitorID} User ID: ${socket.userID}`)
if (monitorID in monitorList) {
monitorList[monitorID].stop();
delete monitorList[monitorID]
}
await R.exec("DELETE FROM monitor WHERE id = ? AND user_id = ? ", [
monitorID,
2021-07-27 13:47:13 -04:00
socket.userID,
2021-06-25 09:55:49 -04:00
]);
callback({
ok: true,
2021-07-27 13:47:13 -04:00
msg: "Deleted Successfully.",
2021-06-25 09:55:49 -04:00
});
await sendMonitorList(socket);
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-06-25 09:55:49 -04:00
});
}
});
socket.on("changePassword", async (password, callback) => {
try {
checkLogin(socket)
if (! password.currentPassword) {
throw new Error("Invalid new password")
}
let user = await R.findOne("user", " id = ? AND active = 1 ", [
2021-07-27 13:47:13 -04:00
socket.userID,
2021-06-25 09:55:49 -04:00
])
if (user && passwordHash.verify(password.currentPassword, user.password)) {
2021-08-09 01:34:44 -04:00
user.resetPassword(password.newPassword);
2021-06-25 09:55:49 -04:00
callback({
ok: true,
2021-07-27 13:47:13 -04:00
msg: "Password has been updated successfully.",
2021-06-25 09:55:49 -04:00
})
} else {
throw new Error("Incorrect current password")
}
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-06-25 09:55:49 -04:00
});
}
});
2021-07-06 02:30:10 -04:00
2021-07-31 09:57:58 -04:00
socket.on("getSettings", async (callback) => {
2021-07-06 02:30:10 -04:00
try {
checkLogin(socket)
callback({
ok: true,
2021-07-31 09:57:58 -04:00
data: await getSettings("general"),
});
} catch (e) {
callback({
ok: false,
msg: e.message,
});
}
});
socket.on("setSettings", async (data, callback) => {
try {
checkLogin(socket)
await setSettings("general", data)
callback({
ok: true,
msg: "Saved"
2021-07-06 02:30:10 -04:00
});
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-07-06 02:30:10 -04:00
});
}
});
2021-07-09 02:14:03 -04:00
// Add or Edit
socket.on("addNotification", async (notification, notificationID, callback) => {
try {
checkLogin(socket)
await Notification.save(notification, notificationID, socket.userID)
await sendNotificationList(socket)
callback({
ok: true,
msg: "Saved",
});
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-07-09 02:14:03 -04:00
});
}
});
socket.on("deleteNotification", async (notificationID, callback) => {
try {
checkLogin(socket)
await Notification.delete(notificationID, socket.userID)
await sendNotificationList(socket)
callback({
ok: true,
msg: "Deleted",
});
} catch (e) {
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-07-09 02:14:03 -04:00
});
}
});
socket.on("testNotification", async (notification, callback) => {
try {
checkLogin(socket)
2021-07-18 08:49:46 -04:00
let msg = await Notification.send(notification, notification.name + " Testing")
2021-07-09 02:14:03 -04:00
callback({
ok: true,
2021-07-27 13:47:13 -04:00
msg,
2021-07-09 02:14:03 -04:00
});
} catch (e) {
2021-07-18 08:49:46 -04:00
console.error(e)
2021-07-09 02:14:03 -04:00
callback({
ok: false,
2021-07-27 13:47:13 -04:00
msg: e.message,
2021-07-09 02:14:03 -04:00
});
}
});
2021-07-18 06:51:58 -04:00
socket.on("checkApprise", async (callback) => {
try {
checkLogin(socket)
callback(Notification.checkApprise());
} catch (e) {
callback(false);
}
});
2021-08-03 13:03:40 -04:00
debug("added all socket handlers")
2021-08-04 01:31:17 -04:00
// ***************************
// Better do anything after added all socket handlers here
// ***************************
2021-08-03 13:03:40 -04:00
debug("check auto login")
if (await setting("disableAuth")) {
console.log("Disabled Auth: auto login to admin")
await afterLogin(socket, await R.findOne("user"))
socket.emit("autoLogin")
} else {
debug("need auth")
}
2021-06-25 09:55:49 -04:00
});
2021-07-18 06:51:58 -04:00
console.log("Init")
server.listen(port, hostname, () => {
2021-08-10 04:36:21 -04:00
if (hostname) {
console.log(`Listening on ${hostname}:${port}`);
} else {
console.log("Listening on ${port}");
}
2021-06-25 09:55:49 -04:00
startMonitors();
});
})();
async function updateMonitorNotification(monitorID, notificationIDList) {
R.exec("DELETE FROM monitor_notification WHERE monitor_id = ? ", [
2021-07-27 13:47:13 -04:00
monitorID,
])
for (let notificationID in notificationIDList) {
if (notificationIDList[notificationID]) {
let relation = R.dispense("monitor_notification");
relation.monitor_id = monitorID;
relation.notification_id = notificationID;
await R.store(relation)
}
}
}
2021-06-25 09:55:49 -04:00
async function checkOwner(userID, monitorID) {
let row = await R.getRow("SELECT id FROM monitor WHERE id = ? AND user_id = ? ", [
monitorID,
userID,
])
if (! row) {
throw new Error("You do not own this monitor.");
}
}
async function sendMonitorList(socket) {
2021-06-29 04:06:20 -04:00
let list = await getMonitorJSONList(socket.userID);
io.to(socket.userID).emit("monitorList", list)
return list;
2021-06-25 09:55:49 -04:00
}
2021-07-09 02:14:03 -04:00
async function sendNotificationList(socket) {
let result = [];
let list = await R.find("notification", " user_id = ? ", [
2021-07-27 13:47:13 -04:00
socket.userID,
2021-07-09 02:14:03 -04:00
]);
for (let bean of list) {
result.push(bean.export())
}
io.to(socket.userID).emit("notificationList", result)
return list;
}
2021-06-25 09:55:49 -04:00
async function afterLogin(socket, user) {
socket.userID = user.id;
socket.join(user.id)
2021-06-29 04:06:20 -04:00
let monitorList = await sendMonitorList(socket)
2021-07-26 11:26:47 -04:00
sendNotificationList(socket)
2021-08-08 13:58:56 -04:00
// Delay a bit, so that it let the main page to query the data first, since SQLite can process one sql at the same time only.
// For example, query the edit data first.
setTimeout(() => {
for (let monitorID in monitorList) {
sendHeartbeatList(socket, monitorID);
sendImportantHeartbeatList(socket, monitorID);
Monitor.sendStats(io, monitorID, user.id)
}
}, 500);
2021-06-25 09:55:49 -04:00
}
async function getMonitorJSONList(userID) {
2021-06-27 04:10:55 -04:00
let result = {};
2021-06-25 09:55:49 -04:00
2021-07-01 01:11:16 -04:00
let monitorList = await R.find("monitor", " user_id = ? ", [
2021-07-27 13:47:13 -04:00
userID,
2021-06-25 09:55:49 -04:00
])
for (let monitor of monitorList) {
result[monitor.id] = await monitor.toJSON();
2021-06-25 09:55:49 -04:00
}
return result;
}
function checkLogin(socket) {
if (! socket.userID) {
throw new Error("You are not logged in.");
}
}
async function initDatabase() {
2021-07-21 14:02:35 -04:00
if (! fs.existsSync(Database.path)) {
2021-07-15 13:44:51 -04:00
console.log("Copying Database")
2021-07-21 14:02:35 -04:00
fs.copyFileSync(Database.templatePath, Database.path);
2021-07-11 01:47:57 -04:00
}
2021-07-15 13:44:51 -04:00
console.log("Connecting to Database")
2021-08-09 01:34:44 -04:00
await Database.connect();
2021-07-18 06:51:58 -04:00
console.log("Connected")
2021-07-21 14:02:35 -04:00
// Patch the database
await Database.patch()
2021-06-25 09:55:49 -04:00
let jwtSecretBean = await R.findOne("setting", " `key` = ? ", [
2021-07-27 13:47:13 -04:00
"jwtSecret",
2021-06-25 09:55:49 -04:00
]);
if (! jwtSecretBean) {
2021-08-09 01:34:44 -04:00
console.log("JWT secret is not found, generate one.");
2021-08-09 08:09:01 -04:00
jwtSecretBean = await initJWTSecret();
2021-08-09 01:34:44 -04:00
console.log("Stored JWT secret into database");
2021-06-25 09:55:49 -04:00
} else {
2021-08-09 01:34:44 -04:00
console.log("Load JWT secret from database.");
2021-06-25 09:55:49 -04:00
}
2021-07-21 14:02:35 -04:00
// If there is no record in user table, it is a new Uptime Kuma instance, need to setup
2021-07-11 01:47:57 -04:00
if ((await R.count("user")) === 0) {
console.log("No user, need setup")
needSetup = true;
}
2021-06-25 09:55:49 -04:00
jwtSecret = jwtSecretBean.value;
}
async function startMonitor(userID, monitorID) {
await checkOwner(userID, monitorID)
console.log(`Resume Monitor: ${monitorID} User ID: ${userID}`)
await R.exec("UPDATE monitor SET active = 1 WHERE id = ? AND user_id = ? ", [
monitorID,
2021-07-27 13:47:13 -04:00
userID,
2021-06-25 09:55:49 -04:00
]);
let monitor = await R.findOne("monitor", " id = ? ", [
2021-07-27 13:47:13 -04:00
monitorID,
2021-06-25 09:55:49 -04:00
])
2021-06-27 04:10:55 -04:00
if (monitor.id in monitorList) {
monitorList[monitor.id].stop();
}
2021-06-25 09:55:49 -04:00
monitorList[monitor.id] = monitor;
monitor.start(io)
}
2021-06-27 04:10:55 -04:00
async function restartMonitor(userID, monitorID) {
return await startMonitor(userID, monitorID)
}
2021-06-25 09:55:49 -04:00
async function pauseMonitor(userID, monitorID) {
await checkOwner(userID, monitorID)
console.log(`Pause Monitor: ${monitorID} User ID: ${userID}`)
await R.exec("UPDATE monitor SET active = 0 WHERE id = ? AND user_id = ? ", [
monitorID,
2021-07-27 13:47:13 -04:00
userID,
2021-06-25 09:55:49 -04:00
]);
if (monitorID in monitorList) {
monitorList[monitorID].stop();
}
}
/**
* Resume active monitors
*/
async function startMonitors() {
let list = await R.find("monitor", " active = 1 ")
for (let monitor of list) {
monitor.start(io)
monitorList[monitor.id] = monitor;
}
}
2021-06-29 04:06:20 -04:00
/**
* Send Heartbeat History list to socket
*/
async function sendHeartbeatList(socket, monitorID) {
let list = await R.find("heartbeat", `
monitor_id = ?
ORDER BY time DESC
LIMIT 100
`, [
2021-07-27 13:47:13 -04:00
monitorID,
2021-06-29 04:06:20 -04:00
])
let result = [];
for (let bean of list) {
2021-07-27 13:47:13 -04:00
result.unshift(bean.toJSON())
2021-06-29 04:06:20 -04:00
}
socket.emit("heartbeatList", monitorID, result)
}
2021-06-30 09:04:58 -04:00
async function sendImportantHeartbeatList(socket, monitorID) {
let list = await R.find("heartbeat", `
monitor_id = ?
AND important = 1
ORDER BY time DESC
LIMIT 500
`, [
2021-07-27 13:47:13 -04:00
monitorID,
2021-06-30 09:04:58 -04:00
])
socket.emit("importantHeartbeatList", monitorID, list)
}
2021-07-15 13:44:51 -04:00
async function shutdownFunction(signal) {
2021-07-28 08:35:55 -04:00
console.log("Shutdown requested");
2021-07-27 13:47:13 -04:00
console.log("Called signal: " + signal);
2021-07-15 13:44:51 -04:00
console.log("Stopping all monitors")
for (let id in monitorList) {
let monitor = monitorList[id]
monitor.stop()
}
2021-07-21 14:02:35 -04:00
await sleep(2000);
await Database.close();
2021-07-28 08:35:55 -04:00
console.log("Stopped DB")
2021-07-15 13:44:51 -04:00
}
function finalFunction() {
2021-07-28 08:35:55 -04:00
console.log("Graceful Shutdown Done")
2021-07-15 13:44:51 -04:00
}
gracefulShutdown(server, {
2021-07-27 13:47:13 -04:00
signals: "SIGINT SIGTERM",
2021-07-15 13:44:51 -04:00
timeout: 30000, // timeout: 30 secs
development: false, // not in dev mode
forceExit: true, // triggers process.exit() at the end of shutdown process
onShutdown: shutdownFunction, // shutdown function (async) - e.g. for cleanup DB, ...
2021-07-27 13:47:13 -04:00
finally: finalFunction, // finally function (sync) - e.g. for logging
2021-07-15 13:44:51 -04:00
});