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 { Component, For, Show, createMemo, createSignal } from 'solid-js';
import {
Table,
TableBody,
TableCell,
TableHead,
TableHeader,
TableRow,
} from '@/components/shared/Table';
import { getPlatformTableHeadClassForKind } from '@/features/platformPage/sharedPlatformPage';
import {
getStoragePoolColumnWidthStyle,
getStoragePoolTableColumns,
getStoragePoolTableLayoutModeForContainer,
getStorageEmptyStateMessage,
getStorageLoadingMessage,
STORAGE_POOLS_BODY_CLASS,
STORAGE_POOLS_EMPTY_STATE_CLASS,
STORAGE_POOLS_HEADER_ROW_CLASS,
STORAGE_POOLS_LOADING_STATE_CLASS,
STORAGE_POOLS_TABLE_CLASS,
isStoragePoolColumnVisible,
} from '@/features/storageBackups/storagePagePresentation';
import { useObservedElementWidth } from '@/hooks/useObservedElementWidth';
import { createVisibleTableColumnSpan } from '@/components/shared/tableVisibleColumnSpan';
import { resolveStorageRecordMetricResourceId } from '@/features/storageBackups/storageMetricsIdentity';
import type { StorageCapacityDeltaPresentation } from '@/features/storageBackups/storageCapacityDeltaPresentation';
import type { StorageAlertRowState } from '@/features/storageBackups/storageAlertState';
import type { PhysicalDiskAlertResourceIdResolver } from '@/features/storageBackups/diskPresentation';
import type { Alert } from '@/types/api';
import type { Resource } from '@/types/resource';
import { StorageGroupRow } from './StorageGroupRow';
import { StoragePoolRow } from './StoragePoolRow';
import type { StorageGroupedRecords, StorageGroupKey } from './useStorageModel';
import { useStoragePoolsTableModel } from './useStoragePoolsTableModel';
import { buildStorageSummaryGroupId } from './storageSummaryGroups';
import { useStoragePoolsTableWindowing } from './useStoragePoolsTableWindowing';
type StoragePoolsTableProps = {
groupedRecords: StorageGroupedRecords[];
groupBy: StorageGroupKey;
expandedGroups: Set<string>;
toggleGroup: (key: string) => void;
expandedPoolId: string | null;
setExpandedPoolId: (value: string | null | ((current: string | null) => string | null)) => void;
storageGrowthBySeriesId: Map<string, StorageCapacityDeltaPresentation>;
storageGrowthColumnLabel: string;
physicalDisks: Resource[];
getDiskAlertResourceIds?: PhysicalDiskAlertResourceIdResolver;
nodeOnlineByLabel: Map<string, boolean>;
highlightedRecordId: string | null;
getRecordAlertState: (recordId: string) => StorageAlertRowState;
/** A pool's open alerts, for its drawer: the set that tints its row. */
getRecordAlerts?: (recordId: string) => Alert[];
isLoading: boolean;
highlightedSummarySeriesId?: string | null;
onHoverChange?: (recordId: string | null) => void;
};
export const StoragePoolsTable: Component<StoragePoolsTableProps> = (props) => {
const tableWidth = useObservedElementWidth();
const layoutMode = createMemo(() =>
getStoragePoolTableLayoutModeForContainer(tableWidth.width() ?? 0),
);
const columnClass = (
baseClass: string,
columnId: Parameters<typeof isStoragePoolColumnVisible>[1],
visibleClass: 'table-column' | 'table-cell',
) =>
`${baseClass} ${isStoragePoolColumnVisible(layoutMode(), columnId) ? visibleClass : 'hidden'}`.trim();
const model = useStoragePoolsTableModel({
groupedRecords: () => props.groupedRecords,
groupBy: () => props.groupBy,
expandedGroups: () => props.expandedGroups,
expandedPoolId: () => props.expandedPoolId,
highlightedRecordId: () => props.highlightedRecordId,
nodeOnlineByLabel: () => props.nodeOnlineByLabel,
getRecordAlertState: props.getRecordAlertState,
setExpandedPoolId: props.setExpandedPoolId,
});
const tableWindow = useStoragePoolsTableWindowing({
groups: model.groups,
expandedPoolId: () => props.expandedPoolId,
});
// Spacer rows span the visible columns only (see tableVisibleColumnSpan).
const [bodyEl, setBodyEl] = createSignal<HTMLTableSectionElement | null>(null);
const columnSpan = createVisibleTableColumnSpan(bodyEl);
return (
<Show
when={props.isLoading}
fallback={
<Show
when={props.groupedRecords.length > 0}
fallback={
<div class={STORAGE_POOLS_EMPTY_STATE_CLASS}>{getStorageEmptyStateMessage()}</div>
}
>
<Table
class={STORAGE_POOLS_TABLE_CLASS}
wrapperRef={tableWidth.setElement}
data-storage-table="pools"
data-storage-layout={layoutMode()}
>
<colgroup>
<For each={getStoragePoolTableColumns(props.storageGrowthColumnLabel)}>
{(column) => (
<col
class={columnClass(column.colClassName, column.id, 'table-column')}
style={getStoragePoolColumnWidthStyle(layoutMode(), column.id)}
data-storage-column={column.id}
/>
)}
</For>
</colgroup>
<TableHeader>
<TableRow class={STORAGE_POOLS_HEADER_ROW_CLASS}>
<For each={getStoragePoolTableColumns(props.storageGrowthColumnLabel)}>
{(column) => (
<TableHead
class={columnClass(
`${getPlatformTableHeadClassForKind(column.kind)} ${column.className}`,
column.id,
'table-cell',
)}
data-storage-column={column.id}
aria-label={column.label}
title={column.label}
>
<Show
when={layoutMode() === 'full'}
fallback={<span class="min-w-0 truncate">{column.compactLabel}</span>}
>
<span class="min-w-0 truncate">{column.label}</span>
</Show>
</TableHead>
)}
</For>
</TableRow>
</TableHeader>
<TableBody
ref={(body) => {
tableWindow.setBodyRef(body);
setBodyEl(body);
}}
class={STORAGE_POOLS_BODY_CLASS}
>
<Show when={tableWindow.topSpacerHeight() > 0}>
<TableRow aria-hidden="true" class="h-0 border-0!">
<TableCell colspan={columnSpan()} class="h-0 border-0! p-0! leading-0">
<svg
aria-hidden="true"
width="1"
height={String(tableWindow.topSpacerHeight())}
class="pointer-events-none block w-px"
/>
</TableCell>
</TableRow>
</Show>
<For each={tableWindow.visibleItems()}>
{(item) => {
if (item.kind === 'group') {
return (
<StorageGroupRow
group={item.group}
summaryGroupId={buildStorageSummaryGroupId(props.groupBy, item.group.key)}
expanded={item.group.expanded}
onToggle={() => props.toggleGroup(item.group.key)}
/>
);
}
const record = item.record;
const metricResourceId = resolveStorageRecordMetricResourceId(record);
const rowModel = createMemo(() => model.buildRowModel(record.id, record));
return (
<StoragePoolRow
layoutMode={layoutMode()}
record={record}
growthDelta={props.storageGrowthBySeriesId.get(metricResourceId) ?? null}
summarySeriesId={metricResourceId}
expanded={rowModel().expanded}
summaryHighlighted={props.highlightedSummarySeriesId === metricResourceId}
onToggleExpand={() => model.togglePool(record.id)}
onHoverChange={props.onHoverChange}
rowClass={rowModel().rowClass}
alertHeadline={rowModel().alertHeadline}
alertHeadlineCompact={rowModel().alertHeadlineCompact}
alertHeadlineClass={rowModel().alertHeadlineClass}
physicalDisks={props.physicalDisks}
getDiskAlertResourceIds={props.getDiskAlertResourceIds}
alerts={props.getRecordAlerts?.(record.id)}
alertDataAttrs={rowModel().alertDataAttrs}
/>
);
}}
</For>
<Show when={tableWindow.bottomSpacerHeight() > 0}>
<TableRow aria-hidden="true" class="h-0 border-0!">
<TableCell colspan={columnSpan()} class="h-0 border-0! p-0! leading-0">
<svg
aria-hidden="true"
width="1"
height={String(tableWindow.bottomSpacerHeight())}
class="pointer-events-none block w-px"
/>
</TableCell>
</TableRow>
</Show>
</TableBody>
</Table>
</Show>
}
>
<div class={STORAGE_POOLS_LOADING_STATE_CLASS}>{getStorageLoadingMessage()}</div>
</Show>
);
};
export default StoragePoolsTable;