@oneuptime/common 12.0.22 → 12.0.24

package/Utils/NetworkDiscovery/ScanNameUtil.ts

@@ -0,0 +1,181 @@
+import ColumnLength from "../../Types/Database/ColumnLength";
+
+/*
+ * The optional operator-supplied name on a Network Device Discovery Scan.
+ *
+ * WHY IT EXISTS
+ *
+ * A scan used to be identified by its target alone — `10.15.128.0-255`,
+ * `10.240-249.0-254.220-226`. Half a dozen rows in, nothing on the Discovery
+ * Scans list says which one was the router sweep and which one was the switch
+ * range for a region; the only way to find out is to open each scan and read
+ * the range back against a subnet plan kept somewhere else (OneUptime issue
+ * #3391). A name is that missing sentence, stored with the scan rather than in
+ * a spreadsheet beside it.
+ *
+ * It is deliberately OPTIONAL and deliberately NOT unique: it is a label for
+ * humans, not an identifier. Every scan that existed before this column did
+ * has none, and every surface that shows a name therefore has to keep working
+ * when it is absent — which is what getScanLabel() below is for.
+ *
+ * WHY IT LIVES IN Common
+ *
+ * The same two questions — "is this name storable?" and "what do I call this
+ * scan?" — are asked by the create form (App Dashboard), the write hooks
+ * (Common server service), the recurring-scan worker (App Workers) and the
+ * sweep itself (Probe). Answering them in one module is what keeps the form's
+ * error message identical to the server's, and the probe's log line readable
+ * against the row the operator is looking at. Same reason ScanTargetUtil sits
+ * next door.
+ */
+
+/*
+ * The parts of a scan that answer "which scan is this?". Structural rather
+ * than the model type, so a partially-selected row — the workers and the probe
+ * both select two or three columns — satisfies it, and so this module stays
+ * importable from the Probe without dragging a database model behind it.
+ *
+ * Both are nullable: `cidr` is NOT NULL in the database, but a caller that did
+ * not select it hands over a row where it is simply missing.
+ */
+export interface DiscoveryScanIdentity {
+  name?: string | null | undefined;
+  cidr?: string | null | undefined;
+}
+
+export class ScanNameUtil {
+  /*
+   * Matches the column: NetworkDeviceDiscoveryScan.name is a ShortText, so a
+   * longer value does not truncate in Postgres — it throws, failing the whole
+   * INSERT. Read off ColumnLength rather than written as 100 so the two cannot
+   * drift apart if the column type ever changes.
+   */
+  public static readonly MAX_SCAN_NAME_LENGTH: number = ColumnLength.ShortText;
+
+  /*
+   * ASCII control characters, including DEL. Written as escapes rather than as
+   * a literal range so the characters this guards against cannot end up inside
+   * the guard itself, and so the file stays readable in a diff.
+   *
+   * no-control-regex is disabled deliberately, the same way
+   * MetricResourceAttributeUtil disables it: a control character inside a
+   * user-typed name is precisely what this has to match in order to remove it.
+   */
+  // eslint-disable-next-line no-control-regex
+  private static readonly CONTROL_CHARACTERS: RegExp = /[\u0000-\u001F\u007F]/g;
+
+  /*
+   * The name as it should be stored, or null when the operator supplied none.
+   *
+   * Three things happen here, in this order:
+   *
+   *   - anything that is not a string becomes null. The value arrives straight
+   *     from request JSON (BaseAPI assigns ShortText columns verbatim), so a
+   *     client really can hand over a number, an object or an array. Callers
+   *     that want to REJECT those call getValidationError() first; this
+   *     function's job is only to say what would be stored.
+   *   - control characters — a newline pasted out of a spreadsheet cell, a
+   *     stray tab — become spaces, and every run of whitespace collapses to a
+   *     single space. A name is rendered on one line in a table cell and
+   *     inlined into log messages; a multi-line one breaks both, and nothing
+   *     downstream would ever repair it.
+   *   - the result is trimmed, and an empty result is null rather than "".
+   *     "Not named" is one state, not two: an empty string in the column would
+   *     read as a name everywhere `name ?` is asked, and render as a blank
+   *     first line above the scan target.
+   */
+  public static normalize(name: unknown): string | null {
+    if (typeof name !== "string") {
+      return null;
+    }
+
+    const collapsed: string = name
+      .replace(ScanNameUtil.CONTROL_CHARACTERS, " ")
+      .replace(/\s+/g, " ")
+      .trim();
+
+    return collapsed.length > 0 ? collapsed : null;
+  }
+
+  /*
+   * The single validation entry point for a scan name, shared by the create
+   * form and both write hooks. Returns null when the name is storable —
+   * INCLUDING when there is no name at all, because the field is optional and
+   * "" is a perfectly good way to say so.
+   *
+   * `name` is typed unknown for the same reason ScanTargetUtil's target is:
+   * the server hook runs before the model's own type and length checks, so it
+   * is the first thing to see whatever the client actually sent.
+   */
+  public static getValidationError(name: unknown): string | null {
+    if (name === undefined || name === null) {
+      return null;
+    }
+
+    if (typeof name !== "string") {
+      return "A scan name must be text.";
+    }
+
+    const normalized: string | null = ScanNameUtil.normalize(name);
+
+    if (normalized === null) {
+      return null;
+    }
+
+    /*
+     * Measured against the NORMALIZED value, which is what would be stored:
+     * rejecting a 101-character value that is 100 characters plus a trailing
+     * newline would be refusing to save something this module was about to fix
+     * anyway.
+     */
+    if (normalized.length > ScanNameUtil.MAX_SCAN_NAME_LENGTH) {
+      return (
+        `A scan name cannot be longer than ${ScanNameUtil.MAX_SCAN_NAME_LENGTH} characters. ` +
+        `This one is ${normalized.length}.`
+      );
+    }
+
+    return null;
+  }
+
+  /*
+   * The name to show for a scan, or null when it has none — so a caller can
+   * render the scan target instead rather than an empty line.
+   *
+   * Normalized on the way out as well as on the way in, because rows written
+   * before this column existed, and rows written by any writer that bypasses
+   * the hooks (migrations, the probe-ingest endpoints), are not guaranteed to
+   * have been through normalize().
+   */
+  public static getDisplayName(scan: DiscoveryScanIdentity): string | null {
+    return ScanNameUtil.normalize(scan.name);
+  }
+
+  /*
+   * How to refer to a scan in one line of running text — a log message, a
+   * modal's description, a status note.
+   *
+   * A named scan carries its target along with it (`Router Discovery — Region
+   * 1100 (10.15.128.0-255)`): the name says which scan, the target says what
+   * it sweeps, and an operator reading a log line usually wants both. An
+   * unnamed one is exactly what it was before this column existed — the target
+   * alone.
+   *
+   * Returns "" when the row has neither, which happens only when the caller
+   * selected neither column. Callers append their own fallback (the scan id)
+   * rather than having one invented for them here.
+   */
+  public static getScanLabel(scan: DiscoveryScanIdentity): string {
+    const name: string | null = ScanNameUtil.getDisplayName(scan);
+    const target: string =
+      typeof scan.cidr === "string" ? scan.cidr.trim() : "";
+
+    if (name && target) {
+      return `${name} (${target})`;
+    }
+
+    return name || target || "";
+  }
+}
+
+export default ScanNameUtil;

package/Utils/NetworkDiscovery/ScanTargetUtil.ts

@@ -98,6 +98,9 @@ export class ScanTargetUtil {
   private static readonly OCTET_TERM_PATTERN: RegExp =
     /^(\d{1,3})(?:-(\d{1,3}))?$/;
 
+  // One octet of a bare address. Bounds are validated after parsing.
+  private static readonly IP_OCTET_PATTERN: RegExp = /^\d{1,3}$/;
+
   private static readonly EXAMPLE_CIDR: string = "192.168.1.0/24";
 
   private static readonly EXAMPLE_OCTET_RANGE: string = "10.16-22.0-255.51-66";
@@ -192,6 +195,54 @@ export class ScanTargetUtil {
     return ScanTargetUtil.expandOctetRangeTarget(parsed);
   }
 
+  /*
+   * True when `ip` falls inside `target`, in either notation. This is the
+   * matcher behind the auto-import rules' "Host IP is in" condition, sharing
+   * the exact parser scan targets are validated and expanded with — so a
+   * condition that saves is a condition that matches what its scan sweeps.
+   *
+   * Containment, not enumeration: a CIDR block is a mask comparison over the
+   * whole block (network and broadcast addresses INCLUDED — a rule asking
+   * "is this address in 10.0.0.0/24" means the subnet, not the sweep list),
+   * and an octet range is per-octet interval membership. The latter is NOT a
+   * single numeric interval: for `10.16-22.0-255.51-66`, the address
+   * 10.17.5.10 sits between the range's lowest and highest addresses but its
+   * fourth octet is outside 51-66, so it does not match.
+   *
+   * Malformed targets and malformed addresses match nothing.
+   */
+  public static contains(target: string, ip: string): boolean {
+    const parsed: ScanTarget | null = ScanTargetUtil.parse(target);
+
+    if (!parsed) {
+      return false;
+    }
+
+    const octets: Array<number> | null = ScanTargetUtil.parseIpOctets(ip);
+
+    if (!octets) {
+      return false;
+    }
+
+    if (parsed.notation === ScanTargetNotation.Cidr) {
+      const ipLong: number =
+        (((octets[0]! * 256 + octets[1]!) * 256 + octets[2]!) * 256 +
+          octets[3]!) >>>
+        0;
+
+      return (
+        ipLong >= parsed.networkLong! &&
+        ipLong < parsed.networkLong! + parsed.blockSize!
+      );
+    }
+
+    return parsed.octetRanges!.every(
+      (range: OctetRange, index: number): boolean => {
+        return octets[index]! >= range.start && octets[index]! <= range.end;
+      },
+    );
+  }
+
   /*
    * Both notations in one sentence, for form hints and error messages. Kept
    * here so the UI, the server-side validator and the probe all describe the
@@ -411,6 +462,37 @@ export class ScanTargetUtil {
     return hosts;
   }
 
+  // '10.0.0.1' -> [10, 0, 0, 1]; anything malformed -> null.
+  private static parseIpOctets(ip: string): Array<number> | null {
+    if (typeof ip !== "string") {
+      return null;
+    }
+
+    const terms: Array<string> = ip.trim().split(".");
+
+    if (terms.length !== 4) {
+      return null;
+    }
+
+    const octets: Array<number> = [];
+
+    for (const term of terms) {
+      if (!ScanTargetUtil.IP_OCTET_PATTERN.test(term)) {
+        return null;
+      }
+
+      const octet: number = parseInt(term, 10);
+
+      if (octet > 255) {
+        return null;
+      }
+
+      octets.push(octet);
+    }
+
+    return octets;
+  }
+
   private static getMalformedTargetMessage(target: string): string {
     const shown: string =
       typeof target === "string" ? target.trim() : String(target);

package/Utils/StatusPage/ResourceExplorer.ts

@@ -154,6 +154,25 @@ export interface StatusPageResourceGridModel {
   orphanResources: Array<StatusPageResource>;
 }
 
+/*
+ * How a group's checkbox column stands at the moment: whether the box at the
+ * top of the list should be ticked, half ticked, or empty.
+ *
+ * Computed over whichever resources the list is actually drawing - a filtered
+ * list's "select all" means "everything the search matched", not "everything in
+ * the group", because those are the only rows the operator can see.
+ */
+export interface StatusPageResourceSelectionState {
+  /* Every resource on offer is selected, and there is at least one. */
+  isAllSelected: boolean;
+  /* Some but not all - the half-filled box. */
+  isIndeterminate: boolean;
+  /* How many of the resources on offer are selected. */
+  selectedCount: number;
+  /* How many resources were on offer at all. */
+  selectableCount: number;
+}
+
 export default class StatusPageResourceExplorerUtil {
   /*
    * How many navigator rows are drawn before the list stops and offers to draw
@@ -622,6 +641,245 @@ export default class StatusPageResourceExplorerUtil {
     );
   }
 
+  /* ------------------------------------------------------------------ */
+  /* Selecting resources                                                 */
+  /* ------------------------------------------------------------------ */
+
+  /*
+   * Removing monitors from a status page used to be a row at a time: open the
+   * row's menu, confirm, wait for the refetch, and do it again for the next of
+   * twenty seven (issue #3419). The list carries a checkbox column instead, and
+   * everything below is the model behind it.
+   *
+   * A selection is a set of id STRINGS rather than of resources. Resources are
+   * re-fetched constantly here - every create, delete, reorder and refresh
+   * replaces the whole array - so holding the objects would mean holding rows
+   * that no longer exist, compared by identity against their own replacements.
+   */
+
+  /*
+   * A resource's id as a selection holds it.
+   *
+   * Null when there is nothing to hold on to. The server never returns such a
+   * row, but a list drawn from local state briefly can, and a set containing
+   * `""` would silently make every id-less row the same row.
+   */
+  public static getResourceId(
+    statusPageResource: StatusPageResource,
+  ): string | null {
+    const id: string = statusPageResource._id?.toString() || "";
+
+    return id.length > 0 ? id : null;
+  }
+
+  /*
+   * The ids of everything in the list that can be selected at all, in the order
+   * the list draws them and without repeats.
+   */
+  public static getResourceIds(
+    statusPageResources: Array<StatusPageResource>,
+  ): Array<string> {
+    const ids: Array<string> = [];
+    const seen: Set<string> = new Set<string>();
+
+    for (const statusPageResource of statusPageResources) {
+      const id: string | null =
+        StatusPageResourceExplorerUtil.getResourceId(statusPageResource);
+
+      if (!id || seen.has(id)) {
+        continue;
+      }
+
+      seen.add(id);
+      ids.push(id);
+    }
+
+    return ids;
+  }
+
+  /*
+   * One row's box, ticked or unticked. Always a new set, because it always
+   * changes something.
+   */
+  public static toggleSelectedResourceId(data: {
+    selectedResourceIds: Set<string>;
+    resourceId: string;
+  }): Set<string> {
+    const next: Set<string> = new Set<string>(data.selectedResourceIds);
+
+    if (next.has(data.resourceId)) {
+      next.delete(data.resourceId);
+    } else {
+      next.add(data.resourceId);
+    }
+
+    return next;
+  }
+
+  /*
+   * The box at the top of the list: every resource handed in is selected, or
+   * none of them is.
+   *
+   * Only the resources handed in are touched. A search is on while this is
+   * pressed as often as not, and un-ticking "select all" over four matching
+   * rows must not quietly drop the twenty the operator selected before they
+   * started typing.
+   *
+   * Returns the set it was given when nothing would change, so a component
+   * holding it in state does not re-render itself for a no-op.
+   */
+  public static setResourcesSelected(data: {
+    selectedResourceIds: Set<string>;
+    statusPageResources: Array<StatusPageResource>;
+    isSelected: boolean;
+  }): Set<string> {
+    const ids: Array<string> = StatusPageResourceExplorerUtil.getResourceIds(
+      data.statusPageResources,
+    );
+
+    const next: Set<string> = new Set<string>(data.selectedResourceIds);
+
+    let hasChanged: boolean = false;
+
+    for (const id of ids) {
+      if (data.isSelected) {
+        if (!next.has(id)) {
+          next.add(id);
+          hasChanged = true;
+        }
+
+        continue;
+      }
+
+      if (next.delete(id)) {
+        hasChanged = true;
+      }
+    }
+
+    return hasChanged ? next : data.selectedResourceIds;
+  }
+
+  /*
+   * What the box at the top of the list should look like, over whichever
+   * resources are being drawn.
+   *
+   * An empty list is never "all selected": a ticked box over nothing to tick
+   * reads as a selection that was lost.
+   */
+  public static getSelectionState(data: {
+    statusPageResources: Array<StatusPageResource>;
+    selectedResourceIds: Set<string>;
+  }): StatusPageResourceSelectionState {
+    const ids: Array<string> = StatusPageResourceExplorerUtil.getResourceIds(
+      data.statusPageResources,
+    );
+
+    let selectedCount: number = 0;
+
+    for (const id of ids) {
+      if (data.selectedResourceIds.has(id)) {
+        selectedCount++;
+      }
+    }
+
+    const isAllSelected: boolean =
+      ids.length > 0 && selectedCount === ids.length;
+
+    return {
+      isAllSelected: isAllSelected,
+      isIndeterminate: selectedCount > 0 && !isAllSelected,
+      selectedCount: selectedCount,
+      selectableCount: ids.length,
+    };
+  }
+
+  /*
+   * The selected resources themselves, in the order the list holds them, so a
+   * bulk action reports its progress in the order the operator is looking at.
+   *
+   * Ids in the selection that match nothing in the list are dropped rather than
+   * guessed at - see retainSelectedResourceIds for where they come from.
+   */
+  public static getSelectedResources(data: {
+    statusPageResources: Array<StatusPageResource>;
+    selectedResourceIds: Set<string>;
+  }): Array<StatusPageResource> {
+    const seen: Set<string> = new Set<string>();
+
+    return data.statusPageResources.filter(
+      (statusPageResource: StatusPageResource): boolean => {
+        const id: string | null =
+          StatusPageResourceExplorerUtil.getResourceId(statusPageResource);
+
+        if (!id || seen.has(id) || !data.selectedResourceIds.has(id)) {
+          return false;
+        }
+
+        seen.add(id);
+
+        return true;
+      },
+    );
+  }
+
+  /*
+   * The selection, minus anything the list no longer holds.
+   *
+   * Every write on this pane ends in a refetch, and a resource that was removed
+   * - by this operator's own bulk action, or by somebody else's - must not stay
+   * in the selection: the bulk bar would go on counting it, and the next action
+   * would try to delete a row that is already gone.
+   *
+   * Returns the set it was given when nothing was dropped, for the same reason
+   * setResourcesSelected does.
+   */
+  public static retainSelectedResourceIds(data: {
+    selectedResourceIds: Set<string>;
+    statusPageResources: Array<StatusPageResource>;
+  }): Set<string> {
+    if (data.selectedResourceIds.size === 0) {
+      return data.selectedResourceIds;
+    }
+
+    const present: Set<string> = new Set<string>(
+      StatusPageResourceExplorerUtil.getResourceIds(data.statusPageResources),
+    );
+
+    const next: Set<string> = new Set<string>();
+
+    for (const id of data.selectedResourceIds) {
+      if (present.has(id)) {
+        next.add(id);
+      }
+    }
+
+    return next.size === data.selectedResourceIds.size
+      ? data.selectedResourceIds
+      : next;
+  }
+
+  /*
+   * What the confirmation for a bulk removal is called, and what it says.
+   *
+   * It says the monitors survive, for the same reason the single-row confirm
+   * does: "remove" on a status page means "stop publishing this", and an
+   * operator clearing twenty seven rows deserves to be told that once, loudly,
+   * rather than to wonder afterwards.
+   */
+  public static getBulkRemoveConfirmTitle(data: { count: number }): string {
+    return `Remove ${data.count.toLocaleString()} ${
+      data.count === 1 ? "resource" : "resources"
+    }`;
+  }
+
+  public static getBulkRemoveConfirmMessage(data: { count: number }): string {
+    if (data.count === 1) {
+      return "Are you sure you want to remove 1 resource from this status page? The monitor itself is not deleted.";
+    }
+
+    return `Are you sure you want to remove ${data.count.toLocaleString()} resources from this status page? The monitors themselves are not deleted.`;
+  }
+
   /*
    * The `order` to write when a resource is dragged from one position to
    * another.