@oneuptime/common 11.0.1 → 11.0.3

package/Server/API/DashboardAPI.ts

@@ -45,6 +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";
@@ -54,6 +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";
 
@@ -211,6 +221,131 @@ 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,
+    select: {
+      _id: true,
+      name: true,
+      externalId: true,
+      kind: true,
+      vmid: true,
+      guestType: true,
+      parentNodeName: true,
+      isUp: true,
+      haState: true,
+      latestCpuPercent: true,
+      latestMemoryPercent: true,
+      lastSeenAt: true,
+      proxmoxClusterId: true,
+      proxmoxCluster: { name: true },
+    },
+  },
+  "ceph-resource": {
+    modelType: CephResource,
+    service: CephResourceService,
+    select: {
+      _id: true,
+      name: true,
+      externalId: true,
+      kind: true,
+      hostname: true,
+      deviceClass: true,
+      isUp: true,
+      isIn: true,
+      statBytes: true,
+      statBytesUsed: true,
+      storedBytes: true,
+      maxAvailBytes: true,
+      objects: true,
+      lastSeenAt: true,
+      cephClusterId: true,
+      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/ProjectAPI.ts

@@ -45,6 +45,21 @@ export default class ProjectAPI extends BaseAPI<Project, ProjectServiceType> {
 
           const projectId: ObjectID = new ObjectID(req.params["id"] as string);
 
+          /*
+           * The permission check below is bound to the authenticated tenant
+           * (resolved from the tenantid header), so the project being
+           * mutated must be that same tenant — otherwise permissions on one
+           * project would authorize changing the plan (and charging the
+           * payment method) of another.
+           */
+          const tenantId: ObjectID | null = this.getTenantId(req);
+
+          if (!tenantId || tenantId.toString() !== projectId.toString()) {
+            throw new BadDataException(
+              "Project ID in the URL does not match the project the request is authenticated for",
+            );
+          }
+
           const body: JSONObject = (req.body as JSONObject) || {};
           const data: JSONObject = (body["data"] as JSONObject) || {};
           const paymentProviderPlanId: string | undefined = data[

package/Server/API/ProxmoxResourceAPI.ts

@@ -0,0 +1,132 @@
+import ProxmoxResource from "../../Models/DatabaseModels/ProxmoxResource";
+import ProxmoxCluster from "../../Models/DatabaseModels/ProxmoxCluster";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import ProxmoxResourceService, {
+  ProxmoxInventorySummary,
+  Service as ProxmoxResourceServiceType,
+} from "../Services/ProxmoxResourceService";
+import ProxmoxClusterService from "../Services/ProxmoxClusterService";
+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";
+
+/*
+ * ------------------------------------------------------------------
+ * ProxmoxResourceAPI
+ *
+ * Augments the auto-generated CRUD router with a single custom
+ * endpoint the Proxmox layout/overview pages use to fetch sidebar
+ * badge counts in one round-trip:
+ *
+ *   POST /proxmox-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 ProxmoxResourceService as root.
+ * ------------------------------------------------------------------
+ */
+export default class ProxmoxResourceAPI extends BaseAPI<
+  ProxmoxResource,
+  ProxmoxResourceServiceType
+> {
+  public constructor() {
+    super(ProxmoxResource, ProxmoxResourceService);
+
+    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, proxmoxClusterId) 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;
+    proxmoxClusterId: ObjectID;
+  }> {
+    const clusterIdParam: string | undefined = req.params["clusterId"];
+    if (!clusterIdParam) {
+      throw new BadDataException("Cluster ID is required");
+    }
+
+    let proxmoxClusterId: ObjectID;
+    try {
+      proxmoxClusterId = new ObjectID(clusterIdParam);
+    } catch {
+      throw new BadDataException("Invalid Cluster ID");
+    }
+
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    const cluster: ProxmoxCluster | null =
+      await ProxmoxClusterService.findOneById({
+        id: proxmoxClusterId,
+        select: {
+          _id: true,
+          projectId: true,
+        },
+        props,
+      });
+
+    if (!cluster || !cluster.projectId) {
+      throw new NotFoundException("Proxmox Cluster not found");
+    }
+
+    return {
+      projectId: cluster.projectId,
+      proxmoxClusterId,
+    };
+  }
+
+  private async getInventorySummary(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const { projectId, proxmoxClusterId } =
+      await this.resolveClusterForRequest(req);
+
+    const summary: ProxmoxInventorySummary =
+      await this.service.getInventorySummary({
+        projectId,
+        proxmoxClusterId,
+      });
+
+    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,
+      guestCount: summary.countsByKind["Guest"] || 0,
+      storageCount: summary.countsByKind["Storage"] || 0,
+      nodeOnlineCount: summary.nodeOnlineCount,
+      guestRunningCount: summary.guestRunningCount,
+    };
+
+    return Response.sendJsonObjectResponse(req, res, responseBody);
+  }
+}

package/Server/API/ResellerPlanAPI.ts

@@ -77,6 +77,7 @@ export default class ResellerPlanAPI extends BaseAPI<
                 _id: true,
                 planId: true,
                 reseller: {
+                  _id: true,
                   resellerId: true,
                 },
                 teamMemberLimit: true,
@@ -98,6 +99,13 @@ export default class ResellerPlanAPI extends BaseAPI<
             );
           }
 
+          const resellerObjectId: ObjectID | undefined =
+            resellerPlan.reseller?.id || undefined;
+
+          if (!resellerObjectId) {
+            throw new BadDataException("Invalid reseller plan id.");
+          }
+
           const licenseKey: string | undefined = req.body.uuid;
 
           if (!licenseKey) {
@@ -166,6 +174,12 @@ export default class ResellerPlanAPI extends BaseAPI<
             const project: Project | null = await ProjectService.findOneBy({
               query: {
                 resellerLicenseId: licenseKey,
+                /*
+                 * license keys are not globally unique — scope to the
+                 * authenticated reseller so one reseller cannot modify
+                 * another reseller's customer project.
+                 */
+                resellerId: resellerObjectId,
               },
               select: {
                 _id: true,
@@ -207,6 +221,8 @@ export default class ResellerPlanAPI extends BaseAPI<
             const project: Project | null = await ProjectService.findOneBy({
               query: {
                 resellerLicenseId: licenseKey,
+                // scope to the authenticated reseller — see enhance_tier.
+                resellerId: resellerObjectId,
               },
               select: {
                 _id: true,
@@ -226,6 +242,7 @@ export default class ResellerPlanAPI extends BaseAPI<
             await ProjectService.deleteOneBy({
               query: {
                 resellerLicenseId: licenseKey,
+                resellerId: resellerObjectId,
                 _id: project.id?.toString() as string,
               },
               props: {

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)

package/Server/Infrastructure/GlobalCache.ts

@@ -164,9 +164,15 @@ export default abstract class GlobalCache {
       throw new DatabaseNotConnectedException("Cache is not connected");
     }
 
-    await client.set(`${namespace}-${key}`, value);
     const expiresInSeconds: number =
       options?.expiresInSeconds ?? OneUptimeDate.getSecondsInDays(30);
-    await client.expire(`${namespace}-${key}`, expiresInSeconds);
+
+    /*
+     * Atomic SET ... EX — a separate SET followed by EXPIRE can crash
+     * in between and leave the key with no TTL. For fence / throttle
+     * keys (e.g. otel-maintenance-fence) a TTL-less key never expires
+     * and permanently suppresses the work it gates.
+     */
+    await client.set(`${namespace}-${key}`, value, "EX", expiresInSeconds);
   }
 }