@oneuptime/common 12.0.9 → 12.0.11

package/Models/DatabaseModels/NetworkDevice.ts

@@ -646,6 +646,50 @@ export default class NetworkDevice extends BaseModel {
   })
   public monitoringMethod?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateNetworkDevice,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadNetworkDevice,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditNetworkDevice,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Device Role",
+    description:
+      "What this device does on the network — router, switch, access point and so on. Left empty, the role is worked out from the device's own SNMP identity. Set it when there is no SNMP to read: a ping-only device has no identity to classify, and the role decides both the shape it is drawn with and where it sits in the topology hierarchy.",
+    example: "switch",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public deviceRole?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/NetworkDeviceLink.ts

@@ -376,6 +376,122 @@ export default class NetworkDeviceLink extends BaseModel {
   })
   public toDeviceId?: ObjectID = undefined;
 
+  /*
+   * --- Which end is up ---
+   *
+   * A link says two devices are cabled together. It does not say which one
+   * the other hangs off, and the topology map has to decide: the
+   * parent-child view draws an actual tree, so somebody is the parent.
+   * Left to itself it infers one from device roles and connection counts,
+   * which is a good guess on a network that speaks SNMP and no guess at
+   * all on one that does not — the case issue #3192 is about, where the
+   * child is a ping-only device whose role nothing can classify.
+   *
+   * This column is the operator answering that question outright. It is
+   * NULL by default and on every row written before it existed, and NULL
+   * means exactly what the map did then: a peer link, direction inferred.
+   * So no existing map moves, and a hierarchy only becomes declared when
+   * somebody declares it.
+   *
+   * The value must be one of this link's own two ends — a parent that is
+   * not on the link is not a statement about the link — which the service
+   * enforces on create and on update, including when an update moves an
+   * end out from under a parent that was already set.
+   */
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateNetworkDeviceLink,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadNetworkDeviceLink,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditNetworkDeviceLink,
+    ],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "parentDeviceId",
+    type: TableColumnType.Entity,
+    modelType: NetworkDevice,
+    title: "Parent Device",
+    description:
+      "Relation to whichever end of this link is the parent, if the hierarchy is declared rather than inferred",
+  })
+  @ManyToOne(
+    () => {
+      return NetworkDevice;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "parentDeviceId" })
+  public parentDevice?: NetworkDevice = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.CreateNetworkDeviceLink,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadNetworkDeviceLink,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditNetworkDeviceLink,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Parent Device ID",
+    description:
+      "ID of whichever end of this link is the parent. Must be the From Device or the To Device. Empty means the two are peers and the map infers the hierarchy.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public parentDeviceId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/RunnerJob.ts

@@ -32,7 +32,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
   pluralName: "Runner Jobs",
   icon: IconProp.Logs,
   tableDescription:
-    "One row per Bash or JavaScript step dispatched to a specific Runner. Tracks claim, execution, and result. Managed by the Worker and the agents; not user-writable.",
+    "One row per step dispatched to a specific Runner — Bash and JavaScript, which carry a script, and SSH and Kubernetes, which carry structured instructions instead. Tracks claim, execution, and result. Managed by the Worker and the agents; not user-writable.",
 })
 @TableAccessControl({
   create: [],
@@ -449,6 +449,21 @@ export default class RunnerJob extends BaseModel {
   })
   public status?: RunnerJobStatus = undefined;
 
+  /*
+   * NOT a required column, even though the database keeps it NOT NULL.
+   *
+   * `required` feeds getRequiredColumns(), which
+   * DatabaseService.checkRequiredFields rejects on any falsy value — and an
+   * empty string is falsy. SSH and Kubernetes jobs carry their instruction in
+   * `payload` and an empty script by design, so marking this required made
+   * every one of them fail at create() with "script is required" before a
+   * Runner ever saw the job. The NOT NULL constraint still holds:
+   * RunnerJobService always writes a string, empty or not.
+   *
+   * Which step types must carry a script and which must carry a payload is a
+   * per-type rule that column metadata cannot express, so it is enforced in
+   * RunnerJobService.enqueue instead.
+   */
   @ColumnAccessControl({
     create: [],
     read: [
@@ -464,7 +479,7 @@ export default class RunnerJob extends BaseModel {
   })
   @TableColumn({
     type: TableColumnType.VeryLongText,
-    required: true,
+    required: false,
     title: "Script",
     description:
       "The script the Runner must execute. Empty for step types that carry structured instructions in the payload instead.",

package/Server/API/LlmProviderAPI.ts

@@ -191,6 +191,14 @@ export default class LlmProviderAPI extends BaseAPI<
               ],
               temperature: 0,
               maxTokens: 16,
+              /*
+               * A connection test is a person waiting on a verdict, not a
+               * chat turn worth saving. The default ten-attempt ladder would
+               * make "your base URL is unreachable" — the answer this button
+               * exists to give — take the better part of a minute to arrive.
+               * One retry still absorbs a single blip.
+               */
+              requestRetries: 1,
               llmProviderConfig: llmProviderConfig,
               ...(provider.additionalParams
                 ? { additionalParams: provider.additionalParams }

package/Server/Infrastructure/Postgres/SchemaMigrations/1787400000000-AddDeviceRoleAndDeclaredLinkParent.ts

@@ -0,0 +1,52 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Two nullable columns, both of them an operator stating something the
+ * network cannot be asked:
+ *
+ *   NetworkDevice.deviceRole      — what this box actually is, for devices
+ *                                   with no SNMP identity to classify.
+ *   NetworkDeviceLink.parentDeviceId — which end of a declared link is up.
+ *
+ * Nullable on purpose, with no backfill. NULL is a meaningful value in
+ * both cases and it is the value every existing row should hold: no role
+ * override (so the classifier keeps deciding) and no declared hierarchy
+ * (so the map keeps inferring one). Defaulting either would silently
+ * restate every device and every link in every project as something an
+ * operator had chosen, which is the one thing neither column may mean.
+ */
+export class AddDeviceRoleAndDeclaredLinkParent1787400000000
+  implements MigrationInterface
+{
+  public name = "AddDeviceRoleAndDeclaredLinkParent1787400000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" ADD "deviceRole" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" ADD "parentDeviceId" uuid`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_01752cd47b773df38b4a54ae53" ON "NetworkDeviceLink" ("parentDeviceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" ADD CONSTRAINT "FK_01752cd47b773df38b4a54ae539" FOREIGN KEY ("parentDeviceId") REFERENCES "NetworkDevice"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" DROP CONSTRAINT "FK_01752cd47b773df38b4a54ae539"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_01752cd47b773df38b4a54ae53"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceLink" DROP COLUMN "parentDeviceId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDevice" DROP COLUMN "deviceRole"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -527,6 +527,7 @@ import { AddOnCallNotificationFallbackColumns1787000000000 } from "./17870000000
 import { AddAIConversationPageContext1787100000000 } from "./1787100000000-AddAIConversationPageContext";
 import { AddAIChatMessageFeedback1787200000000 } from "./1787200000000-AddAIChatMessageFeedback";
 import { AddEpisodeMemberNotifyIndexes1787300000000 } from "./1787300000000-AddEpisodeMemberNotifyIndexes";
+import { AddDeviceRoleAndDeclaredLinkParent1787400000000 } from "./1787400000000-AddDeviceRoleAndDeclaredLinkParent";
 
 export default [
   InitialMigration,
@@ -1058,4 +1059,5 @@ export default [
   AddAIConversationPageContext1787100000000,
   AddAIChatMessageFeedback1787200000000,
   AddEpisodeMemberNotifyIndexes1787300000000,
+  AddDeviceRoleAndDeclaredLinkParent1787400000000,
 ];

package/Server/Services/NetworkDeviceLabelRuleEngineService.ts

@@ -3,11 +3,38 @@ import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
 import NetworkDeviceLabelRule from "../../Models/DatabaseModels/NetworkDeviceLabelRule";
 import NetworkDeviceLabelRuleService from "./NetworkDeviceLabelRuleService";
 import NetworkDeviceService from "./NetworkDeviceService";
+import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import { LabelRuleRunResult } from "../../Types/NetworkAutomation/RuleRunResult";
 import RulePatternMatchUtil from "../../Utils/Rules/RulePatternMatchUtil";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 
+/*
+ * Bounds on one manual "Run now" of a label rule. The automatic path only
+ * ever sees a single freshly created device; a retroactive run walks the
+ * whole estate, so it reads devices in pages and stops at a cap, reporting
+ * isTruncated instead of holding an HTTP request open over a full fleet.
+ */
+export const MAX_DEVICES_PER_LABEL_RULE_RUN: number = 10000;
+const LABEL_RULE_RUN_PAGE_SIZE: number = 1000;
+
+/*
+ * How many (device, label) pairs one INSERT attaches. TypeORM expands
+ * `.of(ids).add(labelId)` into a parameter per id, and Postgres refuses a
+ * statement with more than 65535 of them.
+ */
+const LABEL_ATTACH_CHUNK_SIZE: number = 500;
+
+function chunk<T>(items: Array<T>, size: number): Array<Array<T>> {
+  const chunks: Array<Array<T>> = [];
+  for (let index: number = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}
+
 class NetworkDeviceLabelRuleEngineServiceClass {
   /**
    * Evaluates NetworkDeviceLabelRule rows for the given network device and attaches matched
@@ -133,6 +160,219 @@ class NetworkDeviceLabelRuleEngineServiceClass {
     }
   }
 
+  /*
+   * Runs ONE label rule against the network devices that already exist.
+   *
+   * The automatic engine above only fires on device creation, so a rule
+   * written after an estate was imported or discovered would never reach a
+   * single one of those devices (OneUptime/oneuptime#3191). This is the
+   * manual counterpart: same matcher, same "already-attached labels are not
+   * duplicated" guarantee, applied across the project instead of to one row.
+   *
+   * Safe to run repeatedly — attaching labels is additive and idempotent, so
+   * a second run reports devicesMatched with devicesLabeled at zero.
+   */
+  @CaptureSpan()
+  public async applyRuleToExistingNetworkDevices(data: {
+    ruleId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<LabelRuleRunResult> {
+    const rule: NetworkDeviceLabelRule | null =
+      await NetworkDeviceLabelRuleService.findOneBy({
+        query: {
+          _id: data.ruleId,
+          projectId: data.projectId,
+        },
+        select: {
+          _id: true,
+          name: true,
+          isEnabled: true,
+          networkDeviceLabels: { _id: true },
+          networkDeviceNamePattern: true,
+          networkDeviceDescriptionPattern: true,
+          labelsToAdd: { _id: true },
+        },
+        props: { isRoot: true },
+      });
+
+    if (!rule) {
+      throw new BadDataException("Label rule not found.");
+    }
+
+    /*
+     * A disabled rule is one the user has switched off; running it by hand
+     * would contradict the toggle they can see right next to the button.
+     */
+    if (!rule.isEnabled) {
+      throw new BadDataException(
+        "This label rule is disabled. Enable it before running it.",
+      );
+    }
+
+    const labelIdsToAdd: Array<string> = (rule.labelsToAdd || [])
+      .map((label: Label) => {
+        return label.id?.toString() || "";
+      })
+      .filter((id: string) => {
+        return id !== "";
+      });
+
+    if (labelIdsToAdd.length === 0) {
+      throw new BadDataException(
+        "This label rule has no labels to add, so running it would do nothing.",
+      );
+    }
+
+    const result: LabelRuleRunResult = {
+      devicesEvaluated: 0,
+      devicesMatched: 0,
+      devicesLabeled: 0,
+      labelsAttached: 0,
+      labelsFailed: 0,
+      isTruncated: false,
+    };
+
+    // Counted across pages so a device is never counted twice.
+    const labeledDeviceIds: Set<string> = new Set();
+
+    let skip: number = 0;
+
+    for (;;) {
+      const devices: Array<NetworkDevice> = await NetworkDeviceService.findBy({
+        query: {
+          projectId: data.projectId,
+        },
+        select: {
+          _id: true,
+          name: true,
+          description: true,
+          labels: { _id: true },
+        },
+        /*
+         * Sorted by id so paging stays stable across the writes this run
+         * makes: attaching a label never changes a device's id, so no row
+         * can shift between pages and be skipped or seen twice.
+         */
+        sort: {
+          _id: SortOrder.Ascending,
+        },
+        limit: LABEL_RULE_RUN_PAGE_SIZE,
+        skip: skip,
+        props: { isRoot: true },
+      });
+
+      if (devices.length === 0) {
+        break;
+      }
+
+      /*
+       * One INSERT per label rather than per device: every matched device
+       * needs the same label set, so the work collapses into a handful of
+       * statements no matter how large the estate is.
+       */
+      const deviceIdsByLabelId: Map<string, Array<string>> = new Map();
+
+      for (const device of devices) {
+        result.devicesEvaluated++;
+
+        if (!this.doesNetworkDeviceMatchRule(device, rule)) {
+          continue;
+        }
+
+        result.devicesMatched++;
+
+        const deviceId: string | undefined = device.id?.toString();
+
+        if (!deviceId) {
+          continue;
+        }
+
+        const existingLabelIds: Set<string> = new Set(
+          (device.labels || []).map((label: Label) => {
+            return label.id?.toString() || "";
+          }),
+        );
+
+        for (const labelId of labelIdsToAdd) {
+          if (existingLabelIds.has(labelId)) {
+            continue;
+          }
+
+          const deviceIds: Array<string> =
+            deviceIdsByLabelId.get(labelId) || [];
+          deviceIds.push(deviceId);
+          deviceIdsByLabelId.set(labelId, deviceIds);
+        }
+      }
+
+      for (const [labelId, deviceIds] of deviceIdsByLabelId) {
+        for (const deviceIdChunk of chunk(deviceIds, LABEL_ATTACH_CHUNK_SIZE)) {
+          try {
+            await NetworkDeviceService.getRepository()
+              .createQueryBuilder()
+              .relation(NetworkDevice, "labels")
+              .of(deviceIdChunk)
+              .add(labelId);
+
+            result.labelsAttached += deviceIdChunk.length;
+
+            for (const deviceId of deviceIdChunk) {
+              labeledDeviceIds.add(deviceId);
+            }
+          } catch (error) {
+            /*
+             * A failed batch must not abandon the rest of the estate — the
+             * run reports it and carries on.
+             */
+            result.labelsFailed += deviceIdChunk.length;
+            logger.error(
+              `Error attaching label ${labelId} from network device label rule ${data.ruleId.toString()}: ${error}`,
+              {
+                projectId: data.projectId.toString(),
+              } as LogAttributes,
+            );
+          }
+        }
+      }
+
+      skip += devices.length;
+
+      if (devices.length < LABEL_RULE_RUN_PAGE_SIZE) {
+        break;
+      }
+
+      if (skip >= MAX_DEVICES_PER_LABEL_RULE_RUN) {
+        /*
+         * A full last page is not proof that more devices exist — an estate
+         * of exactly the cap would report a truncation that never happened.
+         * One row settles it.
+         */
+        const nextDevice: Array<NetworkDevice> =
+          await NetworkDeviceService.findBy({
+            query: {
+              projectId: data.projectId,
+            },
+            select: {
+              _id: true,
+            },
+            sort: {
+              _id: SortOrder.Ascending,
+            },
+            limit: 1,
+            skip: skip,
+            props: { isRoot: true },
+          });
+
+        result.isTruncated = nextDevice.length > 0;
+        break;
+      }
+    }
+
+    result.devicesLabeled = labeledDeviceIds.size;
+
+    return result;
+  }
+
   private doesNetworkDeviceMatchRule(
     networkDevice: NetworkDevice,
     rule: NetworkDeviceLabelRule,