@oneuptime/common 13.0.5 → 13.0.6

package/Utils/NetworkDiscovery/RunImportedDeviceNaming.ts

@@ -0,0 +1,390 @@
+import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import {
+  DiscoveredHostNaming,
+  MAX_DEVICE_DNS_NAME_LENGTH,
+  buildDeviceName,
+  buildFallbackDeviceName,
+} from "./DiscoveredDeviceBuilder";
+import { normalizeDiscoveredHosts } from "./DiscoveredHostUtil";
+import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
+
+/*
+ * Naming the devices a discovery run imported BEFORE it knew their names
+ * (part of OneUptime issue #3677, "hosts show up only as raw IP").
+ *
+ * WHY THIS EXISTS. A discovery sweep reports incrementally: the probe uploads
+ * what it has found every 30 seconds while it is still sweeping, and the
+ * auto-import worker imports from those partial snapshots within a minute of
+ * them landing (issue #3599). But reverse DNS runs ONCE, after the sweep —
+ * so a partial snapshot never carries a `dnsHostname`, and a host with no
+ * SNMP sysName (a ping-only host, or one whose community string was wrong) is
+ * imported from it named by its bare address. The Review dialog has the same
+ * gap: an operator who imports while the scan is still running gets the same
+ * address-named devices.
+ *
+ * When the run's final, Completed result arrives, it DOES carry the PTR names.
+ * Nothing used them: the import engine skips every host whose address is
+ * already registered, by design, so the device that was imported ten minutes
+ * earlier as "10.18.166.51" stayed "10.18.166.51" forever, while the Review
+ * dialog showed "kds01.wbhq.com" beside it.
+ *
+ * This module decides which devices to rename after that final result, and
+ * to what. It is pure so every condition below is tested without a database;
+ * the rule engine (NetworkDeviceAutoImportRuleEngineService) does the reads,
+ * the server-side collision checks and the writes.
+ *
+ * A device is renamed only when ALL of these hold, and each one guards a way
+ * of renaming something nobody asked to have renamed:
+ *
+ *   (a) It belongs to the scan's project. The engine's query already says so;
+ *       it is checked again here because a rename across a tenant boundary is
+ *       the one mistake this must never make, whatever a future caller passes.
+ *   (b) Its hostname is an address this result reports. The address is the
+ *       device's identity (see DiscoveredDeviceBuilder on `hostname`), so this
+ *       is what ties the device to the host whose name is being applied.
+ *   (c) It is still named by that bare address — its name, trimmed and without
+ *       case, IS its hostname. A device an operator renamed, or one that was
+ *       imported with a sysName or PTR name, is not touched.
+ *   (d) It was created during THIS run: `startedAt <= createdAt <= completedAt`.
+ *       This is what keeps the fix from mass-renaming an estate on upgrade.
+ *       Plenty of long-standing devices are named by their address on
+ *       purpose, or were imported before reverse DNS existed at all, and a
+ *       project that had lived with those names for a year would otherwise
+ *       find them all renamed by the first scan after the upgrade — silently,
+ *       on the one path nobody reviews. Only a device the run itself could
+ *       have created mid-sweep is fair game. No `startedAt`, no renames.
+ *
+ *       The upper bound matters as much as the lower one. The same Completed
+ *       result can be processed more than once — saving an auto-import rule
+ *       re-arms recent scans, and a capped import resumes on later ticks — and
+ *       a device created AFTER the run finished (added by hand as its address,
+ *       or deleted and re-added) was never this run's partial import. Without
+ *       the bound, a re-armed result would rename it. No `completedAt`, no
+ *       renames either.
+ *   (e) The host now HAS a name: the name the builder gives it under the
+ *       scan's naming choice is something other than the address. A result
+ *       with no sysName and no usable PTR record names the host by its address
+ *       again, and "renaming" a device to its own name is nothing to do. The
+ *       name is whatever buildDeviceName decides, never a source list of this
+ *       module's own, so any name the builder learns to read — one the probe
+ *       also resolves only after the sweep included — is applied here too.
+ *
+ * What is left over is, precisely, a device this run imported by address
+ * because the name had not been resolved yet — which is the device the
+ * operator would have got had the import waited for the final result.
+ */
+
+/*
+ * The longest address worth looking up. The address becomes the device's
+ * varchar(100) hostname, so a longer "address" can never match a device and
+ * is junk — the same ceiling the import engine refuses such rows at.
+ */
+export const MAX_DISCOVERED_HOST_ADDRESS_LENGTH: number = 100;
+
+/*
+ * The device columns the plan reads. The engine maps its NetworkDevice rows
+ * onto this; every field is re-checked at runtime anyway, because a row read
+ * with a narrower select arrives with fields undefined, and undefined must
+ * read as "do not rename", never as a match.
+ */
+export interface RunImportedDeviceRow {
+  deviceId: string;
+  projectId?: string | null | undefined;
+  name?: string | null | undefined;
+  hostname?: string | null | undefined;
+  dnsName?: string | null | undefined;
+  createdAt?: Date | string | null | undefined;
+}
+
+export interface RunImportedDeviceRename {
+  deviceId: string;
+  // The device's address, which is also the host's.
+  hostname: string;
+  // The device's current name — its address, give or take case/whitespace.
+  fromName: string;
+  /*
+   * The names to try, in order: the name the device would have been created
+   * under had the import waited for this result, then the address-suffixed
+   * collision fallback the import itself would retry with. The caller takes
+   * the first one no other device already holds, and skips the device when
+   * both are taken — exactly the import's own collision protocol.
+   */
+  candidateNames: Array<string>;
+  /*
+   * The PTR name to store as the device's dnsName. Present only when the
+   * device has none and the host has a usable one: the same value the builder
+   * would have set at create, and never an overwrite of a name already there.
+   */
+  dnsName?: string | undefined;
+}
+
+/*
+ * A Date, or a date string out of a row, as epoch milliseconds — or undefined
+ * when it is neither. Undefined never compares as "after the run started", so
+ * a junk timestamp leaves the device alone.
+ */
+export function toEpochMilliseconds(value: unknown): number | undefined {
+  if (value instanceof Date) {
+    const time: number = value.getTime();
+    return Number.isNaN(time) ? undefined : time;
+  }
+
+  if (typeof value === "string" && value.trim()) {
+    const time: number = new Date(value.trim()).getTime();
+    return Number.isNaN(time) ? undefined : time;
+  }
+
+  return undefined;
+}
+
+function trimmedString(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+/**
+ * The hosts in a scan result that have a NAME, keyed by address.
+ *
+ * Read through normalizeDiscoveredHosts — the same reading of the jsonb the
+ * Review dialog and the import engine use — so null rows, numeric addresses,
+ * non-string sysNames and unusable PTR names are dealt with once, the same
+ * way. Accepts `unknown` because the value is the jsonb column as stored, and
+ * "not an array" has to mean "no hosts" rather than a throw inside a worker.
+ *
+ * When an address is listed on more than one row, the FIRST row that names it
+ * wins. Duplicate rows are normal (see the import engine), and a row without
+ * a name must not shadow a later row with one.
+ */
+export function getNamedHostsByAddress(
+  hosts: unknown,
+  scan: DiscoveredHostNaming,
+): Map<string, DiscoveredNetworkDevice> {
+  const namedHosts: Map<string, DiscoveredNetworkDevice> = new Map<
+    string,
+    DiscoveredNetworkDevice
+  >();
+
+  if (!Array.isArray(hosts)) {
+    return namedHosts;
+  }
+
+  const normalized: Array<DiscoveredNetworkDevice> = normalizeDiscoveredHosts(
+    hosts as Array<DiscoveredNetworkDevice>,
+  );
+
+  for (const host of normalized) {
+    const address: string = host.ipAddress;
+
+    if (!address || address.length > MAX_DISCOVERED_HOST_ADDRESS_LENGTH) {
+      continue;
+    }
+
+    if (namedHosts.has(address)) {
+      continue;
+    }
+
+    // Condition (e): the host is called something other than its address.
+    const name: string = buildDeviceName(host, scan).trim();
+
+    if (!name || name.toLowerCase() === address.toLowerCase()) {
+      continue;
+    }
+
+    namedHosts.set(address, host);
+  }
+
+  return namedHosts;
+}
+
+/**
+ * The renames one Completed result calls for, in a deterministic order:
+ * oldest device first (then by address, then by id), so when two devices
+ * would take the same name, the one imported first keeps the plain name and
+ * the outcome does not depend on the order the database returned rows in.
+ *
+ * Plans only — no collision checks against the rest of the project, which
+ * need the database. See RunImportedDeviceRename.candidateNames.
+ */
+export function planRunImportedDeviceRenames(data: {
+  projectId: string;
+  hosts: unknown;
+  devices: Array<RunImportedDeviceRow>;
+  scan: DiscoveredHostNaming;
+  runStartedAt: Date | string | null | undefined;
+  runCompletedAt: Date | string | null | undefined;
+}): Array<RunImportedDeviceRename> {
+  // Condition (d) needs both ends of the run; without them, nothing.
+  const runStartedAt: number | undefined = toEpochMilliseconds(
+    data.runStartedAt,
+  );
+
+  const runCompletedAt: number | undefined = toEpochMilliseconds(
+    data.runCompletedAt,
+  );
+
+  const projectId: string = trimmedString(data.projectId);
+
+  if (
+    runStartedAt === undefined ||
+    runCompletedAt === undefined ||
+    !projectId
+  ) {
+    return [];
+  }
+
+  const namedHosts: Map<string, DiscoveredNetworkDevice> =
+    getNamedHostsByAddress(data.hosts, data.scan);
+
+  if (namedHosts.size === 0) {
+    return [];
+  }
+
+  const eligible: Array<{
+    row: RunImportedDeviceRow;
+    host: DiscoveredNetworkDevice;
+    hostname: string;
+    name: string;
+    createdAt: number;
+  }> = [];
+
+  const seenDeviceIds: Set<string> = new Set<string>();
+
+  for (const row of data.devices) {
+    if (!row || typeof row !== "object") {
+      continue;
+    }
+
+    const deviceId: string = trimmedString(row.deviceId);
+
+    // One plan per device, however many times a caller's reads returned it.
+    if (!deviceId || seenDeviceIds.has(deviceId)) {
+      continue;
+    }
+
+    // (a) The scan's project, and only the scan's project.
+    if (trimmedString(row.projectId) !== projectId) {
+      continue;
+    }
+
+    // (b) An address this result reports — and reports a name for, see (e).
+    const hostname: string = trimmedString(row.hostname);
+    const host: DiscoveredNetworkDevice | undefined = hostname
+      ? namedHosts.get(hostname)
+      : undefined;
+
+    if (!host) {
+      continue;
+    }
+
+    // (c) Still named by that bare address.
+    const name: string = trimmedString(row.name);
+
+    if (!name || name.toLowerCase() !== hostname.toLowerCase()) {
+      continue;
+    }
+
+    /*
+     * (d) Created during this run. Equal counts at both ends: the claim stamps
+     * startedAt and the final upload stamps completedAt, and a device created
+     * in the same millisecond as either is still this run's.
+     */
+    const createdAt: number | undefined = toEpochMilliseconds(row.createdAt);
+
+    if (
+      createdAt === undefined ||
+      createdAt < runStartedAt ||
+      createdAt > runCompletedAt
+    ) {
+      continue;
+    }
+
+    seenDeviceIds.add(deviceId);
+    eligible.push({
+      row: row,
+      host: host,
+      hostname: hostname,
+      name: name,
+      createdAt: createdAt,
+    });
+  }
+
+  eligible.sort(
+    (
+      left: { createdAt: number; hostname: string; row: RunImportedDeviceRow },
+      right: { createdAt: number; hostname: string; row: RunImportedDeviceRow },
+    ): number => {
+      if (left.createdAt !== right.createdAt) {
+        return left.createdAt - right.createdAt;
+      }
+
+      if (left.hostname !== right.hostname) {
+        return left.hostname < right.hostname ? -1 : 1;
+      }
+
+      return left.row.deviceId < right.row.deviceId ? -1 : 1;
+    },
+  );
+
+  return eligible.map(
+    (entry: {
+      row: RunImportedDeviceRow;
+      host: DiscoveredNetworkDevice;
+      hostname: string;
+      name: string;
+    }): RunImportedDeviceRename => {
+      /*
+       * The same two names, from the same builder, that the import itself
+       * would have tried — so a renamed device is indistinguishable from one
+       * imported after the name was known, short-name choice included.
+       */
+      const candidateNames: Array<string> = [];
+
+      for (const candidate of [
+        buildDeviceName(entry.host, data.scan),
+        buildFallbackDeviceName(entry.host, data.scan),
+      ]) {
+        const trimmed: string = candidate.trim();
+
+        if (!trimmed || trimmed.toLowerCase() === entry.name.toLowerCase()) {
+          continue;
+        }
+
+        const alreadyListed: boolean = candidateNames.some(
+          (listed: string): boolean => {
+            return listed.toLowerCase() === trimmed.toLowerCase();
+          },
+        );
+
+        if (!alreadyListed) {
+          candidateNames.push(trimmed);
+        }
+      }
+
+      const plan: RunImportedDeviceRename = {
+        deviceId: trimmedString(entry.row.deviceId),
+        hostname: entry.hostname,
+        fromName: entry.name,
+        candidateNames: candidateNames,
+      };
+
+      /*
+       * Filled only, never overwritten: a device that already has a DNS name
+       * got it from a PTR record (or from an operator), and a later answer is
+       * not a reason to replace it. The rename happens either way.
+       */
+      if (!trimmedString(entry.row.dnsName)) {
+        const dnsName: string | undefined = normalizeReverseDnsName(
+          entry.host.dnsHostname,
+        );
+
+        if (dnsName) {
+          plan.dnsName =
+            dnsName.length > MAX_DEVICE_DNS_NAME_LENGTH
+              ? dnsName.substring(0, MAX_DEVICE_DNS_NAME_LENGTH)
+              : dnsName;
+        }
+      }
+
+      return plan;
+    },
+  );
+}

package/Utils/NetworkDiscovery/ShortDeviceNamePlanner.ts

@@ -0,0 +1,291 @@
+import { MAX_DEVICE_NAME_LENGTH } from "./DiscoveredDeviceBuilder";
+import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
+import { getShortHostname } from "./ShortHostnameUtil";
+
+/*
+ * What the Devices list's bulk "Shorten names to hostname" action does to each
+ * selected device (OneUptime issue #3678).
+ *
+ * The scan setting fixes devices discovery imports from now on. It does
+ * nothing for the hundreds already in a project under their full DNS names,
+ * and re-importing does not rename them either — a host whose address is
+ * already registered is skipped, by design. Editing each one by hand is what
+ * the issue was filed about, so the action exists, and this is its decision
+ * logic: pure, so every rule below is tested without a dashboard.
+ */
+
+// The device fields the plan reads. NetworkDevice rows satisfy it.
+export interface ShortenableDevice {
+  id: string;
+  name?: string | null | undefined;
+  hostname?: string | null | undefined;
+  sysName?: string | null | undefined;
+  dnsName?: string | null | undefined;
+}
+
+export interface ShortDeviceNameRename {
+  kind: "rename";
+  id: string;
+  currentName: string;
+  newName: string;
+  /*
+   * The full name to store as the device's DNS name, when the device has none
+   * and its current name is one. Absent when there is nothing to store.
+   */
+  dnsName?: string | undefined;
+}
+
+export interface ShortDeviceNameSkip {
+  kind: "skip";
+  id: string;
+  currentName: string;
+  reason: string;
+}
+
+export type ShortDeviceNamePlan = ShortDeviceNameRename | ShortDeviceNameSkip;
+
+export const SKIPPED_NO_NAME_MESSAGE: string =
+  "Skipped: the device has no name to shorten.";
+
+export const SKIPPED_NOT_FULLY_QUALIFIED_MESSAGE: string =
+  "Skipped: the name is not a fully qualified hostname, so there is no domain to remove.";
+
+/*
+ * The collision-fallback suffix import appends — " (10.0.0.5)" — split off
+ * the name so a device imported as "kds01.wbhq.com (10.0.0.5)" can still be
+ * shortened.
+ *
+ * Only when the bracketed text is exactly the device's own hostname. That is
+ * the one shape DiscoveredDeviceBuilder.buildFallbackDeviceName produces, and
+ * anything else in brackets — "core-sw (rack 4)", an old address after the
+ * device was re-addressed — is an operator's text that this action has no
+ * business reinterpreting.
+ */
+export function splitAddressSuffix(data: {
+  name: string;
+  hostname?: string | null | undefined;
+}): { baseName: string; addressSuffix?: string | undefined } {
+  const hostname: string =
+    typeof data.hostname === "string" ? data.hostname.trim() : "";
+
+  if (!hostname) {
+    return { baseName: data.name };
+  }
+
+  const suffix: string = ` (${hostname})`;
+
+  if (data.name.length > suffix.length && data.name.endsWith(suffix)) {
+    return {
+      baseName: data.name.substring(0, data.name.length - suffix.length),
+      addressSuffix: suffix,
+    };
+  }
+
+  return { baseName: data.name };
+}
+
+function truncate(value: string, maxLength: number): string {
+  return value.length > maxLength ? value.substring(0, maxLength) : value;
+}
+
+/**
+ * The plan for one device, on its own — no knowledge of the rest of the
+ * selection. `planShortDeviceNames` adds that.
+ */
+export function planShortDeviceName(
+  device: ShortenableDevice,
+): ShortDeviceNamePlan {
+  const currentName: string =
+    typeof device.name === "string" ? device.name.trim() : "";
+
+  if (!currentName) {
+    return {
+      kind: "skip",
+      id: device.id,
+      currentName: currentName,
+      reason: SKIPPED_NO_NAME_MESSAGE,
+    };
+  }
+
+  const split: { baseName: string; addressSuffix?: string | undefined } =
+    splitAddressSuffix({ name: currentName, hostname: device.hostname });
+
+  const shortName: string | undefined = getShortHostname(split.baseName);
+
+  if (!shortName) {
+    return {
+      kind: "skip",
+      id: device.id,
+      currentName: currentName,
+      reason: SKIPPED_NOT_FULLY_QUALIFIED_MESSAGE,
+    };
+  }
+
+  /*
+   * A suffixed name keeps its suffix: it was address-qualified because the
+   * plain name was already taken, and the short name is even more likely to
+   * be. The short part is clamped so the whole still fits the import ceiling.
+   */
+  const suffix: string = split.addressSuffix || "";
+
+  const newName: string = truncate(
+    truncate(shortName, Math.max(1, MAX_DEVICE_NAME_LENGTH - suffix.length)) +
+      suffix,
+    MAX_DEVICE_NAME_LENGTH,
+  );
+
+  const plan: ShortDeviceNameRename = {
+    kind: "rename",
+    id: device.id,
+    currentName: currentName,
+    newName: newName,
+  };
+
+  const dnsName: string | undefined = getDnsNameToKeep({
+    device: device,
+    currentName: currentName,
+    baseName: split.baseName,
+  });
+
+  if (dnsName) {
+    plan.dnsName = dnsName;
+  }
+
+  return plan;
+}
+
+/*
+ * Whether the full name being cut away should be kept as the device's DNS
+ * name — so the action does not destroy the one copy of the FQDN, which is
+ * what the issue's follow-up comment asked for, and so a site rule matching
+ * that FQDN still sees it afterwards.
+ *
+ * Every condition below guards a way the old name might NOT be a DNS name, or
+ * might not be whole:
+ *
+ *   - The device already has a DNS name. That one came from a PTR record, and
+ *     it is never overwritten with an inference.
+ *   - The name equals the device's sysName. Then it is the name the device
+ *     calls itself, it is still stored as sysName, and nothing is lost.
+ *   - The name is at the import ceiling. DiscoveredDeviceBuilder clamps names
+ *     to MAX_DEVICE_NAME_LENGTH, so a name that long may be a cut-off FQDN,
+ *     and storing half a name as a DNS name would be inventing one. The rename
+ *     still happens — a first label is at most 63 characters, so it survives
+ *     any clamp intact.
+ *
+ * What is left over is a hand-typed FQDN-shaped name, which is stored as a DNS
+ * name too. That is judged acceptable: it is a DNS-shaped name the operator
+ * chose, and the column's description says where its value may come from.
+ */
+function getDnsNameToKeep(data: {
+  device: ShortenableDevice;
+  currentName: string;
+  baseName: string;
+}): string | undefined {
+  const existingDnsName: string =
+    typeof data.device.dnsName === "string" ? data.device.dnsName.trim() : "";
+
+  if (existingDnsName) {
+    return undefined;
+  }
+
+  const sysName: string =
+    typeof data.device.sysName === "string"
+      ? data.device.sysName.trim().toLowerCase()
+      : "";
+
+  if (sysName && sysName === data.baseName.trim().toLowerCase()) {
+    return undefined;
+  }
+
+  if (data.currentName.length >= MAX_DEVICE_NAME_LENGTH) {
+    return undefined;
+  }
+
+  return normalizeReverseDnsName(data.baseName);
+}
+
+export function buildInBatchCollisionMessage(data: {
+  newName: string;
+  otherNames: Array<string>;
+}): string {
+  const listed: string = data.otherNames
+    .slice(0, 3)
+    .map((name: string) => {
+      return `"${name}"`;
+    })
+    .join(", ");
+
+  const more: number = data.otherNames.length - 3;
+
+  return `Skipped: ${listed}${more > 0 ? ` and ${more} more` : ""} would also be renamed "${data.newName}", and two devices cannot share a name. Rename them individually.`;
+}
+
+/**
+ * The plan for a whole selection.
+ *
+ * On top of the per-device rules, two selected devices that would end up with
+ * the SAME short name — "kds01.store-1.example.com" and
+ * "kds01.store-2.example.com" — are BOTH skipped, each naming the other.
+ * Renaming the first and refusing the second would make the outcome depend on
+ * the order the table happened to be sorted in, and the device that kept its
+ * long name would be an accident. Compared without case, because device name
+ * uniqueness is case-insensitive.
+ *
+ * Collisions with devices OUTSIDE the selection are not visible here; the
+ * action checks those against the server, device by device.
+ */
+export function planShortDeviceNames(
+  devices: Array<ShortenableDevice>,
+): Array<ShortDeviceNamePlan> {
+  const plans: Array<ShortDeviceNamePlan> = devices.map(
+    (device: ShortenableDevice) => {
+      return planShortDeviceName(device);
+    },
+  );
+
+  const renamesByName: Map<string, Array<ShortDeviceNameRename>> = new Map<
+    string,
+    Array<ShortDeviceNameRename>
+  >();
+
+  for (const plan of plans) {
+    if (plan.kind !== "rename") {
+      continue;
+    }
+
+    const key: string = plan.newName.toLowerCase();
+    const group: Array<ShortDeviceNameRename> = renamesByName.get(key) || [];
+    group.push(plan);
+    renamesByName.set(key, group);
+  }
+
+  return plans.map((plan: ShortDeviceNamePlan) => {
+    if (plan.kind !== "rename") {
+      return plan;
+    }
+
+    const group: Array<ShortDeviceNameRename> =
+      renamesByName.get(plan.newName.toLowerCase()) || [];
+
+    if (group.length < 2) {
+      return plan;
+    }
+
+    return {
+      kind: "skip",
+      id: plan.id,
+      currentName: plan.currentName,
+      reason: buildInBatchCollisionMessage({
+        newName: plan.newName,
+        otherNames: group
+          .filter((other: ShortDeviceNameRename) => {
+            return other !== plan;
+          })
+          .map((other: ShortDeviceNameRename) => {
+            return other.currentName;
+          }),
+      }),
+    };
+  });
+}