uptime-kuma/server/server.js

1890 lines
65 KiB
JavaScript
Raw Normal View History

/*
* Uptime Kuma Server
* node "server/server.js"
* DO NOT require("./server") in other modules, it likely creates circular dependency!
*/
2021-08-08 09:03:10 -04:00
console.log("Welcome to Uptime Kuma");
2022-10-09 08:59:58 -04:00
// As the log function need to use dayjs, it should be very top
const dayjs = require("dayjs");
dayjs.extend(require("dayjs/plugin/utc"));
2022-12-15 00:39:48 -05:00
dayjs.extend(require("./modules/dayjs/plugin/timezone"));
dayjs.extend(require("dayjs/plugin/customParseFormat"));
2022-10-09 08:59:58 -04:00
2023-02-01 07:07:08 -05:00
// 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 = " < 14 || 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(", ");
2023-05-26 06:08:52 -04:00
// 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}.`);
}
2021-10-09 14:36:20 -04:00
const args = require("args-parser")(process.argv);
2022-05-31 11:06:43 -04:00
const { sleep, log, getRandomInt, genSecret, isDev } = require("../src/util");
2021-10-15 12:57:26 -04:00
const config = require("./config");
2021-10-09 14:36:20 -04:00
log.info("server", "Welcome to Uptime Kuma");
log.debug("server", "Arguments");
log.debug("server", args);
if (! process.env.NODE_ENV) {
process.env.NODE_ENV = "production";
}
log.info("server", "Node Env: " + process.env.NODE_ENV);
2023-08-07 15:10:21 -04:00
log.info("server", "Inside Container: " + (process.env.UPTIME_KUMA_IS_CONTAINER === "1"));
2021-07-31 09:57:58 -04:00
log.info("server", "Importing Node libraries");
2021-07-31 09:57:58 -04:00
const fs = require("fs");
log.info("server", "Importing 3rd-party libraries");
log.debug("server", "Importing express");
2021-07-31 09:57:58 -04:00
const express = require("express");
const expressStaticGzip = require("express-static-gzip");
log.debug("server", "Importing redbean-node");
2021-07-27 13:47:13 -04:00
const { R } = require("redbean-node");
log.debug("server", "Importing jsonwebtoken");
2021-07-27 13:47:13 -04:00
const jwt = require("jsonwebtoken");
log.debug("server", "Importing http-graceful-shutdown");
2021-07-27 13:47:13 -04:00
const gracefulShutdown = require("http-graceful-shutdown");
log.debug("server", "Importing prometheus-api-metrics");
2021-07-27 13:47:13 -04:00
const prometheusAPIMetrics = require("prometheus-api-metrics");
log.debug("server", "Importing compare-versions");
2021-09-23 11:31:01 -04:00
const compareVersions = require("compare-versions");
2021-10-21 10:54:04 -04:00
const { passwordStrength } = require("check-password-strength");
2021-07-31 09:57:58 -04:00
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(args);
const io = module.exports.io = server.io;
const app = server.app;
2022-04-07 10:53:32 -04:00
log.info("server", "Importing this project modules");
log.debug("server", "Importing Monitor");
2021-07-31 09:57:58 -04:00
const Monitor = require("./model/monitor");
log.debug("server", "Importing Settings");
2022-06-16 05:28:17 -04:00
const { getSettings, setSettings, setting, initJWTSecret, checkLogin, startUnitTest, FBSD, doubleCheckPassword, startE2eTests } = require("./util-server");
2021-09-07 10:42:46 -04:00
log.debug("server", "Importing Notification");
2021-07-31 09:57:58 -04:00
const { Notification } = require("./notification");
2021-09-07 10:42:46 -04:00
Notification.init();
log.debug("server", "Importing Proxy");
const { Proxy } = require("./proxy");
log.debug("server", "Importing Database");
2021-07-31 09:57:58 -04:00
const Database = require("./database");
log.debug("server", "Importing Background Jobs");
const { initBackgroundJobs, stopBackgroundJobs } = require("./jobs");
2022-03-29 05:38:48 -04:00
const { loginRateLimiter, twoFaRateLimiter } = require("./rate-limiter");
const { apiAuth } = 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
2021-08-21 07:50:22 -04:00
const checkVersion = require("./check-version");
log.info("server", "Version: " + checkVersion.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 (::)
2022-01-11 12:44:01 -05:00
// Also read HOST if not FreeBSD, as HOST is a system environment variable in FreeBSD
let hostEnv = FBSD ? null : process.env.HOST;
let hostname = args.host || process.env.UPTIME_KUMA_HOST || hostEnv;
if (hostname) {
log.info("server", "Custom hostname: " + hostname);
}
2022-04-17 03:27:35 -04:00
const port = [ args.port, process.env.UPTIME_KUMA_PORT, process.env.PORT, 3001 ]
.map(portValue => parseInt(portValue))
.find(portValue => !isNaN(portValue));
2021-06-25 09:55:49 -04:00
2021-10-19 04:29:09 -04:00
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;
2021-09-02 08:18:27 -04:00
2021-10-11 14:18:40 -04:00
// 2FA / notp verification defaults
const twoFAVerifyOptions = {
2021-10-11 14:18:40 -04:00
"window": 1,
"time": 30
2021-10-18 05:15:28 -04:00
};
2021-09-02 08:18:27 -04:00
/**
* Run unit test after the server is ready
* @type {boolean}
*/
const testMode = !!args["test"] || false;
2022-06-16 05:28:17 -04:00
const e2eTestMode = !!args["e2e"] || false;
2021-09-02 10:37:51 -04:00
2021-10-15 12:57:26 -04:00
if (config.demoMode) {
log.info("server", "==== Demo Mode ====");
2021-09-02 08:18:27 -04:00
}
// Must be after io instantiation
const { sendNotificationList, sendHeartbeatList, sendImportantHeartbeatList, sendInfo, sendProxyList, sendDockerHostList, sendAPIKeyList } = require("./client");
2021-09-16 10:48:28 -04:00
const { statusPageSocketHandler } = require("./socket-handlers/status-page-socket-handler");
const databaseSocketHandler = require("./socket-handlers/database-socket-handler");
2021-11-18 05:22:03 -05:00
const TwoFA = require("./2fa");
2022-03-10 08:34:30 -05:00
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");
2022-12-12 09:57:57 -05:00
const { generalSocketHandler } = require("./socket-handlers/general-socket-handler");
2022-10-08 11:56:58 -04:00
const { Settings } = require("./settings");
2022-12-12 04:19:22 -05:00
const { CacheableDnsHttpAgent } = require("./cacheable-dns-http-agent");
2023-03-05 02:59:43 -05:00
const apicache = require("./modules/apicache");
2023-06-27 03:54:33 -04:00
const { resetChrome } = require("./monitor-types/real-browser-monitor-type");
app.use(express.json());
2021-07-09 07:33:22 -04:00
2021-10-19 02:26:10 -04:00
// Global Middleware
app.use(function (req, res, next) {
2021-10-19 04:29:09 -04:00
if (!disableFrameSameOrigin) {
res.setHeader("X-Frame-Options", "SAMEORIGIN");
}
2021-10-19 02:26:10 -04:00
res.removeHeader("X-Powered-By");
next();
});
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
(async () => {
2021-09-20 04:29:18 -04:00
Database.init(args);
await initDatabase(testMode);
2022-10-09 08:59:58 -04:00
await server.initAfterDatabaseReady();
2022-10-08 11:56:58 -04:00
server.entryPage = await Settings.get("entryPage");
2022-04-06 10:43:22 -04:00
await StatusPage.loadDomainMappingList();
2021-07-27 12:52:31 -04:00
log.info("server", "Adding route");
2021-07-27 12:52:31 -04:00
2021-09-11 07:40:03 -04:00
// ***************************
2021-07-27 12:52:31 -04:00
// Normal Router here
2021-09-11 07:40:03 -04:00
// ***************************
2021-07-27 12:52:31 -04:00
// Entry Page
2022-04-06 10:43:22 -04:00
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}`);
2022-04-06 10:43:22 -04:00
2022-10-08 11:56:58 -04:00
const uptimeKumaEntryPage = server.entryPage;
if (hostname in StatusPage.domainMappingList) {
2022-05-30 03:45:44 -04:00
log.debug("entry", "This is a status page domain");
let slug = StatusPage.domainMappingList[hostname];
2022-05-30 03:45:44 -04:00
await StatusPage.handleStatusPageResponse(response, server.indexHTML, slug);
2022-10-03 11:01:52 -04:00
} else if (uptimeKumaEntryPage && uptimeKumaEntryPage.startsWith("statusPage-")) {
response.redirect("/status/" + uptimeKumaEntryPage.replace("statusPage-", ""));
2022-05-30 03:45:44 -04:00
} else {
response.redirect("/dashboard");
}
});
2022-04-17 07:30:58 -04:00
if (isDev) {
app.use(express.urlencoded({ extended: true }));
2022-04-17 07:30:58 -04:00
app.post("/test-webhook", async (request, response) => {
log.debug("test", request.headers);
2022-04-17 07:30:58 -04:00
log.debug("test", request.body);
response.send("OK");
});
}
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")) {
2021-08-09 06:16:27 -04:00
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
app.get("/metrics", apiAuth, prometheusAPIMetrics());
2021-08-09 06:16:27 -04:00
app.use("/", expressStaticGzip("dist", {
enableBrotli: true,
}));
2021-07-22 03:22:15 -04:00
// ./data/upload
app.use("/upload", express.static(Database.uploadDir));
2021-09-14 00:10:25 -04:00
app.get("/.well-known/change-password", async (_, response) => {
response.redirect("https://github.com/louislam/uptime-kuma/wiki/Reset-Password-via-CLI");
});
2021-09-14 02:55:45 -04:00
// API Router
const apiRouter = require("./routers/api-router");
app.use(apiRouter);
2021-09-11 07:40:03 -04:00
2022-05-30 03:45:44 -04:00
// Status Page Router
const statusPageRouter = require("./routers/status-page-router");
app.use(statusPageRouter);
2021-10-19 02:26:10 -04:00
// Universal Route Handler, must be at the end of all express routes.
2021-08-09 06:16:27 -04:00
app.get("*", async (_request, response) => {
if (_request.originalUrl.startsWith("/upload/")) {
response.status(404).send("File not found.");
} else {
2022-05-30 03:45:44 -04:00
response.send(server.indexHTML);
}
2021-07-09 02:14:03 -04:00
});
log.info("server", "Adding socket handler");
2021-07-27 13:47:13 -04:00
io.on("connection", async (socket) => {
2021-07-13 06:08:12 -04:00
2023-07-14 06:02:49 -04:00
sendInfo(socket, true);
2021-07-13 06:08:12 -04:00
2021-07-11 01:47:57 -04:00
if (needSetup) {
log.info("server", "Redirect to setup page");
socket.emit("setup");
2021-07-11 01:47:57 -04:00
}
2021-07-29 23:33:44 -04:00
// ***************************
2021-09-11 07:40:03 -04:00
// Public Socket API
2021-07-29 23:33:44 -04:00
// ***************************
2021-06-25 09:55:49 -04:00
socket.on("loginByToken", async (token, callback) => {
2022-07-31 11:36:33 -04:00
const clientIP = await server.getClientIP(socket);
log.info("auth", `Login by token. IP=${clientIP}`);
2021-06-25 09:55:49 -04:00
try {
2023-06-27 03:54:33 -04:00
let decoded = jwt.verify(token, server.jwtSecret);
2021-06-25 09:55:49 -04:00
log.info("auth", "Username from JWT: " + decoded.username);
2021-06-25 09:55:49 -04:00
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) {
log.debug("auth", "afterLogin");
afterLogin(socket, user);
log.debug("auth", "afterLogin ok");
2021-06-25 09:55:49 -04:00
2022-07-31 11:36:33 -04:00
log.info("auth", `Successfully logged in user ${decoded.username}. IP=${clientIP}`);
2021-08-03 13:03:40 -04:00
2021-06-25 09:55:49 -04:00
callback({
ok: true,
});
2021-06-25 09:55:49 -04:00
} else {
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.info("auth", `Inactive or deleted user ${decoded.username}. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
2021-06-25 09:55:49 -04:00
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) {
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.error("auth", `Invalid token. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
2021-06-25 09:55:49 -04:00
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) => {
2022-07-31 11:36:33 -04:00
const clientIP = await server.getClientIP(socket);
log.info("auth", `Login by username + password. IP=${clientIP}`);
2021-06-25 09:55:49 -04:00
2022-03-29 05:38:48 -04:00
// Checking
if (typeof callback !== "function") {
return;
}
if (!data) {
return;
}
2021-06-25 09:55:49 -04:00
2021-10-23 04:35:13 -04:00
// Login Rate Limit
if (! await loginRateLimiter.pass(callback)) {
2022-07-31 11:36:33 -04:00
log.info("auth", `Too many failed requests for user ${data.username}. IP=${clientIP}`);
2021-10-23 04:35:13 -04:00
return;
}
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) {
2022-04-25 18:26:26 -04:00
if (user.twofa_status === 0) {
2021-10-29 14:35:05 -04:00
afterLogin(socket, user);
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.info("auth", `Successfully logged in user ${data.username}. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
ok: true,
token: jwt.sign({
username: data.username,
2023-06-27 03:54:33 -04:00
}, server.jwtSecret),
});
}
2022-04-25 18:26:26 -04:00
if (user.twofa_status === 1 && !data.token) {
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.info("auth", `2FA token required for user ${data.username}. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
tokenRequired: true,
});
}
if (data.token) {
let verify = notp.totp.verify(data.token, user.twofa_secret, twoFAVerifyOptions);
2021-10-18 18:42:33 -04:00
if (user.twofa_last_token !== data.token && verify) {
2021-10-29 14:35:05 -04:00
afterLogin(socket, user);
2021-10-18 18:42:33 -04:00
await R.exec("UPDATE `user` SET twofa_last_token = ? WHERE id = ? ", [
data.token,
socket.userID,
]);
2022-07-31 11:36:33 -04:00
log.info("auth", `Successfully logged in user ${data.username}. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
ok: true,
token: jwt.sign({
username: data.username,
2023-06-27 03:54:33 -04:00
}, server.jwtSecret),
});
} else {
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.warn("auth", `Invalid token provided for user ${data.username}. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
ok: false,
msg: "Invalid Token!",
});
}
}
2021-06-25 09:55:49 -04:00
} else {
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.warn("auth", `Incorrect username or password for user ${data.username}. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
2021-06-25 09:55:49 -04:00
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) => {
2022-03-29 05:38:48 -04:00
// Rate Limit
if (! await loginRateLimiter.pass(callback)) {
return;
}
socket.leave(socket.userID);
2021-06-25 09:55:49 -04:00
socket.userID = null;
2022-03-29 05:38:48 -04:00
if (typeof callback === "function") {
callback();
}
2021-07-11 01:47:57 -04:00
});
2022-03-29 05:38:48 -04:00
socket.on("prepare2FA", async (currentPassword, callback) => {
try {
2022-03-29 05:38:48 -04:00
if (! await twoFaRateLimiter.pass(callback)) {
return;
}
checkLogin(socket);
2022-03-29 05:38:48 -04:00
await doubleCheckPassword(socket, currentPassword);
let user = await R.findOne("user", " id = ? AND active = 1 ", [
socket.userID,
]);
2022-04-25 18:26:26 -04:00
if (user.twofa_status === 0) {
2021-10-18 05:37:11 -04:00
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, "");
2021-09-11 14:25:51 -04:00
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: "2FA is already enabled.",
});
}
} catch (error) {
callback({
ok: false,
2022-03-29 05:38:48 -04:00
msg: error.message,
});
}
});
2022-03-29 05:38:48 -04:00
socket.on("save2FA", async (currentPassword, callback) => {
2022-07-31 11:36:33 -04:00
const clientIP = await server.getClientIP(socket);
try {
2022-03-29 05:38:48 -04:00
if (! await twoFaRateLimiter.pass(callback)) {
return;
}
checkLogin(socket);
2022-03-29 05:38:48 -04:00
await doubleCheckPassword(socket, currentPassword);
await R.exec("UPDATE `user` SET twofa_status = 1 WHERE id = ? ", [
socket.userID,
]);
2022-07-31 11:36:33 -04:00
log.info("auth", `Saved 2FA token. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
ok: true,
msg: "2FA Enabled.",
});
} catch (error) {
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.error("auth", `Error changing 2FA token. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
ok: false,
2022-03-29 05:38:48 -04:00
msg: error.message,
});
}
});
2022-03-29 05:38:48 -04:00
socket.on("disable2FA", async (currentPassword, callback) => {
2022-07-31 11:36:33 -04:00
const clientIP = await server.getClientIP(socket);
try {
2022-03-29 05:38:48 -04:00
if (! await twoFaRateLimiter.pass(callback)) {
return;
}
checkLogin(socket);
2022-03-29 05:38:48 -04:00
await doubleCheckPassword(socket, currentPassword);
2021-11-18 05:22:03 -05:00
await TwoFA.disable2FA(socket.userID);
2022-07-31 11:36:33 -04:00
log.info("auth", `Disabled 2FA token. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
ok: true,
msg: "2FA Disabled.",
});
} catch (error) {
2021-11-11 06:31:28 -05:00
2022-07-31 11:36:33 -04:00
log.error("auth", `Error disabling 2FA token. IP=${clientIP}`);
2021-11-11 06:31:28 -05:00
callback({
ok: false,
2022-03-29 05:38:48 -04:00
msg: error.message,
});
}
});
2022-03-29 05:38:48 -04:00
socket.on("verifyToken", async (token, currentPassword, callback) => {
try {
checkLogin(socket);
await doubleCheckPassword(socket, currentPassword);
2022-03-29 05:38:48 -04:00
let user = await R.findOne("user", " id = ? AND active = 1 ", [
socket.userID,
]);
let verify = notp.totp.verify(token, user.twofa_secret, twoFAVerifyOptions);
2022-03-29 05:38:48 -04:00
if (user.twofa_last_token !== token && verify) {
callback({
ok: true,
valid: true,
});
} else {
callback({
ok: false,
msg: "Invalid Token.",
valid: false,
});
}
} catch (error) {
callback({
ok: false,
2022-03-29 05:38:48 -04:00
msg: error.message,
});
}
});
socket.on("twoFAStatus", async (callback) => {
try {
2022-03-29 05:38:48 -04:00
checkLogin(socket);
let user = await R.findOne("user", " id = ? AND active = 1 ", [
socket.userID,
]);
2022-04-25 18:26:26 -04:00
if (user.twofa_status === 1) {
callback({
ok: true,
status: true,
});
} else {
callback({
ok: true,
status: false,
});
}
} catch (error) {
callback({
ok: false,
2022-03-29 05:38:48 -04:00
msg: error.message,
});
}
});
2021-07-11 01:47:57 -04:00
socket.on("needSetup", async (callback) => {
callback(needSetup);
});
socket.on("setup", async (username, password, callback) => {
try {
2021-10-21 10:54:04 -04:00
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.");
}
2021-07-11 01:47:57 -04:00
if ((await R.count("user")) !== 0) {
2021-10-18 16:35:47 -04:00
throw new Error("Uptime Kuma has been initialized. If you want to run setup again, please delete the database.");
2021-07-11 01:47:57 -04:00
}
let user = R.dispense("user");
2021-07-11 01:47:57 -04:00
user.username = username;
user.password = passwordHash.generate(password);
await R.store(user);
2021-07-11 01:47:57 -04:00
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;
// 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");
}
2021-08-06 14:10:38 -04:00
monitor.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
delete monitor.accepted_statuscodes;
✨ feat: added kafka producer (#3268) * ✨ feat: added kafka producer Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: eslint warn Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: typings and auth problems Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: better variable name to trrack disconnection Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: grouping Kafka Producer special settings into one template Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * ✨ feat: add kafka producer translations into `en.json` Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: disable close-on-select on kafka broker picker Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: `en.json` invalid json (conflict resolve) Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * Nostr dm notifications (#3051) * Add nostr DM notification provider * require crypto for node 18 compatibility * remove whitespace Co-authored-by: Frank Elsinga <frank@elsinga.de> * move closer to where it is used * simplify success or failure logic * don't clobber the non-alert msg * Update server/notification-providers/nostr.js Co-authored-by: Frank Elsinga <frank@elsinga.de> * polyfills required for node <= 18 * resolve linter warnings * missing comma --------- Co-authored-by: Frank Elsinga <frank@elsinga.de> * Drop nostr * Minor * Fix a bug of clone --------- Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> Co-authored-by: Frank Elsinga <frank@elsinga.de> Co-authored-by: Louis Lam <louislam@users.noreply.github.com>
2023-07-17 04:15:44 -04:00
monitor.kafkaProducerBrokers = JSON.stringify(monitor.kafkaProducerBrokers);
monitor.kafkaProducerSaslOptions = JSON.stringify(monitor.kafkaProducerSaslOptions);
bean.import(monitor);
bean.user_id = socket.userID;
2022-12-08 10:21:55 -05:00
bean.validate();
await R.store(bean);
2021-06-25 09:55:49 -04:00
await updateMonitorNotification(bean.id, notificationIDList);
2022-04-07 11:02:57 -04:00
await server.sendMonitorList(socket);
if (monitor.active !== false) {
await startMonitor(socket.userID, bean.id);
}
2021-06-27 04:10:55 -04:00
log.info("monitor", `Added Monitor: ${monitor.id} User ID: ${socket.userID}`);
2021-11-11 06:31:28 -05:00
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) {
2021-11-11 06:31:28 -05:00
log.error("monitor", `Error adding Monitor: ${monitor.id} User ID: ${socket.userID}`);
2021-11-11 06:31:28 -05:00
2021-06-27 04:10:55 -04:00
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 {
let removeGroupChildren = false;
checkLogin(socket);
2021-06-27 04:10:55 -04:00
let bean = await R.findOne("monitor", " id = ? ", [ monitor.id ]);
2021-06-27 04:10:55 -04:00
if (bean.user_id !== socket.userID) {
throw new Error("Permission denied.");
2021-06-27 04:10:55 -04:00
}
// 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 = this.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;
2022-01-23 09:22:57 -05:00
bean.resendInterval = monitor.resendInterval;
2021-07-01 02:03:06 -04:00
bean.hostname = monitor.hostname;
2023-01-08 03:22:36 -05:00
bean.game = monitor.game;
bean.maxretries = monitor.maxretries;
2022-06-21 10:33:09 -04:00
bean.port = parseInt(monitor.port);
2021-07-01 05:19:28 -04:00
bean.keyword = monitor.keyword;
2023-04-05 20:10:21 -04:00
bean.invertKeyword = monitor.invertKeyword;
2021-07-30 07:18:26 -04:00
bean.ignoreTls = monitor.ignoreTls;
bean.expiryNotification = monitor.expiryNotification;
2021-07-30 07:18:26 -04:00
bean.upsideDown = monitor.upsideDown;
bean.packetSize = monitor.packetSize;
2021-08-08 12:23:51 -04:00
bean.maxredirects = monitor.maxredirects;
bean.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
2021-08-22 18:05:48 -04:00
bean.dns_resolve_type = monitor.dns_resolve_type;
bean.dns_resolve_server = monitor.dns_resolve_server;
2021-09-30 12:09:43 -04:00
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;
2021-12-18 16:35:18 -05:00
bean.mqttUsername = monitor.mqttUsername;
2022-04-18 07:05:14 -04:00
bean.mqttPassword = monitor.mqttPassword;
2021-12-18 16:35:18 -05:00
bean.mqttTopic = monitor.mqttTopic;
bean.mqttSuccessMessage = monitor.mqttSuccessMessage;
2022-05-12 13:48:03 -04:00
bean.databaseConnectionString = monitor.databaseConnectionString;
bean.databaseQuery = monitor.databaseQuery;
2022-05-13 13:58:23 -04:00
bean.authMethod = monitor.authMethod;
bean.authWorkstation = monitor.authWorkstation;
bean.authDomain = monitor.authDomain;
2022-08-20 11:45:11 -04:00
bean.grpcUrl = monitor.grpcUrl;
bean.grpcProtobuf = monitor.grpcProtobuf;
2022-12-28 10:31:33 -05:00
bean.grpcServiceName = monitor.grpcServiceName;
bean.grpcMethod = monitor.grpcMethod;
bean.grpcBody = monitor.grpcBody;
bean.grpcMetadata = monitor.grpcMetadata;
bean.grpcEnableTls = monitor.grpcEnableTls;
2022-05-12 05:48:38 -04:00
bean.radiusUsername = monitor.radiusUsername;
bean.radiusPassword = monitor.radiusPassword;
bean.radiusCalledStationId = monitor.radiusCalledStationId;
bean.radiusCallingStationId = monitor.radiusCallingStationId;
bean.radiusSecret = monitor.radiusSecret;
2022-08-11 20:57:03 -04:00
bean.httpBodyEncoding = monitor.httpBodyEncoding;
✨ feat: json-query monitor added (#3253) * ✨ feat: json-query monitor added Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: import warning error Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: br tag and remove comment Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: supporting compare string with other types Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: switch to a better lib for json query Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: better description on json query and using `v-html` in jsonQueryDescription element to fix `a` tags Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: result variable in error message Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: typos in json query description Co-authored-by: Frank Elsinga <frank@elsinga.de> * 📝 docs: `HTTP(s) Json Query` added to monitor list in `README.md` Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: needed white space in `README.md` Co-authored-by: Frank Elsinga <frank@elsinga.de> * Nostr dm notifications (#3051) * Add nostr DM notification provider * require crypto for node 18 compatibility * remove whitespace Co-authored-by: Frank Elsinga <frank@elsinga.de> * move closer to where it is used * simplify success or failure logic * don't clobber the non-alert msg * Update server/notification-providers/nostr.js Co-authored-by: Frank Elsinga <frank@elsinga.de> * polyfills required for node <= 18 * resolve linter warnings * missing comma --------- Co-authored-by: Frank Elsinga <frank@elsinga.de> * Drop nostr * Rebuild package-lock.json * Lint --------- Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> Co-authored-by: Frank Elsinga <frank@elsinga.de> Co-authored-by: zappityzap <128872140+zappityzap@users.noreply.github.com> Co-authored-by: Louis Lam <louislam@users.noreply.github.com>
2023-07-13 11:37:26 -04:00
bean.expectedValue = monitor.expectedValue;
bean.jsonPath = monitor.jsonPath;
✨ feat: added kafka producer (#3268) * ✨ feat: added kafka producer Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: eslint warn Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: typings and auth problems Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: better variable name to trrack disconnection Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: grouping Kafka Producer special settings into one template Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * ✨ feat: add kafka producer translations into `en.json` Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: disable close-on-select on kafka broker picker Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * 🐛 fix: `en.json` invalid json (conflict resolve) Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> * Nostr dm notifications (#3051) * Add nostr DM notification provider * require crypto for node 18 compatibility * remove whitespace Co-authored-by: Frank Elsinga <frank@elsinga.de> * move closer to where it is used * simplify success or failure logic * don't clobber the non-alert msg * Update server/notification-providers/nostr.js Co-authored-by: Frank Elsinga <frank@elsinga.de> * polyfills required for node <= 18 * resolve linter warnings * missing comma --------- Co-authored-by: Frank Elsinga <frank@elsinga.de> * Drop nostr * Minor * Fix a bug of clone --------- Signed-off-by: Muhammed Hussein Karimi <info@karimi.dev> Co-authored-by: Frank Elsinga <frank@elsinga.de> Co-authored-by: Louis Lam <louislam@users.noreply.github.com>
2023-07-17 04:15:44 -04:00
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.gamedigGivenPortOnly = monitor.gamedigGivenPortOnly;
2021-06-27 04:10:55 -04:00
2022-12-08 10:21:55 -05:00
bean.validate();
await R.store(bean);
2021-06-27 04:10:55 -04:00
if (removeGroupChildren) {
await Monitor.unlinkAllChildren(monitor.id);
}
await updateMonitorNotification(bean.id, monitor.notificationIDList);
if (bean.isActive()) {
await restartMonitor(socket.userID, bean.id);
2021-06-27 04:10:55 -04:00
}
2022-04-07 11:02:57 -04:00
await server.sendMonitorList(socket);
2021-06-25 09:55:49 -04:00
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) {
log.error("monitor", 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("getMonitorList", async (callback) => {
try {
checkLogin(socket);
2022-04-07 11:02:57 -04:00
await server.sendMonitorList(socket);
callback({
ok: true,
});
} catch (e) {
log.error("monitor", e);
callback({
ok: false,
msg: e.message,
});
}
});
2021-06-25 09:55:49 -04:00
socket.on("getMonitor", async (monitorID, callback) => {
try {
checkLogin(socket);
2021-06-25 09:55:49 -04:00
log.info("monitor", `Get Monitor: ${monitorID} User ID: ${socket.userID}`);
2021-06-25 09:55:49 -04:00
let bean = await R.findOne("monitor", " id = ? AND user_id = ? ", [
monitorID,
socket.userID,
]);
2021-06-25 09:55:49 -04:00
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
});
}
});
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.");
}
let list = await R.getAll(`
SELECT * FROM heartbeat
WHERE monitor_id = ? AND
time > DATETIME('now', '-' || ? || ' hours')
ORDER BY time ASC
`, [
monitorID,
period,
]);
callback({
ok: true,
data: list,
});
} catch (e) {
callback({
ok: false,
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);
2021-06-25 09:55:49 -04:00
await startMonitor(socket.userID, monitorID);
2022-04-07 11:02:57 -04:00
await server.sendMonitorList(socket);
2021-06-25 09:55:49 -04:00
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);
2022-04-07 11:02:57 -04:00
await server.sendMonitorList(socket);
2021-06-25 09:55:49 -04:00
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);
2021-06-25 09:55:49 -04:00
log.info("manage", `Delete Monitor: ${monitorID} User ID: ${socket.userID}`);
2021-06-25 09:55:49 -04:00
2022-04-07 10:53:32 -04:00
if (monitorID in server.monitorList) {
server.monitorList[monitorID].stop();
delete server.monitorList[monitorID];
2021-06-25 09:55:49 -04:00
}
const startTime = Date.now();
2021-06-25 09:55:49 -04:00
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
]);
2023-03-05 02:59:43 -05:00
// Fix #2880
apicache.clear();
const endTime = Date.now();
log.info("DB", `Delete Monitor completed in : ${endTime - startTime} ms`);
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
});
2022-04-07 11:02:57 -04:00
await server.sendMonitorList(socket);
// Clear heartbeat list on client
await sendImportantHeartbeatList(socket, monitorID, true, true);
2021-06-25 09:55:49 -04:00
} 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: "Tag not found",
});
return;
}
bean.name = tag.name;
bean.color = tag.color;
await R.store(bean);
callback({
ok: true,
msg: "Saved",
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: "Deleted Successfully.",
});
} 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: "Added Successfully.",
});
} 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: "Edited Successfully.",
});
} 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: "Deleted Successfully.",
});
} catch (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("changePassword", async (password, callback) => {
try {
checkLogin(socket);
2021-06-25 09:55:49 -04:00
2021-10-21 10:54:04 -04:00
if (! password.newPassword) {
throw new Error("Invalid new password");
2021-06-25 09:55:49 -04:00
}
2021-10-21 10:54:04 -04:00
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.");
}
2022-03-29 05:38:48 -04:00
let user = await doubleCheckPassword(socket, password.currentPassword);
await user.resetPassword(password.newPassword);
2021-06-25 09:55:49 -04:00
2022-03-29 05:38:48 -04:00
callback({
ok: true,
msg: "Password has been updated 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
});
}
});
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);
2022-10-09 08:59:58 -04:00
const data = await getSettings("general");
if (!data.serverTimezone) {
data.serverTimezone = await server.getTimezone();
}
2021-07-06 02:30:10 -04:00
callback({
ok: true,
2022-10-09 08:59:58 -04:00
data: data,
2021-07-31 09:57:58 -04:00
});
} catch (e) {
callback({
ok: false,
msg: e.message,
});
}
});
2022-03-29 05:38:48 -04:00
socket.on("setSettings", async (data, currentPassword, callback) => {
2021-07-31 09:57:58 -04:00
try {
checkLogin(socket);
2021-07-31 09:57:58 -04:00
2022-04-28 11:12:16 -04:00
// 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) {
2022-03-29 05:38:48 -04:00
await doubleCheckPassword(socket, currentPassword);
}
2023-06-27 03:54:33 -04:00
const previousChromeExecutable = await Settings.get("chromeExecutable");
const previousNSCDStatus = await Settings.get("nscd");
2023-06-27 03:54:33 -04:00
2021-09-15 08:40:26 -04:00
await setSettings("general", data);
2022-10-08 11:56:58 -04:00
server.entryPage = data.entryPage;
2021-07-31 09:57:58 -04:00
2022-12-12 04:19:22 -05:00
await CacheableDnsHttpAgent.update();
2022-10-09 08:59:58 -04:00
// Also need to apply timezone globally
if (data.serverTimezone) {
await server.setTimezone(data.serverTimezone);
}
2021-07-31 09:57:58 -04:00
2023-06-27 03:54:33 -04:00
// 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) {
server.startNSCDServices();
} else {
server.stopNSCDServices();
}
}
2021-07-31 09:57:58 -04:00
callback({
ok: true,
msg: "Saved"
2021-07-06 02:30:10 -04:00
});
sendInfo(socket);
server.sendMaintenanceList(socket);
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);
2021-07-09 02:14:03 -04:00
let notificationBean = await Notification.save(notification, notificationID, socket.userID);
await sendNotificationList(socket);
2021-07-09 02:14:03 -04:00
callback({
ok: true,
msg: "Saved",
id: notificationBean.id,
2021-07-09 02:14:03 -04:00
});
} 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);
2021-07-09 02:14:03 -04:00
await Notification.delete(notificationID, socket.userID);
await sendNotificationList(socket);
2021-07-09 02:14:03 -04:00
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-09 02:14:03 -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) {
console.error(e);
2021-07-18 08:49:46 -04:00
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);
2021-07-18 06:51:58 -04:00
callback(Notification.checkApprise());
} catch (e) {
callback(false);
}
});
2021-08-03 13:03:40 -04:00
2021-09-11 15:53:17 -04:00
socket.on("uploadBackup", async (uploadedJSON, importHandle, callback) => {
2021-09-01 11:09:32 -04:00
try {
checkLogin(socket);
2021-09-01 11:09:32 -04:00
2021-09-02 10:13:31 -04:00
let backupData = JSON.parse(uploadedJSON);
2021-09-01 11:09:32 -04:00
log.info("manage", `Importing Backup, User ID: ${socket.userID}, Version: ${backupData.version}`);
2021-09-23 11:31:01 -04:00
2021-09-11 15:53:17 -04:00
let notificationListData = backupData.notificationList;
let proxyListData = backupData.proxyList;
2021-09-11 15:53:17 -04:00
let monitorListData = backupData.monitorList;
2021-09-01 11:09:32 -04:00
let version17x = compareVersions.compare(backupData.version, "1.7.0", ">=");
// If the import option is "overwrite" it'll clear most of the tables, except "settings" and "user"
2022-04-25 18:26:26 -04:00
if (importHandle === "overwrite") {
// Stops every monitor first, so it doesn't execute any heartbeat while importing
2022-04-07 10:53:32 -04:00
for (let id in server.monitorList) {
let monitor = server.monitorList[id];
await monitor.stop();
2021-09-01 11:09:32 -04:00
}
2021-09-11 15:53:17 -04:00
await R.exec("DELETE FROM heartbeat");
await R.exec("DELETE FROM monitor_notification");
await R.exec("DELETE FROM monitor_tls_info");
await R.exec("DELETE FROM notification");
await R.exec("DELETE FROM monitor_tag");
await R.exec("DELETE FROM tag");
2021-09-11 15:53:17 -04:00
await R.exec("DELETE FROM monitor");
await R.exec("DELETE FROM proxy");
2021-09-01 11:09:32 -04:00
}
// Only starts importing if the backup file contains at least one notification
2021-09-11 15:53:17 -04:00
if (notificationListData.length >= 1) {
// Get every existing notification name and puts them in one simple string
2021-09-11 15:53:17 -04:00
let notificationNameList = await R.getAll("SELECT name FROM notification");
let notificationNameListString = JSON.stringify(notificationNameList);
2021-09-01 11:09:32 -04:00
2021-09-11 15:53:17 -04:00
for (let i = 0; i < notificationListData.length; i++) {
// Only starts importing the notification if the import option is "overwrite", "keep" or "skip" but the notification doesn't exists
2022-04-25 18:26:26 -04:00
if ((importHandle === "skip" && notificationNameListString.includes(notificationListData[i].name) === false) || importHandle === "keep" || importHandle === "overwrite") {
2021-09-01 11:09:32 -04:00
2021-09-11 15:53:17 -04:00
let notification = JSON.parse(notificationListData[i].config);
await Notification.save(notification, null, socket.userID);
2021-09-01 11:09:32 -04:00
2021-09-11 15:53:17 -04:00
}
}
}
2021-09-01 11:09:32 -04:00
// Only starts importing if the backup file contains at least one proxy
2022-04-13 22:12:03 -04:00
if (proxyListData && proxyListData.length >= 1) {
const proxies = await R.findAll("proxy");
// Loop over proxy list and save proxies
for (const proxy of proxyListData) {
const exists = proxies.find(item => item.id === proxy.id);
// Do not process when proxy already exists in import handle is skip and keep
2022-04-17 03:27:35 -04:00
if ([ "skip", "keep" ].includes(importHandle) && !exists) {
return;
}
// Save proxy as new entry if exists update exists one
await Proxy.save(proxy, exists ? proxy.id : undefined, proxy.userId);
}
}
// Only starts importing if the backup file contains at least one monitor
2021-09-11 15:53:17 -04:00
if (monitorListData.length >= 1) {
// Get every existing monitor name and puts them in one simple string
2021-09-11 15:53:17 -04:00
let monitorNameList = await R.getAll("SELECT name FROM monitor");
let monitorNameListString = JSON.stringify(monitorNameList);
for (let i = 0; i < monitorListData.length; i++) {
// Only starts importing the monitor if the import option is "overwrite", "keep" or "skip" but the notification doesn't exists
2022-04-25 19:26:57 -04:00
if ((importHandle === "skip" && monitorNameListString.includes(monitorListData[i].name) === false) || importHandle === "keep" || importHandle === "overwrite") {
2021-09-11 15:53:17 -04:00
// Define in here every new variable for monitors which where implemented after the first version of the Import/Export function (1.6.0)
// --- Start ---
// Define default values
let retryInterval = 0;
let timeout = monitorListData[i].timeout || (monitorListData[i].interval * 0.8); // fallback to old value
/*
Only replace the default value with the backup file data for the specific version, where it appears the first time
More information about that where "let version" will be defined
*/
if (version17x) {
retryInterval = monitorListData[i].retryInterval;
}
// --- End ---
2021-09-11 15:53:17 -04:00
let monitor = {
// Define the new variable from earlier here
2021-09-11 15:53:17 -04:00
name: monitorListData[i].name,
description: monitorListData[i].description,
2021-09-11 15:53:17 -04:00
type: monitorListData[i].type,
url: monitorListData[i].url,
method: monitorListData[i].method || "GET",
body: monitorListData[i].body,
headers: monitorListData[i].headers,
2022-05-13 13:58:23 -04:00
authMethod: monitorListData[i].authMethod,
basic_auth_user: monitorListData[i].basic_auth_user,
basic_auth_pass: monitorListData[i].basic_auth_pass,
2022-05-13 13:58:23 -04:00
authWorkstation: monitorListData[i].authWorkstation,
authDomain: monitorListData[i].authDomain,
timeout,
2021-09-11 15:53:17 -04:00
interval: monitorListData[i].interval,
retryInterval: retryInterval,
2022-04-21 06:18:15 -04:00
resendInterval: monitorListData[i].resendInterval || 0,
2021-09-11 15:53:17 -04:00
hostname: monitorListData[i].hostname,
maxretries: monitorListData[i].maxretries,
port: monitorListData[i].port,
keyword: monitorListData[i].keyword,
2023-04-05 20:10:21 -04:00
invertKeyword: monitorListData[i].invertKeyword,
2021-09-11 15:53:17 -04:00
ignoreTls: monitorListData[i].ignoreTls,
upsideDown: monitorListData[i].upsideDown,
maxredirects: monitorListData[i].maxredirects,
accepted_statuscodes: monitorListData[i].accepted_statuscodes,
dns_resolve_type: monitorListData[i].dns_resolve_type,
dns_resolve_server: monitorListData[i].dns_resolve_server,
notificationIDList: monitorListData[i].notificationIDList,
proxy_id: monitorListData[i].proxy_id || null,
};
2021-09-11 15:53:17 -04:00
2021-10-09 05:45:05 -04:00
if (monitorListData[i].pushToken) {
monitor.pushToken = monitorListData[i].pushToken;
}
let bean = R.dispense("monitor");
2021-09-11 15:53:17 -04:00
let notificationIDList = monitor.notificationIDList;
delete monitor.notificationIDList;
monitor.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
delete monitor.accepted_statuscodes;
bean.import(monitor);
bean.user_id = socket.userID;
await R.store(bean);
2021-09-11 15:53:17 -04:00
// Only for backup files with the version 1.7.0 or higher, since there was the tag feature implemented
if (version17x) {
// Only import if the specific monitor has tags assigned
for (const oldTag of monitorListData[i].tags) {
// Check if tag already exists and get data ->
let tag = await R.findOne("tag", " name = ?", [
oldTag.name,
]);
let tagId;
if (! tag) {
// -> If it doesn't exist, create new tag from backup file
let beanTag = R.dispense("tag");
beanTag.name = oldTag.name;
beanTag.color = oldTag.color;
await R.store(beanTag);
tagId = beanTag.id;
} else {
// -> If it already exist, set tagId to value from database
tagId = tag.id;
}
// Assign the new created tag to the monitor
await R.exec("INSERT INTO monitor_tag (tag_id, monitor_id, value) VALUES (?, ?, ?)", [
tagId,
bean.id,
oldTag.value,
]);
}
}
await updateMonitorNotification(bean.id, notificationIDList);
2021-09-11 15:53:17 -04:00
// If monitor was active start it immediately, otherwise pause it
2022-04-25 19:26:57 -04:00
if (monitorListData[i].active === 1) {
2021-09-11 15:53:17 -04:00
await startMonitor(socket.userID, bean.id);
} else {
await pauseMonitor(socket.userID, bean.id);
}
2021-09-01 11:09:32 -04:00
}
2021-09-01 11:09:32 -04:00
}
await sendNotificationList(socket);
2022-04-07 11:02:57 -04:00
await server.sendMonitorList(socket);
2021-09-01 11:09:32 -04:00
}
callback({
ok: true,
msg: "Backup successfully restored.",
});
} catch (e) {
callback({
ok: false,
msg: e.message,
});
}
});
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,
]);
await sendImportantHeartbeatList(socket, monitorID, true, true);
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,
2021-08-31 18:36:24 -04:00
});
} catch (e) {
callback({
ok: false,
msg: e.message,
});
}
});
socket.on("clearStatistics", async (callback) => {
try {
checkLogin(socket);
2021-08-31 18:36:24 -04:00
log.info("manage", `Clear Statistics User ID: ${socket.userID}`);
2021-08-31 18:36:24 -04:00
await R.exec("DELETE FROM heartbeat");
callback({
ok: true,
});
} catch (e) {
callback({
ok: false,
msg: e.message,
});
}
});
2021-09-16 10:48:28 -04:00
// Status Page Socket Handler for admin only
statusPageSocketHandler(socket);
2022-03-29 02:48:02 -04:00
cloudflaredSocketHandler(socket);
databaseSocketHandler(socket);
proxySocketHandler(socket);
dockerSocketHandler(socket);
maintenanceSocketHandler(socket);
apiKeySocketHandler(socket);
2022-12-12 09:57:57 -05:00
generalSocketHandler(socket, server);
2021-09-16 10:48:28 -04:00
log.debug("server", "added all socket handlers");
2021-08-03 13:03:40 -04:00
2021-08-04 01:31:17 -04:00
// ***************************
// Better do anything after added all socket handlers here
// ***************************
log.debug("auth", "check auto login");
2021-08-03 13:03:40 -04:00
if (await setting("disableAuth")) {
log.info("auth", "Disabled Auth: auto login to admin");
afterLogin(socket, await R.findOne("user"));
socket.emit("autoLogin");
2021-08-03 13:03:40 -04:00
} else {
log.debug("auth", "need auth");
2021-08-03 13:03:40 -04:00
}
2021-06-25 09:55:49 -04:00
});
log.info("server", "Init the server");
2021-08-10 09:28:54 -04:00
server.httpServer.once("error", async (err) => {
2021-08-10 09:28:54 -04:00
console.error("Cannot listen: " + err.message);
await shutdownFunction();
2021-08-10 09:28:54 -04:00
});
2021-08-10 04:36:21 -04:00
server.start();
server.httpServer.listen(port, hostname, () => {
2021-08-10 04:36:21 -04:00
if (hostname) {
log.info("server", `Listening on ${hostname}:${port}`);
2021-08-10 04:36:21 -04:00
} else {
log.info("server", `Listening on ${port}`);
2021-08-10 04:36:21 -04:00
}
2021-06-25 09:55:49 -04:00
startMonitors();
2021-08-21 07:50:22 -04:00
checkVersion.startInterval();
if (testMode) {
startUnitTest();
}
2022-06-16 05:28:17 -04:00
if (e2eTestMode) {
startE2eTests();
}
2021-06-25 09:55:49 -04:00
});
2023-05-12 12:55:48 -04:00
await initBackgroundJobs();
2022-03-29 23:59:49 -04:00
// Start cloudflared at the end if configured
await cloudflaredAutoStart(cloudflaredToken);
2022-03-29 23:59:49 -04:00
2021-06-25 09:55:49 -04:00
})();
/**
* 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) {
2021-08-10 09:37:51 -04:00
await 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);
}
}
}
/**
* Check if a given user owns a specific monitor
* @param {number} userID
* @param {number} monitorID
* @returns {Promise<void>}
* @throws {Error} The specified user does not own the monitor
*/
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,
]);
2021-06-25 09:55:49 -04:00
if (! row) {
throw new Error("You do not own this monitor.");
}
}
/**
* Function called after user login
2021-11-10 00:24:31 -05:00
* 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>}
*/
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
2022-04-07 11:02:57 -04:00
let monitorList = await server.sendMonitorList(socket);
2023-07-14 06:02:49 -04:00
sendInfo(socket);
server.sendMaintenanceList(socket);
sendNotificationList(socket);
sendProxyList(socket);
sendDockerHostList(socket);
sendAPIKeyList(socket);
2021-08-08 13:58:56 -04:00
2021-08-23 06:52:55 -04:00
await sleep(500);
2022-03-21 03:28:59 -04:00
await StatusPage.sendStatusPageList(io, socket);
2021-08-23 06:52:55 -04:00
for (let monitorID in monitorList) {
await sendHeartbeatList(socket, monitorID);
}
for (let monitorID in monitorList) {
await sendImportantHeartbeatList(socket, monitorID);
}
for (let monitorID in monitorList) {
await Monitor.sendStats(io, monitorID, user.id);
2021-08-23 06:52:55 -04:00
}
2022-12-12 09:57:57 -05:00
// 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");
}
2021-06-25 09:55:49 -04:00
}
/**
* Initialize the database
* @param {boolean} [testMode=false] Should the connection be
* started in test mode?
* @returns {Promise<void>}
*/
async function initDatabase(testMode = false) {
2021-07-21 14:02:35 -04:00
if (! fs.existsSync(Database.path)) {
log.info("server", "Copying Database");
2021-07-21 14:02:35 -04:00
fs.copyFileSync(Database.templatePath, Database.path);
2021-07-11 01:47:57 -04:00
}
log.info("server", "Connecting to the Database");
await Database.connect(testMode);
log.info("server", "Connected");
2021-07-18 06:51:58 -04:00
2021-07-21 14:02:35 -04:00
// Patch the database
await Database.patch();
2021-07-21 14:02:35 -04:00
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) {
log.info("server", "JWT secret is not found, generate one.");
2021-08-09 08:09:01 -04:00
jwtSecretBean = await initJWTSecret();
log.info("server", "Stored JWT secret into database");
2021-06-25 09:55:49 -04:00
} else {
log.info("server", "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) {
log.info("server", "No user, need setup");
2021-07-11 01:47:57 -04:00
needSetup = true;
}
2023-06-27 03:54:33 -04:00
server.jwtSecret = jwtSecretBean.value;
2021-06-25 09:55:49 -04:00
}
/**
* Start the specified monitor
* @param {number} userID ID of user who owns monitor
* @param {number} monitorID ID of monitor to start
* @returns {Promise<void>}
*/
2021-06-25 09:55:49 -04:00
async function startMonitor(userID, monitorID) {
await checkOwner(userID, monitorID);
2021-06-25 09:55:49 -04:00
log.info("manage", `Resume Monitor: ${monitorID} User ID: ${userID}`);
2021-06-25 09:55:49 -04:00
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
2022-04-07 10:53:32 -04:00
if (monitor.id in server.monitorList) {
server.monitorList[monitor.id].stop();
2021-06-27 04:10:55 -04:00
}
2022-04-07 10:53:32 -04:00
server.monitorList[monitor.id] = monitor;
monitor.start(io);
2021-06-25 09:55:49 -04:00
}
/**
* Restart a given monitor
* @param {number} userID ID of user who owns monitor
* @param {number} monitorID ID of monitor to start
* @returns {Promise<void>}
*/
2021-06-27 04:10:55 -04:00
async function restartMonitor(userID, monitorID) {
return await startMonitor(userID, monitorID);
2021-06-27 04:10:55 -04:00
}
/**
* Pause a given monitor
* @param {number} userID ID of user who owns monitor
* @param {number} monitorID ID of monitor to start
* @returns {Promise<void>}
*/
2021-06-25 09:55:49 -04:00
async function pauseMonitor(userID, monitorID) {
await checkOwner(userID, monitorID);
2021-06-25 09:55:49 -04:00
log.info("manage", `Pause Monitor: ${monitorID} User ID: ${userID}`);
2021-06-25 09:55:49 -04:00
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
]);
2022-04-07 10:53:32 -04:00
if (monitorID in server.monitorList) {
server.monitorList[monitorID].stop();
2021-06-25 09:55:49 -04:00
}
}
/** Resume active monitors */
2021-06-25 09:55:49 -04:00
async function startMonitors() {
let list = await R.find("monitor", " active = 1 ");
2021-06-25 09:55:49 -04:00
for (let monitor of list) {
2022-04-07 10:53:32 -04:00
server.monitorList[monitor.id] = monitor;
}
for (let monitor of list) {
monitor.start(io);
// Give some delays, so all monitors won't make request at the same moment when just start the server.
await sleep(getRandomInt(300, 1000));
2021-06-25 09:55:49 -04:00
}
}
/**
* Shutdown the application
2021-11-10 00:24:31 -05:00
* Stops all monitors and closes the database connection.
* @param {string} signal The signal that triggered this function to be called.
* @returns {Promise<void>}
*/
2021-07-15 13:44:51 -04:00
async function shutdownFunction(signal) {
log.info("server", "Shutdown requested");
log.info("server", "Called signal: " + signal);
2021-07-15 13:44:51 -04:00
await server.stop();
log.info("server", "Stopping all monitors");
2022-04-07 10:53:32 -04:00
for (let id in server.monitorList) {
let monitor = server.monitorList[id];
monitor.stop();
2021-07-15 13:44:51 -04:00
}
2021-07-21 14:02:35 -04:00
await sleep(2000);
await Database.close();
stopBackgroundJobs();
await cloudflaredStop();
2022-12-08 06:13:47 -05:00
Settings.stopCacheCleaner();
2021-07-15 13:44:51 -04:00
}
/** Final function called before application exits */
2021-07-15 13:44:51 -04:00
function finalFunction() {
log.info("server", "Graceful shutdown successful!");
2021-07-15 13:44:51 -04:00
}
gracefulShutdown(server.httpServer, {
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
});
2021-08-17 03:32:34 -04:00
// Catch unexpected errors here
process.addListener("unhandledRejection", (error, promise) => {
console.trace(error);
UptimeKumaServer.errorLog(error, false);
2021-08-17 03:32:34 -04:00
console.error("If you keep encountering errors, please report to https://github.com/louislam/uptime-kuma/issues");
});