Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
import { Accessor, createMemo } from 'solid-js';
import { buildStorageRecords } from '@/features/storageBackups/storageAdapters';
import type { StorageHealthFilter } from '@/features/storageBackups/models';
import type { StorageCapacityDeltaPresentation } from '@/features/storageBackups/storageCapacityDeltaPresentation';
import {
buildPhysicalDiskGroupFilterOptions,
buildPhysicalDiskRoleFilterOptions,
getPhysicalDiskSourceKey,
} from '@/features/storageBackups/diskPresentation';
import type { State } from '@/types/api';
import type { Resource } from '@/types/resource';
import { useStorageAlertState } from './useStorageAlertState';
import { consolidateCephClusterPoolRecords } from '@/features/storageBackups/cephRecordPresentation';
import { storageAlertSeverityWeight } from '@/features/storageBackups/storageAlertState';
import { useStorageCephModel } from './useStorageCephModel';
import {
buildStorageNodeOnlineByLabel,
buildStorageNodeOptions,
filterStorageDiskNodeOptions,
storageResourceMatchesSourceFilter,
} from './storagePageState';
import { type StorageGroupKey, type StorageSortKey, useStorageModel } from './useStorageModel';
type UseStoragePageDataOptions = {
state: Accessor<State>;
resources: Accessor<Resource[]>;
activeAlerts: Accessor<unknown> | unknown;
alertsEnabled: Accessor<boolean>;
nodes: Accessor<Resource[]>;
physicalDisks: Accessor<Resource[]>;
cephResources: Accessor<Resource[]>;
search: Accessor<string>;
sourceFilter: Accessor<string>;
healthFilter: Accessor<StorageHealthFilter>;
selectedNodeId: Accessor<string>;
sortKey: Accessor<StorageSortKey>;
sortDirection: Accessor<'asc' | 'desc'>;
storageGrowthBySeriesId?: Accessor<ReadonlyMap<string, StorageCapacityDeltaPresentation>>;
groupBy: Accessor<StorageGroupKey>;
};
export const useStoragePageData = (options: UseStoragePageDataOptions) => {
const records = createMemo(() =>
buildStorageRecords({ state: options.state(), resources: options.resources() }),
);
// Alert state follows the rows the table shows, so a Ceph pool folded into
// its mounting storage still explains and ranks that row.
const alertRecords = createMemo(() => consolidateCephClusterPoolRecords(records()));
const { getRecordAlertState, getRecordAlerts } = useStorageAlertState({
records: alertRecords,
activeAlerts: options.activeAlerts,
alertsEnabled: options.alertsEnabled,
});
const sourceScopedNodes = createMemo(() =>
options
.nodes()
.filter((node) => storageResourceMatchesSourceFilter(node, options.sourceFilter())),
);
const nodeOptions = createMemo(() => buildStorageNodeOptions(sourceScopedNodes()));
const diskNodeOptions = createMemo(() =>
filterStorageDiskNodeOptions(nodeOptions(), options.physicalDisks()),
);
const nodeOnlineByLabel = createMemo(() => buildStorageNodeOnlineByLabel(sourceScopedNodes()));
const { sourceOptions, filteredRecords, groupedRecords } = useStorageModel({
records,
search: options.search,
sourceFilter: options.sourceFilter,
healthFilter: options.healthFilter,
selectedNodeId: options.selectedNodeId,
nodeOptions,
sortKey: options.sortKey,
sortDirection: options.sortDirection,
storageGrowthBySeriesId: options.storageGrowthBySeriesId,
alertWeightByRecordId: (recordId) => {
const alertState = getRecordAlertState(recordId);
return alertState.hasUnacknowledgedAlert
? storageAlertSeverityWeight(alertState.severity)
: 0;
},
groupBy: options.groupBy,
});
const diskSourceOptions = createMemo(() => [
'all',
...Array.from(new Set(options.physicalDisks().map((disk) => getPhysicalDiskSourceKey(disk))))
.filter((key) => key !== 'all')
.sort(),
]);
const diskRoleOptions = createMemo(() =>
buildPhysicalDiskRoleFilterOptions(options.physicalDisks()),
);
const diskGroupOptions = createMemo(() =>
buildPhysicalDiskGroupFilterOptions(options.physicalDisks()),
);
const { cephSummaryStats } = useStorageCephModel({
records,
cephResources: options.cephResources,
});
return {
records,
getRecordAlertState,
getRecordAlerts,
nodeOptions,
diskNodeOptions,
nodeOnlineByLabel,
sourceOptions,
diskSourceOptions,
diskRoleOptions,
diskGroupOptions,
filteredRecords,
groupedRecords,
cephSummaryStats,
};
};