feat: OMV integration & health monitoring widget

packages/api/src/router/widgets/health-monitoring.ts

@@ -0,0 +1,52 @@
+import { observable } from "@trpc/server/observable";
+
+import type { HealthMonitoring } from "@homarr/integrations";
+import { createItemAndIntegrationChannel } from "@homarr/redis";
+
+import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { createTRPCRouter, publicProcedure } from "../../trpc";
+
+export const healthMonitoringRouter = createTRPCRouter({
+  getHealthStatus: publicProcedure
+    .unstable_concat(createManyIntegrationMiddleware("query", "openmediavault"))
+    .query(async ({ ctx }) => {
+      return await Promise.all(
+        ctx.integrations.map(async (integration) => {
+          const channel = createItemAndIntegrationChannel<HealthMonitoring>("healthMonitoring", integration.id);
+          const data = await channel.getAsync();
+          const healthInfo = data?.data;
+          if (!healthInfo) {
+            throw new Error(`No data found for integration ID: ${integration.id}`);
+          }
+
+          return {
+            integrationId: integration.id,
+            healthInfo,
+          };
+        }),
+      );
+    }),
+
+  subscribeHealthStatus: publicProcedure
+    .unstable_concat(createManyIntegrationMiddleware("query", "openmediavault"))
+    .subscription(({ ctx }) => {
+      return observable<{ integrationId: string; healthInfo: HealthMonitoring }>((emit) => {
+        const unsubscribes: (() => void)[] = [];
+        for (const integration of ctx.integrations) {
+          const channel = createItemAndIntegrationChannel<HealthMonitoring>("healthMonitoring", integration.id);
+          const unsubscribe = channel.subscribe((healthInfo) => {
+            emit.next({
+              integrationId: integration.id,
+              healthInfo,
+            });
+          });
+          unsubscribes.push(unsubscribe);
+        }
+        return () => {
+          unsubscribes.forEach((unsubscribe) => {
+            unsubscribe();
+          });
+        };
+      });
+    }),
+});

packages/api/src/router/widgets/index.ts

@@ -3,6 +3,7 @@ import { appRouter } from "./app";
 import { calendarRouter } from "./calendar";
 import { dnsHoleRouter } from "./dns-hole";
 import { downloadsRouter } from "./downloads";
+import { healthMonitoringRouter } from "./health-monitoring";
 import { indexerManagerRouter } from "./indexer-manager";
 import { mediaRequestsRouter } from "./media-requests";
 import { mediaServerRouter } from "./media-server";
@@ -23,4 +24,5 @@ export const widgetRouter = createTRPCRouter({
   mediaRequests: mediaRequestsRouter,
   rssFeed: rssFeedRouter,
   indexerManager: indexerManagerRouter,
+  healthMonitoring: healthMonitoringRouter,
 });

packages/cron-jobs/src/index.ts

@@ -1,6 +1,7 @@
 import { analyticsJob } from "./jobs/analytics";
 import { iconsUpdaterJob } from "./jobs/icons-updater";
 import { downloadsJob } from "./jobs/integrations/downloads";
+import { healthMonitoringJob } from "./jobs/integrations/health-monitoring";
 import { smartHomeEntityStateJob } from "./jobs/integrations/home-assistant";
 import { indexerManagerJob } from "./jobs/integrations/indexer-manager";
 import { mediaOrganizerJob } from "./jobs/integrations/media-organizer";
@@ -22,6 +23,7 @@ export const jobGroup = createCronJobGroup({
   mediaRequests: mediaRequestsJob,
   rssFeeds: rssFeedsJob,
   indexerManager: indexerManagerJob,
+  healthMonitoring: healthMonitoringJob,
 });
 
 export type JobGroupKeys = ReturnType<(typeof jobGroup)["getKeys"]>[number];

packages/cron-jobs/src/jobs/integrations/health-monitoring.ts

@@ -0,0 +1,22 @@
+import { EVERY_5_SECONDS } from "@homarr/cron-jobs-core/expressions";
+import { db } from "@homarr/db";
+import { getItemsWithIntegrationsAsync } from "@homarr/db/queries";
+import { integrationCreatorFromSecrets } from "@homarr/integrations";
+import { createItemAndIntegrationChannel } from "@homarr/redis";
+
+import { createCronJob } from "../../lib";
+
+export const healthMonitoringJob = createCronJob("healthMonitoring", EVERY_5_SECONDS).withCallback(async () => {
+  const itemsForIntegration = await getItemsWithIntegrationsAsync(db, {
+    kinds: ["healthMonitoring"],
+  });
+
+  for (const itemForIntegration of itemsForIntegration) {
+    for (const integration of itemForIntegration.integrations) {
+      const openmediavault = integrationCreatorFromSecrets(integration.integration);
+      const healthInfo = await openmediavault.getSystemInfoAsync();
+      const channel = createItemAndIntegrationChannel("healthMonitoring", integration.integrationId);
+      await channel.publishAndUpdateLastStateAsync(healthInfo);
+    }
+  }
+});

packages/definitions/src/integration.ts

@@ -119,6 +119,12 @@ export const integrationDefs = {
     iconUrl: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons@master/png/home-assistant.png",
     category: ["smartHomeServer"],
   },
+  openmediavault: {
+    name: "OpenMediaVault",
+    secretKinds: [["username", "password"]],
+    iconUrl: "https://cdn.jsdelivr.net/gh/walkxcode/dashboard-icons@master/png/openmediavault.png",
+    category: ["healthMonitoring"],
+  },
 } as const satisfies Record<string, integrationDefinition>;
 
 export const integrationKinds = objectKeys(integrationDefs) as AtLeastOneOf<IntegrationKind>;
@@ -168,4 +174,5 @@ export type IntegrationCategory =
   | "usenet"
   | "torrent"
   | "smartHomeServer"
-  | "indexerManager";
+  | "indexerManager"
+  | "healthMonitoring";

packages/definitions/src/widget.ts

@@ -16,5 +16,6 @@ export const widgetKinds = [
   "mediaRequests-requestStats",
   "rssFeed",
   "indexerManager",
+  "healthMonitoring",
 ] as const;
 export type WidgetKind = (typeof widgetKinds)[number];

packages/integrations/src/base/creator.ts

@@ -14,6 +14,7 @@ import { JellyfinIntegration } from "../jellyfin/jellyfin-integration";
 import { JellyseerrIntegration } from "../jellyseerr/jellyseerr-integration";
 import { RadarrIntegration } from "../media-organizer/radarr/radarr-integration";
 import { SonarrIntegration } from "../media-organizer/sonarr/sonarr-integration";
+import { OpenMediaVaultIntegration } from "../openmediavault/openmediavault-integration";
 import { OverseerrIntegration } from "../overseerr/overseerr-integration";
 import { PiHoleIntegration } from "../pi-hole/pi-hole-integration";
 import { ProwlarrIntegration } from "../prowlarr/prowlarr-integration";
@@ -60,4 +61,5 @@ export const integrationCreators = {
   jellyseerr: JellyseerrIntegration,
   overseerr: OverseerrIntegration,
   prowlarr: ProwlarrIntegration,
+  openmediavault: OpenMediaVaultIntegration,
 } satisfies Partial<Record<IntegrationKind, new (integration: IntegrationInput) => Integration>>;

packages/integrations/src/index.ts

@@ -6,23 +6,25 @@ export { DownloadClientIntegration } from "./interfaces/downloads/download-clien
 export { JellyseerrIntegration } from "./jellyseerr/jellyseerr-integration";
 export { RadarrIntegration } from "./media-organizer/radarr/radarr-integration";
 export { SonarrIntegration } from "./media-organizer/sonarr/sonarr-integration";
+export { OpenMediaVaultIntegration } from "./openmediavault/openmediavault-integration";
+export { OverseerrIntegration } from "./overseerr/overseerr-integration";
+export { PiHoleIntegration } from "./pi-hole/pi-hole-integration";
+export { ProwlarrIntegration } from "./prowlarr/prowlarr-integration";
 export { SabnzbdIntegration } from "./download-client/sabnzbd/sabnzbd-integration";
 export { NzbGetIntegration } from "./download-client/nzbget/nzbget-integration";
 export { QBitTorrentIntegration } from "./download-client/qbittorrent/qbittorrent-integration";
 export { DelugeIntegration } from "./download-client/deluge/deluge-integration";
 export { TransmissionIntegration } from "./download-client/transmission/transmission-integration";
-export { OverseerrIntegration } from "./overseerr/overseerr-integration";
-export { PiHoleIntegration } from "./pi-hole/pi-hole-integration";
-export { ProwlarrIntegration } from "./prowlarr/prowlarr-integration";
 
 // Types
-export type { IntegrationInput } from "./base/integration";
-export type { DownloadClientJobsAndStatus } from "./interfaces/downloads/download-client-data";
-export type { ExtendedDownloadClientItem } from "./interfaces/downloads/download-client-items";
-export type { ExtendedClientStatus } from "./interfaces/downloads/download-client-status";
+export type { HealthMonitoring } from "./interfaces/health-monitoring/healt-monitoring";
 export { MediaRequestStatus } from "./interfaces/media-requests/media-request";
 export type { MediaRequestList, MediaRequestStats } from "./interfaces/media-requests/media-request";
 export type { StreamSession } from "./interfaces/media-server/session";
+export type { ExtendedClientStatus } from "./interfaces/downloads/download-client-status";
+export type { ExtendedDownloadClientItem } from "./interfaces/downloads/download-client-items";
+export type { DownloadClientJobsAndStatus } from "./interfaces/downloads/download-client-data";
+export type { IntegrationInput } from "./base/integration";
 
 // Schemas
 export { downloadClientItemSchema } from "./interfaces/downloads/download-client-items";

packages/integrations/src/interfaces/health-monitoring/healt-monitoring.ts

@@ -0,0 +1,27 @@
+export interface HealthMonitoring {
+  version: string;
+  cpuModelName: string;
+  cpuUtilization: number;
+  memUsed: string;
+  memAvailable: string;
+  uptime: number;
+  loadAverage: {
+    "1min": number;
+    "5min": number;
+    "15min": number;
+  };
+  rebootRequired: boolean;
+  availablePkgUpdates: number;
+  cpuTemp: number;
+  fileSystem: {
+    deviceName: string;
+    used: string;
+    available: string;
+    percentage: number;
+  }[];
+  smart: {
+    deviceName: string;
+    temperature: number;
+    overallStatus: string;
+  }[];
+}

packages/integrations/src/openmediavault/openmediavault-integration.ts

@@ -0,0 +1,151 @@
+import { Integration } from "../base/integration";
+import { IntegrationTestConnectionError } from "../base/test-connection-error";
+import type { HealthMonitoring } from "../types";
+import { cpuTempSchema, fileSystemSchema, smartSchema, systemInformationSchema } from "./openmediavault-types";
+
+export class OpenMediaVaultIntegration extends Integration {
+  private async makeOpenMediaVaultRPCCallAsync(
+    serviceName: string,
+    method: string,
+    params: Record<string, unknown>,
+    headers: Record<string, string> = {},
+  ): Promise<Response> {
+    return await fetch(`${this.integration.url}/rpc.php`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+      },
+      body: JSON.stringify({
+        service: serviceName,
+        method,
+        params,
+      }),
+    });
+  }
+
+  private async omvAuthAsync() {
+    const authResponse = await this.makeOpenMediaVaultRPCCallAsync("session", "login", {
+      username: this.getSecretValue("username"),
+      password: this.getSecretValue("password"),
+    });
+    const authResult = (await authResponse.json()) as Response;
+    const response = (authResult as { response?: { sessionid?: string } }).response;
+    let sessionId;
+    const headers: Record<string, string> = {};
+    if (response?.sessionid) {
+      sessionId = response.sessionid;
+      headers["X-OPENMEDIAVAULT-SESSIONID"] = sessionId;
+    } else {
+      sessionId = OpenMediaVaultIntegration.extractSessionIdFromCookies(authResponse.headers);
+      const loginToken = OpenMediaVaultIntegration.extractLoginTokenFromCookies(authResponse.headers);
+      headers.Cookie = `${loginToken};${sessionId}`;
+    }
+    return headers;
+  }
+
+  static extractSessionIdFromCookies(headers: Headers): string {
+    const cookies = headers.get("set-cookie") ?? "";
+    const sessionId = cookies
+      .split(";")
+      .find((cookie) => cookie.includes("X-OPENMEDIAVAULT-SESSIONID") || cookie.includes("OPENMEDIAVAULT-SESSIONID"));
+
+    if (sessionId) {
+      return sessionId;
+    } else {
+      throw new Error("Session ID not found in cookies");
+    }
+  }
+
+  static extractLoginTokenFromCookies(headers: Headers): string {
+    const cookies = headers.get("set-cookie") ?? "";
+    const loginToken = cookies
+      .split(";")
+      .find((cookie) => cookie.includes("X-OPENMEDIAVAULT-LOGIN") || cookie.includes("OPENMEDIAVAULT-LOGIN"));
+
+    if (loginToken) {
+      return loginToken;
+    } else {
+      throw new Error("Login token not found in cookies");
+    }
+  }
+
+  public async getSystemInfoAsync(): Promise<HealthMonitoring> {
+    const headers = await this.omvAuthAsync();
+
+    const systemResponses = await this.makeOpenMediaVaultRPCCallAsync("system", "getInformation", {}, headers);
+    const fileSystemResponse = await this.makeOpenMediaVaultRPCCallAsync(
+      "filesystemmgmt",
+      "enumerateMountedFilesystems",
+      { includeroot: true },
+      headers,
+    );
+    const smartResponse = await this.makeOpenMediaVaultRPCCallAsync("smart", "enumerateDevices", {}, headers);
+    const cpuTempResponse = await this.makeOpenMediaVaultRPCCallAsync("cputemp", "get", {}, headers);
+
+    const systemResult = systemInformationSchema.safeParse(await systemResponses.json());
+    const fileSystemResult = fileSystemSchema.safeParse(await fileSystemResponse.json());
+    const smartResult = smartSchema.safeParse(await smartResponse.json());
+    const cpuTempResult = cpuTempSchema.safeParse(await cpuTempResponse.json());
+
+    if (!systemResult.success) {
+      throw new Error("Invalid system information response");
+    }
+    if (!fileSystemResult.success) {
+      throw new Error("Invalid file system response");
+    }
+    if (!smartResult.success) {
+      throw new Error("Invalid SMART information response");
+    }
+    if (!cpuTempResult.success) {
+      throw new Error("Invalid CPU temperature response");
+    }
+
+    const fileSystem = fileSystemResult.data.response.map((fileSystem) => ({
+      deviceName: fileSystem.devicename,
+      used: fileSystem.used,
+      available: fileSystem.available,
+      percentage: fileSystem.percentage,
+    }));
+
+    const smart = smartResult.data.response.map((smart) => ({
+      deviceName: smart.devicename,
+      temperature: smart.temperature,
+      overallStatus: smart.overallstatus,
+    }));
+
+    return {
+      version: systemResult.data.response.version,
+      cpuModelName: systemResult.data.response.cpuModelName,
+      cpuUtilization: systemResult.data.response.cpuUtilization,
+      memUsed: systemResult.data.response.memUsed,
+      memAvailable: systemResult.data.response.memAvailable,
+      uptime: systemResult.data.response.uptime,
+      loadAverage: {
+        "1min": systemResult.data.response.loadAverage["1min"],
+        "5min": systemResult.data.response.loadAverage["5min"],
+        "15min": systemResult.data.response.loadAverage["15min"],
+      },
+      rebootRequired: systemResult.data.response.rebootRequired,
+      availablePkgUpdates: systemResult.data.response.availablePkgUpdates,
+      cpuTemp: cpuTempResult.data.response.cputemp,
+      fileSystem,
+      smart,
+    };
+  }
+
+  public async testConnectionAsync(): Promise<void> {
+    const response = await this.makeOpenMediaVaultRPCCallAsync("session", "login", {
+      username: this.getSecretValue("username"),
+      password: this.getSecretValue("password"),
+    });
+
+    if (!response.ok) {
+      throw new IntegrationTestConnectionError("invalidCredentials");
+    }
+    const result = (await response.json()) as unknown;
+    if (typeof result !== "object" || result === null || !("response" in result)) {
+      throw new IntegrationTestConnectionError("invalidJson");
+    }
+  }
+}