mirror of
https://github.com/louislam/uptime-kuma.git
synced 2024-10-30 03:00:40 +00:00
426 lines
13 KiB
JavaScript
426 lines
13 KiB
JavaScript
let express = require("express");
|
|
const { allowDevAllOrigin, getSettings, setting, percentageToColor, allowAllOrigin, filterAndJoin } = require("../util-server");
|
|
const { R } = require("redbean-node");
|
|
const server = require("../server");
|
|
const apicache = require("../modules/apicache");
|
|
const Monitor = require("../model/monitor");
|
|
const dayjs = require("dayjs");
|
|
const { UP, flipStatus, debug } = require("../../src/util");
|
|
const { makeBadge } = require("badge-maker");
|
|
const { badgeConstants } = require("../config");
|
|
let router = express.Router();
|
|
|
|
let cache = apicache.middleware;
|
|
let io = server.io;
|
|
|
|
router.get("/api/entry-page", async (_, response) => {
|
|
allowDevAllOrigin(response);
|
|
response.json(server.entryPage);
|
|
});
|
|
|
|
router.get("/api/push/:pushToken", async (request, response) => {
|
|
try {
|
|
|
|
let pushToken = request.params.pushToken;
|
|
let msg = request.query.msg || "OK";
|
|
let ping = request.query.ping || null;
|
|
|
|
let monitor = await R.findOne("monitor", " push_token = ? AND active = 1 ", [
|
|
pushToken
|
|
]);
|
|
|
|
if (! monitor) {
|
|
throw new Error("Monitor not found or not active.");
|
|
}
|
|
|
|
const previousHeartbeat = await Monitor.getPreviousHeartbeat(monitor.id);
|
|
|
|
let status = UP;
|
|
if (monitor.isUpsideDown()) {
|
|
status = flipStatus(status);
|
|
}
|
|
|
|
let isFirstBeat = true;
|
|
let previousStatus = status;
|
|
let duration = 0;
|
|
|
|
let bean = R.dispense("heartbeat");
|
|
bean.time = R.isoDateTime(dayjs.utc());
|
|
|
|
if (previousHeartbeat) {
|
|
isFirstBeat = false;
|
|
previousStatus = previousHeartbeat.status;
|
|
duration = dayjs(bean.time).diff(dayjs(previousHeartbeat.time), "second");
|
|
}
|
|
|
|
debug("PreviousStatus: " + previousStatus);
|
|
debug("Current Status: " + status);
|
|
|
|
bean.important = Monitor.isImportantBeat(isFirstBeat, previousStatus, status);
|
|
bean.monitor_id = monitor.id;
|
|
bean.status = status;
|
|
bean.msg = msg;
|
|
bean.ping = ping;
|
|
bean.duration = duration;
|
|
|
|
await R.store(bean);
|
|
|
|
io.to(monitor.user_id).emit("heartbeat", bean.toJSON());
|
|
Monitor.sendStats(io, monitor.id, monitor.user_id);
|
|
|
|
response.json({
|
|
ok: true,
|
|
});
|
|
|
|
if (bean.important) {
|
|
await Monitor.sendNotification(isFirstBeat, monitor, bean);
|
|
}
|
|
|
|
} catch (e) {
|
|
response.json({
|
|
ok: false,
|
|
msg: e.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// Status Page Config
|
|
router.get("/api/status-page/config", async (_request, response) => {
|
|
allowDevAllOrigin(response);
|
|
|
|
let config = await getSettings("statusPage");
|
|
|
|
if (! config.statusPageTheme) {
|
|
config.statusPageTheme = "light";
|
|
}
|
|
|
|
if (! config.statusPagePublished) {
|
|
config.statusPagePublished = true;
|
|
}
|
|
|
|
if (! config.statusPageTags) {
|
|
config.statusPageTags = false;
|
|
}
|
|
|
|
if (! config.title) {
|
|
config.title = "Uptime Kuma";
|
|
}
|
|
|
|
response.json(config);
|
|
});
|
|
|
|
// Status Page - Get the current Incident
|
|
// Can fetch only if published
|
|
router.get("/api/status-page/incident", async (_, response) => {
|
|
allowDevAllOrigin(response);
|
|
|
|
try {
|
|
await checkPublished();
|
|
|
|
let incident = await R.findOne("incident", " pin = 1 AND active = 1");
|
|
|
|
if (incident) {
|
|
incident = incident.toPublicJSON();
|
|
}
|
|
|
|
response.json({
|
|
ok: true,
|
|
incident,
|
|
});
|
|
|
|
} catch (error) {
|
|
send403(response, error.message);
|
|
}
|
|
});
|
|
|
|
// Status Page - Monitor List
|
|
// Can fetch only if published
|
|
router.get("/api/status-page/monitor-list", cache("5 minutes"), async (_request, response) => {
|
|
allowDevAllOrigin(response);
|
|
|
|
try {
|
|
await checkPublished();
|
|
const publicGroupList = [];
|
|
const tagsVisible = (await getSettings("statusPage")).statusPageTags;
|
|
const list = await R.find("group", " public = 1 ORDER BY weight ");
|
|
for (let groupBean of list) {
|
|
let monitorGroup = await groupBean.toPublicJSON();
|
|
if (tagsVisible) {
|
|
monitorGroup.monitorList = await Promise.all(monitorGroup.monitorList.map(async (monitor) => {
|
|
// Includes tags as an array in response, allows for tags to be displayed on public status page
|
|
const tags = await R.getAll(
|
|
`SELECT monitor_tag.monitor_id, monitor_tag.value, tag.name, tag.color
|
|
FROM monitor_tag
|
|
JOIN tag
|
|
ON monitor_tag.tag_id = tag.id
|
|
WHERE monitor_tag.monitor_id = ?`, [monitor.id]
|
|
);
|
|
return {
|
|
...monitor,
|
|
tags: tags
|
|
};
|
|
}));
|
|
}
|
|
|
|
publicGroupList.push(monitorGroup);
|
|
}
|
|
|
|
response.json(publicGroupList);
|
|
|
|
} catch (error) {
|
|
send403(response, error.message);
|
|
}
|
|
});
|
|
|
|
// Status Page Polling Data
|
|
// Can fetch only if published
|
|
router.get("/api/status-page/heartbeat", cache("5 minutes"), async (_request, response) => {
|
|
allowDevAllOrigin(response);
|
|
|
|
try {
|
|
await checkPublished();
|
|
|
|
let heartbeatList = {};
|
|
let uptimeList = {};
|
|
|
|
let monitorIDList = await R.getCol(`
|
|
SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
|
|
WHERE monitor_group.group_id = \`group\`.id
|
|
AND public = 1
|
|
`);
|
|
|
|
for (let monitorID of monitorIDList) {
|
|
let list = await R.getAll(`
|
|
SELECT * FROM heartbeat
|
|
WHERE monitor_id = ?
|
|
ORDER BY time DESC
|
|
LIMIT 50
|
|
`, [
|
|
monitorID,
|
|
]);
|
|
|
|
list = R.convertToBeans("heartbeat", list);
|
|
heartbeatList[monitorID] = list.reverse().map(row => row.toPublicJSON());
|
|
|
|
const type = 24;
|
|
uptimeList[`${monitorID}_${type}`] = await Monitor.calcUptime(type, monitorID);
|
|
}
|
|
|
|
response.json({
|
|
heartbeatList,
|
|
uptimeList
|
|
});
|
|
|
|
} catch (error) {
|
|
send403(response, error.message);
|
|
}
|
|
});
|
|
|
|
router.get("/api/badge/:id/status", cache("5 minutes"), async (request, response) => {
|
|
allowAllOrigin(response);
|
|
|
|
const {
|
|
label,
|
|
upLabel = "Up",
|
|
downLabel = "Down",
|
|
upColor = badgeConstants.defaultUpColor,
|
|
downColor = badgeConstants.defaultDownColor,
|
|
style = badgeConstants.defaultStyle,
|
|
value, // for demo purpose only
|
|
} = request.query;
|
|
|
|
try {
|
|
await checkPublished();
|
|
|
|
const requestedMonitorId = parseInt(request.params.id, 10);
|
|
const overrideValue = value !== undefined ? parseInt(value) : undefined;
|
|
|
|
let publicMonitor = await R.getRow(`
|
|
SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
|
|
WHERE monitor_group.group_id = \`group\`.id
|
|
AND monitor_group.monitor_id = ?
|
|
AND public = 1
|
|
`,
|
|
[requestedMonitorId]
|
|
);
|
|
|
|
const badgeValues = { style };
|
|
|
|
if (!publicMonitor) {
|
|
// return a "N/A" badge in naColor (grey), if monitor is not public / not available / non exsitant
|
|
|
|
badgeValues.message = "N/A";
|
|
badgeValues.color = badgeConstants.naColor;
|
|
} else {
|
|
const heartbeat = await Monitor.getPreviousHeartbeat(requestedMonitorId);
|
|
const state = overrideValue !== undefined ? overrideValue : heartbeat.status === 1;
|
|
|
|
badgeValues.color = state ? upColor : downColor;
|
|
badgeValues.message = label ?? state ? upLabel : downLabel;
|
|
}
|
|
|
|
// build the svg based on given values
|
|
const svg = makeBadge(badgeValues);
|
|
|
|
response.type("image/svg+xml");
|
|
response.send(svg);
|
|
} catch (error) {
|
|
send403(response, error.message);
|
|
}
|
|
});
|
|
|
|
router.get("/api/badge/:id/uptime/:duration?", cache("5 minutes"), async (request, response) => {
|
|
allowAllOrigin(response);
|
|
|
|
const {
|
|
label,
|
|
labelPrefix,
|
|
labelSuffix = badgeConstants.defaultUptimeLabelSuffix,
|
|
prefix,
|
|
suffix = badgeConstants.defaultUptimeValueSuffix,
|
|
color,
|
|
labelColor,
|
|
style = badgeConstants.defaultStyle,
|
|
value, // for demo purpose only
|
|
} = request.query;
|
|
|
|
try {
|
|
await checkPublished();
|
|
|
|
const requestedMonitorId = parseInt(request.params.id, 10);
|
|
// if no duration is given, set value to 24 (h)
|
|
const requestedDuration = request.params.duration !== undefined ? parseInt(request.params.duration, 10) : 24;
|
|
const overrideValue = value && parseFloat(value);
|
|
|
|
let publicMonitor = await R.getRow(`
|
|
SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
|
|
WHERE monitor_group.group_id = \`group\`.id
|
|
AND monitor_group.monitor_id = ?
|
|
AND public = 1
|
|
`,
|
|
[requestedMonitorId]
|
|
);
|
|
|
|
const badgeValues = { style };
|
|
|
|
if (!publicMonitor) {
|
|
// return a "N/A" badge in naColor (grey), if monitor is not public / not available / non exsitant
|
|
badgeValues.message = "N/A";
|
|
badgeValues.color = badgeConstants.naColor;
|
|
} else {
|
|
const uptime = overrideValue ?? await Monitor.calcUptime(
|
|
requestedDuration,
|
|
requestedMonitorId
|
|
);
|
|
|
|
// limit the displayed uptime percentage to four (two, when displayed as percent) decimal digits
|
|
const cleanUptime = parseFloat(uptime.toPrecision(4));
|
|
|
|
// use a given, custom color or calculate one based on the uptime value
|
|
badgeValues.color = color ?? percentageToColor(uptime);
|
|
// use a given, custom labelColor or use the default badge label color ( defined by badge-maker)
|
|
badgeValues.labelColor = labelColor ?? "";
|
|
// build a lable string. If a custom label is given, override the default one ( requestedDuration )
|
|
badgeValues.label = filterAndJoin([labelPrefix, label ?? requestedDuration, labelSuffix]);
|
|
badgeValues.message = filterAndJoin([prefix, `${cleanUptime * 100}`, suffix]);
|
|
}
|
|
|
|
// build the SVG based on given values
|
|
const svg = makeBadge(badgeValues);
|
|
|
|
response.type("image/svg+xml");
|
|
response.send(svg);
|
|
} catch (error) {
|
|
send403(response, error.message);
|
|
}
|
|
});
|
|
|
|
router.get("/api/badge/:id/ping/:duration?", cache("5 minutes"), async (request, response) => {
|
|
allowAllOrigin(response);
|
|
|
|
const {
|
|
label,
|
|
labelPrefix,
|
|
labelSuffix = badgeConstants.defaultPingLabelSuffix,
|
|
prefix,
|
|
suffix = badgeConstants.defaultPingValueSuffix,
|
|
color = badgeConstants.defaultPingColor,
|
|
labelColor,
|
|
style = badgeConstants.defaultStyle,
|
|
value, // for demo purpose only
|
|
} = request.query;
|
|
|
|
try {
|
|
await checkPublished();
|
|
|
|
const requestedMonitorId = parseInt(request.params.id, 10);
|
|
|
|
// Default duration is 24 (h) if not defined in queryParam, limited to 720h (30d)
|
|
const requestedDuration = Math.min(request.params.duration ? parseInt(request.params.duration, 10) : 24, 720);
|
|
const overrideValue = value && parseFloat(value);
|
|
|
|
const publicAvgPing = parseInt(await R.getCell(`
|
|
SELECT AVG(ping) FROM monitor_group, \`group\`, heartbeat
|
|
WHERE monitor_group.group_id = \`group\`.id
|
|
AND heartbeat.time > DATETIME('now', ? || ' hours')
|
|
AND heartbeat.ping IS NOT NULL
|
|
AND public = 1
|
|
AND heartbeat.monitor_id = ?
|
|
`,
|
|
[-requestedDuration, requestedMonitorId]
|
|
));
|
|
|
|
const badgeValues = { style };
|
|
|
|
if (!publicAvgPing) {
|
|
// return a "N/A" badge in naColor (grey), if monitor is not public / not available / non exsitant
|
|
|
|
badgeValues.message = "N/A";
|
|
badgeValues.color = badgeConstants.naColor;
|
|
} else {
|
|
const avgPing = parseInt(overrideValue ?? publicAvgPing);
|
|
|
|
badgeValues.color = color;
|
|
// use a given, custom labelColor or use the default badge label color ( defined by badge-maker)
|
|
badgeValues.labelColor = labelColor ?? "";
|
|
// build a lable string. If a custom label is given, override the default one ( requestedDuration )
|
|
badgeValues.label = filterAndJoin([labelPrefix, label ?? requestedDuration, labelSuffix]);
|
|
badgeValues.message = filterAndJoin([prefix, avgPing, suffix]);
|
|
}
|
|
|
|
// build the SVG based on given values
|
|
const svg = makeBadge(badgeValues);
|
|
|
|
response.type("image/svg+xml");
|
|
response.send(svg);
|
|
} catch (error) {
|
|
send403(response, error.message);
|
|
}
|
|
});
|
|
|
|
async function checkPublished() {
|
|
if (! await isPublished()) {
|
|
throw new Error("The status page is not published");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Default is published
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async function isPublished() {
|
|
const value = await setting("statusPagePublished");
|
|
if (value === null) {
|
|
return true;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function send403(res, msg = "") {
|
|
res.status(403).json({
|
|
"status": "fail",
|
|
"msg": msg,
|
|
});
|
|
}
|
|
|
|
module.exports = router;
|