Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

9.3 KB
Raw Blame
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;