@oneuptime/common 11.0.2 → 11.0.3

package/Models/DatabaseModels/ScheduledMaintenanceTemplate.ts

@@ -1,4 +1,5 @@
 import DockerHost from "./DockerHost";
+import PodmanHost from "./PodmanHost";
 import Host from "./Host";
 import KubernetesCluster from "./KubernetesCluster";
 import Label from "./Label";
@@ -736,6 +737,61 @@ export default class ScheduledMaintenanceTemplate extends BaseModel {
   })
   public dockerHosts?: Array<DockerHost> = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ScheduledMaintenanceAdmin,
+      Permission.ScheduledMaintenanceMember,
+      Permission.CreateScheduledMaintenanceTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.ScheduledMaintenanceAdmin,
+      Permission.ScheduledMaintenanceMember,
+      Permission.ScheduledMaintenanceViewer,
+      Permission.ReadScheduledMaintenanceTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ScheduledMaintenanceAdmin,
+      Permission.ScheduledMaintenanceMember,
+      Permission.EditScheduledMaintenanceTemplate,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: PodmanHost,
+    title: "Podman Hosts",
+    description:
+      "List of Podman hosts to pre-populate on scheduled maintenance events created from this template.",
+  })
+  @ManyToMany(
+    () => {
+      return PodmanHost;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "ScheduledMaintenanceTemplatePodmanHost",
+    inverseJoinColumn: {
+      name: "podmanHostId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "scheduledMaintenanceTemplateId",
+      referencedColumnName: "_id",
+    },
+  })
+  public podmanHosts?: Array<PodmanHost> = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/TelemetryException.ts

@@ -23,6 +23,7 @@ import DatabaseBaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 import Service from "./Service";
 import Host from "./Host";
 import DockerHost from "./DockerHost";
+import PodmanHost from "./PodmanHost";
 import KubernetesCluster from "./KubernetesCluster";
 import ServerlessFunction from "./ServerlessFunction";
 import CloudResource from "./CloudResource";
@@ -80,6 +81,7 @@ import RumApplication from "./RumApplication";
     Service,
     Host,
     DockerHost,
+    PodmanHost,
     KubernetesCluster,
     ServerlessFunction,
     CloudResource,

package/Server/API/DashboardAPI.ts

@@ -45,8 +45,11 @@ import Host from "../../Models/DatabaseModels/Host";
 import KubernetesResource from "../../Models/DatabaseModels/KubernetesResource";
 import DockerHost from "../../Models/DatabaseModels/DockerHost";
 import DockerResource from "../../Models/DatabaseModels/DockerResource";
+import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
+import PodmanResource from "../../Models/DatabaseModels/PodmanResource";
 import ProxmoxResource from "../../Models/DatabaseModels/ProxmoxResource";
 import CephResource from "../../Models/DatabaseModels/CephResource";
+import DockerSwarmResource from "../../Models/DatabaseModels/DockerSwarmResource";
 import Span from "../../Models/AnalyticsModels/Span";
 import Log from "../../Models/AnalyticsModels/Log";
 import IncidentService from "../Services/IncidentService";
@@ -56,8 +59,11 @@ import HostService from "../Services/HostService";
 import KubernetesResourceService from "../Services/KubernetesResourceService";
 import DockerHostService from "../Services/DockerHostService";
 import DockerResourceService from "../Services/DockerResourceService";
+import PodmanHostService from "../Services/PodmanHostService";
+import PodmanResourceService from "../Services/PodmanResourceService";
 import ProxmoxResourceService from "../Services/ProxmoxResourceService";
 import CephResourceService from "../Services/CephResourceService";
+import DockerSwarmResourceService from "../Services/DockerSwarmResourceService";
 import SpanService from "../Services/SpanService";
 import LogService from "../Services/LogService";
 
@@ -215,6 +221,67 @@ const PUBLIC_DASHBOARD_RESOURCES: Record<
       dockerHost: { name: true },
     },
   },
+  "podman-host": {
+    modelType: PodmanHost,
+    service: PodmanHostService,
+    select: {
+      _id: true,
+      name: true,
+      otelCollectorStatus: true,
+      containersRunning: true,
+      containersStopped: true,
+      containersPaused: true,
+      osType: true,
+      osVersion: true,
+    },
+  },
+  "podman-container": {
+    modelType: PodmanResource,
+    service: PodmanResourceService,
+    select: {
+      _id: true,
+      name: true,
+      imageName: true,
+      state: true,
+      latestCpuPercent: true,
+      latestMemoryBytes: true,
+      podmanHostId: true,
+      podmanHost: { name: true },
+    },
+  },
+  "podman-image": {
+    modelType: PodmanResource,
+    service: PodmanResourceService,
+    select: {
+      _id: true,
+      name: true,
+      containerId: true,
+      podmanHostId: true,
+      podmanHost: { name: true },
+    },
+  },
+  "podman-network": {
+    modelType: PodmanResource,
+    service: PodmanResourceService,
+    select: {
+      _id: true,
+      name: true,
+      state: true,
+      podmanHostId: true,
+      podmanHost: { name: true },
+    },
+  },
+  "podman-volume": {
+    modelType: PodmanResource,
+    service: PodmanResourceService,
+    select: {
+      _id: true,
+      name: true,
+      state: true,
+      podmanHostId: true,
+      podmanHost: { name: true },
+    },
+  },
   "proxmox-resource": {
     modelType: ProxmoxResource,
     service: ProxmoxResourceService,
@@ -257,6 +324,28 @@ const PUBLIC_DASHBOARD_RESOURCES: Record<
       cephCluster: { name: true },
     },
   },
+  "docker-swarm-resource": {
+    modelType: DockerSwarmResource,
+    service: DockerSwarmResourceService,
+    select: {
+      _id: true,
+      name: true,
+      externalId: true,
+      kind: true,
+      role: true,
+      state: true,
+      serviceMode: true,
+      desiredReplicas: true,
+      runningReplicas: true,
+      image: true,
+      isReady: true,
+      latestCpuPercent: true,
+      latestMemoryPercent: true,
+      lastSeenAt: true,
+      dockerSwarmClusterId: true,
+      dockerSwarmCluster: { name: true },
+    },
+  },
   span: {
     modelType: Span,
     service: SpanService,

package/Server/API/DockerSwarmResourceAPI.ts

@@ -0,0 +1,137 @@
+import DockerSwarmResource from "../../Models/DatabaseModels/DockerSwarmResource";
+import DockerSwarmCluster from "../../Models/DatabaseModels/DockerSwarmCluster";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import DockerSwarmResourceService, {
+  DockerSwarmInventorySummary,
+  Service as DockerSwarmResourceServiceType,
+} from "../Services/DockerSwarmResourceService";
+import DockerSwarmClusterService from "../Services/DockerSwarmClusterService";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import { JSONObject } from "../../Types/JSON";
+
+/*
+ * ------------------------------------------------------------------
+ * DockerSwarmResourceAPI
+ *
+ * Augments the auto-generated CRUD router with a single custom
+ * endpoint the DockerSwarm layout/overview pages use to fetch sidebar
+ * badge counts in one round-trip:
+ *
+ *   POST /docker-swarm-resource/inventory-summary/:clusterId
+ *
+ * The standard CRUD endpoints (list / get) are still registered by
+ * BaseAPI; the UI uses them via ModelAPI for list/detail reads.
+ * Write endpoints reject (@TableAccessControl create/update/delete
+ * = []); ingest writes go through DockerSwarmResourceService as root.
+ * ------------------------------------------------------------------
+ */
+export default class DockerSwarmResourceAPI extends BaseAPI<
+  DockerSwarmResource,
+  DockerSwarmResourceServiceType
+> {
+  public constructor() {
+    super(DockerSwarmResource, DockerSwarmResourceService);
+
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/inventory-summary/:clusterId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.getInventorySummary(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  /*
+   * Cluster + auth resolution for the cluster-scoped sub-route.
+   * Returns the (projectId, dockerSwarmClusterId) tuple after enforcing
+   * the standard ACL chain. Throws NotFound when the cluster is
+   * missing or the caller lacks read access (indistinguishable on
+   * purpose).
+   */
+  private async resolveClusterForRequest(req: ExpressRequest): Promise<{
+    projectId: ObjectID;
+    dockerSwarmClusterId: ObjectID;
+  }> {
+    const clusterIdParam: string | undefined = req.params["clusterId"];
+    if (!clusterIdParam) {
+      throw new BadDataException("Cluster ID is required");
+    }
+
+    let dockerSwarmClusterId: ObjectID;
+    try {
+      dockerSwarmClusterId = new ObjectID(clusterIdParam);
+    } catch {
+      throw new BadDataException("Invalid Cluster ID");
+    }
+
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    const cluster: DockerSwarmCluster | null =
+      await DockerSwarmClusterService.findOneById({
+        id: dockerSwarmClusterId,
+        select: {
+          _id: true,
+          projectId: true,
+        },
+        props,
+      });
+
+    if (!cluster || !cluster.projectId) {
+      throw new NotFoundException("DockerSwarm Cluster not found");
+    }
+
+    return {
+      projectId: cluster.projectId,
+      dockerSwarmClusterId,
+    };
+  }
+
+  private async getInventorySummary(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const { projectId, dockerSwarmClusterId } =
+      await this.resolveClusterForRequest(req);
+
+    const summary: DockerSwarmInventorySummary =
+      await this.service.getInventorySummary({
+        projectId,
+        dockerSwarmClusterId,
+      });
+
+    const responseBody: JSONObject = {
+      countsByKind: summary.countsByKind as unknown as JSONObject,
+      // Convenience fields so the UI doesn't have to repeat COALESCE:
+      nodeCount: summary.countsByKind["Node"] || 0,
+      serviceCount: summary.countsByKind["Service"] || 0,
+      taskCount: summary.countsByKind["Task"] || 0,
+      stackCount: summary.countsByKind["Stack"] || 0,
+      networkCount: summary.countsByKind["Network"] || 0,
+      secretCount: summary.countsByKind["Secret"] || 0,
+      configCount: summary.countsByKind["Config"] || 0,
+      volumeCount: summary.countsByKind["Volume"] || 0,
+      nodeReadyCount: summary.nodeReadyCount,
+      taskRunningCount: summary.taskRunningCount,
+    };
+
+    return Response.sendJsonObjectResponse(req, res, responseBody);
+  }
+}

package/Server/API/TelemetryAPI.ts

@@ -1201,6 +1201,7 @@ router.post(
             "primaryEntityId",
             "hostId",
             "dockerHostId",
+            "podmanHostId",
             "kubernetesClusterId",
             "exceptionType",
             "environment",
@@ -1365,7 +1366,13 @@ router.post(
 
       const facetKeys: Array<string> = body["facetKeys"]
         ? (body["facetKeys"] as Array<string>)
-        : ["primaryEntityId", "hostId", "dockerHostId", "kubernetesClusterId"];
+        : [
+            "primaryEntityId",
+            "hostId",
+            "dockerHostId",
+            "podmanHostId",
+            "kubernetesClusterId",
+          ];
 
       const startTime: Date = body["startTime"]
         ? OneUptimeDate.fromString(body["startTime"] as string)