2022-04-19 10:38:59 +03:00
/ *
* Uptime Kuma Server
* node "server/server.js"
* DO NOT require ( "./server" ) in other modules , it likely creates circular dependency !
* /
2021-08-08 16:03:10 +03:00
console . log ( "Welcome to Uptime Kuma" ) ;
2022-01-14 20:25:28 +03:00
// Check Node.js Version
const nodeVersion = parseInt ( process . versions . node . split ( "." ) [ 0 ] ) ;
const requiredVersion = 14 ;
console . log ( ` Your Node.js version: ${ nodeVersion } ` ) ;
if ( nodeVersion < requiredVersion ) {
console . error ( ` Error: Your Node.js version is not supported, please upgrade to Node.js >= ${ requiredVersion } . ` ) ;
process . exit ( - 1 ) ;
}
2021-10-09 21:36:20 +03:00
const args = require ( "args-parser" ) ( process . argv ) ;
2022-04-17 14:30:58 +03:00
const { sleep , log , getRandomInt , genSecret , debug , isDev } = require ( "../src/util" ) ;
2021-10-15 19:57:26 +03:00
const config = require ( "./config" ) ;
2021-10-09 21:36:20 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Welcome to Uptime Kuma" ) ;
log . debug ( "server" , "Arguments" ) ;
log . debug ( "server" , args ) ;
2021-09-14 18:28:38 +03:00
if ( ! process . env . NODE _ENV ) {
process . env . NODE _ENV = "production" ;
}
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Node Env: " + process . env . NODE _ENV ) ;
2021-07-31 16:57:58 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Importing Node libraries" ) ;
2021-07-31 16:57:58 +03:00
const fs = require ( "fs" ) ;
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Importing 3rd-party libraries" ) ;
log . debug ( "server" , "Importing express" ) ;
2021-07-31 16:57:58 +03:00
const express = require ( "express" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing redbean-node" ) ;
2021-07-27 20:47:13 +03:00
const { R } = require ( "redbean-node" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing jsonwebtoken" ) ;
2021-07-27 20:47:13 +03:00
const jwt = require ( "jsonwebtoken" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing http-graceful-shutdown" ) ;
2021-07-27 20:47:13 +03:00
const gracefulShutdown = require ( "http-graceful-shutdown" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing prometheus-api-metrics" ) ;
2021-07-27 20:47:13 +03:00
const prometheusAPIMetrics = require ( "prometheus-api-metrics" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing compare-versions" ) ;
2021-09-23 18:31:01 +03:00
const compareVersions = require ( "compare-versions" ) ;
2021-10-21 17:54:04 +03:00
const { passwordStrength } = require ( "check-password-strength" ) ;
2021-07-31 16:57:58 +03:00
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing 2FA Modules" ) ;
2021-09-09 22:10:31 +03:00
const notp = require ( "notp" ) ;
const base32 = require ( "thirty-two" ) ;
2022-04-19 10:38:59 +03:00
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 17:53:32 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Importing this project modules" ) ;
log . debug ( "server" , "Importing Monitor" ) ;
2021-07-31 16:57:58 +03:00
const Monitor = require ( "./model/monitor" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing Settings" ) ;
2022-05-06 09:41:34 +03:00
const { getSettings , setSettings , setting , initJWTSecret , checkLogin , startUnitTest , FBSD , doubleCheckPassword } = require ( "./util-server" ) ;
2021-09-07 17:42:46 +03:00
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing Notification" ) ;
2021-07-31 16:57:58 +03:00
const { Notification } = require ( "./notification" ) ;
2021-09-07 17:42:46 +03:00
Notification . init ( ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing Proxy" ) ;
2021-10-30 20:37:15 +03:00
const { Proxy } = require ( "./proxy" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing Database" ) ;
2021-07-31 16:57:58 +03:00
const Database = require ( "./database" ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "Importing Background Jobs" ) ;
2022-04-05 14:41:29 +03:00
const { initBackgroundJobs , stopBackgroundJobs } = require ( "./jobs" ) ;
2022-03-29 12:38:48 +03:00
const { loginRateLimiter , twoFaRateLimiter } = require ( "./rate-limiter" ) ;
2021-09-27 18:40:38 +03:00
2021-07-27 19:52:31 +03:00
const { basicAuth } = require ( "./auth" ) ;
2021-07-27 20:47:13 +03:00
const { login } = require ( "./auth" ) ;
2021-07-28 15:35:55 +03:00
const passwordHash = require ( "./password-hash" ) ;
2021-07-31 16:57:58 +03:00
2021-08-21 14:50:22 +03:00
const checkVersion = require ( "./check-version" ) ;
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Version: " + checkVersion . version ) ;
2021-08-10 11:36:21 +03:00
2021-08-10 11:45:37 +03: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 20:44:01 +03:00
// Also read HOST if not FreeBSD, as HOST is a system environment variable in FreeBSD
2022-01-08 01:13:38 +03:00
let hostEnv = FBSD ? null : process . env . HOST ;
2022-01-08 16:36:33 +03:00
let hostname = args . host || process . env . UPTIME _KUMA _HOST || hostEnv ;
2021-10-14 09:09:16 +03:00
if ( hostname ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Custom hostname: " + hostname ) ;
2021-10-14 09:09:16 +03:00
}
2022-04-17 10:27:35 +03:00
const port = [ args . port , process . env . UPTIME _KUMA _PORT , process . env . PORT , 3001 ]
2022-01-08 01:16:26 +03:00
. map ( portValue => parseInt ( portValue ) )
. find ( portValue => ! isNaN ( portValue ) ) ;
2021-06-25 16:55:49 +03:00
2021-10-19 11:29:09 +03:00
const disableFrameSameOrigin = ! ! process . env . UPTIME _KUMA _DISABLE _FRAME _SAMEORIGIN || args [ "disable-frame-sameorigin" ] || false ;
2022-03-30 15:08:26 +03:00
const cloudflaredToken = args [ "cloudflared-token" ] || process . env . UPTIME _KUMA _CLOUDFLARED _TOKEN || undefined ;
2021-09-02 15:18:27 +03:00
2021-10-11 21:18:40 +03:00
// 2FA / notp verification defaults
2022-04-16 20:39:49 +03:00
const twoFAVerifyOptions = {
2021-10-11 21:18:40 +03:00
"window" : 1 ,
"time" : 30
2021-10-18 12:15:28 +03:00
} ;
2021-09-02 15:18:27 +03:00
2021-10-05 14:13:57 +03:00
/ * *
* Run unit test after the server is ready
* @ type { boolean }
* /
const testMode = ! ! args [ "test" ] || false ;
2021-09-02 17:37:51 +03:00
2021-10-15 19:57:26 +03:00
if ( config . demoMode ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "==== Demo Mode ====" ) ;
2021-09-02 16:10:18 +03:00
}
2021-09-02 15:27:18 +03:00
2021-09-04 21:03:40 +03:00
// Must be after io instantiation
2021-10-30 20:37:15 +03:00
const { sendNotificationList , sendHeartbeatList , sendImportantHeartbeatList , sendInfo , sendProxyList } = require ( "./client" ) ;
2021-09-16 17:48:28 +03:00
const { statusPageSocketHandler } = require ( "./socket-handlers/status-page-socket-handler" ) ;
2021-10-26 18:02:32 +03:00
const databaseSocketHandler = require ( "./socket-handlers/database-socket-handler" ) ;
2021-11-18 13:22:03 +03:00
const TwoFA = require ( "./2fa" ) ;
2022-03-10 16:34:30 +03:00
const StatusPage = require ( "./model/status_page" ) ;
2022-04-05 14:41:29 +03:00
const { cloudflaredSocketHandler , autoStart : cloudflaredAutoStart , stop : cloudflaredStop } = require ( "./socket-handlers/cloudflared-socket-handler" ) ;
2022-04-07 09:45:37 +03:00
const { proxySocketHandler } = require ( "./socket-handlers/proxy-socket-handler" ) ;
2022-01-23 17:22:00 +03:00
const apicache = require ( "./modules/apicache" ) ;
2021-09-04 21:03:40 +03:00
app . use ( express . json ( ) ) ;
2021-07-09 14:33:22 +03:00
2021-10-19 09:26:10 +03:00
// Global Middleware
app . use ( function ( req , res , next ) {
2021-10-19 11:29:09 +03:00
if ( ! disableFrameSameOrigin ) {
2021-10-19 09:41:05 +03:00
res . setHeader ( "X-Frame-Options" , "SAMEORIGIN" ) ;
}
2021-10-19 09:26:10 +03:00
res . removeHeader ( "X-Powered-By" ) ;
next ( ) ;
} ) ;
2021-07-21 21:02:35 +03:00
/ * *
* Use for decode the auth object
* @ type { null }
* /
2021-06-25 16:55:49 +03:00
let jwtSecret = null ;
2021-07-21 21:02:35 +03:00
2022-01-23 17:22:00 +03:00
/ * *
* Main maintenance list
* @ type { { } }
* /
let maintenanceList = { } ;
2021-07-21 21:02:35 +03:00
/ * *
* Show Setup Page
* @ type { boolean }
* /
2021-07-11 08:47:57 +03:00
let needSetup = false ;
2021-06-25 16:55:49 +03:00
2021-07-28 18:40:50 +03:00
/ * *
* Cache Index HTML
* @ type { string }
* /
2021-10-19 20:32:19 +03:00
let indexHTML = "" ;
try {
indexHTML = fs . readFileSync ( "./dist/index.html" ) . toString ( ) ;
} catch ( e ) {
// "dist/index.html" is not necessary for development
if ( process . env . NODE _ENV !== "development" ) {
2022-04-13 18:33:37 +03:00
log . error ( "server" , "Error: Cannot find 'dist/index.html', did you install correctly?" ) ;
2021-10-19 20:32:19 +03:00
process . exit ( 1 ) ;
}
}
2021-07-28 18:40:50 +03:00
2021-06-25 16:55:49 +03:00
( async ( ) => {
2021-09-20 11:29:18 +03:00
Database . init ( args ) ;
2021-11-04 18:19:31 +03:00
await initDatabase ( testMode ) ;
2021-06-25 16:55:49 +03:00
2021-09-15 15:40:26 +03:00
exports . entryPage = await setting ( "entryPage" ) ;
2022-04-06 17:43:22 +03:00
await StatusPage . loadDomainMappingList ( ) ;
2021-07-27 19:52:31 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Adding route" ) ;
2021-07-27 19:52:31 +03:00
2021-09-11 14:40:03 +03:00
// ***************************
2021-07-27 19:52:31 +03:00
// Normal Router here
2021-09-11 14:40:03 +03:00
// ***************************
2021-07-27 19:52:31 +03:00
2021-11-02 16:48:46 +03:00
// Entry Page
2022-04-06 17:43:22 +03:00
app . get ( "/" , async ( request , response ) => {
debug ( ` Request Domain: ${ request . hostname } ` ) ;
if ( request . hostname in StatusPage . domainMappingList ) {
debug ( "This is a status page domain" ) ;
response . send ( indexHTML ) ;
} else if ( exports . entryPage && exports . entryPage . startsWith ( "statusPage-" ) ) {
2022-03-17 17:44:47 +03:00
response . redirect ( "/status/" + exports . entryPage . replace ( "statusPage-" , "" ) ) ;
2021-11-02 16:48:46 +03:00
} else {
response . redirect ( "/dashboard" ) ;
}
} ) ;
2022-04-17 14:30:58 +03:00
if ( isDev ) {
app . post ( "/test-webhook" , async ( request , response ) => {
log . debug ( "test" , request . body ) ;
response . send ( "OK" ) ;
} ) ;
}
2021-08-09 13:16:27 +03:00
// Robots.txt
app . get ( "/robots.txt" , async ( _request , response ) => {
let txt = "User-agent: *\nDisallow:" ;
if ( ! await setting ( "searchEngineIndex" ) ) {
txt += " /" ;
}
response . setHeader ( "Content-Type" , "text/plain" ) ;
response . send ( txt ) ;
} ) ;
2021-06-25 16:55:49 +03:00
2021-07-27 19:52:31 +03:00
// Basic Auth Router here
// Prometheus API metrics /metrics
// With Basic Auth using the first user's username/password
2021-08-09 13:16:27 +03:00
app . get ( "/metrics" , basicAuth , prometheusAPIMetrics ( ) ) ;
app . use ( "/" , express . static ( "dist" ) ) ;
2021-07-22 10:22:15 +03:00
2021-09-21 16:22:35 +03:00
// ./data/upload
app . use ( "/upload" , express . static ( Database . uploadDir ) ) ;
2021-09-14 07:10:25 +03: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 09:55:45 +03:00
// API Router
const apiRouter = require ( "./routers/api-router" ) ;
app . use ( apiRouter ) ;
2021-09-11 14:40:03 +03:00
2021-10-19 09:26:10 +03:00
// Universal Route Handler, must be at the end of all express routes.
2021-08-09 13:16:27 +03:00
app . get ( "*" , async ( _request , response ) => {
2021-09-21 16:22:35 +03:00
if ( _request . originalUrl . startsWith ( "/upload/" ) ) {
response . status ( 404 ) . send ( "File not found." ) ;
} else {
response . send ( indexHTML ) ;
}
2021-07-09 09:14:03 +03:00
} ) ;
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Adding socket handler" ) ;
2021-07-27 20:47:13 +03:00
io . on ( "connection" , async ( socket ) => {
2021-07-13 13:08:12 +03:00
2021-10-08 15:03:52 +03:00
sendInfo ( socket ) ;
2021-07-13 13:08:12 +03:00
2021-07-11 08:47:57 +03:00
if ( needSetup ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Redirect to setup page" ) ;
2021-09-21 16:22:35 +03:00
socket . emit ( "setup" ) ;
2021-07-11 08:47:57 +03:00
}
2021-07-30 06:33:44 +03:00
// ***************************
2021-09-11 14:40:03 +03:00
// Public Socket API
2021-07-30 06:33:44 +03:00
// ***************************
2021-06-25 16:55:49 +03:00
socket . on ( "loginByToken" , async ( token , callback ) => {
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Login by token. IP= ${ getClientIp ( socket ) } ` ) ;
2021-06-25 16:55:49 +03:00
try {
let decoded = jwt . verify ( token , jwtSecret ) ;
2022-04-13 18:33:37 +03:00
log . info ( "auth" , "Username from JWT: " + decoded . username ) ;
2021-06-25 16:55:49 +03:00
let user = await R . findOne ( "user" , " username = ? AND active = 1 " , [
2021-07-27 20:47:13 +03:00
decoded . username ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-06-25 16:55:49 +03:00
if ( user ) {
2022-04-13 18:33:37 +03:00
log . debug ( "auth" , "afterLogin" ) ;
2021-09-21 16:22:35 +03:00
afterLogin ( socket , user ) ;
2022-04-13 18:33:37 +03:00
log . debug ( "auth" , "afterLogin ok" ) ;
2021-06-25 16:55:49 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Successfully logged in user ${ decoded . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-08-03 20:03:40 +03:00
2021-06-25 16:55:49 +03:00
callback ( {
ok : true ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-06-25 16:55:49 +03:00
} else {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Inactive or deleted user ${ decoded . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-06-25 16:55:49 +03:00
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : "The user is inactive or deleted." ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-06-25 16:55:49 +03:00
}
} catch ( error ) {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . error ( "auth" , ` Invalid token. IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-06-25 16:55:49 +03:00
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : "Invalid token." ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-06-25 16:55:49 +03:00
}
} ) ;
socket . on ( "login" , async ( data , callback ) => {
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Login by username + password. IP= ${ getClientIp ( socket ) } ` ) ;
2021-06-25 16:55:49 +03:00
2022-03-29 12:38:48 +03:00
// Checking
if ( typeof callback !== "function" ) {
return ;
}
if ( ! data ) {
return ;
}
2021-06-25 16:55:49 +03:00
2021-10-23 11:35:13 +03:00
// Login Rate Limit
if ( ! await loginRateLimiter . pass ( callback ) ) {
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Too many failed requests for user ${ data . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-10-23 11:35:13 +03:00
return ;
}
2021-09-21 16:22:35 +03:00
let user = await login ( data . username , data . password ) ;
2021-07-13 17:22:46 +03:00
2021-07-27 19:52:31 +03:00
if ( user ) {
2022-04-26 01:26:26 +03:00
if ( user . twofa _status === 0 ) {
2021-10-29 21:35:05 +03:00
afterLogin ( socket , user ) ;
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Successfully logged in user ${ data . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
ok : true ,
token : jwt . sign ( {
username : data . username ,
} , jwtSecret ) ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
2022-04-26 01:26:26 +03:00
if ( user . twofa _status === 1 && ! data . token ) {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` 2FA token required for user ${ data . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
tokenRequired : true ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
if ( data . token ) {
2022-04-16 20:39:49 +03:00
let verify = notp . totp . verify ( data . token , user . twofa _secret , twoFAVerifyOptions ) ;
2021-09-09 22:10:31 +03:00
2021-10-19 01:42:33 +03:00
if ( user . twofa _last _token !== data . token && verify ) {
2021-10-29 21:35:05 +03:00
afterLogin ( socket , user ) ;
2021-10-19 01:42:33 +03:00
await R . exec ( "UPDATE `user` SET twofa_last_token = ? WHERE id = ? " , [
data . token ,
socket . userID ,
] ) ;
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Successfully logged in user ${ data . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
ok : true ,
token : jwt . sign ( {
username : data . username ,
} , jwtSecret ) ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
} else {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . warn ( "auth" , ` Invalid token provided for user ${ data . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
ok : false ,
2021-09-11 15:34:12 +03:00
msg : "Invalid Token!" ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
}
2021-06-25 16:55:49 +03:00
} else {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . warn ( "auth" , ` Incorrect username or password for user ${ data . username } . IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-06-25 16:55:49 +03:00
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : "Incorrect username or password." ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-06-25 16:55:49 +03:00
}
} ) ;
socket . on ( "logout" , async ( callback ) => {
2022-03-29 12:38:48 +03:00
// Rate Limit
if ( ! await loginRateLimiter . pass ( callback ) ) {
return ;
}
2021-09-21 16:22:35 +03:00
socket . leave ( socket . userID ) ;
2021-06-25 16:55:49 +03:00
socket . userID = null ;
2022-03-29 12:38:48 +03:00
if ( typeof callback === "function" ) {
callback ( ) ;
}
2021-07-11 08:47:57 +03:00
} ) ;
2022-03-29 12:38:48 +03:00
socket . on ( "prepare2FA" , async ( currentPassword , callback ) => {
2021-09-09 22:10:31 +03:00
try {
2022-03-29 12:38:48 +03:00
if ( ! await twoFaRateLimiter . pass ( callback ) ) {
return ;
}
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2022-03-29 12:38:48 +03:00
await doubleCheckPassword ( socket , currentPassword ) ;
2021-09-09 22:10:31 +03:00
let user = await R . findOne ( "user" , " id = ? AND active = 1 " , [
socket . userID ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-09-09 22:10:31 +03:00
2022-04-26 01:26:26 +03:00
if ( user . twofa _status === 0 ) {
2021-10-18 12:37:11 +03:00
let newSecret = genSecret ( ) ;
2021-09-09 22:10:31 +03:00
let encodedSecret = base32 . encode ( newSecret ) ;
2021-09-30 19:23:18 +03:00
// 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 21:25:51 +03:00
let uri = ` otpauth://totp/Uptime%20Kuma: ${ user . username } ?secret= ${ encodedSecret } ` ;
2021-09-09 22:10:31 +03:00
await R . exec ( "UPDATE `user` SET twofa_secret = ? WHERE id = ? " , [
newSecret ,
socket . userID ,
] ) ;
callback ( {
ok : true ,
uri : uri ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
} else {
callback ( {
ok : false ,
msg : "2FA is already enabled." ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
} catch ( error ) {
callback ( {
ok : false ,
2022-03-29 12:38:48 +03:00
msg : error . message ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
} ) ;
2022-03-29 12:38:48 +03:00
socket . on ( "save2FA" , async ( currentPassword , callback ) => {
2021-09-09 22:10:31 +03:00
try {
2022-03-29 12:38:48 +03:00
if ( ! await twoFaRateLimiter . pass ( callback ) ) {
return ;
}
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2022-03-29 12:38:48 +03:00
await doubleCheckPassword ( socket , currentPassword ) ;
2021-09-09 22:10:31 +03:00
await R . exec ( "UPDATE `user` SET twofa_status = 1 WHERE id = ? " , [
socket . userID ,
] ) ;
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Saved 2FA token. IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
ok : true ,
msg : "2FA Enabled." ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
} catch ( error ) {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . error ( "auth" , ` Error changing 2FA token. IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
ok : false ,
2022-03-29 12:38:48 +03:00
msg : error . message ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
} ) ;
2022-03-29 12:38:48 +03:00
socket . on ( "disable2FA" , async ( currentPassword , callback ) => {
2021-09-09 22:10:31 +03:00
try {
2022-03-29 12:38:48 +03:00
if ( ! await twoFaRateLimiter . pass ( callback ) ) {
return ;
}
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2022-03-29 12:38:48 +03:00
await doubleCheckPassword ( socket , currentPassword ) ;
2021-11-18 13:22:03 +03:00
await TwoFA . disable2FA ( socket . userID ) ;
2021-09-09 22:10:31 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "auth" , ` Disabled 2FA token. IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
ok : true ,
msg : "2FA Disabled." ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
} catch ( error ) {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . error ( "auth" , ` Error disabling 2FA token. IP= ${ getClientIp ( socket ) } ` ) ;
2021-11-11 14:31:28 +03:00
2021-09-09 22:10:31 +03:00
callback ( {
ok : false ,
2022-03-29 12:38:48 +03:00
msg : error . message ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
} ) ;
2022-03-29 12:38:48 +03:00
socket . on ( "verifyToken" , async ( token , currentPassword , callback ) => {
try {
checkLogin ( socket ) ;
await doubleCheckPassword ( socket , currentPassword ) ;
2021-09-09 22:10:31 +03:00
2022-03-29 12:38:48 +03:00
let user = await R . findOne ( "user" , " id = ? AND active = 1 " , [
socket . userID ,
] ) ;
2021-09-09 22:10:31 +03:00
2022-04-16 20:39:49 +03:00
let verify = notp . totp . verify ( token , user . twofa _secret , twoFAVerifyOptions ) ;
2021-09-09 22:10:31 +03:00
2022-03-29 12:38:48 +03:00
if ( user . twofa _last _token !== token && verify ) {
callback ( {
ok : true ,
valid : true ,
} ) ;
} else {
callback ( {
ok : false ,
msg : "Invalid Token." ,
valid : false ,
} ) ;
}
} catch ( error ) {
2021-09-09 22:10:31 +03:00
callback ( {
ok : false ,
2022-03-29 12:38:48 +03:00
msg : error . message ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
} ) ;
socket . on ( "twoFAStatus" , async ( callback ) => {
try {
2022-03-29 12:38:48 +03:00
checkLogin ( socket ) ;
2021-09-09 22:10:31 +03:00
let user = await R . findOne ( "user" , " id = ? AND active = 1 " , [
socket . userID ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-09-09 22:10:31 +03:00
2022-04-26 01:26:26 +03:00
if ( user . twofa _status === 1 ) {
2021-09-09 22:10:31 +03:00
callback ( {
ok : true ,
status : true ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
} else {
callback ( {
ok : true ,
status : false ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
} catch ( error ) {
2022-03-29 12:38:48 +03:00
console . log ( error ) ;
2021-09-09 22:10:31 +03:00
callback ( {
ok : false ,
2022-03-29 12:38:48 +03:00
msg : error . message ,
2021-09-21 16:22:35 +03:00
} ) ;
2021-09-09 22:10:31 +03:00
}
} ) ;
2021-07-11 08:47:57 +03:00
socket . on ( "needSetup" , async ( callback ) => {
callback ( needSetup ) ;
} ) ;
socket . on ( "setup" , async ( username , password , callback ) => {
try {
2021-10-21 17:54:04 +03: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 08:47:57 +03:00
if ( ( await R . count ( "user" ) ) !== 0 ) {
2021-10-18 23:35:47 +03:00
throw new Error ( "Uptime Kuma has been initialized. If you want to run setup again, please delete the database." ) ;
2021-07-11 08:47:57 +03:00
}
2021-09-21 16:22:35 +03:00
let user = R . dispense ( "user" ) ;
2021-07-11 08:47:57 +03:00
user . username = username ;
2021-09-21 16:22:35 +03:00
user . password = passwordHash . generate ( password ) ;
await R . store ( user ) ;
2021-07-11 08:47:57 +03:00
needSetup = false ;
callback ( {
ok : true ,
2021-07-27 20:47:13 +03:00
msg : "Added Successfully." ,
2021-07-11 08:47:57 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-07-11 08:47:57 +03:00
} ) ;
}
2021-06-25 16:55:49 +03:00
} ) ;
2021-07-30 06:33:44 +03:00
// ***************************
2021-06-25 16:55:49 +03:00
// Auth Only API
2021-07-30 06:33:44 +03:00
// ***************************
2021-06-25 16:55:49 +03:00
2021-07-30 14:18:26 +03:00
// Add a new monitor
2021-06-25 16:55:49 +03:00
socket . on ( "add" , async ( monitor , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
let bean = R . dispense ( "monitor" ) ;
2021-07-09 12:55:48 +03:00
let notificationIDList = monitor . notificationIDList ;
delete monitor . notificationIDList ;
2021-08-06 21:10:38 +03:00
monitor . accepted _statuscodes _json = JSON . stringify ( monitor . accepted _statuscodes ) ;
delete monitor . accepted _statuscodes ;
2021-09-21 16:22:35 +03:00
bean . import ( monitor ) ;
bean . user _id = socket . userID ;
await R . store ( bean ) ;
2021-06-25 16:55:49 +03:00
2021-09-21 16:22:35 +03:00
await updateMonitorNotification ( bean . id , notificationIDList ) ;
2021-07-09 12:55:48 +03:00
2022-04-07 18:02:57 +03:00
await server . sendMonitorList ( socket ) ;
2021-11-16 06:35:04 +03:00
await startMonitor ( socket . userID , bean . id ) ;
2021-06-27 11:10:55 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "monitor" , ` Added Monitor: ${ monitor . id } User ID: ${ socket . userID } ` ) ;
2021-11-11 14:31:28 +03:00
2021-06-25 16:55:49 +03:00
callback ( {
ok : true ,
msg : "Added Successfully." ,
2021-07-27 20:47:13 +03:00
monitorID : bean . id ,
2021-06-25 16:55:49 +03:00
} ) ;
2021-06-27 11:10:55 +03:00
} catch ( e ) {
2021-11-11 14:31:28 +03:00
2022-04-13 18:33:37 +03:00
log . error ( "monitor" , ` Error adding Monitor: ${ monitor . id } User ID: ${ socket . userID } ` ) ;
2021-11-11 14:31:28 +03:00
2021-06-27 11:10:55 +03:00
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-06-27 11:10:55 +03:00
} ) ;
}
} ) ;
2021-07-30 14:18:26 +03:00
// Edit a monitor
2021-06-27 11:10:55 +03:00
socket . on ( "editMonitor" , async ( monitor , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-06-27 11:10:55 +03:00
2021-09-21 16:22:35 +03:00
let bean = await R . findOne ( "monitor" , " id = ? " , [ monitor . id ] ) ;
2021-06-27 11:10:55 +03:00
if ( bean . user _id !== socket . userID ) {
2021-09-21 16:22:35 +03:00
throw new Error ( "Permission denied." ) ;
2021-06-27 11:10:55 +03:00
}
2022-01-07 07:26:26 +03:00
// Reset Prometheus labels
2022-04-07 17:53:32 +03:00
server . monitorList [ monitor . id ] ? . prometheus ( ) ? . remove ( ) ;
2022-01-07 07:26:26 +03:00
2021-09-21 16:22:35 +03:00
bean . name = monitor . name ;
bean . type = monitor . type ;
bean . url = monitor . url ;
2021-10-02 17:48:27 +03:00
bean . method = monitor . method ;
bean . body = monitor . body ;
bean . headers = monitor . headers ;
2021-11-04 12:12:06 +03:00
bean . basic _auth _user = monitor . basic _auth _user ;
bean . basic _auth _pass = monitor . basic _auth _pass ;
2021-09-21 16:22:35 +03:00
bean . interval = monitor . interval ;
2021-09-11 19:54:55 +03:00
bean . retryInterval = monitor . retryInterval ;
2021-07-01 09:03:06 +03:00
bean . hostname = monitor . hostname ;
2021-07-19 19:23:06 +03:00
bean . maxretries = monitor . maxretries ;
2021-07-01 09:03:06 +03:00
bean . port = monitor . port ;
2021-07-01 12:19:28 +03:00
bean . keyword = monitor . keyword ;
2021-07-30 14:18:26 +03:00
bean . ignoreTls = monitor . ignoreTls ;
2022-04-05 16:27:50 +03:00
bean . expiryNotification = monitor . expiryNotification ;
2021-07-30 14:18:26 +03:00
bean . upsideDown = monitor . upsideDown ;
2021-08-08 19:23:51 +03:00
bean . maxredirects = monitor . maxredirects ;
2021-08-05 14:04:38 +03:00
bean . accepted _statuscodes _json = JSON . stringify ( monitor . accepted _statuscodes ) ;
2021-08-23 01:05:48 +03:00
bean . dns _resolve _type = monitor . dns _resolve _type ;
bean . dns _resolve _server = monitor . dns _resolve _server ;
2021-09-30 19:09:43 +03:00
bean . pushToken = monitor . pushToken ;
2021-10-30 20:37:15 +03:00
bean . proxyId = Number . isInteger ( monitor . proxyId ) ? monitor . proxyId : null ;
2021-12-19 00:35:18 +03:00
bean . mqttUsername = monitor . mqttUsername ;
2022-04-18 14:05:14 +03:00
bean . mqttPassword = monitor . mqttPassword ;
2021-12-19 00:35:18 +03:00
bean . mqttTopic = monitor . mqttTopic ;
bean . mqttSuccessMessage = monitor . mqttSuccessMessage ;
2021-06-27 11:10:55 +03:00
2021-09-21 16:22:35 +03:00
await R . store ( bean ) ;
2021-06-27 11:10:55 +03:00
2021-09-21 16:22:35 +03:00
await updateMonitorNotification ( bean . id , monitor . notificationIDList ) ;
2021-07-09 12:55:48 +03:00
2021-06-27 11:10:55 +03:00
if ( bean . active ) {
2021-09-21 16:22:35 +03:00
await restartMonitor ( socket . userID , bean . id ) ;
2021-06-27 11:10:55 +03:00
}
2022-04-07 18:02:57 +03:00
await server . sendMonitorList ( socket ) ;
2021-06-25 16:55:49 +03:00
2021-06-27 11:10:55 +03:00
callback ( {
ok : true ,
msg : "Saved." ,
2021-07-27 20:47:13 +03:00
monitorID : bean . id ,
2021-06-27 11:10:55 +03:00
} ) ;
2021-06-25 16:55:49 +03:00
} catch ( e ) {
2022-04-13 18:33:37 +03:00
log . error ( "monitor" , e ) ;
2021-06-25 16:55:49 +03:00
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-06-25 16:55:49 +03:00
} ) ;
}
} ) ;
2022-01-23 17:22:00 +03:00
// Add a new maintenance
socket . on ( "addMaintenance" , async ( maintenance , callback ) => {
try {
checkLogin ( socket ) ;
let bean = R . dispense ( "maintenance" ) ;
bean . import ( maintenance ) ;
bean . user _id = socket . userID ;
let maintenanceID = await R . store ( bean ) ;
await sendMaintenanceList ( socket ) ;
callback ( {
ok : true ,
msg : "Added Successfully." ,
maintenanceID ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
// Edit a maintenance
socket . on ( "editMaintenance" , async ( maintenance , callback ) => {
try {
checkLogin ( socket ) ;
let bean = await R . findOne ( "maintenance" , " id = ? " , [ maintenance . id ] ) ;
if ( bean . user _id !== socket . userID ) {
throw new Error ( "Permission denied." ) ;
}
bean . title = maintenance . title ;
bean . description = maintenance . description ;
bean . start _date = maintenance . start _date ;
bean . end _date = maintenance . end _date ;
await R . store ( bean ) ;
await sendMaintenanceList ( socket ) ;
callback ( {
ok : true ,
msg : "Saved." ,
maintenanceID : bean . id ,
} ) ;
} catch ( e ) {
console . error ( e ) ;
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
// Add a new monitor_maintenance
socket . on ( "addMonitorMaintenance" , async ( maintenanceID , monitors , callback ) => {
try {
checkLogin ( socket ) ;
await R . exec ( "DELETE FROM monitor_maintenance WHERE maintenance_id = ?" , [
maintenanceID
] ) ;
for await ( const monitor of monitors ) {
let bean = R . dispense ( "monitor_maintenance" ) ;
bean . import ( {
monitor _id : monitor . id ,
maintenance _id : maintenanceID
} ) ;
await R . store ( bean ) ;
}
apicache . clear ( ) ;
callback ( {
ok : true ,
msg : "Added Successfully." ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2022-04-30 18:17:22 +03:00
// Add a new monitor_maintenance
socket . on ( "addMaintenanceStatusPage" , async ( maintenanceID , statusPages , callback ) => {
try {
checkLogin ( socket ) ;
await R . exec ( "DELETE FROM maintenance_status_page WHERE maintenance_id = ?" , [
maintenanceID
] ) ;
for await ( const statusPage of statusPages ) {
let bean = R . dispense ( "maintenance_status_page" ) ;
bean . import ( {
status _page _id : statusPage . id ,
maintenance _id : maintenanceID
} ) ;
await R . store ( bean ) ;
}
apicache . clear ( ) ;
callback ( {
ok : true ,
msg : "Added Successfully." ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-08-26 13:55:19 +03:00
socket . on ( "getMonitorList" , async ( callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2022-04-07 18:02:57 +03:00
await server . sendMonitorList ( socket ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : true ,
} ) ;
} catch ( e ) {
2022-04-13 18:33:37 +03:00
log . error ( "monitor" , e ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2022-01-23 17:22:00 +03:00
socket . on ( "getMaintenanceList" , async ( callback ) => {
try {
checkLogin ( socket ) ;
await sendMaintenanceList ( socket ) ;
callback ( {
ok : true ,
} ) ;
} catch ( e ) {
console . error ( e ) ;
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-06-25 16:55:49 +03:00
socket . on ( "getMonitor" , async ( monitorID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-06-25 16:55:49 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "monitor" , ` Get Monitor: ${ monitorID } User ID: ${ socket . userID } ` ) ;
2021-06-25 16:55:49 +03:00
let bean = await R . findOne ( "monitor" , " id = ? AND user_id = ? " , [
monitorID ,
socket . userID ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-06-25 16:55:49 +03:00
callback ( {
ok : true ,
2021-07-09 12:55:48 +03:00
monitor : await bean . toJSON ( ) ,
2021-06-25 16:55:49 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-06-25 16:55:49 +03:00
} ) ;
}
} ) ;
2022-01-23 17:22:00 +03:00
socket . on ( "getMaintenance" , async ( maintenanceID , callback ) => {
try {
checkLogin ( socket ) ;
console . log ( ` Get Maintenance: ${ maintenanceID } User ID: ${ socket . userID } ` ) ;
let bean = await R . findOne ( "maintenance" , " id = ? AND user_id = ? " , [
maintenanceID ,
socket . userID ,
] ) ;
callback ( {
ok : true ,
maintenance : await bean . toJSON ( ) ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "getMonitorMaintenance" , async ( maintenanceID , callback ) => {
try {
checkLogin ( socket ) ;
console . log ( ` Get Monitors for Maintenance: ${ maintenanceID } User ID: ${ socket . userID } ` ) ;
let monitors = await R . getAll ( "SELECT monitor.id, monitor.name FROM monitor_maintenance mm JOIN monitor ON mm.monitor_id = monitor.id WHERE mm.maintenance_id = ? " , [
maintenanceID ,
] ) ;
callback ( {
ok : true ,
monitors ,
} ) ;
} catch ( e ) {
console . error ( e ) ;
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2022-04-30 18:17:22 +03:00
socket . on ( "getMaintenanceStatusPage" , async ( maintenanceID , callback ) => {
try {
checkLogin ( socket ) ;
console . log ( ` Get Status Pages for Maintenance: ${ maintenanceID } User ID: ${ socket . userID } ` ) ;
let statusPages = await R . getAll ( "SELECT status_page.id, status_page.title FROM maintenance_status_page msp JOIN status_page ON msp.status_page_id = status_page.id WHERE msp.maintenance_id = ? " , [
maintenanceID ,
] ) ;
callback ( {
ok : true ,
statusPages ,
} ) ;
} catch ( e ) {
console . error ( e ) ;
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-10-18 14:00:39 +03:00
socket . on ( "getMonitorBeats" , async ( monitorID , period , callback ) => {
try {
checkLogin ( socket ) ;
2022-04-13 18:33:37 +03:00
log . info ( "monitor" , ` Get Monitor Beats: ${ monitorID } User ID: ${ socket . userID } ` ) ;
2021-10-18 14:00:39 +03:00
2021-10-22 13:38:41 +03:00
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 ,
] ) ;
2021-10-18 14:00:39 +03:00
callback ( {
2021-10-22 13:38:41 +03:00
ok : true ,
data : list ,
2021-10-18 14:00:39 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-06-25 16:55:49 +03:00
// Start or Resume the monitor
socket . on ( "resumeMonitor" , async ( monitorID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-06-25 16:55:49 +03:00
await startMonitor ( socket . userID , monitorID ) ;
2022-04-07 18:02:57 +03:00
await server . sendMonitorList ( socket ) ;
2021-06-25 16:55:49 +03:00
callback ( {
ok : true ,
2021-07-27 20:47:13 +03:00
msg : "Resumed Successfully." ,
2021-06-25 16:55:49 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-06-25 16:55:49 +03:00
} ) ;
}
} ) ;
socket . on ( "pauseMonitor" , async ( monitorID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
await pauseMonitor ( socket . userID , monitorID ) ;
2022-04-07 18:02:57 +03:00
await server . sendMonitorList ( socket ) ;
2021-06-25 16:55:49 +03:00
callback ( {
ok : true ,
2021-07-27 20:47:13 +03:00
msg : "Paused Successfully." ,
2021-06-25 16:55:49 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-06-25 16:55:49 +03:00
} ) ;
}
} ) ;
socket . on ( "deleteMonitor" , async ( monitorID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-06-25 16:55:49 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "manage" , ` Delete Monitor: ${ monitorID } User ID: ${ socket . userID } ` ) ;
2021-06-25 16:55:49 +03:00
2022-04-07 17:53:32 +03:00
if ( monitorID in server . monitorList ) {
server . monitorList [ monitorID ] . stop ( ) ;
delete server . monitorList [ monitorID ] ;
2021-06-25 16:55:49 +03:00
}
await R . exec ( "DELETE FROM monitor WHERE id = ? AND user_id = ? " , [
monitorID ,
2021-07-27 20:47:13 +03:00
socket . userID ,
2021-06-25 16:55:49 +03:00
] ) ;
callback ( {
ok : true ,
2021-07-27 20:47:13 +03:00
msg : "Deleted Successfully." ,
2021-06-25 16:55:49 +03:00
} ) ;
2022-04-07 18:02:57 +03:00
await server . sendMonitorList ( socket ) ;
2021-09-23 18:21:08 +03:00
// Clear heartbeat list on client
await sendImportantHeartbeatList ( socket , monitorID , true , true ) ;
2021-06-25 16:55:49 +03:00
} catch ( e ) {
2021-08-26 13:55:19 +03:00
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2022-01-23 17:22:00 +03:00
socket . on ( "deleteMaintenance" , async ( maintenanceID , callback ) => {
try {
checkLogin ( socket ) ;
console . log ( ` Delete Maintenance: ${ maintenanceID } User ID: ${ socket . userID } ` ) ;
if ( maintenanceID in maintenanceList ) {
delete maintenanceList [ maintenanceID ] ;
}
await R . exec ( "DELETE FROM maintenance WHERE id = ? AND user_id = ? " , [
maintenanceID ,
socket . userID ,
] ) ;
callback ( {
ok : true ,
msg : "Deleted Successfully." ,
} ) ;
await sendMaintenanceList ( socket ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-08-26 13:55:19 +03:00
socket . on ( "getTags" , async ( callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-26 13:55:19 +03:00
2021-09-21 16:22:35 +03:00
const list = await R . findAll ( "tag" ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : true ,
tags : list . map ( bean => bean . toJSON ( ) ) ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "addTag" , async ( tag , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-26 13:55:19 +03:00
2021-09-21 16:22:35 +03:00
let bean = R . dispense ( "tag" ) ;
bean . name = tag . name ;
bean . color = tag . color ;
await R . store ( bean ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : true ,
tag : await bean . toJSON ( ) ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "editTag" , async ( tag , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-26 13:55:19 +03:00
2021-09-21 16:22:35 +03:00
let bean = await R . findOne ( "monitor" , " id = ? " , [ tag . id ] ) ;
bean . name = tag . name ;
bean . color = tag . color ;
await R . store ( bean ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : true ,
tag : await bean . toJSON ( ) ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "deleteTag" , async ( tagID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-26 13:55:19 +03:00
2021-09-21 16:22:35 +03:00
await R . exec ( "DELETE FROM tag WHERE id = ? " , [ tagID ] ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : true ,
msg : "Deleted Successfully." ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "addMonitorTag" , async ( tagID , monitorID , value , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-26 13:55:19 +03:00
await R . exec ( "INSERT INTO monitor_tag (tag_id, monitor_id, value) VALUES (?, ?, ?)" , [
tagID ,
monitorID ,
value ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : true ,
msg : "Added Successfully." ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "editMonitorTag" , async ( tagID , monitorID , value , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-26 13:55:19 +03:00
await R . exec ( "UPDATE monitor_tag SET value = ? WHERE tag_id = ? AND monitor_id = ?" , [
value ,
tagID ,
monitorID ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-08-26 13:55:19 +03:00
callback ( {
ok : true ,
msg : "Edited Successfully." ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-09-10 09:22:34 +03:00
socket . on ( "deleteMonitorTag" , async ( tagID , monitorID , value , callback ) => {
2021-08-26 13:55:19 +03:00
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-26 13:55:19 +03:00
2021-09-10 09:22:34 +03:00
await R . exec ( "DELETE FROM monitor_tag WHERE tag_id = ? AND monitor_id = ? AND value = ?" , [
2021-08-26 13:55:19 +03:00
tagID ,
monitorID ,
2021-09-10 09:22:34 +03:00
value ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-08-26 13:55:19 +03:00
// Cleanup unused Tags
await R . exec ( "delete from tag where ( select count(*) from monitor_tag mt where tag.id = mt.tag_id ) = 0" ) ;
callback ( {
ok : true ,
msg : "Deleted Successfully." ,
} ) ;
} catch ( e ) {
2021-06-25 16:55:49 +03:00
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-06-25 16:55:49 +03:00
} ) ;
}
} ) ;
socket . on ( "changePassword" , async ( password , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-06-25 16:55:49 +03:00
2021-10-21 17:54:04 +03:00
if ( ! password . newPassword ) {
2021-09-21 16:22:35 +03:00
throw new Error ( "Invalid new password" ) ;
2021-06-25 16:55:49 +03:00
}
2021-10-21 17:54:04 +03: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 12:38:48 +03:00
let user = await doubleCheckPassword ( socket , password . currentPassword ) ;
await user . resetPassword ( password . newPassword ) ;
2021-06-25 16:55:49 +03:00
2022-03-29 12:38:48 +03:00
callback ( {
ok : true ,
msg : "Password has been updated successfully." ,
} ) ;
2021-06-25 16:55:49 +03:00
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-06-25 16:55:49 +03:00
} ) ;
}
} ) ;
2021-07-06 09:30:10 +03:00
2021-07-31 16:57:58 +03:00
socket . on ( "getSettings" , async ( callback ) => {
2021-07-06 09:30:10 +03:00
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-07-06 09:30:10 +03:00
callback ( {
ok : true ,
2021-07-31 16:57:58 +03:00
data : await getSettings ( "general" ) ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2022-03-29 12:38:48 +03:00
socket . on ( "setSettings" , async ( data , currentPassword , callback ) => {
2021-07-31 16:57:58 +03:00
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-07-31 16:57:58 +03:00
2022-04-28 18:12:16 +03: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 12:38:48 +03:00
await doubleCheckPassword ( socket , currentPassword ) ;
}
2021-09-15 15:40:26 +03:00
await setSettings ( "general" , data ) ;
exports . entryPage = data . entryPage ;
2021-07-31 16:57:58 +03:00
callback ( {
ok : true ,
msg : "Saved"
2021-07-06 09:30:10 +03:00
} ) ;
2021-10-08 15:03:52 +03:00
sendInfo ( socket ) ;
2021-07-06 09:30:10 +03:00
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-07-06 09:30:10 +03:00
} ) ;
}
} ) ;
2021-07-09 09:14:03 +03:00
// Add or Edit
socket . on ( "addNotification" , async ( notification , notificationID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-07-09 09:14:03 +03:00
2021-09-21 16:22:35 +03:00
let notificationBean = await Notification . save ( notification , notificationID , socket . userID ) ;
await sendNotificationList ( socket ) ;
2021-07-09 09:14:03 +03:00
callback ( {
ok : true ,
msg : "Saved" ,
2021-09-09 16:24:29 +03:00
id : notificationBean . id ,
2021-07-09 09:14:03 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-07-09 09:14:03 +03:00
} ) ;
}
} ) ;
socket . on ( "deleteNotification" , async ( notificationID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-07-09 09:14:03 +03:00
2021-09-21 16:22:35 +03:00
await Notification . delete ( notificationID , socket . userID ) ;
await sendNotificationList ( socket ) ;
2021-07-09 09:14:03 +03:00
callback ( {
ok : true ,
msg : "Deleted" ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-07-09 09:14:03 +03:00
} ) ;
}
} ) ;
socket . on ( "testNotification" , async ( notification , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-07-09 09:14:03 +03:00
2021-09-21 16:22:35 +03:00
let msg = await Notification . send ( notification , notification . name + " Testing" ) ;
2021-07-09 09:14:03 +03:00
callback ( {
ok : true ,
2021-07-27 20:47:13 +03:00
msg ,
2021-07-09 09:14:03 +03:00
} ) ;
} catch ( e ) {
2021-09-21 16:22:35 +03:00
console . error ( e ) ;
2021-07-18 15:49:46 +03:00
2021-07-09 09:14:03 +03:00
callback ( {
ok : false ,
2021-07-27 20:47:13 +03:00
msg : e . message ,
2021-07-09 09:14:03 +03:00
} ) ;
}
} ) ;
2021-07-18 13:51:58 +03:00
socket . on ( "checkApprise" , async ( callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-07-18 13:51:58 +03:00
callback ( Notification . checkApprise ( ) ) ;
} catch ( e ) {
callback ( false ) ;
}
} ) ;
2021-08-03 20:03:40 +03:00
2021-09-11 22:53:17 +03:00
socket . on ( "uploadBackup" , async ( uploadedJSON , importHandle , callback ) => {
2021-09-01 18:09:32 +03:00
try {
2021-09-24 09:34:53 +03:00
checkLogin ( socket ) ;
2021-09-01 18:09:32 +03:00
2021-09-02 17:13:31 +03:00
let backupData = JSON . parse ( uploadedJSON ) ;
2021-09-01 18:09:32 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "manage" , ` Importing Backup, User ID: ${ socket . userID } , Version: ${ backupData . version } ` ) ;
2021-09-23 18:31:01 +03:00
2021-09-11 22:53:17 +03:00
let notificationListData = backupData . notificationList ;
2021-10-30 20:37:15 +03:00
let proxyListData = backupData . proxyList ;
2021-09-11 22:53:17 +03:00
let monitorListData = backupData . monitorList ;
2021-09-01 18:09:32 +03:00
2021-09-24 09:34:53 +03:00
let version17x = compareVersions . compare ( backupData . version , "1.7.0" , ">=" ) ;
2021-09-17 04:25:18 +03:00
// If the import option is "overwrite" it'll clear most of the tables, except "settings" and "user"
2022-04-26 01:26:26 +03:00
if ( importHandle === "overwrite" ) {
2021-09-17 04:25:18 +03:00
// Stops every monitor first, so it doesn't execute any heartbeat while importing
2022-04-07 17:53:32 +03:00
for ( let id in server . monitorList ) {
let monitor = server . monitorList [ id ] ;
2021-09-21 16:22:35 +03:00
await monitor . stop ( ) ;
2021-09-01 18:09:32 +03:00
}
2021-09-11 22:53:17 +03: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" ) ;
2021-09-15 23:07:28 +03:00
await R . exec ( "DELETE FROM monitor_tag" ) ;
await R . exec ( "DELETE FROM tag" ) ;
2021-09-11 22:53:17 +03:00
await R . exec ( "DELETE FROM monitor" ) ;
2021-10-30 20:37:15 +03:00
await R . exec ( "DELETE FROM proxy" ) ;
2021-09-01 18:09:32 +03:00
}
2021-09-17 04:25:18 +03:00
// Only starts importing if the backup file contains at least one notification
2021-09-11 22:53:17 +03:00
if ( notificationListData . length >= 1 ) {
2021-09-17 04:25:18 +03:00
// Get every existing notification name and puts them in one simple string
2021-09-11 22:53:17 +03:00
let notificationNameList = await R . getAll ( "SELECT name FROM notification" ) ;
let notificationNameListString = JSON . stringify ( notificationNameList ) ;
2021-09-01 18:09:32 +03:00
2021-09-11 22:53:17 +03:00
for ( let i = 0 ; i < notificationListData . length ; i ++ ) {
2021-09-17 04:25:18 +03:00
// Only starts importing the notification if the import option is "overwrite", "keep" or "skip" but the notification doesn't exists
2022-04-26 01:26:26 +03:00
if ( ( importHandle === "skip" && notificationNameListString . includes ( notificationListData [ i ] . name ) === false ) || importHandle === "keep" || importHandle === "overwrite" ) {
2021-09-01 18:09:32 +03:00
2021-09-11 22:53:17 +03:00
let notification = JSON . parse ( notificationListData [ i ] . config ) ;
2021-09-21 16:22:35 +03:00
await Notification . save ( notification , null , socket . userID ) ;
2021-09-01 18:09:32 +03:00
2021-09-11 22:53:17 +03:00
}
}
}
2021-09-01 18:09:32 +03:00
2021-10-30 20:37:15 +03:00
// Only starts importing if the backup file contains at least one proxy
2022-04-14 05:12:03 +03:00
if ( proxyListData && proxyListData . length >= 1 ) {
2021-10-30 20:37:15 +03:00
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 10:27:35 +03:00
if ( [ "skip" , "keep" ] . includes ( importHandle ) && ! exists ) {
2021-10-30 20:37:15 +03:00
return ;
}
// Save proxy as new entry if exists update exists one
await Proxy . save ( proxy , exists ? proxy . id : undefined , proxy . userId ) ;
}
}
2021-09-17 04:25:18 +03:00
// Only starts importing if the backup file contains at least one monitor
2021-09-11 22:53:17 +03:00
if ( monitorListData . length >= 1 ) {
2021-09-17 04:25:18 +03:00
// Get every existing monitor name and puts them in one simple string
2021-09-11 22:53:17 +03:00
let monitorNameList = await R . getAll ( "SELECT name FROM monitor" ) ;
let monitorNameListString = JSON . stringify ( monitorNameList ) ;
for ( let i = 0 ; i < monitorListData . length ; i ++ ) {
2021-09-17 04:25:18 +03:00
// Only starts importing the monitor if the import option is "overwrite", "keep" or "skip" but the notification doesn't exists
2022-04-26 02:26:57 +03:00
if ( ( importHandle === "skip" && monitorNameListString . includes ( monitorListData [ i ] . name ) === false ) || importHandle === "keep" || importHandle === "overwrite" ) {
2021-09-11 22:53:17 +03:00
2021-09-17 04:25:18 +03: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
2021-09-16 13:29:33 +03:00
let retryInterval = 0 ;
2021-09-17 04:25:18 +03:00
/ *
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
* /
2021-09-23 18:15:11 +03:00
if ( version17x ) {
2021-09-16 13:29:33 +03:00
retryInterval = monitorListData [ i ] . retryInterval ;
2021-09-15 23:07:28 +03:00
}
2021-09-17 04:25:18 +03:00
// --- End ---
2021-09-11 22:53:17 +03:00
let monitor = {
2021-09-17 04:25:18 +03:00
// Define the new variable from earlier here
2021-09-11 22:53:17 +03:00
name : monitorListData [ i ] . name ,
type : monitorListData [ i ] . type ,
url : monitorListData [ i ] . url ,
2021-10-02 17:48:27 +03:00
method : monitorListData [ i ] . method || "GET" ,
body : monitorListData [ i ] . body ,
headers : monitorListData [ i ] . headers ,
2021-11-04 12:12:06 +03:00
basic _auth _user : monitorListData [ i ] . basic _auth _user ,
basic _auth _pass : monitorListData [ i ] . basic _auth _pass ,
2021-09-11 22:53:17 +03:00
interval : monitorListData [ i ] . interval ,
2021-09-15 23:07:28 +03:00
retryInterval : retryInterval ,
2021-09-11 22:53:17 +03:00
hostname : monitorListData [ i ] . hostname ,
maxretries : monitorListData [ i ] . maxretries ,
port : monitorListData [ i ] . port ,
keyword : monitorListData [ i ] . keyword ,
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 : { } ,
2021-10-30 20:37:15 +03:00
proxy _id : monitorListData [ i ] . proxy _id || null ,
2021-09-21 16:22:35 +03:00
} ;
2021-09-11 22:53:17 +03:00
2021-10-09 12:45:05 +03:00
if ( monitorListData [ i ] . pushToken ) {
monitor . pushToken = monitorListData [ i ] . pushToken ;
}
2021-09-21 16:22:35 +03:00
let bean = R . dispense ( "monitor" ) ;
2021-09-11 22:53:17 +03:00
let notificationIDList = monitor . notificationIDList ;
delete monitor . notificationIDList ;
monitor . accepted _statuscodes _json = JSON . stringify ( monitor . accepted _statuscodes ) ;
delete monitor . accepted _statuscodes ;
2021-09-21 16:22:35 +03:00
bean . import ( monitor ) ;
bean . user _id = socket . userID ;
await R . store ( bean ) ;
2021-09-11 22:53:17 +03:00
2021-09-17 04:25:18 +03:00
// Only for backup files with the version 1.7.0 or higher, since there was the tag feature implemented
2021-09-23 18:15:11 +03:00
if ( version17x ) {
2021-09-17 04:25:18 +03:00
// Only import if the specific monitor has tags assigned
2021-09-24 09:34:53 +03:00
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 ;
2021-09-15 23:07:28 +03:00
}
2021-09-24 09:34:53 +03:00
// 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 ,
] ) ;
2021-09-15 23:07:28 +03:00
}
}
2021-09-24 09:34:53 +03:00
await updateMonitorNotification ( bean . id , notificationIDList ) ;
2021-09-11 22:53:17 +03:00
2021-09-17 04:25:18 +03:00
// If monitor was active start it immediately, otherwise pause it
2022-04-26 02:26:57 +03:00
if ( monitorListData [ i ] . active === 1 ) {
2021-09-11 22:53:17 +03:00
await startMonitor ( socket . userID , bean . id ) ;
} else {
await pauseMonitor ( socket . userID , bean . id ) ;
}
2021-09-01 18:09:32 +03:00
2021-09-08 00:32:25 +03:00
}
2021-09-01 18:09:32 +03:00
}
2021-09-21 16:22:35 +03:00
await sendNotificationList ( socket ) ;
2022-04-07 18:02:57 +03:00
await server . sendMonitorList ( socket ) ;
2021-09-01 18:09:32 +03:00
}
callback ( {
ok : true ,
msg : "Backup successfully restored." ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-08-29 19:47:01 +03:00
socket . on ( "clearEvents" , async ( monitorID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-29 19:47:01 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "manage" , ` Clear Events Monitor: ${ monitorID } User ID: ${ socket . userID } ` ) ;
2021-08-29 19:47:01 +03:00
await R . exec ( "UPDATE heartbeat SET msg = ?, important = ? WHERE monitor_id = ? " , [
"" ,
"0" ,
monitorID ,
] ) ;
2021-09-04 21:03:40 +03:00
await sendImportantHeartbeatList ( socket , monitorID , true , true ) ;
2021-08-29 19:47:01 +03:00
callback ( {
ok : true ,
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "clearHeartbeats" , async ( monitorID , callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-08-29 19:47:01 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "manage" , ` Clear Heartbeats Monitor: ${ monitorID } User ID: ${ socket . userID } ` ) ;
2021-08-29 19:47:01 +03:00
await R . exec ( "DELETE FROM heartbeat WHERE monitor_id = ?" , [
monitorID
] ) ;
2021-09-04 21:03:40 +03:00
await sendHeartbeatList ( socket , monitorID , true , true ) ;
2021-08-29 19:47:01 +03:00
callback ( {
ok : true ,
2021-09-01 01:36:24 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
socket . on ( "clearStatistics" , async ( callback ) => {
try {
2021-09-21 16:22:35 +03:00
checkLogin ( socket ) ;
2021-09-01 01:36:24 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "manage" , ` Clear Statistics User ID: ${ socket . userID } ` ) ;
2021-09-01 01:36:24 +03:00
await R . exec ( "DELETE FROM heartbeat" ) ;
callback ( {
ok : true ,
2021-08-29 19:47:01 +03:00
} ) ;
} catch ( e ) {
callback ( {
ok : false ,
msg : e . message ,
} ) ;
}
} ) ;
2021-09-16 17:48:28 +03:00
// Status Page Socket Handler for admin only
statusPageSocketHandler ( socket ) ;
2022-03-29 09:48:02 +03:00
cloudflaredSocketHandler ( socket ) ;
2021-10-26 18:02:32 +03:00
databaseSocketHandler ( socket ) ;
2022-04-07 09:45:37 +03:00
proxySocketHandler ( socket ) ;
2021-09-16 17:48:28 +03:00
2022-04-13 18:33:37 +03:00
log . debug ( "server" , "added all socket handlers" ) ;
2021-08-03 20:03:40 +03:00
2021-08-04 08:31:17 +03:00
// ***************************
// Better do anything after added all socket handlers here
// ***************************
2022-04-13 18:33:37 +03:00
log . debug ( "auth" , "check auto login" ) ;
2021-08-03 20:03:40 +03:00
if ( await setting ( "disableAuth" ) ) {
2022-04-13 18:33:37 +03:00
log . info ( "auth" , "Disabled Auth: auto login to admin" ) ;
2021-09-21 16:22:35 +03:00
afterLogin ( socket , await R . findOne ( "user" ) ) ;
socket . emit ( "autoLogin" ) ;
2021-08-03 20:03:40 +03:00
} else {
2022-04-13 18:33:37 +03:00
log . debug ( "auth" , "need auth" ) ;
2021-08-03 20:03:40 +03:00
}
2021-06-25 16:55:49 +03:00
} ) ;
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Init the server" ) ;
2021-08-10 16:28:54 +03:00
2022-04-19 10:38:59 +03:00
server . httpServer . once ( "error" , async ( err ) => {
2021-08-10 16:28:54 +03:00
console . error ( "Cannot listen: " + err . message ) ;
2022-04-05 14:41:29 +03:00
await shutdownFunction ( ) ;
2021-08-10 16:28:54 +03:00
} ) ;
2021-08-10 11:36:21 +03:00
2022-04-19 10:38:59 +03:00
server . httpServer . listen ( port , hostname , ( ) => {
2021-08-10 11:36:21 +03:00
if ( hostname ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , ` Listening on ${ hostname } : ${ port } ` ) ;
2021-08-10 11:36:21 +03:00
} else {
2022-04-13 18:33:37 +03:00
log . info ( "server" , ` Listening on ${ port } ` ) ;
2021-08-10 11:36:21 +03:00
}
2021-06-25 16:55:49 +03:00
startMonitors ( ) ;
2021-08-21 14:50:22 +03:00
checkVersion . startInterval ( ) ;
2021-10-05 14:13:57 +03:00
if ( testMode ) {
startUnitTest ( ) ;
}
2021-06-25 16:55:49 +03:00
} ) ;
2021-09-27 18:40:38 +03:00
initBackgroundJobs ( args ) ;
2022-03-30 06:59:49 +03:00
// Start cloudflared at the end if configured
2022-03-30 15:08:26 +03:00
await cloudflaredAutoStart ( cloudflaredToken ) ;
2022-03-30 06:59:49 +03:00
2021-06-25 16:55:49 +03:00
} ) ( ) ;
2022-04-20 21:56:40 +03:00
/ * *
* Update notifications for a given monitor
* @ param { number } monitorID ID of monitor to update
2022-04-21 22:02:18 +03:00
* @ param { number [ ] } notificationIDList List of new notification
2022-04-20 21:56:40 +03:00
* providers to add
* @ returns { Promise < void > }
* /
2021-07-09 12:55:48 +03:00
async function updateMonitorNotification ( monitorID , notificationIDList ) {
2021-08-10 16:37:51 +03:00
await R . exec ( "DELETE FROM monitor_notification WHERE monitor_id = ? " , [
2021-07-27 20:47:13 +03:00
monitorID ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-07-09 12:55:48 +03:00
for ( let notificationID in notificationIDList ) {
if ( notificationIDList [ notificationID ] ) {
let relation = R . dispense ( "monitor_notification" ) ;
relation . monitor _id = monitorID ;
relation . notification _id = notificationID ;
2021-09-21 16:22:35 +03:00
await R . store ( relation ) ;
2021-07-09 12:55:48 +03:00
}
}
}
2022-04-20 21:56:40 +03:00
/ * *
* 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 16:55:49 +03:00
async function checkOwner ( userID , monitorID ) {
let row = await R . getRow ( "SELECT id FROM monitor WHERE id = ? AND user_id = ? " , [
monitorID ,
userID ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-06-25 16:55:49 +03:00
if ( ! row ) {
throw new Error ( "You do not own this monitor." ) ;
}
}
2022-01-23 17:22:00 +03:00
async function sendMaintenanceList ( socket ) {
let list = await getMaintenanceJSONList ( socket . userID ) ;
io . to ( socket . userID ) . emit ( "maintenanceList" , list ) ;
return list ;
}
2022-04-20 21:56:40 +03:00
/ * *
* Function called after user login
2021-11-10 08:24:31 +03:00
* This function is used to send the heartbeat list of a monitor .
2022-04-20 21:56:40 +03:00
* @ param { Socket } socket Socket . io instance
* @ param { Object } user User object
* @ returns { Promise < void > }
* /
2021-06-25 16:55:49 +03:00
async function afterLogin ( socket , user ) {
socket . userID = user . id ;
2021-09-21 16:22:35 +03:00
socket . join ( user . id ) ;
2021-06-29 11:06:20 +03:00
2022-04-07 18:02:57 +03:00
let monitorList = await server . sendMonitorList ( socket ) ;
2022-01-23 17:22:00 +03:00
sendMaintenanceList ( socket ) ;
2021-09-21 16:22:35 +03:00
sendNotificationList ( socket ) ;
2021-10-30 20:37:15 +03:00
sendProxyList ( socket ) ;
2021-08-08 20:58:56 +03:00
2021-08-23 13:52:55 +03:00
await sleep ( 500 ) ;
2022-03-21 10:28:59 +03:00
await StatusPage . sendStatusPageList ( io , socket ) ;
2021-08-23 13:52:55 +03:00
for ( let monitorID in monitorList ) {
await sendHeartbeatList ( socket , monitorID ) ;
}
for ( let monitorID in monitorList ) {
await sendImportantHeartbeatList ( socket , monitorID ) ;
}
for ( let monitorID in monitorList ) {
2021-09-21 16:22:35 +03:00
await Monitor . sendStats ( io , monitorID , user . id ) ;
2021-08-23 13:52:55 +03:00
}
2021-06-25 16:55:49 +03:00
}
2022-04-30 16:50:05 +03:00
/ * *
* Get a list of maintenances for the given user .
* @ param { string } userID - The ID of the user to get maintenances for .
* @ returns { Promise < Object > } A promise that resolves to an object with maintenance IDs as keys and maintenances objects as values .
* /
2022-01-23 17:22:00 +03:00
async function getMaintenanceJSONList ( userID ) {
let result = { } ;
let maintenanceList = await R . find ( "maintenance" , " user_id = ? ORDER BY end_date DESC, title" , [
userID ,
] ) ;
for ( let maintenance of maintenanceList ) {
result [ maintenance . id ] = await maintenance . toJSON ( ) ;
}
return result ;
}
2022-04-20 21:56:40 +03:00
/ * *
* Initialize the database
* @ param { boolean } [ testMode = false ] Should the connection be
* started in test mode ?
* @ returns { Promise < void > }
* /
2021-11-04 18:19:31 +03:00
async function initDatabase ( testMode = false ) {
2021-07-21 21:02:35 +03:00
if ( ! fs . existsSync ( Database . path ) ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Copying Database" ) ;
2021-07-21 21:02:35 +03:00
fs . copyFileSync ( Database . templatePath , Database . path ) ;
2021-07-11 08:47:57 +03:00
}
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Connecting to the Database" ) ;
2021-11-04 18:19:31 +03:00
await Database . connect ( testMode ) ;
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Connected" ) ;
2021-07-18 13:51:58 +03:00
2021-07-21 21:02:35 +03:00
// Patch the database
2021-09-21 16:22:35 +03:00
await Database . patch ( ) ;
2021-07-21 21:02:35 +03:00
2021-06-25 16:55:49 +03:00
let jwtSecretBean = await R . findOne ( "setting" , " `key` = ? " , [
2021-07-27 20:47:13 +03:00
"jwtSecret" ,
2021-06-25 16:55:49 +03:00
] ) ;
if ( ! jwtSecretBean ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "JWT secret is not found, generate one." ) ;
2021-08-09 15:09:01 +03:00
jwtSecretBean = await initJWTSecret ( ) ;
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Stored JWT secret into database" ) ;
2021-06-25 16:55:49 +03:00
} else {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Load JWT secret from database." ) ;
2021-06-25 16:55:49 +03:00
}
2021-07-21 21:02:35 +03:00
// If there is no record in user table, it is a new Uptime Kuma instance, need to setup
2021-07-11 08:47:57 +03:00
if ( ( await R . count ( "user" ) ) === 0 ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "No user, need setup" ) ;
2021-07-11 08:47:57 +03:00
needSetup = true ;
}
2021-06-25 16:55:49 +03:00
jwtSecret = jwtSecretBean . value ;
}
2022-04-20 21:56:40 +03: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 16:55:49 +03:00
async function startMonitor ( userID , monitorID ) {
2021-09-21 16:22:35 +03:00
await checkOwner ( userID , monitorID ) ;
2021-06-25 16:55:49 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "manage" , ` Resume Monitor: ${ monitorID } User ID: ${ userID } ` ) ;
2021-06-25 16:55:49 +03:00
await R . exec ( "UPDATE monitor SET active = 1 WHERE id = ? AND user_id = ? " , [
monitorID ,
2021-07-27 20:47:13 +03:00
userID ,
2021-06-25 16:55:49 +03:00
] ) ;
let monitor = await R . findOne ( "monitor" , " id = ? " , [
2021-07-27 20:47:13 +03:00
monitorID ,
2021-09-21 16:22:35 +03:00
] ) ;
2021-06-25 16:55:49 +03:00
2022-04-07 17:53:32 +03:00
if ( monitor . id in server . monitorList ) {
server . monitorList [ monitor . id ] . stop ( ) ;
2021-06-27 11:10:55 +03:00
}
2022-04-07 17:53:32 +03:00
server . monitorList [ monitor . id ] = monitor ;
2021-09-21 16:22:35 +03:00
monitor . start ( io ) ;
2021-06-25 16:55:49 +03:00
}
2022-04-20 21:56:40 +03: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 11:10:55 +03:00
async function restartMonitor ( userID , monitorID ) {
2021-09-21 16:22:35 +03:00
return await startMonitor ( userID , monitorID ) ;
2021-06-27 11:10:55 +03:00
}
2022-04-20 21:56:40 +03:00
/ * *
* Pause a given monitor
2022-04-21 15:01:22 +03:00
* @ param { number } userID ID of user who owns monitor
2022-04-20 21:56:40 +03:00
* @ param { number } monitorID ID of monitor to start
* @ returns { Promise < void > }
* /
2021-06-25 16:55:49 +03:00
async function pauseMonitor ( userID , monitorID ) {
2021-09-21 16:22:35 +03:00
await checkOwner ( userID , monitorID ) ;
2021-06-25 16:55:49 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "manage" , ` Pause Monitor: ${ monitorID } User ID: ${ userID } ` ) ;
2021-06-25 16:55:49 +03:00
await R . exec ( "UPDATE monitor SET active = 0 WHERE id = ? AND user_id = ? " , [
monitorID ,
2021-07-27 20:47:13 +03:00
userID ,
2021-06-25 16:55:49 +03:00
] ) ;
2022-04-07 17:53:32 +03:00
if ( monitorID in server . monitorList ) {
server . monitorList [ monitorID ] . stop ( ) ;
2021-06-25 16:55:49 +03:00
}
}
2022-04-20 21:56:40 +03:00
/** Resume active monitors */
2021-06-25 16:55:49 +03:00
async function startMonitors ( ) {
2021-09-21 16:22:35 +03:00
let list = await R . find ( "monitor" , " active = 1 " ) ;
2021-06-25 16:55:49 +03:00
for ( let monitor of list ) {
2022-04-07 17:53:32 +03:00
server . monitorList [ monitor . id ] = monitor ;
2021-08-19 13:41:31 +03:00
}
2021-08-19 13:33:52 +03:00
2021-08-19 13:41:31 +03:00
for ( let monitor of list ) {
monitor . start ( io ) ;
2021-08-19 13:33:52 +03:00
// 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 16:55:49 +03:00
}
}
2022-04-20 21:56:40 +03:00
/ * *
* Shutdown the application
2021-11-10 08:24:31 +03:00
* Stops all monitors and closes the database connection .
* @ param { string } signal The signal that triggered this function to be called .
2022-04-20 21:56:40 +03:00
* @ returns { Promise < void > }
* /
2021-07-15 20:44:51 +03:00
async function shutdownFunction ( signal ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Shutdown requested" ) ;
log . info ( "server" , "Called signal: " + signal ) ;
2021-07-15 20:44:51 +03:00
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Stopping all monitors" ) ;
2022-04-07 17:53:32 +03:00
for ( let id in server . monitorList ) {
let monitor = server . monitorList [ id ] ;
2021-09-21 16:22:35 +03:00
monitor . stop ( ) ;
2021-07-15 20:44:51 +03:00
}
2021-07-21 21:02:35 +03:00
await sleep ( 2000 ) ;
await Database . close ( ) ;
2022-04-05 14:41:29 +03:00
stopBackgroundJobs ( ) ;
await cloudflaredStop ( ) ;
2021-07-15 20:44:51 +03:00
}
2021-11-11 14:31:28 +03:00
function getClientIp ( socket ) {
2022-04-12 11:57:22 +03:00
return socket . client . conn . remoteAddress . replace ( /^.*:/ , "" ) ;
2021-07-15 20:44:51 +03:00
}
2022-04-20 21:56:40 +03:00
/** Final function called before application exits */
2021-07-15 20:44:51 +03:00
function finalFunction ( ) {
2022-04-13 18:33:37 +03:00
log . info ( "server" , "Graceful shutdown successful!" ) ;
2021-07-15 20:44:51 +03:00
}
2022-04-19 10:38:59 +03:00
gracefulShutdown ( server . httpServer , {
2021-07-27 20:47:13 +03:00
signals : "SIGINT SIGTERM" ,
2021-07-15 20:44:51 +03: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 20:47:13 +03:00
finally : finalFunction , // finally function (sync) - e.g. for logging
2021-07-15 20:44:51 +03:00
} ) ;
2021-08-17 10:32:34 +03:00
// Catch unexpected errors here
process . addListener ( "unhandledRejection" , ( error , promise ) => {
console . trace ( error ) ;
2022-05-06 09:41:34 +03:00
UptimeKumaServer . errorLog ( error , false ) ;
2021-08-17 10:32:34 +03:00
console . error ( "If you keep encountering errors, please report to https://github.com/louislam/uptime-kuma/issues" ) ;
} ) ;