@oneuptime/common 12.0.25 → 12.0.26

package/build/dist/Utils/NetworkDiscovery/PingMonitorBuilder.js

@@ -0,0 +1,163 @@
+import Monitor from "../../Models/DatabaseModels/Monitor";
+import Hostname from "../../Types/API/Hostname";
+import IP from "../../Types/IP/IP";
+import MonitorStep from "../../Types/Monitor/MonitorStep";
+import MonitorSteps from "../../Types/Monitor/MonitorSteps";
+import MonitorType from "../../Types/Monitor/MonitorType";
+import ObjectID from "../../Types/ObjectID";
+/*
+ * The Ping monitor a ping-only discovered host imports with.
+ *
+ * WHY THIS EXISTS
+ *
+ * A host that answered ICMP but not SNMP imports as a monitor-backed device:
+ * no probe, no credentials, polling off (DiscoveredDeviceBuilder). That is
+ * deliberate — there is nothing to walk it with — but it leaves the device
+ * with NO health source at all. Its status reads "Pending" forever, its
+ * "Last Seen" reads never, and the only way out was for an operator to hand-
+ * create a Ping monitor and hand-bind it, per device. Fourteen discovered
+ * phones meant fourteen monitors and fourteen device edits, which is
+ * OneUptime/oneuptime#3447.
+ *
+ * The probe already proved the host answers ICMP — that is the only reason it
+ * is in the scan results at all (SubnetScanner records a no-SNMP host only
+ * when it was in `pingAliveHosts`). So the monitor this builds is not a guess:
+ * it re-asks, on a schedule, the exact question the scan already answered once.
+ *
+ * WHAT IT DELIBERATELY DOES NOT DO
+ *
+ * No database and no permission work — the caller persists it through
+ * MonitorService/ModelAPI so tenant, billing, probe-attachment and status-
+ * timeline hooks still run. Creating a monitor is billable and plan-limited,
+ * so provisioning is always something the operator opted into, never a
+ * side effect of importing.
+ */
+/*
+ * Monitor.name is varchar(100), but the real ceiling is the SLUG: Monitor is
+ * @SlugifyColumn("name", "slug") and Slug.getSlug appends a dash plus ten
+ * random digits into its own varchar(100), and the create path THROWS on
+ * overflow rather than truncating. So a name over ~88 characters fails the
+ * create even though the name column would have taken it — the same trap
+ * MAX_DEVICE_NAME_LENGTH exists for on the device side.
+ *
+ * 88 leaves exactly the slug's 11-character tail. Device names already arrive
+ * clamped to 80 by DiscoveredDeviceBuilder and the prefix is 5, so 85 is the
+ * realistic worst case through the import path; this is the backstop for a
+ * device renamed by hand afterwards.
+ */
+export const MAX_PING_MONITOR_NAME_LENGTH = 88;
+const PING_MONITOR_NAME_PREFIX = "Ping ";
+/*
+ * How often the provisioned monitor pings, as a cron expression.
+ *
+ * Set explicitly because leaving `monitoringInterval` NULL is NOT "use a
+ * sensible default" — MonitorProbeService falls back to now + 1 MINUTE when
+ * the column is null (both in claimMonitorProbesForProbing's batch UPDATE and
+ * in the per-probe path). Importing a subnet's worth of IP phones would then
+ * ping every one of them every sixty seconds, forever, because nobody chose
+ * that. Five minutes is what the monitor create page pre-seeds, so a
+ * provisioned monitor matches a hand-made one and the operator can change it
+ * from the same dropdown.
+ */
+export const PING_MONITOR_INTERVAL = "*/5 * * * *";
+/**
+ * The monitor's name: "Ping <device name>", clamped to the column.
+ *
+ * Named after the DEVICE rather than the address because that is what an
+ * operator scanning a monitor list is looking for, and because two devices can
+ * legitimately share an address across separate VRFs while their names differ.
+ */
+export function buildPingMonitorName(deviceName) {
+    const trimmedDeviceName = (deviceName || "").trim();
+    const composed = `${PING_MONITOR_NAME_PREFIX}${trimmedDeviceName}`;
+    return composed.length > MAX_PING_MONITOR_NAME_LENGTH
+        ? composed.substring(0, MAX_PING_MONITOR_NAME_LENGTH)
+        : composed;
+}
+/**
+ * The destination the monitor pings.
+ *
+ * A discovered host's address is an IP in every case the scanner produces —
+ * it sweeps address ranges — but the column is free text and a hand-written
+ * scan row could hold a name, so anything that does not parse as an IP is
+ * carried as a Hostname rather than rejected. MonitorStep accepts either.
+ */
+export function buildPingMonitorDestination(address) {
+    const trimmedAddress = (address || "").trim();
+    if (IP.isIP(trimmedAddress)) {
+        return IP.fromString(trimmedAddress);
+    }
+    return new Hostname(trimmedAddress);
+}
+/**
+ * Turn OFF incident creation on every criteria instance of a step, leaving
+ * `changeMonitorStatus` alone.
+ *
+ * A hand-made Ping monitor defaults to opening an incident when the host stops
+ * answering, which is right for a monitor someone deliberately created for one
+ * service. This is a BULK action: an operator ticking "import 14 hosts" is
+ * recording inventory, and the default would hand them fourteen monitors that
+ * each open an incident — with on-call notifications, workspace posts and
+ * status-page impact — the first time a consumer access point or an IP phone
+ * misses a ping.
+ *
+ * `changeMonitorStatus` stays true because that is the whole point: it is what
+ * moves the monitor's status, which is what the device's status pill reads.
+ * So the device goes Up/Down correctly and nobody gets paged for it. Turning
+ * incidents back on is one edit per monitor, and is the operator's call.
+ */
+function suppressIncidentCreation(step) {
+    var _a, _b, _c;
+    const criteriaInstances = ((_c = (_b = (_a = step.data) === null || _a === void 0 ? void 0 : _a.monitorCriteria) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.monitorCriteriaInstanceArray) || [];
+    for (const criteriaInstance of criteriaInstances) {
+        if (criteriaInstance.data) {
+            criteriaInstance.data.createIncidents = false;
+        }
+    }
+}
+/**
+ * One ping-only discovered host -> the Ping monitor that will report its
+ * health once bound to the device through `NetworkDevice.monitorId`.
+ *
+ * The caller creates this monitor FIRST, then creates the device carrying the
+ * new monitor's id: `NetworkDeviceService.onCreateSuccess` stamps the
+ * monitor's current status onto the device at bind time, so the device's
+ * status pill resolves on the first render rather than waiting for the
+ * monitor's next status CHANGE (which on a healthy network may never come —
+ * that was OneUptime/oneuptime#3392).
+ */
+export function buildPingMonitorForDiscoveredHost(data) {
+    var _a;
+    const address = (((_a = data.host) === null || _a === void 0 ? void 0 : _a.ipAddress) || "").trim();
+    if (!address) {
+        throw new Error("A discovered host needs an address before a Ping monitor can be built for it.");
+    }
+    const monitor = new Monitor();
+    monitor.projectId = new ObjectID(data.projectId.toString());
+    monitor.name = buildPingMonitorName(data.deviceName);
+    monitor.description = `Reachability for ${address}, created when this device was imported from a network discovery scan. The device answered ping but not SNMP, so this monitor is what reports whether it is up.`;
+    monitor.monitorType = MonitorType.Ping;
+    monitor.monitoringInterval = PING_MONITOR_INTERVAL;
+    const step = MonitorStep.getDefaultMonitorStep({
+        monitorName: monitor.name,
+        monitorType: MonitorType.Ping,
+        onlineMonitorStatusId: data.seedIds.onlineMonitorStatusId,
+        offlineMonitorStatusId: data.seedIds.offlineMonitorStatusId,
+        defaultIncidentSeverityId: data.seedIds.defaultIncidentSeverityId,
+        defaultAlertSeverityId: data.seedIds.defaultAlertSeverityId,
+    });
+    /*
+     * The destination is what makes the step valid: MonitorStep's validation
+     * rejects a Ping step without one ("Monitor Destination is required").
+     */
+    step.setMonitorDestination(buildPingMonitorDestination(address));
+    suppressIncidentCreation(step);
+    const monitorSteps = new MonitorSteps();
+    monitorSteps.data = {
+        monitorStepsInstanceArray: [step],
+        defaultMonitorStatusId: data.seedIds.onlineMonitorStatusId,
+    };
+    monitor.monitorSteps = monitorSteps;
+    return monitor;
+}
+//# sourceMappingURL=PingMonitorBuilder.js.map

package/build/dist/Utils/NetworkDiscovery/PingMonitorBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PingMonitorBuilder.js","sourceRoot":"","sources":["../../../../Utils/NetworkDiscovery/PingMonitorBuilder.ts"],"names":[],"mappings":"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"}

package/build/dist/Utils/NetworkDiscovery/RescanIntervalUtil.js

@@ -0,0 +1,99 @@
+/*
+ * The recurrence cadence of a Network Device Discovery Scan: how often a
+ * recurring scan re-runs, and when the next run is due.
+ *
+ * WHY IT LIVES IN Common
+ *
+ * Four places have an opinion about this number and they must not disagree:
+ *
+ *   - the create/edit form (App Dashboard, DiscoveryScanFormValidation) — so
+ *     the operator is told the floor before they save, not after;
+ *   - the write hooks (Common server service) — which derive `nextScanAt` on
+ *     an edit, because the requeue worker only ever looks at that column and
+ *     a NULL there means "never runs again";
+ *   - the probe-ingest result endpoint (App Telemetry) — which stamps
+ *     `nextScanAt` when a run finishes;
+ *   - the requeue worker (App Workers) — which is sized against this floor.
+ *
+ * The floor and the clamp used to be written out three times, in three
+ * packages, with three chances to drift. Same reason ScanTargetUtil and
+ * ScanNameUtil sit next door.
+ */
+import OneUptimeDate from "../../Types/Date";
+/*
+ * The shortest cadence a recurring discovery scan may run at.
+ *
+ * A sweep is bounded but heavy: at the ScanTargetUtil.MAX_SCAN_HOSTS ceiling
+ * (32,768 addresses) it can take the better part of an hour, and a probe runs
+ * one sweep at a time. Re-queueing more often than this simply stacks scans on
+ * the probe, which never catches up.
+ */
+export const MINIMUM_RESCAN_INTERVAL_IN_MINUTES = 15;
+/*
+ * The cadence a stored interval actually runs at.
+ *
+ * Clamped rather than rejected, and that is deliberate: rows written before
+ * the form enforced a floor — and rows written by an API client, which the
+ * server does not refuse — still recur, just no faster than the probe can
+ * keep up with. Returns null for a value that does not describe a cadence at
+ * all (absent, zero, negative, NaN), which is the caller's signal that there
+ * is no next run to schedule.
+ */
+export const clampRescanIntervalInMinutes = (intervalInMinutes) => {
+    if (typeof intervalInMinutes !== "number" ||
+        !isFinite(intervalInMinutes) ||
+        intervalInMinutes <= 0) {
+        return null;
+    }
+    return Math.max(intervalInMinutes, MINIMUM_RESCAN_INTERVAL_IN_MINUTES);
+};
+/*
+ * When a scan is next due, derived from the scan itself.
+ *
+ * `nextScanAt` is not an independent fact, it is a function of the recurrence
+ * settings and the last completion — which is exactly why it can be recomputed
+ * when those settings change. Before it was derived, the only writer was the
+ * result-ingest endpoint at the moment a run finished, so turning recurrence
+ * ON for a scan that had already completed stamped nothing: the column stayed
+ * NULL, `("nextScanAt" <= now)` is UNKNOWN for NULL, and the requeue worker
+ * never matched the row again. The scan advertised "Every 60 min" in the list
+ * and never ran (OneUptime issue #3444).
+ *
+ * The value returned for an unchanged, already-recurring scan is the same one
+ * the ingest endpoint stamped (it wrote `completedAt + interval` too), so
+ * recomputing is a no-op rather than a rescheduling.
+ *
+ *   - not recurring, or no usable interval -> null, i.e. never
+ *   - still Pending or In Progress -> null; the run in flight will stamp it
+ *   - Completed / Failed -> the moment one interval after it finished. Already
+ *     in the past is fine and means "due now": the worker's predicate is
+ *     `nextScanAt <= now`.
+ */
+export const getNextScanAt = (scan, now) => {
+    if (!scan.isRecurring) {
+        return null;
+    }
+    const intervalInMinutes = clampRescanIntervalInMinutes(scan.rescanIntervalInMinutes);
+    if (intervalInMinutes === null) {
+        return null;
+    }
+    if (scan.status !== "Completed" && scan.status !== "Failed") {
+        return null;
+    }
+    /*
+     * A Completed row without a completedAt should not exist — every writer of
+     * one writes the other — but a row hand-edited or written by an older build
+     * still deserves a next run rather than being stranded, so it is scheduled
+     * from now.
+     */
+    const lastRunAt = scan.completedAt || now;
+    /*
+     * Deliberately NOT clamped forward to `now`. A moment already in the past is
+     * a correct answer — it means "due, and the worker has not got to it yet" —
+     * and clamping would cost the property that makes this safe to re-derive on
+     * every save: the same row always produces the same answer, so re-posting an
+     * unchanged schedule writes nothing.
+     */
+    return OneUptimeDate.addRemoveMinutes(OneUptimeDate.fromString(lastRunAt), intervalInMinutes);
+};
+//# sourceMappingURL=RescanIntervalUtil.js.map

package/build/dist/Utils/NetworkDiscovery/RescanIntervalUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RescanIntervalUtil.js","sourceRoot":"","sources":["../../../../Utils/NetworkDiscovery/RescanIntervalUtil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAE7C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAW,EAAE,CAAC;AAM7D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAgC,CACvE,iBAA4C,EAC7B,EAAE;IACjB,IACE,OAAO,iBAAiB,KAAK,QAAQ;QACrC,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAC5B,iBAAiB,IAAI,CAAC,EACtB,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,IAAI,CAAC,GAAG,CAAC,iBAAiB,EAAE,kCAAkC,CAAC,CAAC;AACzE,CAAC,CAAC;AA0BF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,aAAa,GAA0B,CAClD,IAAyB,EACzB,GAAS,EACI,EAAE;IACf,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,iBAAiB,GAAkB,4BAA4B,CACnE,IAAI,CAAC,uBAAuB,CAC7B,CAAC;IAEF,IAAI,iBAAiB,KAAK,IAAI,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,IAAI,CAAC,MAAM,KAAK,WAAW,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,MAAM,SAAS,GAAS,IAAI,CAAC,WAAW,IAAI,GAAG,CAAC;IAEhD;;;;;;OAMG;IACH,OAAO,aAAa,CAAC,gBAAgB,CACnC,aAAa,CAAC,UAAU,CAAC,SAAS,CAAC,EACnC,iBAAiB,CAClB,CAAC;AACJ,CAAC,CAAC"}

package/build/dist/Utils/NetworkDiscovery/ScanModeUtil.js

@@ -0,0 +1,85 @@
+/*
+ * What a Network Device Discovery Scan actually probes each address with.
+ *
+ * WHY IT EXISTS
+ *
+ * A discovery scan used to be an SNMP scan, full stop: the sweep pinged every
+ * address as a cheap reachability gate and then asked each live one for its
+ * SNMP system group. That is the right sweep for a subnet of managed gear, and
+ * the wrong one for the case operators kept hitting — "I just want to know what
+ * is alive in 10.20.30.0/24". The wizard had no way to say so, and because
+ * SNMP Version was a required field on its own step, an ICMP-only scan could
+ * not even be submitted: "SNMP Version is required" blocked Next regardless of
+ * intent (OneUptime issue #3445).
+ *
+ * `isSnmpEnabled` on the scan is that missing sentence, and this module is the
+ * one place that reads it.
+ *
+ * WHY THE READ IS `!== false` AND NOT `Boolean(...)`
+ *
+ * Three writers can hand a scan row to this predicate, and only one of them is
+ * guaranteed to have the column:
+ *
+ *   - The database, where the column is NOT NULL DEFAULT true, so every scan
+ *     that predates it reads as SNMP-enabled — which is what those scans were.
+ *   - The probe-ingest payload, where the column only appears if the SERVER is
+ *     new enough to select it. A new probe polling an older server would
+ *     otherwise see `undefined`, read it as "SNMP is off", and quietly stop
+ *     doing SNMP discovery on every scan in the project.
+ *   - A direct API call, which may simply omit it.
+ *
+ * So absence means "SNMP", exactly as it did before the column existed, and
+ * only an EXPLICIT false turns it off. Same defensive shape as
+ * `snmpReachable === false` in DiscoveryImportEligibility, and for the same
+ * reason: the legacy value of a new optional flag has to keep meaning what the
+ * rows already on disk meant.
+ *
+ * WHY IT LIVES IN Common
+ *
+ * The question "does this scan do SNMP?" is asked by the create/edit form (App
+ * Dashboard), the probe-ingest endpoints (App Telemetry), the sweep itself
+ * (Probe) and the results dialog. One copy is what stops the wizard hiding the
+ * SNMP fields for a scan the probe then SNMP-probes anyway. Same reason
+ * ScanNameUtil and ScanTargetUtil sit next door.
+ */
+/*
+ * How a scan describes itself in one short phrase — for a table cell, a badge,
+ * or a log line. Deliberately names ICMP the way the wizard does ("Ping only")
+ * rather than by protocol, because that is the word the operator chose.
+ */
+export var ScanMethodLabel;
+(function (ScanMethodLabel) {
+    ScanMethodLabel["PingAndSnmp"] = "Ping + SNMP";
+    ScanMethodLabel["PingOnly"] = "Ping only";
+})(ScanMethodLabel || (ScanMethodLabel = {}));
+export class ScanModeUtil {
+    /**
+     * True when this scan should probe SNMP after the ICMP sweep.
+     *
+     * Absence reads as TRUE — see the module comment. Callers must ask through
+     * this rather than reading the column, so that "the wizard hid the SNMP
+     * fields" and "the probe skipped SNMP" can never disagree.
+     */
+    static isSnmpEnabled(scan) {
+        return (scan === null || scan === void 0 ? void 0 : scan.isSnmpEnabled) !== false;
+    }
+    /**
+     * True when this scan is an ICMP ping sweep and nothing else.
+     *
+     * The exact negation of isSnmpEnabled, spelled out because most callers read
+     * better asking the positive question about the case they are handling — a
+     * `showIf` that hides the SNMP step, a status message that must not mention
+     * SNMP — and a bare `!` in front of a predicate is easy to lose in a diff.
+     */
+    static isIcmpOnly(scan) {
+        return !ScanModeUtil.isSnmpEnabled(scan);
+    }
+    /** The scan's method as a short phrase for a badge or a log line. */
+    static getMethodLabel(scan) {
+        return ScanModeUtil.isSnmpEnabled(scan)
+            ? ScanMethodLabel.PingAndSnmp
+            : ScanMethodLabel.PingOnly;
+    }
+}
+export default ScanModeUtil;
+//# sourceMappingURL=ScanModeUtil.js.map

package/build/dist/Utils/NetworkDiscovery/ScanModeUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScanModeUtil.js","sourceRoot":"","sources":["../../../../Utils/NetworkDiscovery/ScanModeUtil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAaH;;;;GAIG;AACH,MAAM,CAAN,IAAY,eAGX;AAHD,WAAY,eAAe;IACzB,8CAA2B,CAAA;IAC3B,yCAAsB,CAAA;AACxB,CAAC,EAHW,eAAe,KAAf,eAAe,QAG1B;AAED,MAAM,OAAO,YAAY;IACvB;;;;;;OAMG;IACI,MAAM,CAAC,aAAa,CACzB,IAA0C;QAE1C,OAAO,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,aAAa,MAAK,KAAK,CAAC;IACvC,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,UAAU,CACtB,IAA0C;QAE1C,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED,qEAAqE;IAC9D,MAAM,CAAC,cAAc,CAC1B,IAA0C;QAE1C,OAAO,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC;YACrC,CAAC,CAAC,eAAe,CAAC,WAAW;YAC7B,CAAC,CAAC,eAAe,CAAC,QAAQ,CAAC;IAC/B,CAAC;CACF;AAED,eAAe,YAAY,CAAC"}