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

552 lines
20 KiB
JavaScript
Raw Normal View History

2021-09-14 02:55:45 -04:00
let express = require("express");
const { allowDevAllOrigin, allowAllOrigin, percentageToColor, filterAndJoin, sendHttpError } = require("../util-server");
2021-09-14 02:55:45 -04:00
const { R } = require("redbean-node");
const apicache = require("../modules/apicache");
2021-09-22 03:10:08 -04:00
const Monitor = require("../model/monitor");
2021-09-30 12:09:43 -04:00
const dayjs = require("dayjs");
2023-01-31 16:33:36 -05:00
const { UP, MAINTENANCE, DOWN, PENDING, flipStatus, log } = require("../../src/util");
const StatusPage = require("../model/status_page");
const { UptimeKumaServer } = require("../uptime-kuma-server");
2023-03-02 16:57:36 -05:00
const { UptimeCacheList } = require("../uptime-cache-list");
2022-01-03 09:48:52 -05:00
const { makeBadge } = require("badge-maker");
2022-01-04 06:21:53 -05:00
const { badgeConstants } = require("../config");
2022-12-28 04:37:25 -05:00
const { Prometheus } = require("../prometheus");
2021-09-14 02:55:45 -04:00
let router = express.Router();
let cache = apicache.middleware;
const server = UptimeKumaServer.getInstance();
2021-09-30 12:09:43 -04:00
let io = server.io;
2022-04-06 10:43:22 -04:00
router.get("/api/entry-page", async (request, response) => {
2021-09-15 08:40:26 -04:00
allowDevAllOrigin(response);
2022-04-06 10:43:22 -04:00
let result = { };
if (request.hostname in StatusPage.domainMappingList) {
result.type = "statusPageMatchedDomain";
result.statusPageSlug = StatusPage.domainMappingList[request.hostname];
} else {
result.type = "entryPage";
result.entryPage = server.entryPage;
}
response.json(result);
2021-09-15 08:40:26 -04:00
});
2021-09-30 12:09:43 -04:00
router.get("/api/push/:pushToken", async (request, response) => {
try {
2021-09-30 12:09:43 -04:00
let pushToken = request.params.pushToken;
let msg = request.query.msg || "OK";
let ping = parseInt(request.query.ping) || null;
2022-04-28 11:44:08 -04:00
let statusString = request.query.status || "up";
let status = (statusString === "up") ? UP : DOWN;
2021-09-30 12:09:43 -04: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 01:59:59 -05:00
const previousHeartbeat = await Monitor.getPreviousHeartbeat(monitor.id);
if (monitor.isUpsideDown()) {
status = flipStatus(status);
}
let isFirstBeat = true;
let previousStatus = status;
let duration = 0;
2021-09-30 12:09:43 -04:00
let bean = R.dispense("heartbeat");
bean.time = R.isoDateTimeMillis(dayjs.utc());
if (previousHeartbeat) {
isFirstBeat = false;
previousStatus = previousHeartbeat.status;
duration = dayjs(bean.time).diff(dayjs(previousHeartbeat.time), "second");
}
if (await Monitor.isUnderMaintenance(monitor.id)) {
msg = "Monitor under maintenance";
status = MAINTENANCE;
}
log.debug("router", `/api/push/ called at ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
log.debug("router", "PreviousStatus: " + previousStatus);
log.debug("router", "Current Status: " + status);
bean.important = Monitor.isImportantBeat(isFirstBeat, previousStatus, status);
bean.monitor_id = monitor.id;
bean.status = status;
2021-09-30 12:09:43 -04:00
bean.msg = msg;
2021-10-01 04:43:11 -04:00
bean.ping = ping;
bean.duration = duration;
2021-09-30 12:26:27 -04:00
2021-09-30 12:09:43 -04:00
await R.store(bean);
io.to(monitor.user_id).emit("heartbeat", bean.toJSON());
2023-03-02 16:57:36 -05:00
UptimeCacheList.clearCache(monitor.id);
2021-09-30 12:09:43 -04:00
Monitor.sendStats(io, monitor.id, monitor.user_id);
2022-12-28 04:37:25 -05:00
new Prometheus(monitor).update(bean, undefined);
2021-09-30 12:09:43 -04:00
response.json({
ok: true,
});
if (Monitor.isImportantForNotification(isFirstBeat, previousStatus, status)) {
await Monitor.sendNotification(isFirstBeat, monitor, bean);
}
2021-09-30 12:09:43 -04:00
} catch (e) {
response.status(404).json({
2021-09-30 12:09:43 -04:00
ok: false,
msg: e.message
});
}
});
2022-01-04 06:21:53 -05:00
router.get("/api/badge/:id/status", cache("5 minutes"), async (request, response) => {
allowAllOrigin(response);
const {
label,
upLabel = "Up",
downLabel = "Down",
2023-01-11 15:14:46 -05:00
pendingLabel = "Pending",
maintenanceLabel = "Maintenance",
2022-01-04 06:21:53 -05:00
upColor = badgeConstants.defaultUpColor,
downColor = badgeConstants.defaultDownColor,
2023-01-11 15:14:46 -05:00
pendingColor = badgeConstants.defaultPendingColor,
maintenanceColor = badgeConstants.defaultMaintenanceColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
2022-01-04 06:21:53 -05:00
} = request.query;
try {
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 06:21:53 -05:00
);
2022-01-04 07:40:53 -05:00
const badgeValues = { style };
2022-01-04 06:21:53 -05: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;
2022-01-04 06:21:53 -05:00
if (label === undefined) {
badgeValues.label = "Status";
} else {
badgeValues.label = label;
}
switch (state) {
2023-01-31 16:33:36 -05:00
case DOWN:
badgeValues.color = downColor;
badgeValues.message = downLabel;
break;
2023-01-31 16:33:36 -05:00
case UP:
badgeValues.color = upColor;
badgeValues.message = upLabel;
break;
2023-01-31 16:33:36 -05:00
case PENDING:
2023-01-11 15:14:46 -05:00
badgeValues.color = pendingColor;
badgeValues.message = pendingLabel;
break;
2023-01-31 16:33:36 -05:00
case MAINTENANCE:
badgeValues.color = maintenanceColor;
badgeValues.message = maintenanceLabel;
break;
default:
badgeValues.color = badgeConstants.naColor;
badgeValues.message = "N/A";
}
2022-01-04 06:21:53 -05:00
}
// build the svg based on given values
const svg = makeBadge(badgeValues);
response.type("image/svg+xml");
response.send(svg);
} catch (error) {
sendHttpError(response, error.message);
2022-01-04 06:21:53 -05:00
}
});
router.get("/api/badge/:id/uptime/:duration?", cache("5 minutes"), async (request, response) => {
allowAllOrigin(response);
2022-01-03 09:48:52 -05:00
const {
label,
labelPrefix,
labelSuffix = badgeConstants.defaultUptimeLabelSuffix,
2022-01-03 09:48:52 -05:00
prefix,
suffix = badgeConstants.defaultUptimeValueSuffix,
2022-01-04 06:21:53 -05:00
color,
labelColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
2022-01-03 09:48:52 -05:00
} = request.query;
try {
const requestedMonitorId = parseInt(request.params.id, 10);
2022-01-04 06:21:53 -05: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 09:48:52 -05: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-03 09:48:52 -05:00
);
2022-01-04 07:40:53 -05:00
const badgeValues = { style };
2022-01-03 09:48:52 -05:00
if (!publicMonitor) {
// return a "N/A" badge in naColor (grey), if monitor is not public / not available / non existent
2022-01-03 09:48:52 -05:00
badgeValues.message = "N/A";
2022-01-04 06:21:53 -05:00
badgeValues.color = badgeConstants.naColor;
2022-01-03 09:48:52 -05:00
} else {
2022-01-04 06:21:53 -05:00
const uptime = overrideValue ?? await Monitor.calcUptime(
requestedDuration,
2022-01-03 09:48:52 -05:00
requestedMonitorId
);
// limit the displayed uptime percentage to four (two, when displayed as percent) decimal digits
2023-03-24 10:42:50 -04:00
const cleanUptime = (uptime * 100).toPrecision(4);
2022-01-05 05:48:25 -05:00
// use a given, custom color or calculate one based on the uptime value
2022-01-04 06:21:53 -05: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 06:21:53 -05:00
badgeValues.labelColor = labelColor ?? "";
// build a label string. If a custom label is given, override the default one (requestedDuration)
badgeValues.label = filterAndJoin([
labelPrefix,
label ?? `Uptime (${requestedDuration}${labelSuffix})`,
]);
2023-03-24 10:42:50 -04:00
badgeValues.message = filterAndJoin([ prefix, cleanUptime, suffix ]);
2022-01-04 06:21:53 -05:00
}
2022-01-03 09:48:52 -05:00
2022-01-04 06:21:53 -05:00
// build the SVG based on given values
const svg = makeBadge(badgeValues);
response.type("image/svg+xml");
response.send(svg);
} catch (error) {
sendHttpError(response, error.message);
2022-01-04 06:21:53 -05:00
}
});
router.get("/api/badge/:id/ping/:duration?", cache("5 minutes"), async (request, response) => {
allowAllOrigin(response);
const {
label,
labelPrefix,
labelSuffix = badgeConstants.defaultPingLabelSuffix,
2022-01-04 06:21:53 -05:00
prefix,
suffix = badgeConstants.defaultPingValueSuffix,
2022-01-04 06:21:53 -05:00
color = badgeConstants.defaultPingColor,
labelColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
2022-01-04 06:21:53 -05:00
} = request.query;
try {
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 06:21:53 -05:00
));
2022-01-04 07:40:53 -05:00
const badgeValues = { style };
2022-01-04 06:21:53 -05: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 06:21:53 -05:00
badgeValues.labelColor = labelColor ?? "";
// build a lable string. If a custom label is given, override the default one (requestedDuration)
badgeValues.label = filterAndJoin([ labelPrefix, label ?? `Avg. Ping (${requestedDuration}${labelSuffix})` ]);
badgeValues.message = filterAndJoin([ prefix, avgPing, suffix ]);
2022-01-03 09:48:52 -05:00
}
2022-01-04 06:23:16 -05:00
// build the SVG based on given values
2022-01-03 09:48:52 -05:00
const svg = makeBadge(badgeValues);
response.type("image/svg+xml");
response.send(svg);
} catch (error) {
sendHttpError(response, error.message);
2022-01-03 09:48:52 -05:00
}
2022-01-04 06:21:53 -05:00
});
2022-01-03 09:48:52 -05:00
router.get("/api/badge/:id/avg-response/:duration?", cache("5 minutes"), async (request, response) => {
allowAllOrigin(response);
const {
label,
labelPrefix,
labelSuffix,
prefix,
suffix = badgeConstants.defaultPingValueSuffix,
color = badgeConstants.defaultPingColor,
labelColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
} = request.query;
try {
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 existent
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 label string. If a custom label is given, override the default one (requestedDuration)
badgeValues.label = filterAndJoin([
labelPrefix,
label ?? `Avg. Response (${requestedDuration}h)`,
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) {
sendHttpError(response, error.message);
}
});
router.get("/api/badge/:id/cert-exp", cache("5 minutes"), async (request, response) => {
allowAllOrigin(response);
const date = request.query.date;
const {
label,
labelPrefix,
labelSuffix,
prefix,
suffix = date ? "" : badgeConstants.defaultCertExpValueSuffix,
upColor = badgeConstants.defaultUpColor,
warnColor = badgeConstants.defaultWarnColor,
downColor = badgeConstants.defaultDownColor,
warnDays = badgeConstants.defaultCertExpireWarnDays,
downDays = badgeConstants.defaultCertExpireDownDays,
labelColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
} = request.query;
try {
const requestedMonitorId = parseInt(request.params.id, 10);
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 existent
badgeValues.message = "N/A";
badgeValues.color = badgeConstants.naColor;
} else {
const tlsInfoBean = await R.findOne("monitor_tls_info", "monitor_id = ?", [
requestedMonitorId,
]);
if (!tlsInfoBean) {
// return a "No/Bad Cert" badge in naColor (grey), if no cert saved (does not save bad certs?)
badgeValues.message = "No/Bad Cert";
badgeValues.color = badgeConstants.naColor;
} else {
const tlsInfo = JSON.parse(tlsInfoBean.info_json);
if (!tlsInfo.valid) {
// return a "Bad Cert" badge in naColor (grey), when cert is not valid
badgeValues.message = "Bad Cert";
badgeValues.color = downColor;
} else {
const daysRemaining = parseInt(overrideValue ?? tlsInfo.certInfo.daysRemaining);
if (daysRemaining > warnDays) {
badgeValues.color = upColor;
} else if (daysRemaining > downDays) {
badgeValues.color = warnColor;
} else {
badgeValues.color = downColor;
}
// use a given, custom labelColor or use the default badge label color (defined by badge-maker)
badgeValues.labelColor = labelColor ?? "";
// build a label string. If a custom label is given, override the default one
badgeValues.label = filterAndJoin([
labelPrefix,
label ?? "Cert Exp.",
labelSuffix,
]);
badgeValues.message = filterAndJoin([ prefix, date ? tlsInfo.certInfo.validTo : daysRemaining, suffix ]);
}
}
}
// build the SVG based on given values
const svg = makeBadge(badgeValues);
response.type("image/svg+xml");
response.send(svg);
} catch (error) {
sendHttpError(response, error.message);
}
});
router.get("/api/badge/:id/response", cache("5 minutes"), async (request, response) => {
allowAllOrigin(response);
const {
label,
labelPrefix,
labelSuffix,
prefix,
suffix = badgeConstants.defaultPingValueSuffix,
color = badgeConstants.defaultPingColor,
labelColor,
style = badgeConstants.defaultStyle,
value, // for demo purpose only
} = request.query;
try {
const requestedMonitorId = parseInt(request.params.id, 10);
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 existent
badgeValues.message = "N/A";
badgeValues.color = badgeConstants.naColor;
} else {
const heartbeat = await Monitor.getPreviousHeartbeat(
requestedMonitorId
);
if (!heartbeat.ping) {
// return a "N/A" badge in naColor (grey), if previous heartbeat has no ping
badgeValues.message = "N/A";
badgeValues.color = badgeConstants.naColor;
} else {
const ping = parseInt(overrideValue ?? heartbeat.ping);
badgeValues.color = color;
// use a given, custom labelColor or use the default badge label color (defined by badge-maker)
badgeValues.labelColor = labelColor ?? "";
// build a label string. If a custom label is given, override the default one
badgeValues.label = filterAndJoin([
labelPrefix,
label ?? "Response",
labelSuffix,
]);
badgeValues.message = filterAndJoin([ prefix, ping, suffix ]);
}
}
// build the SVG based on given values
const svg = makeBadge(badgeValues);
response.type("image/svg+xml");
response.send(svg);
} catch (error) {
sendHttpError(response, error.message);
}
});
2021-09-14 02:55:45 -04:00
module.exports = router;