summaryrefslogtreecommitdiffstats
path: root/server/server.js
diff options
context:
space:
mode:
Diffstat (limited to 'server/server.js')
-rw-r--r--server/server.js1877
1 files changed, 1877 insertions, 0 deletions
diff --git a/server/server.js b/server/server.js
new file mode 100644
index 0000000..ec5ad49
--- /dev/null
+++ b/server/server.js
@@ -0,0 +1,1877 @@
+/*
+ * Uptime Kuma Server
+ * node "server/server.js"
+ * DO NOT require("./server") in other modules, it likely creates circular dependency!
+ */
+console.log("Welcome to Uptime Kuma");
+
+// As the log function need to use dayjs, it should be very top
+const dayjs = require("dayjs");
+dayjs.extend(require("dayjs/plugin/utc"));
+dayjs.extend(require("./modules/dayjs/plugin/timezone"));
+dayjs.extend(require("dayjs/plugin/customParseFormat"));
+
+// Load environment variables from `.env`
+require("dotenv").config();
+
+// Check Node.js Version
+const nodeVersion = process.versions.node;
+
+// Get the required Node.js version from package.json
+const requiredNodeVersions = require("../package.json").engines.node;
+const bannedNodeVersions = " < 18 || 20.0.* || 20.1.* || 20.2.* || 20.3.* ";
+console.log(`Your Node.js version: ${nodeVersion}`);
+
+const semver = require("semver");
+const requiredNodeVersionsComma = requiredNodeVersions.split("||").map((version) => version.trim()).join(", ");
+
+// Exit Uptime Kuma immediately if the Node.js version is banned
+if (semver.satisfies(nodeVersion, bannedNodeVersions)) {
+ console.error("\x1b[31m%s\x1b[0m", `Error: Your Node.js version: ${nodeVersion} is not supported, please upgrade your Node.js to ${requiredNodeVersionsComma}.`);
+ process.exit(-1);
+}
+
+// Warning if the Node.js version is not in the support list, but it maybe still works
+if (!semver.satisfies(nodeVersion, requiredNodeVersions)) {
+ console.warn("\x1b[31m%s\x1b[0m", `Warning: Your Node.js version: ${nodeVersion} is not officially supported, please upgrade your Node.js to ${requiredNodeVersionsComma}.`);
+}
+
+const args = require("args-parser")(process.argv);
+const { sleep, log, getRandomInt, genSecret, isDev } = require("../src/util");
+const config = require("./config");
+
+log.debug("server", "Arguments");
+log.debug("server", args);
+
+if (! process.env.NODE_ENV) {
+ process.env.NODE_ENV = "production";
+}
+
+if (!process.env.UPTIME_KUMA_WS_ORIGIN_CHECK) {
+ process.env.UPTIME_KUMA_WS_ORIGIN_CHECK = "cors-like";
+}
+
+log.info("server", "Env: " + process.env.NODE_ENV);
+log.debug("server", "Inside Container: " + (process.env.UPTIME_KUMA_IS_CONTAINER === "1"));
+
+if (process.env.UPTIME_KUMA_WS_ORIGIN_CHECK === "bypass") {
+ log.warn("server", "WebSocket Origin Check: " + process.env.UPTIME_KUMA_WS_ORIGIN_CHECK);
+}
+
+const checkVersion = require("./check-version");
+log.info("server", "Uptime Kuma Version: " + checkVersion.version);
+
+log.info("server", "Loading modules");
+
+log.debug("server", "Importing express");
+const express = require("express");
+const expressStaticGzip = require("express-static-gzip");
+log.debug("server", "Importing redbean-node");
+const { R } = require("redbean-node");
+log.debug("server", "Importing jsonwebtoken");
+const jwt = require("jsonwebtoken");
+log.debug("server", "Importing http-graceful-shutdown");
+const gracefulShutdown = require("http-graceful-shutdown");
+log.debug("server", "Importing prometheus-api-metrics");
+const prometheusAPIMetrics = require("prometheus-api-metrics");
+const { passwordStrength } = require("check-password-strength");
+
+log.debug("server", "Importing 2FA Modules");
+const notp = require("notp");
+const base32 = require("thirty-two");
+
+const { UptimeKumaServer } = require("./uptime-kuma-server");
+const server = UptimeKumaServer.getInstance();
+const io = module.exports.io = server.io;
+const app = server.app;
+
+log.debug("server", "Importing Monitor");
+const Monitor = require("./model/monitor");
+const User = require("./model/user");
+
+log.debug("server", "Importing Settings");
+const { getSettings, setSettings, setting, initJWTSecret, checkLogin, doubleCheckPassword, shake256, SHAKE256_LENGTH, allowDevAllOrigin,
+} = require("./util-server");
+
+log.debug("server", "Importing Notification");
+const { Notification } = require("./notification");
+Notification.init();
+
+log.debug("server", "Importing Database");
+const Database = require("./database");
+
+log.debug("server", "Importing Background Jobs");
+const { initBackgroundJobs, stopBackgroundJobs } = require("./jobs");
+const { loginRateLimiter, twoFaRateLimiter } = require("./rate-limiter");
+
+const { apiAuth } = require("./auth");
+const { login } = require("./auth");
+const passwordHash = require("./password-hash");
+
+const hostname = config.hostname;
+
+if (hostname) {
+ log.info("server", "Custom hostname: " + hostname);
+}
+
+const port = config.port;
+
+const disableFrameSameOrigin = !!process.env.UPTIME_KUMA_DISABLE_FRAME_SAMEORIGIN || args["disable-frame-sameorigin"] || false;
+const cloudflaredToken = args["cloudflared-token"] || process.env.UPTIME_KUMA_CLOUDFLARED_TOKEN || undefined;
+
+// 2FA / notp verification defaults
+const twoFAVerifyOptions = {
+ "window": 1,
+ "time": 30
+};
+
+/**
+ * Run unit test after the server is ready
+ * @type {boolean}
+ */
+const testMode = !!args["test"] || false;
+
+// Must be after io instantiation
+const { sendNotificationList, sendHeartbeatList, sendInfo, sendProxyList, sendDockerHostList, sendAPIKeyList, sendRemoteBrowserList, sendMonitorTypeList } = require("./client");
+const { statusPageSocketHandler } = require("./socket-handlers/status-page-socket-handler");
+const { databaseSocketHandler } = require("./socket-handlers/database-socket-handler");
+const { remoteBrowserSocketHandler } = require("./socket-handlers/remote-browser-socket-handler");
+const TwoFA = require("./2fa");
+const StatusPage = require("./model/status_page");
+const { cloudflaredSocketHandler, autoStart: cloudflaredAutoStart, stop: cloudflaredStop } = require("./socket-handlers/cloudflared-socket-handler");
+const { proxySocketHandler } = require("./socket-handlers/proxy-socket-handler");
+const { dockerSocketHandler } = require("./socket-handlers/docker-socket-handler");
+const { maintenanceSocketHandler } = require("./socket-handlers/maintenance-socket-handler");
+const { apiKeySocketHandler } = require("./socket-handlers/api-key-socket-handler");
+const { generalSocketHandler } = require("./socket-handlers/general-socket-handler");
+const { Settings } = require("./settings");
+const apicache = require("./modules/apicache");
+const { resetChrome } = require("./monitor-types/real-browser-monitor-type");
+const { EmbeddedMariaDB } = require("./embedded-mariadb");
+const { SetupDatabase } = require("./setup-database");
+const { chartSocketHandler } = require("./socket-handlers/chart-socket-handler");
+
+app.use(express.json());
+
+// Global Middleware
+app.use(function (req, res, next) {
+ if (!disableFrameSameOrigin) {
+ res.setHeader("X-Frame-Options", "SAMEORIGIN");
+ }
+ res.removeHeader("X-Powered-By");
+ next();
+});
+
+/**
+ * Show Setup Page
+ * @type {boolean}
+ */
+let needSetup = false;
+
+(async () => {
+ // Create a data directory
+ Database.initDataDir(args);
+
+ // Check if is chosen a database type
+ let setupDatabase = new SetupDatabase(args, server);
+ if (setupDatabase.isNeedSetup()) {
+ // Hold here and start a special setup page until user choose a database type
+ await setupDatabase.start(hostname, port);
+ }
+
+ // Connect to database
+ try {
+ await initDatabase(testMode);
+ } catch (e) {
+ log.error("server", "Failed to prepare your database: " + e.message);
+ process.exit(1);
+ }
+
+ // Database should be ready now
+ await server.initAfterDatabaseReady();
+ server.entryPage = await Settings.get("entryPage");
+ await StatusPage.loadDomainMappingList();
+
+ log.debug("server", "Adding route");
+
+ // ***************************
+ // Normal Router here
+ // ***************************
+
+ // Entry Page
+ app.get("/", async (request, response) => {
+ let hostname = request.hostname;
+ if (await setting("trustProxy")) {
+ const proxy = request.headers["x-forwarded-host"];
+ if (proxy) {
+ hostname = proxy;
+ }
+ }
+
+ log.debug("entry", `Request Domain: ${hostname}`);
+
+ const uptimeKumaEntryPage = server.entryPage;
+ if (hostname in StatusPage.domainMappingList) {
+ log.debug("entry", "This is a status page domain");
+
+ let slug = StatusPage.domainMappingList[hostname];
+ await StatusPage.handleStatusPageResponse(response, server.indexHTML, slug);
+
+ } else if (uptimeKumaEntryPage && uptimeKumaEntryPage.startsWith("statusPage-")) {
+ response.redirect("/status/" + uptimeKumaEntryPage.replace("statusPage-", ""));
+
+ } else {
+ response.redirect("/dashboard");
+ }
+ });
+
+ app.get("/setup-database-info", (request, response) => {
+ allowDevAllOrigin(response);
+ response.json({
+ runningSetup: false,
+ needSetup: false,
+ });
+ });
+
+ if (isDev) {
+ app.use(express.urlencoded({ extended: true }));
+ app.post("/test-webhook", async (request, response) => {
+ log.debug("test", request.headers);
+ log.debug("test", request.body);
+ response.send("OK");
+ });
+
+ app.post("/test-x-www-form-urlencoded", async (request, response) => {
+ log.debug("test", request.headers);
+ log.debug("test", request.body);
+ response.send("OK");
+ });
+
+ const fs = require("fs");
+
+ app.get("/_e2e/take-sqlite-snapshot", async (request, response) => {
+ await Database.close();
+ try {
+ fs.cpSync(Database.sqlitePath, `${Database.sqlitePath}.e2e-snapshot`);
+ } catch (err) {
+ throw new Error("Unable to copy SQLite DB.");
+ }
+ await Database.connect();
+
+ response.send("Snapshot taken.");
+ });
+
+ app.get("/_e2e/restore-sqlite-snapshot", async (request, response) => {
+ if (!fs.existsSync(`${Database.sqlitePath}.e2e-snapshot`)) {
+ throw new Error("Snapshot doesn't exist.");
+ }
+
+ await Database.close();
+ try {
+ fs.cpSync(`${Database.sqlitePath}.e2e-snapshot`, Database.sqlitePath);
+ } catch (err) {
+ throw new Error("Unable to copy snapshot file.");
+ }
+ await Database.connect();
+
+ response.send("Snapshot restored.");
+ });
+ }
+
+ // 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);
+ });
+
+ // Basic Auth Router here
+
+ // Prometheus API metrics /metrics
+ // With Basic Auth using the first user's username/password
+ app.get("/metrics", apiAuth, prometheusAPIMetrics());
+
+ app.use("/", expressStaticGzip("dist", {
+ enableBrotli: true,
+ }));
+
+ // ./data/upload
+ app.use("/upload", express.static(Database.uploadDir));
+
+ app.get("/.well-known/change-password", async (_, response) => {
+ response.redirect("https://github.com/louislam/uptime-kuma/wiki/Reset-Password-via-CLI");
+ });
+
+ // API Router
+ const apiRouter = require("./routers/api-router");
+ app.use(apiRouter);
+
+ // Status Page Router
+ const statusPageRouter = require("./routers/status-page-router");
+ app.use(statusPageRouter);
+
+ // Universal Route Handler, must be at the end of all express routes.
+ app.get("*", async (_request, response) => {
+ if (_request.originalUrl.startsWith("/upload/")) {
+ response.status(404).send("File not found.");
+ } else {
+ response.send(server.indexHTML);
+ }
+ });
+
+ log.debug("server", "Adding socket handler");
+ io.on("connection", async (socket) => {
+
+ await sendInfo(socket, true);
+
+ if (needSetup) {
+ log.info("server", "Redirect to setup page");
+ socket.emit("setup");
+ }
+
+ // ***************************
+ // Public Socket API
+ // ***************************
+
+ socket.on("loginByToken", async (token, callback) => {
+ const clientIP = await server.getClientIP(socket);
+
+ log.info("auth", `Login by token. IP=${clientIP}`);
+
+ try {
+ let decoded = jwt.verify(token, server.jwtSecret);
+
+ log.info("auth", "Username from JWT: " + decoded.username);
+
+ let user = await R.findOne("user", " username = ? AND active = 1 ", [
+ decoded.username,
+ ]);
+
+ if (user) {
+ // Check if the password changed
+ if (decoded.h !== shake256(user.password, SHAKE256_LENGTH)) {
+ throw new Error("The token is invalid due to password change or old token");
+ }
+
+ log.debug("auth", "afterLogin");
+ await afterLogin(socket, user);
+ log.debug("auth", "afterLogin ok");
+
+ log.info("auth", `Successfully logged in user ${decoded.username}. IP=${clientIP}`);
+
+ callback({
+ ok: true,
+ });
+ } else {
+
+ log.info("auth", `Inactive or deleted user ${decoded.username}. IP=${clientIP}`);
+
+ callback({
+ ok: false,
+ msg: "authUserInactiveOrDeleted",
+ msgi18n: true,
+ });
+ }
+ } catch (error) {
+ log.error("auth", `Invalid token. IP=${clientIP}`);
+ if (error.message) {
+ log.error("auth", error.message, `IP=${clientIP}`);
+ }
+ callback({
+ ok: false,
+ msg: "authInvalidToken",
+ msgi18n: true,
+ });
+ }
+
+ });
+
+ socket.on("login", async (data, callback) => {
+ const clientIP = await server.getClientIP(socket);
+
+ log.info("auth", `Login by username + password. IP=${clientIP}`);
+
+ // Checking
+ if (typeof callback !== "function") {
+ return;
+ }
+
+ if (!data) {
+ return;
+ }
+
+ // Login Rate Limit
+ if (!await loginRateLimiter.pass(callback)) {
+ log.info("auth", `Too many failed requests for user ${data.username}. IP=${clientIP}`);
+ return;
+ }
+
+ let user = await login(data.username, data.password);
+
+ if (user) {
+ if (user.twofa_status === 0) {
+ await afterLogin(socket, user);
+
+ log.info("auth", `Successfully logged in user ${data.username}. IP=${clientIP}`);
+
+ callback({
+ ok: true,
+ token: User.createJWT(user, server.jwtSecret),
+ });
+ }
+
+ if (user.twofa_status === 1 && !data.token) {
+
+ log.info("auth", `2FA token required for user ${data.username}. IP=${clientIP}`);
+
+ callback({
+ tokenRequired: true,
+ });
+ }
+
+ if (data.token) {
+ let verify = notp.totp.verify(data.token, user.twofa_secret, twoFAVerifyOptions);
+
+ if (user.twofa_last_token !== data.token && verify) {
+ await afterLogin(socket, user);
+
+ await R.exec("UPDATE `user` SET twofa_last_token = ? WHERE id = ? ", [
+ data.token,
+ socket.userID,
+ ]);
+
+ log.info("auth", `Successfully logged in user ${data.username}. IP=${clientIP}`);
+
+ callback({
+ ok: true,
+ token: User.createJWT(user, server.jwtSecret),
+ });
+ } else {
+
+ log.warn("auth", `Invalid token provided for user ${data.username}. IP=${clientIP}`);
+
+ callback({
+ ok: false,
+ msg: "authInvalidToken",
+ msgi18n: true,
+ });
+ }
+ }
+ } else {
+
+ log.warn("auth", `Incorrect username or password for user ${data.username}. IP=${clientIP}`);
+
+ callback({
+ ok: false,
+ msg: "authIncorrectCreds",
+ msgi18n: true,
+ });
+ }
+
+ });
+
+ socket.on("logout", async (callback) => {
+ // Rate Limit
+ if (!await loginRateLimiter.pass(callback)) {
+ return;
+ }
+
+ socket.leave(socket.userID);
+ socket.userID = null;
+
+ if (typeof callback === "function") {
+ callback();
+ }
+ });
+
+ socket.on("prepare2FA", async (currentPassword, callback) => {
+ try {
+ if (!await twoFaRateLimiter.pass(callback)) {
+ return;
+ }
+
+ checkLogin(socket);
+ await doubleCheckPassword(socket, currentPassword);
+
+ let user = await R.findOne("user", " id = ? AND active = 1 ", [
+ socket.userID,
+ ]);
+
+ if (user.twofa_status === 0) {
+ let newSecret = genSecret();
+ let encodedSecret = base32.encode(newSecret);
+
+ // Google authenticator doesn't like equal signs
+ // The fix is found at https://github.com/guyht/notp
+ // Related issue: https://github.com/louislam/uptime-kuma/issues/486
+ encodedSecret = encodedSecret.toString().replace(/=/g, "");
+
+ let uri = `otpauth://totp/Uptime%20Kuma:${user.username}?secret=${encodedSecret}`;
+
+ await R.exec("UPDATE `user` SET twofa_secret = ? WHERE id = ? ", [
+ newSecret,
+ socket.userID,
+ ]);
+
+ callback({
+ ok: true,
+ uri: uri,
+ });
+ } else {
+ callback({
+ ok: false,
+ msg: "2faAlreadyEnabled",
+ msgi18n: true,
+ });
+ }
+ } catch (error) {
+ callback({
+ ok: false,
+ msg: error.message,
+ });
+ }
+ });
+
+ socket.on("save2FA", async (currentPassword, callback) => {
+ const clientIP = await server.getClientIP(socket);
+
+ try {
+ if (!await twoFaRateLimiter.pass(callback)) {
+ return;
+ }
+
+ checkLogin(socket);
+ await doubleCheckPassword(socket, currentPassword);
+
+ await R.exec("UPDATE `user` SET twofa_status = 1 WHERE id = ? ", [
+ socket.userID,
+ ]);
+
+ log.info("auth", `Saved 2FA token. IP=${clientIP}`);
+
+ callback({
+ ok: true,
+ msg: "2faEnabled",
+ msgi18n: true,
+ });
+ } catch (error) {
+
+ log.error("auth", `Error changing 2FA token. IP=${clientIP}`);
+
+ callback({
+ ok: false,
+ msg: error.message,
+ });
+ }
+ });
+
+ socket.on("disable2FA", async (currentPassword, callback) => {
+ const clientIP = await server.getClientIP(socket);
+
+ try {
+ if (!await twoFaRateLimiter.pass(callback)) {
+ return;
+ }
+
+ checkLogin(socket);
+ await doubleCheckPassword(socket, currentPassword);
+ await TwoFA.disable2FA(socket.userID);
+
+ log.info("auth", `Disabled 2FA token. IP=${clientIP}`);
+
+ callback({
+ ok: true,
+ msg: "2faDisabled",
+ msgi18n: true,
+ });
+ } catch (error) {
+
+ log.error("auth", `Error disabling 2FA token. IP=${clientIP}`);
+
+ callback({
+ ok: false,
+ msg: error.message,
+ });
+ }
+ });
+
+ socket.on("verifyToken", async (token, currentPassword, callback) => {
+ try {
+ checkLogin(socket);
+ await doubleCheckPassword(socket, currentPassword);
+
+ let user = await R.findOne("user", " id = ? AND active = 1 ", [
+ socket.userID,
+ ]);
+
+ let verify = notp.totp.verify(token, user.twofa_secret, twoFAVerifyOptions);
+
+ if (user.twofa_last_token !== token && verify) {
+ callback({
+ ok: true,
+ valid: true,
+ });
+ } else {
+ callback({
+ ok: false,
+ msg: "authInvalidToken",
+ msgi18n: true,
+ valid: false,
+ });
+ }
+
+ } catch (error) {
+ callback({
+ ok: false,
+ msg: error.message,
+ });
+ }
+ });
+
+ socket.on("twoFAStatus", async (callback) => {
+ try {
+ checkLogin(socket);
+
+ let user = await R.findOne("user", " id = ? AND active = 1 ", [
+ socket.userID,
+ ]);
+
+ if (user.twofa_status === 1) {
+ callback({
+ ok: true,
+ status: true,
+ });
+ } else {
+ callback({
+ ok: true,
+ status: false,
+ });
+ }
+ } catch (error) {
+ callback({
+ ok: false,
+ msg: error.message,
+ });
+ }
+ });
+
+ socket.on("needSetup", async (callback) => {
+ callback(needSetup);
+ });
+
+ socket.on("setup", async (username, password, callback) => {
+ try {
+ if (passwordStrength(password).value === "Too weak") {
+ throw new Error("Password is too weak. It should contain alphabetic and numeric characters. It must be at least 6 characters in length.");
+ }
+
+ if ((await R.knex("user").count("id as count").first()).count !== 0) {
+ throw new Error("Uptime Kuma has been initialized. If you want to run 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,
+ msg: "successAdded",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ // ***************************
+ // Auth Only API
+ // ***************************
+
+ // Add a new monitor
+ socket.on("add", async (monitor, callback) => {
+ try {
+ checkLogin(socket);
+ let bean = R.dispense("monitor");
+
+ let notificationIDList = monitor.notificationIDList;
+ delete monitor.notificationIDList;
+
+ // Ensure status code ranges are strings
+ if (!monitor.accepted_statuscodes.every((code) => typeof code === "string")) {
+ throw new Error("Accepted status codes are not all strings");
+ }
+ monitor.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
+ delete monitor.accepted_statuscodes;
+
+ monitor.kafkaProducerBrokers = JSON.stringify(monitor.kafkaProducerBrokers);
+ monitor.kafkaProducerSaslOptions = JSON.stringify(monitor.kafkaProducerSaslOptions);
+
+ monitor.conditions = JSON.stringify(monitor.conditions);
+
+ monitor.rabbitmqNodes = JSON.stringify(monitor.rabbitmqNodes);
+
+ bean.import(monitor);
+ bean.user_id = socket.userID;
+
+ bean.validate();
+
+ await R.store(bean);
+
+ await updateMonitorNotification(bean.id, notificationIDList);
+
+ await server.sendUpdateMonitorIntoList(socket, bean.id);
+
+ if (monitor.active !== false) {
+ await startMonitor(socket.userID, bean.id);
+ }
+
+ log.info("monitor", `Added Monitor: ${bean.id} User ID: ${socket.userID}`);
+
+ callback({
+ ok: true,
+ msg: "successAdded",
+ msgi18n: true,
+ monitorID: bean.id,
+ });
+
+ } catch (e) {
+
+ log.error("monitor", `Error adding Monitor: ${monitor.id} User ID: ${socket.userID}`);
+
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ // Edit a monitor
+ socket.on("editMonitor", async (monitor, callback) => {
+ try {
+ let removeGroupChildren = false;
+ checkLogin(socket);
+
+ let bean = await R.findOne("monitor", " id = ? ", [ monitor.id ]);
+
+ if (bean.user_id !== socket.userID) {
+ throw new Error("Permission denied.");
+ }
+
+ // Check if Parent is Descendant (would cause endless loop)
+ if (monitor.parent !== null) {
+ const childIDs = await Monitor.getAllChildrenIDs(monitor.id);
+ if (childIDs.includes(monitor.parent)) {
+ throw new Error("Invalid Monitor Group");
+ }
+ }
+
+ // Remove children if monitor type has changed (from group to non-group)
+ if (bean.type === "group" && monitor.type !== bean.type) {
+ removeGroupChildren = true;
+ }
+
+ // Ensure status code ranges are strings
+ if (!monitor.accepted_statuscodes.every((code) => typeof code === "string")) {
+ throw new Error("Accepted status codes are not all strings");
+ }
+
+ bean.name = monitor.name;
+ bean.description = monitor.description;
+ bean.parent = monitor.parent;
+ bean.type = monitor.type;
+ bean.url = monitor.url;
+ bean.method = monitor.method;
+ bean.body = monitor.body;
+ bean.headers = monitor.headers;
+ bean.basic_auth_user = monitor.basic_auth_user;
+ bean.basic_auth_pass = monitor.basic_auth_pass;
+ bean.timeout = monitor.timeout;
+ bean.oauth_client_id = monitor.oauth_client_id;
+ bean.oauth_client_secret = monitor.oauth_client_secret;
+ bean.oauth_auth_method = monitor.oauth_auth_method;
+ bean.oauth_token_url = monitor.oauth_token_url;
+ bean.oauth_scopes = monitor.oauth_scopes;
+ bean.tlsCa = monitor.tlsCa;
+ bean.tlsCert = monitor.tlsCert;
+ bean.tlsKey = monitor.tlsKey;
+ bean.interval = monitor.interval;
+ 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);
+
+ if (isNaN(bean.port)) {
+ bean.port = null;
+ }
+
+ bean.keyword = monitor.keyword;
+ bean.invertKeyword = monitor.invertKeyword;
+ 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;
+ bean.dns_resolve_server = monitor.dns_resolve_server;
+ bean.pushToken = monitor.pushToken;
+ bean.docker_container = monitor.docker_container;
+ bean.docker_host = monitor.docker_host;
+ bean.proxyId = Number.isInteger(monitor.proxyId) ? monitor.proxyId : null;
+ bean.mqttUsername = monitor.mqttUsername;
+ bean.mqttPassword = monitor.mqttPassword;
+ bean.mqttTopic = monitor.mqttTopic;
+ bean.mqttSuccessMessage = monitor.mqttSuccessMessage;
+ bean.mqttCheckType = monitor.mqttCheckType;
+ bean.databaseConnectionString = monitor.databaseConnectionString;
+ bean.databaseQuery = monitor.databaseQuery;
+ bean.authMethod = monitor.authMethod;
+ bean.authWorkstation = monitor.authWorkstation;
+ bean.authDomain = monitor.authDomain;
+ bean.grpcUrl = monitor.grpcUrl;
+ bean.grpcProtobuf = monitor.grpcProtobuf;
+ bean.grpcServiceName = monitor.grpcServiceName;
+ bean.grpcMethod = monitor.grpcMethod;
+ bean.grpcBody = monitor.grpcBody;
+ bean.grpcMetadata = monitor.grpcMetadata;
+ bean.grpcEnableTls = monitor.grpcEnableTls;
+ bean.radiusUsername = monitor.radiusUsername;
+ bean.radiusPassword = monitor.radiusPassword;
+ bean.radiusCalledStationId = monitor.radiusCalledStationId;
+ bean.radiusCallingStationId = monitor.radiusCallingStationId;
+ bean.radiusSecret = monitor.radiusSecret;
+ bean.httpBodyEncoding = monitor.httpBodyEncoding;
+ bean.expectedValue = monitor.expectedValue;
+ bean.jsonPath = monitor.jsonPath;
+ bean.kafkaProducerTopic = monitor.kafkaProducerTopic;
+ bean.kafkaProducerBrokers = JSON.stringify(monitor.kafkaProducerBrokers);
+ bean.kafkaProducerAllowAutoTopicCreation = monitor.kafkaProducerAllowAutoTopicCreation;
+ bean.kafkaProducerSaslOptions = JSON.stringify(monitor.kafkaProducerSaslOptions);
+ bean.kafkaProducerMessage = monitor.kafkaProducerMessage;
+ bean.cacheBust = monitor.cacheBust;
+ bean.kafkaProducerSsl = monitor.kafkaProducerSsl;
+ bean.kafkaProducerAllowAutoTopicCreation =
+ monitor.kafkaProducerAllowAutoTopicCreation;
+ bean.gamedigGivenPortOnly = monitor.gamedigGivenPortOnly;
+ bean.remote_browser = monitor.remote_browser;
+ bean.snmpVersion = monitor.snmpVersion;
+ bean.snmpOid = monitor.snmpOid;
+ bean.jsonPathOperator = monitor.jsonPathOperator;
+ bean.timeout = monitor.timeout;
+ bean.rabbitmqNodes = JSON.stringify(monitor.rabbitmqNodes);
+ bean.rabbitmqUsername = monitor.rabbitmqUsername;
+ bean.rabbitmqPassword = monitor.rabbitmqPassword;
+ bean.conditions = JSON.stringify(monitor.conditions);
+
+ bean.validate();
+
+ await R.store(bean);
+
+ if (removeGroupChildren) {
+ await Monitor.unlinkAllChildren(monitor.id);
+ }
+
+ await updateMonitorNotification(bean.id, monitor.notificationIDList);
+
+ if (await Monitor.isActive(bean.id, bean.active)) {
+ await restartMonitor(socket.userID, bean.id);
+ }
+
+ await server.sendUpdateMonitorIntoList(socket, bean.id);
+
+ callback({
+ ok: true,
+ msg: "Saved.",
+ msgi18n: true,
+ monitorID: bean.id,
+ });
+
+ } catch (e) {
+ log.error("monitor", e);
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("getMonitorList", async (callback) => {
+ try {
+ checkLogin(socket);
+ await server.sendMonitorList(socket);
+ callback({
+ ok: true,
+ });
+ } catch (e) {
+ log.error("monitor", e);
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("getMonitor", async (monitorID, callback) => {
+ try {
+ checkLogin(socket);
+
+ log.info("monitor", `Get Monitor: ${monitorID} User ID: ${socket.userID}`);
+
+ let monitor = await R.findOne("monitor", " id = ? AND user_id = ? ", [
+ monitorID,
+ socket.userID,
+ ]);
+ const monitorData = [{ id: monitor.id,
+ active: monitor.active
+ }];
+ const preloadData = await Monitor.preparePreloadData(monitorData);
+ callback({
+ ok: true,
+ monitor: monitor.toJSON(preloadData),
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("getMonitorBeats", async (monitorID, period, callback) => {
+ try {
+ checkLogin(socket);
+
+ log.info("monitor", `Get Monitor Beats: ${monitorID} User ID: ${socket.userID}`);
+
+ if (period == null) {
+ throw new Error("Invalid period.");
+ }
+
+ const sqlHourOffset = Database.sqlHourOffset();
+
+ let list = await R.getAll(`
+ SELECT *
+ FROM heartbeat
+ WHERE monitor_id = ?
+ AND time > ${sqlHourOffset}
+ ORDER BY time ASC
+ `, [
+ monitorID,
+ -period,
+ ]);
+
+ callback({
+ ok: true,
+ data: list,
+ });
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ // Start or Resume the monitor
+ socket.on("resumeMonitor", async (monitorID, callback) => {
+ try {
+ checkLogin(socket);
+ await startMonitor(socket.userID, monitorID);
+ await server.sendUpdateMonitorIntoList(socket, monitorID);
+
+ callback({
+ ok: true,
+ msg: "successResumed",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("pauseMonitor", async (monitorID, callback) => {
+ try {
+ checkLogin(socket);
+ await pauseMonitor(socket.userID, monitorID);
+ await server.sendUpdateMonitorIntoList(socket, monitorID);
+
+ callback({
+ ok: true,
+ msg: "successPaused",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("deleteMonitor", async (monitorID, callback) => {
+ try {
+ checkLogin(socket);
+
+ log.info("manage", `Delete Monitor: ${monitorID} User ID: ${socket.userID}`);
+
+ if (monitorID in server.monitorList) {
+ await server.monitorList[monitorID].stop();
+ delete server.monitorList[monitorID];
+ }
+
+ const startTime = Date.now();
+
+ await R.exec("DELETE FROM monitor WHERE id = ? AND user_id = ? ", [
+ monitorID,
+ socket.userID,
+ ]);
+
+ // Fix #2880
+ apicache.clear();
+
+ const endTime = Date.now();
+
+ log.info("DB", `Delete Monitor completed in : ${endTime - startTime} ms`);
+
+ callback({
+ ok: true,
+ msg: "successDeleted",
+ msgi18n: true,
+ });
+ await server.sendDeleteMonitorFromList(socket, monitorID);
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("getTags", async (callback) => {
+ try {
+ checkLogin(socket);
+
+ const list = await R.findAll("tag");
+
+ callback({
+ ok: true,
+ tags: list.map(bean => bean.toJSON()),
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("addTag", async (tag, callback) => {
+ try {
+ checkLogin(socket);
+
+ let bean = R.dispense("tag");
+ bean.name = tag.name;
+ bean.color = tag.color;
+ await R.store(bean);
+
+ callback({
+ ok: true,
+ tag: await bean.toJSON(),
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("editTag", async (tag, callback) => {
+ try {
+ checkLogin(socket);
+
+ let bean = await R.findOne("tag", " id = ? ", [ tag.id ]);
+ if (bean == null) {
+ callback({
+ ok: false,
+ msg: "tagNotFound",
+ msgi18n: true,
+ });
+ return;
+ }
+ bean.name = tag.name;
+ bean.color = tag.color;
+ await R.store(bean);
+
+ callback({
+ ok: true,
+ msg: "Saved.",
+ msgi18n: true,
+ tag: await bean.toJSON(),
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("deleteTag", async (tagID, callback) => {
+ try {
+ checkLogin(socket);
+
+ await R.exec("DELETE FROM tag WHERE id = ? ", [ tagID ]);
+
+ callback({
+ ok: true,
+ msg: "successDeleted",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("addMonitorTag", async (tagID, monitorID, value, callback) => {
+ try {
+ checkLogin(socket);
+
+ await R.exec("INSERT INTO monitor_tag (tag_id, monitor_id, value) VALUES (?, ?, ?)", [
+ tagID,
+ monitorID,
+ value,
+ ]);
+
+ callback({
+ ok: true,
+ msg: "successAdded",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("editMonitorTag", async (tagID, monitorID, value, callback) => {
+ try {
+ checkLogin(socket);
+
+ await R.exec("UPDATE monitor_tag SET value = ? WHERE tag_id = ? AND monitor_id = ?", [
+ value,
+ tagID,
+ monitorID,
+ ]);
+
+ callback({
+ ok: true,
+ msg: "successEdited",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("deleteMonitorTag", async (tagID, monitorID, value, callback) => {
+ try {
+ checkLogin(socket);
+
+ await R.exec("DELETE FROM monitor_tag WHERE tag_id = ? AND monitor_id = ? AND value = ?", [
+ tagID,
+ monitorID,
+ value,
+ ]);
+
+ callback({
+ ok: true,
+ msg: "successDeleted",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("monitorImportantHeartbeatListCount", async (monitorID, callback) => {
+ try {
+ checkLogin(socket);
+
+ let count;
+ if (monitorID == null) {
+ count = await R.count("heartbeat", "important = 1");
+ } else {
+ count = await R.count("heartbeat", "monitor_id = ? AND important = 1", [
+ monitorID,
+ ]);
+ }
+
+ callback({
+ ok: true,
+ count: count,
+ });
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("monitorImportantHeartbeatListPaged", async (monitorID, offset, count, callback) => {
+ try {
+ checkLogin(socket);
+
+ let list;
+ if (monitorID == null) {
+ list = await R.find("heartbeat", `
+ important = 1
+ ORDER BY time DESC
+ LIMIT ?
+ OFFSET ?
+ `, [
+ count,
+ offset,
+ ]);
+ } else {
+ list = await R.find("heartbeat", `
+ monitor_id = ?
+ AND important = 1
+ ORDER BY time DESC
+ LIMIT ?
+ OFFSET ?
+ `, [
+ monitorID,
+ count,
+ offset,
+ ]);
+ }
+
+ callback({
+ ok: true,
+ data: list,
+ });
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("changePassword", async (password, callback) => {
+ try {
+ checkLogin(socket);
+
+ if (!password.newPassword) {
+ throw new Error("Invalid new password");
+ }
+
+ if (passwordStrength(password.newPassword).value === "Too weak") {
+ throw new Error("Password is too weak. It should contain alphabetic and numeric characters. It must be at least 6 characters in length.");
+ }
+
+ let user = await doubleCheckPassword(socket, password.currentPassword);
+ await user.resetPassword(password.newPassword);
+
+ server.disconnectAllSocketClients(user.id, socket.id);
+
+ callback({
+ ok: true,
+ token: User.createJWT(user, server.jwtSecret),
+ msg: "successAuthChangePassword",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("getSettings", async (callback) => {
+ try {
+ checkLogin(socket);
+ const data = await getSettings("general");
+
+ if (!data.serverTimezone) {
+ data.serverTimezone = await server.getTimezone();
+ }
+
+ callback({
+ ok: true,
+ data: data,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("setSettings", async (data, currentPassword, callback) => {
+ try {
+ checkLogin(socket);
+
+ // If currently is disabled auth, don't need to check
+ // Disabled Auth + Want to Disable Auth => No Check
+ // Disabled Auth + Want to Enable Auth => No Check
+ // Enabled Auth + Want to Disable Auth => Check!!
+ // Enabled Auth + Want to Enable Auth => No Check
+ const currentDisabledAuth = await setting("disableAuth");
+ if (!currentDisabledAuth && data.disableAuth) {
+ await doubleCheckPassword(socket, currentPassword);
+ }
+
+ // Log out all clients if enabling auth
+ // GHSA-23q2-5gf8-gjpp
+ if (currentDisabledAuth && !data.disableAuth) {
+ server.disconnectAllSocketClients(socket.userID, socket.id);
+ }
+
+ const previousChromeExecutable = await Settings.get("chromeExecutable");
+ const previousNSCDStatus = await Settings.get("nscd");
+
+ await setSettings("general", data);
+ server.entryPage = data.entryPage;
+
+ // Also need to apply timezone globally
+ if (data.serverTimezone) {
+ await server.setTimezone(data.serverTimezone);
+ }
+
+ // If Chrome Executable is changed, need to reset the browser
+ if (previousChromeExecutable !== data.chromeExecutable) {
+ log.info("settings", "Chrome executable is changed. Resetting Chrome...");
+ await resetChrome();
+ }
+
+ // Update nscd status
+ if (previousNSCDStatus !== data.nscd) {
+ if (data.nscd) {
+ await server.startNSCDServices();
+ } else {
+ await server.stopNSCDServices();
+ }
+ }
+
+ callback({
+ ok: true,
+ msg: "Saved.",
+ msgi18n: true,
+ });
+
+ await sendInfo(socket);
+ await server.sendMaintenanceList(socket);
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ // Add or Edit
+ socket.on("addNotification", async (notification, notificationID, callback) => {
+ try {
+ checkLogin(socket);
+
+ let notificationBean = await Notification.save(notification, notificationID, socket.userID);
+ await sendNotificationList(socket);
+
+ callback({
+ ok: true,
+ msg: "Saved.",
+ msgi18n: true,
+ id: notificationBean.id,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("deleteNotification", async (notificationID, callback) => {
+ try {
+ checkLogin(socket);
+
+ await Notification.delete(notificationID, socket.userID);
+ await sendNotificationList(socket);
+
+ callback({
+ ok: true,
+ msg: "successDeleted",
+ msgi18n: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("testNotification", async (notification, callback) => {
+ try {
+ checkLogin(socket);
+
+ let msg = await Notification.send(notification, notification.name + " Testing");
+
+ callback({
+ ok: true,
+ msg,
+ });
+
+ } catch (e) {
+ console.error(e);
+
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("checkApprise", async (callback) => {
+ try {
+ checkLogin(socket);
+ callback(Notification.checkApprise());
+ } catch (e) {
+ callback(false);
+ }
+ });
+
+ socket.on("clearEvents", async (monitorID, callback) => {
+ try {
+ checkLogin(socket);
+
+ log.info("manage", `Clear Events Monitor: ${monitorID} User ID: ${socket.userID}`);
+
+ await R.exec("UPDATE heartbeat SET msg = ?, important = ? WHERE monitor_id = ? ", [
+ "",
+ "0",
+ monitorID,
+ ]);
+
+ callback({
+ ok: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("clearHeartbeats", async (monitorID, callback) => {
+ try {
+ checkLogin(socket);
+
+ log.info("manage", `Clear Heartbeats Monitor: ${monitorID} User ID: ${socket.userID}`);
+
+ await R.exec("DELETE FROM heartbeat WHERE monitor_id = ?", [
+ monitorID
+ ]);
+
+ await sendHeartbeatList(socket, monitorID, true, true);
+
+ callback({
+ ok: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ socket.on("clearStatistics", async (callback) => {
+ try {
+ checkLogin(socket);
+
+ log.info("manage", `Clear Statistics User ID: ${socket.userID}`);
+
+ await R.exec("DELETE FROM heartbeat");
+ await R.exec("DELETE FROM stat_daily");
+ await R.exec("DELETE FROM stat_hourly");
+ await R.exec("DELETE FROM stat_minutely");
+
+ // Restart all monitors to reset the stats
+ for (let monitorID in server.monitorList) {
+ await restartMonitor(socket.userID, monitorID);
+ }
+
+ callback({
+ ok: true,
+ });
+
+ } catch (e) {
+ callback({
+ ok: false,
+ msg: e.message,
+ });
+ }
+ });
+
+ // Status Page Socket Handler for admin only
+ statusPageSocketHandler(socket);
+ cloudflaredSocketHandler(socket);
+ databaseSocketHandler(socket);
+ proxySocketHandler(socket);
+ dockerSocketHandler(socket);
+ maintenanceSocketHandler(socket);
+ apiKeySocketHandler(socket);
+ remoteBrowserSocketHandler(socket);
+ generalSocketHandler(socket, server);
+ chartSocketHandler(socket);
+
+ log.debug("server", "added all socket handlers");
+
+ // ***************************
+ // Better do anything after added all socket handlers here
+ // ***************************
+
+ log.debug("auth", "check auto login");
+ if (await setting("disableAuth")) {
+ log.info("auth", "Disabled Auth: auto login to admin");
+ await afterLogin(socket, await R.findOne("user"));
+ socket.emit("autoLogin");
+ } else {
+ socket.emit("loginRequired");
+ log.debug("auth", "need auth");
+ }
+
+ });
+
+ log.debug("server", "Init the server");
+
+ server.httpServer.once("error", async (err) => {
+ log.error("server", "Cannot listen: " + err.message);
+ await shutdownFunction();
+ process.exit(1);
+ });
+
+ await server.start();
+
+ server.httpServer.listen(port, hostname, async () => {
+ if (hostname) {
+ log.info("server", `Listening on ${hostname}:${port}`);
+ } else {
+ log.info("server", `Listening on ${port}`);
+ }
+ await startMonitors();
+
+ // Put this here. Start background jobs after the db and server is ready to prevent clear up during db migration.
+ await initBackgroundJobs();
+
+ checkVersion.startInterval();
+ });
+
+ // Start cloudflared at the end if configured
+ await cloudflaredAutoStart(cloudflaredToken);
+
+})();
+
+/**
+ * Update notifications for a given monitor
+ * @param {number} monitorID ID of monitor to update
+ * @param {number[]} notificationIDList List of new notification
+ * providers to add
+ * @returns {Promise<void>}
+ */
+async function updateMonitorNotification(monitorID, notificationIDList) {
+ await R.exec("DELETE FROM monitor_notification WHERE monitor_id = ? ", [
+ 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);
+ }
+ }
+}
+
+/**
+ * Check if a given user owns a specific monitor
+ * @param {number} userID ID of user to check
+ * @param {number} monitorID ID of monitor to check
+ * @returns {Promise<void>}
+ * @throws {Error} The specified user does not own the monitor
+ */
+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.");
+ }
+}
+
+/**
+ * Function called after user login
+ * This function is used to send the heartbeat list of a monitor.
+ * @param {Socket} socket Socket.io instance
+ * @param {object} user User object
+ * @returns {Promise<void>}
+ */
+async function afterLogin(socket, user) {
+ socket.userID = user.id;
+ socket.join(user.id);
+
+ let monitorList = await server.sendMonitorList(socket);
+ await Promise.allSettled([
+ sendInfo(socket),
+ server.sendMaintenanceList(socket),
+ sendNotificationList(socket),
+ sendProxyList(socket),
+ sendDockerHostList(socket),
+ sendAPIKeyList(socket),
+ sendRemoteBrowserList(socket),
+ sendMonitorTypeList(socket),
+ ]);
+
+ await StatusPage.sendStatusPageList(io, socket);
+
+ const monitorPromises = [];
+ for (let monitorID in monitorList) {
+ monitorPromises.push(sendHeartbeatList(socket, monitorID));
+ monitorPromises.push(Monitor.sendStats(io, monitorID, user.id));
+ }
+
+ await Promise.all(monitorPromises);
+
+ // Set server timezone from client browser if not set
+ // It should be run once only
+ if (! await Settings.get("initServerTimezone")) {
+ log.debug("server", "emit initServerTimezone");
+ socket.emit("initServerTimezone");
+ }
+}
+
+/**
+ * Initialize the database
+ * @param {boolean} testMode Should the connection be
+ * started in test mode?
+ * @returns {Promise<void>}
+ */
+async function initDatabase(testMode = false) {
+ log.debug("server", "Connecting to the database");
+ await Database.connect(testMode);
+ log.info("server", "Connected to the database");
+
+ // Patch the database
+ await Database.patch(port, hostname);
+
+ let jwtSecretBean = await R.findOne("setting", " `key` = ? ", [
+ "jwtSecret",
+ ]);
+
+ if (! jwtSecretBean) {
+ log.info("server", "JWT secret is not found, generate one.");
+ jwtSecretBean = await initJWTSecret();
+ log.info("server", "Stored JWT secret into database");
+ } else {
+ log.debug("server", "Load JWT secret from database.");
+ }
+
+ // If there is no record in user table, it is a new Uptime Kuma instance, need to setup
+ if ((await R.knex("user").count("id as count").first()).count === 0) {
+ log.info("server", "No user, need setup");
+ needSetup = true;
+ }
+
+ server.jwtSecret = jwtSecretBean.value;
+}
+
+/**
+ * Start the specified monitor
+ * @param {number} userID ID of user who owns monitor
+ * @param {number} monitorID ID of monitor to start
+ * @returns {Promise<void>}
+ */
+async function startMonitor(userID, monitorID) {
+ await checkOwner(userID, monitorID);
+
+ log.info("manage", `Resume Monitor: ${monitorID} User ID: ${userID}`);
+
+ await R.exec("UPDATE monitor SET active = 1 WHERE id = ? AND user_id = ? ", [
+ monitorID,
+ userID,
+ ]);
+
+ let monitor = await R.findOne("monitor", " id = ? ", [
+ monitorID,
+ ]);
+
+ if (monitor.id in server.monitorList) {
+ await server.monitorList[monitor.id].stop();
+ }
+
+ server.monitorList[monitor.id] = monitor;
+ await monitor.start(io);
+}
+
+/**
+ * Restart a given monitor
+ * @param {number} userID ID of user who owns monitor
+ * @param {number} monitorID ID of monitor to start
+ * @returns {Promise<void>}
+ */
+async function restartMonitor(userID, monitorID) {
+ return await startMonitor(userID, monitorID);
+}
+
+/**
+ * Pause a given monitor
+ * @param {number} userID ID of user who owns monitor
+ * @param {number} monitorID ID of monitor to start
+ * @returns {Promise<void>}
+ */
+async function pauseMonitor(userID, monitorID) {
+ await checkOwner(userID, monitorID);
+
+ log.info("manage", `Pause Monitor: ${monitorID} User ID: ${userID}`);
+
+ await R.exec("UPDATE monitor SET active = 0 WHERE id = ? AND user_id = ? ", [
+ monitorID,
+ userID,
+ ]);
+
+ if (monitorID in server.monitorList) {
+ await server.monitorList[monitorID].stop();
+ server.monitorList[monitorID].active = 0;
+ }
+}
+
+/**
+ * Resume active monitors
+ * @returns {Promise<void>}
+ */
+async function startMonitors() {
+ let list = await R.find("monitor", " active = 1 ");
+
+ for (let monitor of list) {
+ server.monitorList[monitor.id] = monitor;
+ }
+
+ for (let monitor of list) {
+ try {
+ await monitor.start(io);
+ } catch (e) {
+ log.error("monitor", e);
+ }
+ // Give some delays, so all monitors won't make request at the same moment when just start the server.
+ await sleep(getRandomInt(300, 1000));
+ }
+}
+
+/**
+ * Shutdown the application
+ * Stops all monitors and closes the database connection.
+ * @param {string} signal The signal that triggered this function to be called.
+ * @returns {Promise<void>}
+ */
+async function shutdownFunction(signal) {
+ log.info("server", "Shutdown requested");
+ log.info("server", "Called signal: " + signal);
+
+ await server.stop();
+
+ log.info("server", "Stopping all monitors");
+ for (let id in server.monitorList) {
+ let monitor = server.monitorList[id];
+ await monitor.stop();
+ }
+ await sleep(2000);
+ await Database.close();
+
+ if (EmbeddedMariaDB.hasInstance()) {
+ EmbeddedMariaDB.getInstance().stop();
+ }
+
+ stopBackgroundJobs();
+ await cloudflaredStop();
+ Settings.stopCacheCleaner();
+}
+
+/**
+ * Final function called before application exits
+ * @returns {void}
+ */
+function finalFunction() {
+ log.info("server", "Graceful shutdown successful!");
+}
+
+gracefulShutdown(server.httpServer, {
+ signals: "SIGINT SIGTERM",
+ 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, ...
+ finally: finalFunction, // finally function (sync) - e.g. for logging
+});
+
+// Catch unexpected errors here
+let unexpectedErrorHandler = (error, promise) => {
+ console.trace(error);
+ UptimeKumaServer.errorLog(error, false);
+ console.error("If you keep encountering errors, please report to https://github.com/louislam/uptime-kuma/issues");
+};
+process.addListener("unhandledRejection", unexpectedErrorHandler);
+process.addListener("uncaughtException", unexpectedErrorHandler);
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 20:15:48 +0100