@oneuptime/common 12.0.34 → 13.0.0

package/Tests/Utils/NetworkAutomation/AutoImportRunChain.test.ts

@@ -0,0 +1,320 @@
+import AutoImportRunChain, {
+  AutoImportRunChainOutcome,
+} from "../../../Utils/NetworkAutomation/AutoImportRunChain";
+import {
+  AutoImportRuleRunResult,
+  MAX_AUTO_IMPORT_RUN_PASSES,
+} from "../../../Types/NetworkAutomation/RuleRunResult";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * One press of "Run Rule" drives as many capped server passes as the estate
+ * needs. Before OneUptime issue #3642 it drove exactly one, so a 909-device
+ * estate imported 500 and stopped — with the remainder reachable only by an
+ * operator who noticed the cap line and pressed the button again.
+ *
+ * The loop's exits are the whole contract: done, no progress, cancelled, or
+ * the chain's own ceiling. Each one is asserted here, with no renderer in the
+ * import graph.
+ */
+
+function pass(
+  overrides: Partial<AutoImportRuleRunResult>,
+): AutoImportRuleRunResult {
+  return {
+    hostsEvaluated: 0,
+    hostsMatched: 0,
+    hostsExcluded: 0,
+    hostsSkippedAlreadyRegistered: 0,
+    devicesCreated: 0,
+    devicesFailed: 0,
+    monitorsWouldCreate: 0,
+    monitorsCreated: 0,
+    monitorsSkippedAlreadyExisting: 0,
+    monitorsSkippedUnsupportedHost: 0,
+    monitorsFailed: 0,
+    deviceFailureReasons: [],
+    monitorFailureReasons: [],
+    monitorProvisioningHalted: false,
+    isTruncated: false,
+    hostsPendingImport: 0,
+    monitorsPendingCreation: 0,
+    hasUnevaluatedScans: false,
+    hasMoreScans: false,
+    isDryRun: false,
+    matchedIpAddressSample: [],
+    ...overrides,
+  };
+}
+
+// Answers with the given passes in order, then repeats the last one forever.
+function serve(responses: Array<AutoImportRuleRunResult | null>): {
+  runPass: () => Promise<AutoImportRuleRunResult | null>;
+  calls: () => number;
+} {
+  let index: number = 0;
+
+  return {
+    calls: (): number => {
+      return index;
+    },
+    runPass: async (): Promise<AutoImportRuleRunResult | null> => {
+      const answer: AutoImportRuleRunResult | null =
+        responses[Math.min(index, responses.length - 1)] ?? null;
+      index++;
+      return answer;
+    },
+  };
+}
+
+describe("AutoImportRunChain", () => {
+  /*
+   * The issue, reproduced at the seam that fixes it: the server can only do
+   * 500 at a time, the estate is 909, and one press has to finish it.
+   */
+  it("keeps running passes until the server stops reporting truncation", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        hostsEvaluated: 909,
+        hostsMatched: 909,
+        devicesCreated: 500,
+        hostsPendingImport: 409,
+        isTruncated: true,
+      }),
+      pass({
+        hostsEvaluated: 909,
+        hostsMatched: 909,
+        hostsSkippedAlreadyRegistered: 500,
+        devicesCreated: 409,
+      }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(2);
+    expect(outcome.passCount).toBe(2);
+    expect(outcome.result?.devicesCreated).toBe(909);
+    expect(outcome.result?.isTruncated).toBe(false);
+    expect(outcome.result?.hostsPendingImport).toBe(0);
+  });
+
+  it("stops after one pass when nothing was truncated", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 3 }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.devicesCreated).toBe(3);
+  });
+
+  /*
+   * A pass that hit the cap without creating anything — every attempt failed,
+   * or a concurrent sweep had already spent the project's budget — would fail
+   * identically next time. Chaining into it would spin.
+   */
+  it("stops when a truncated pass made no progress", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        devicesCreated: 0,
+        monitorsCreated: 0,
+        devicesFailed: 500,
+        hostsPendingImport: 409,
+        isTruncated: true,
+      }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.isTruncated).toBe(true);
+    // The remainder is still reported, so the operator is not left guessing.
+    expect(outcome.result?.hostsPendingImport).toBe(409);
+  });
+
+  /*
+   * A pass that halted monitor provisioning has proved the fault is systemic
+   * (issue #3643). It creates nothing, so the no-progress exit already stops
+   * the chain — pinned here because chaining into a halted run would repeat
+   * the identical failure up to the pass ceiling.
+   */
+  it("does not chain past a run that halted monitor provisioning", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        monitorsFailed: 500,
+        monitorProvisioningHalted: true,
+        monitorFailureReasons: [
+          "This rule's Monitor Template could not be loaded.",
+        ],
+        monitorsPendingCreation: 409,
+        isTruncated: true,
+      }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.monitorProvisioningHalted).toBe(true);
+    expect(outcome.result?.monitorFailureReasons).toHaveLength(1);
+  });
+
+  // A monitor-only pass IS progress, even with zero devices created.
+  it("keeps going when only monitors were created", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({
+        monitorsCreated: 500,
+        monitorsPendingCreation: 409,
+        isTruncated: true,
+      }),
+      pass({ monitorsCreated: 409 }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(2);
+    expect(outcome.result?.monitorsCreated).toBe(909);
+    expect(outcome.result?.monitorsPendingCreation).toBe(0);
+  });
+
+  /*
+   * A dry run writes nothing, so the next pass would evaluate the identical
+   * estate and answer identically. Chaining it would be an infinite loop that
+   * accomplishes nothing.
+   */
+  it("never chains a dry run", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ isDryRun: true, isTruncated: true, monitorsWouldCreate: 500 }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: true,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.result?.isTruncated).toBe(true);
+  });
+
+  /*
+   * "One press finishes the job" must not mean "one press runs for an hour".
+   * Past the ceiling the operator gets a report of what is left and decides.
+   */
+  it("stops at its own ceiling and reports what is left", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 400, isTruncated: true }),
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      maxPasses: 3,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(3);
+    expect(outcome.passCount).toBe(3);
+    expect(outcome.result?.devicesCreated).toBe(1500);
+    expect(outcome.result?.isTruncated).toBe(true);
+    expect(outcome.result?.hostsPendingImport).toBe(400);
+  });
+
+  it("defaults to the shared pass ceiling", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 1, hostsPendingImport: 1, isTruncated: true }),
+    ]);
+
+    await AutoImportRunChain.run({ isDryRun: false, runPass: server.runPass });
+
+    expect(server.calls()).toBe(MAX_AUTO_IMPORT_RUN_PASSES);
+  });
+
+  /*
+   * A failed pass does not undo the ones before it: 500 devices really were
+   * imported, and throwing that summary away would leave the operator less
+   * informed than before they pressed the button.
+   */
+  it("keeps earlier passes when a later one fails", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 409, isTruncated: true }),
+      null,
+    ]);
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+    });
+
+    expect(server.calls()).toBe(2);
+    expect(outcome.passCount).toBe(1);
+    expect(outcome.result?.devicesCreated).toBe(500);
+  });
+
+  it("has nothing to report when the very first pass fails", async () => {
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: async (): Promise<AutoImportRuleRunResult | null> => {
+        return null;
+      },
+    });
+
+    expect(outcome.result).toBeNull();
+    expect(outcome.passCount).toBe(0);
+  });
+
+  // Closing the dialog must not leave a chain importing behind the operator.
+  it("stops chaining once cancelled", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 409, isTruncated: true }),
+    ]);
+    let cancelled: boolean = false;
+
+    const outcome: AutoImportRunChainOutcome = await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: async (): Promise<AutoImportRuleRunResult | null> => {
+        cancelled = true;
+        return server.runPass();
+      },
+      isCancelled: (): boolean => {
+        return cancelled;
+      },
+    });
+
+    expect(server.calls()).toBe(1);
+    expect(outcome.wasCancelled).toBe(true);
+    // What the one completed pass did is still accounted for.
+    expect(outcome.result?.devicesCreated).toBe(500);
+  });
+
+  it("reports progress after each truncated pass, never after the last", async () => {
+    const server: ReturnType<typeof serve> = serve([
+      pass({ devicesCreated: 500, hostsPendingImport: 409, isTruncated: true }),
+      pass({ devicesCreated: 409 }),
+    ]);
+    const progressSeen: Array<number> = [];
+
+    await AutoImportRunChain.run({
+      isDryRun: false,
+      runPass: server.runPass,
+      onProgress: (progress: AutoImportRuleRunResult): void => {
+        progressSeen.push(progress.devicesCreated);
+      },
+    });
+
+    expect(progressSeen).toEqual([500]);
+  });
+});

package/Types/BaseDatabase/IncludesAnyOfGroups.ts

@@ -0,0 +1,77 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+
+/**
+ * Matches at least one related entity in each group. Groups are combined with
+ * AND, while ids within a group are combined with OR. An empty group matches
+ * nothing; callers should omit the operator when there are no conditions.
+ */
+export default class IncludesAnyOfGroups extends QueryOperator<
+  Array<Array<string>>
+> {
+  private readonly _groups: Array<Array<string>>;
+
+  public constructor(groups: Array<Array<string>>) {
+    super();
+
+    if (!Array.isArray(groups) || groups.length === 0 || groups.length > 32) {
+      throw new BadDataException(
+        "IncludesAnyOfGroups requires between 1 and 32 groups.",
+      );
+    }
+
+    let totalValues: number = 0;
+    for (const group of groups) {
+      if (!Array.isArray(group) || group.length > 1000) {
+        throw new BadDataException(
+          "IncludesAnyOfGroups requires arrays of at most 1000 ids.",
+        );
+      }
+
+      totalValues += group.length;
+      for (const value of group) {
+        if (
+          typeof value !== "string" ||
+          value.length === 0 ||
+          value.length > 256
+        ) {
+          throw new BadDataException(
+            "IncludesAnyOfGroups ids must be nonempty strings of at most 256 characters.",
+          );
+        }
+      }
+    }
+
+    if (totalValues > 10000) {
+      throw new BadDataException(
+        "IncludesAnyOfGroups supports at most 10000 ids in total.",
+      );
+    }
+
+    this._groups = groups.map((group: Array<string>) => {
+      return [...new Set(group)];
+    });
+  }
+
+  public get groups(): Array<Array<string>> {
+    return this._groups.map((group: Array<string>) => {
+      return [...group];
+    });
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.IncludesAnyOfGroups,
+      value: this.groups,
+    };
+  }
+
+  public static override fromJSON(json: JSONObject): IncludesAnyOfGroups {
+    if (json["_type"] !== ObjectType.IncludesAnyOfGroups) {
+      throw new BadDataException("Invalid IncludesAnyOfGroups JSON type.");
+    }
+
+    return new IncludesAnyOfGroups(json["value"] as Array<Array<string>>);
+  }
+}

package/Types/Dashboard/DashboardComponents/ComponentArgument.ts

@@ -18,6 +18,7 @@ export enum ComponentInputType {
   MultiSelectDropdown = "MultiSelectDropdown",
   EntityDropdown = "EntityDropdown",
   EntityMultiSelectDropdown = "EntityMultiSelectDropdown",
+  ProjectLabelVariable = "ProjectLabelVariable",
   // Monaco code editors, one per language.
   Html = "Html",
   Css = "Css",

package/Types/Dashboard/DashboardComponents/DashboardMonitorListComponent.ts

@@ -13,5 +13,6 @@ export default interface DashboardMonitorListComponent extends BaseComponent {
     monitorStatusIds?: Array<string> | undefined;
     monitorTypes?: Array<string> | undefined;
     labelIds?: Array<string> | undefined;
+    labelVariableId?: string | undefined;
   };
 }

package/Types/Dashboard/DashboardVariable.ts

@@ -3,6 +3,12 @@ export enum DashboardVariableType {
   Query = "Query",
   TextInput = "Text Input",
   TelemetryAttribute = "Telemetry Attribute",
+  ProjectLabel = "Project Labels",
+}
+
+export interface DashboardVariableOption {
+  label: string;
+  value: string;
 }
 
 export default interface DashboardVariable {
@@ -12,6 +18,8 @@ export default interface DashboardVariable {
   type: DashboardVariableType;
   // For CustomList: comma-separated values
   customListValues?: string | undefined;
+  // Author-selected project label IDs and their published display names.
+  labelOptions?: Array<DashboardVariableOption> | undefined;
   // For Query: a ClickHouse query to populate options
   query?: string | undefined;
   /*

package/Types/JSON.ts

@@ -8,6 +8,7 @@ import GreaterThanOrEqual from "./BaseDatabase/GreaterThanOrEqual";
 import InBetween from "./BaseDatabase/InBetween";
 import Includes from "./BaseDatabase/Includes";
 import IncludesAll from "./BaseDatabase/IncludesAll";
+import IncludesAnyOfGroups from "./BaseDatabase/IncludesAnyOfGroups";
 import IncludesNone from "./BaseDatabase/IncludesNone";
 import StartsWith from "./BaseDatabase/StartsWith";
 import EndsWith from "./BaseDatabase/EndsWith";
@@ -81,6 +82,7 @@ export enum ObjectType {
   IsNull = "IsNull",
   Includes = "Includes",
   IncludesAll = "IncludesAll",
+  IncludesAnyOfGroups = "IncludesAnyOfGroups",
   IncludesNone = "IncludesNone",
   StartsWith = "StartsWith",
   EndsWith = "EndsWith",
@@ -176,6 +178,8 @@ export type JSONValue =
   | Array<Includes>
   | IncludesAll
   | Array<IncludesAll>
+  | IncludesAnyOfGroups
+  | Array<IncludesAnyOfGroups>
   | IncludesNone
   | Array<IncludesNone>
   | StartsWith<string>

package/Types/JSONFunctions.ts

@@ -548,6 +548,16 @@ export default class JSONFunctions {
     return JSON5.parse(val);
   }
 
+  /*
+   * Guarding only against an array leaves every OTHER non-object through:
+   * `42`, `"text"`, `true` and `null` are all valid JSON that JSON5.parse
+   * returns happily, and none of them is an array, so each used to be handed
+   * back typed as a JSONObject. Nothing downstream re-checks - the Text to
+   * JSON workflow component reported a bare number as a SUCCESSFUL parse and
+   * put it on its `json` port, and JSONWebToken.decodeJsonPayload read
+   * properties off a string payload and got undefined for every one of them.
+   * A parse that cannot produce an object should say so where it happens.
+   */
   public static parseJSONObject(val: string): JSONObject {
     const result: JSONObject | JSONArray = this.parse(val);
 
@@ -555,6 +565,12 @@ export default class JSONFunctions {
       throw new Error("Expected JSONObject, but got JSONArray");
     }
 
+    if (result === null || typeof result !== "object") {
+      throw new Error(
+        `Expected JSONObject, but got ${result === null ? "null" : typeof result}`,
+      );
+    }
+
     return result;
   }
 

package/Types/Monitor/SnmpMonitor/NetworkTopology.ts

@@ -237,6 +237,19 @@ export interface NetworkTopologyEdge {
    * absent is "not stated", never "these are peers".
    */
   parentNodeId?: string | undefined;
+  /*
+   * On an "fdb" edge, the end whose forwarding table LEARNED the other
+   * end's MAC — the switch. Always one of `fromNodeId`/`toNodeId`.
+   *
+   * Needed because the pair may already have been joined the other way
+   * round: a hand-drawn link stored device→switch, or an LLDP edge read
+   * from the device's side, keeps its ends when the attachment merges in,
+   * so "the switch is the from end" is true of a fresh attachment and
+   * false of a merged one. Readers that need to know which end learned
+   * (the drawer's "Connected to", the link panel's sentence) read this,
+   * and fall back to `fromNodeId` on a payload that predates it.
+   */
+  learnedByNodeId?: string | undefined;
 }
 
 export default interface NetworkTopology {