uptime-kuma/server/routers/api-router.js

427 lines
13 KiB
JavaScript
Raw Normal View History

2021-09-14 09:55:45 +03:00
let express = require("express");
const { allowDevAllOrigin, getSettings, setting, percentageToColor, allowAllOrigin, filterAndJoin } = require("../util-server");
2021-09-14 09:55:45 +03:00
const { R } = require("redbean-node");
2021-09-15 15:40:26 +03:00
const server = require("../server");
const apicache = require("../modules/apicache");
2021-09-22 10:10:08 +03:00
const Monitor = require("../model/monitor");
2021-09-30 19:09:43 +03:00
const dayjs = require("dayjs");
const { UP, flipStatus, debug } = require("../../src/util");
2022-01-03 17:48:52 +03:00
const { makeBadge } = require("badge-maker");
2022-01-04 14:21:53 +03:00
const { badgeConstants } = require("../config");
2021-09-14 09:55:45 +03:00
let router = express.Router();
let cache = apicache.middleware;
2021-09-30 19:09:43 +03:00
let io = server.io;
2021-09-15 15:40:26 +03:00
router.get("/api/entry-page", async (_, response) => {
allowDevAllOrigin(response);
response.json(server.entryPage);
});
2021-09-30 19:09:43 +03:00
router.get("/api/push/:pushToken", async (request, response) => {
try {
2021-09-30 19:09:43 +03:00
let pushToken = request.params.pushToken;
let msg = request.query.msg || "OK";
let ping = request.query.ping || null;
2021-09-30 19:09:43 +03:00
let monitor = await R.findOne("monitor", " push_token = ? AND active = 1 ", [
pushToken
]);
if (! monitor) {
throw new Error("Monitor not found or not active.");
}
2021-12-08 09:59:59 +03:00
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;
2021-09-30 19:09:43 +03:00
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;
2021-09-30 19:09:43 +03:00
bean.msg = msg;
2021-10-01 11:43:11 +03:00
bean.ping = ping;
bean.duration = duration;
2021-09-30 19:26:27 +03:00
2021-09-30 19:09:43 +03:00
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);
}
2021-09-30 19:09:43 +03:00
} catch (e) {
response.json({
ok: false,
msg: e.message
});
}
});
2021-09-14 09:55:45 +03:00
// Status Page Config
router.get("/api/status-page/config", async (_request, response) => {
allowDevAllOrigin(response);
2021-09-15 09:34:30 +03:00
2021-09-20 15:44:07 +03:00
let config = await getSettings("statusPage");
2021-09-14 09:55:45 +03:00
if (! config.statusPageTheme) {
config.statusPageTheme = "light";
}
2021-09-15 09:34:30 +03:00
if (! config.statusPagePublished) {
config.statusPagePublished = true;
}
2021-10-29 08:19:24 +03:00
if (! config.statusPageTags) {
config.statusPageTags = false;
2021-10-29 08:19:24 +03:00
}
2021-09-14 18:27:11 +03:00
if (! config.title) {
config.title = "Uptime Kuma";
}
2021-09-14 09:55:45 +03:00
response.json(config);
});
2021-09-15 09:34:30 +03:00
// 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();
}
2021-09-16 17:48:28 +03:00
response.json({
ok: true,
incident,
});
2021-09-15 09:34:30 +03:00
} catch (error) {
send403(response, error.message);
}
});
2021-09-14 09:55:45 +03:00
// Status Page - Monitor List
2021-09-15 09:34:30 +03:00
// Can fetch only if published
router.get("/api/status-page/monitor-list", cache("5 minutes"), async (_request, response) => {
2021-09-14 09:55:45 +03:00
allowDevAllOrigin(response);
2021-09-15 09:34:30 +03:00
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) => {
2021-10-29 08:19:24 +03:00
// 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]
2021-12-08 09:59:59 +03:00
);
2021-12-08 10:04:18 +03:00
return {
...monitor,
tags: tags
};
}));
2021-10-29 08:19:24 +03:00
}
2021-10-28 05:07:19 +03:00
publicGroupList.push(monitorGroup);
2021-09-15 09:34:30 +03:00
}
response.json(publicGroupList);
2021-09-14 09:55:45 +03:00
2021-09-15 09:34:30 +03:00
} catch (error) {
send403(response, error.message);
}
2021-09-14 09:55:45 +03:00
});
// Status Page Polling Data
2021-09-15 09:34:30 +03:00
// Can fetch only if published
router.get("/api/status-page/heartbeat", cache("5 minutes"), async (_request, response) => {
2021-09-14 09:55:45 +03:00
allowDevAllOrigin(response);
2021-09-23 13:45:30 +03:00
2021-09-15 09:34:30 +03:00
try {
await checkPublished();
2021-09-14 09:55:45 +03:00
let heartbeatList = {};
2021-09-22 10:10:08 +03:00
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
2021-09-22 10:10:08 +03:00
LIMIT 50
`, [
monitorID,
]);
list = R.convertToBeans("heartbeat", list);
heartbeatList[monitorID] = list.reverse().map(row => row.toPublicJSON());
2021-09-22 10:10:08 +03:00
const type = 24;
uptimeList[`${monitorID}_${type}`] = await Monitor.calcUptime(type, monitorID);
2021-09-15 09:34:30 +03:00
}
response.json({
heartbeatList,
2021-09-22 10:10:08 +03:00
uptimeList
2021-09-15 09:34:30 +03:00
});
2021-09-14 09:55:45 +03:00
2021-09-15 09:34:30 +03:00
} catch (error) {
send403(response, error.message);
}
2021-09-14 09:55:45 +03:00
});
2022-01-04 14:21:53 +03:00
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
2022-01-04 14:21:53 +03:00
} = 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]
);
2022-01-04 15:40:53 +03:00
const badgeValues = { style };
2022-01-04 14:21:53 +03:00
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);
2022-01-03 17:48:52 +03:00
const {
label,
labelPrefix,
labelSuffix = badgeConstants.defaultUptimeLabelSuffix,
2022-01-03 17:48:52 +03:00
prefix,
suffix = badgeConstants.defaultUptimeValueSuffix,
2022-01-04 14:21:53 +03:00
color,
labelColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
2022-01-03 17:48:52 +03:00
} = request.query;
try {
await checkPublished();
const requestedMonitorId = parseInt(request.params.id, 10);
2022-01-04 14:21:53 +03:00
// 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);
2022-01-03 17:48:52 +03:00
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]
);
2022-01-04 15:40:53 +03:00
const badgeValues = { style };
2022-01-03 17:48:52 +03:00
if (!publicMonitor) {
2022-01-04 14:21:53 +03:00
// return a "N/A" badge in naColor (grey), if monitor is not public / not available / non exsitant
2022-01-03 17:48:52 +03:00
badgeValues.message = "N/A";
2022-01-04 14:21:53 +03:00
badgeValues.color = badgeConstants.naColor;
2022-01-03 17:48:52 +03:00
} else {
2022-01-04 14:21:53 +03:00
const uptime = overrideValue ?? await Monitor.calcUptime(
requestedDuration,
2022-01-03 17:48:52 +03:00
requestedMonitorId
);
// limit the displayed uptime percentage to four (two, when displayed as percent) decimal digits
2022-01-05 13:48:25 +03:00
const cleanUptime = parseFloat(uptime.toPrecision(4));
// use a given, custom color or calculate one based on the uptime value
2022-01-04 14:21:53 +03:00
badgeValues.color = color ?? percentageToColor(uptime);
// use a given, custom labelColor or use the default badge label color (defined by badge-maker)
2022-01-04 14:21:53 +03:00
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]);
2022-01-05 13:48:25 +03:00
badgeValues.message = filterAndJoin([prefix, `${cleanUptime * 100}`, suffix]);
2022-01-04 14:21:53 +03:00
}
2022-01-03 17:48:52 +03:00
2022-01-04 14:21:53 +03:00
// 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,
2022-01-04 14:21:53 +03:00
prefix,
suffix = badgeConstants.defaultPingValueSuffix,
2022-01-04 14:21:53 +03:00
color = badgeConstants.defaultPingColor,
labelColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
2022-01-04 14:21:53 +03:00
} = 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]
));
2022-01-04 15:40:53 +03:00
const badgeValues = { style };
2022-01-04 14:21:53 +03:00
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)
2022-01-04 14:21:53 +03:00
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]);
2022-01-03 17:48:52 +03:00
}
2022-01-04 14:23:16 +03:00
// build the SVG based on given values
2022-01-03 17:48:52 +03:00
const svg = makeBadge(badgeValues);
response.type("image/svg+xml");
response.send(svg);
} catch (error) {
send403(response, error.message);
}
2022-01-04 14:21:53 +03:00
});
2022-01-03 17:48:52 +03:00
2021-09-15 09:34:30 +03:00
async function checkPublished() {
if (! await isPublished()) {
throw new Error("The status page is not published");
}
}
2021-09-15 13:28:48 +03:00
/**
* Default is published
* @returns {Promise<boolean>}
*/
2021-09-15 09:34:30 +03:00
async function isPublished() {
2021-09-15 13:28:48 +03:00
const value = await setting("statusPagePublished");
if (value === null) {
return true;
}
return value;
2021-09-15 09:34:30 +03:00
}
function send403(res, msg = "") {
res.status(403).json({
"status": "fail",
"msg": msg,
});
2021-09-15 09:34:30 +03:00
}
2021-09-14 09:55:45 +03:00
module.exports = router;