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.

10.1 KB
Raw Blame
import { createEffect, createMemo, createSignal } from 'solid-js';
import { useLocation, useNavigate } from '@solidjs/router';
import {
  SUMMARY_TIME_RANGE_LABEL,
  type SummaryTimeRange,
} from '@/components/shared/summaryTimeRange';
import { buildStorageCapacityDeltaPresentation } from '@/features/storageBackups/storageCapacityDeltaPresentation';
import {
  resolvePhysicalDiskMetricResourceId,
  resolveStorageRecordMetricResourceId,
} from '@/features/storageBackups/storageMetricsIdentity';
import { useKioskMode } from '@/hooks/useKioskMode';
import { useSummaryPageInteractionState } from '@/components/shared/summaryTableFocus';
import { useStorageExpansionState } from './useStorageExpansionState';
import { useStorageFilterState } from './useStorageFilterState';
import { useStoragePageData } from './useStoragePageData';
import { useStoragePageFilters } from './useStoragePageFilters';
import { useStoragePageResources, type StoragePageResourceSource } from './useStoragePageResources';
import { useStoragePageStatus } from './useStoragePageStatus';
import { useStorageResourceHighlight } from './useStorageResourceHighlight';
import { useStorageSummaryCharts } from './useStorageSummaryCharts';
import {
  DEFAULT_STORAGE_SELECTED_NODE_ID,
  DEFAULT_STORAGE_SOURCE_FILTER,
  DEFAULT_STORAGE_DISK_GROUP_FILTER,
  DEFAULT_STORAGE_DISK_ROLE_FILTER,
} from './storagePageState';

type UseStoragePageModelOptions = {
  forcedSourceFilter?: () => string | undefined;
  resourceSource?: StoragePageResourceSource;
  // False while a platform page keeps Storage mounted behind another tab.
  routeActive?: () => boolean;
};

export const useStoragePageModel = (options: UseStoragePageModelOptions = {}) => {
  const navigate = useNavigate();
  const location = useLocation();
  const kioskMode = useKioskMode();
  const [hoveredStorageRowId, setHoveredStorageResourceId] = createSignal<string | null>(null);
  const [selectedDiskId, setSelectedDiskId] = createSignal<string | null>(null);
  // Growth column on the storage table is anchored to a 24h window. The
  // standalone summary chart that let operators retune the range was
  // retired with the platform-first IA migration; nothing reads or sets
  // this now, so the previous persistent signal collapsed to a constant.
  const summaryTimeRange = (): SummaryTimeRange => '24h';
  const {
    state,
    activeAlerts,
    reconnect,
    storageResources,
    nodes,
    physicalDisks,
    getDiskAlertResourceIds,
    getDiskAlerts,
    cephResources,
    alertsEnabled,
  } = useStoragePageResources({ resourceSource: options.resourceSource });

  const {
    search,
    setSearch,
    sourceFilter,
    setSourceFilter,
    healthFilter,
    diskRoleFilter,
    setDiskRoleFilter,
    diskGroupFilter,
    setDiskGroupFilter,
    setHealthFilter,
    view,
    setView,
    selectedNodeId,
    setSelectedNodeId,
    sortKey,
    setSortKey,
    sortDirection,
    setSortDirection,
    groupBy,
    setGroupBy,
  } = useStoragePageFilters({
    location,
    navigate,
    lockedSourceFilter: options.forcedSourceFilter,
  });
  const storageSummaryCharts = useStorageSummaryCharts({
    timeRange: summaryTimeRange,
    nodeId: selectedNodeId,
    caller: 'useStoragePageModel',
    deferInitialLoad: true,
  });
  const storageGrowthRangeLabel = createMemo(
    () => SUMMARY_TIME_RANGE_LABEL[summaryTimeRange()] ?? summaryTimeRange(),
  );
  const storageGrowthColumnLabel = createMemo(() => `Growth (${storageGrowthRangeLabel()})`);
  const storageGrowthBySeriesId = createMemo(() => {
    const growth = new Map<string, ReturnType<typeof buildStorageCapacityDeltaPresentation>>();
    const pools = storageSummaryCharts.data()?.pools ?? {};
    for (const [seriesId, pool] of Object.entries(pools)) {
      growth.set(
        seriesId,
        buildStorageCapacityDeltaPresentation(pool.used ?? [], storageGrowthRangeLabel()),
      );
    }
    return growth;
  });

  const {
    records,
    getRecordAlertState,
    getRecordAlerts,
    nodeOptions,
    diskNodeOptions,
    nodeOnlineByLabel,
    sourceOptions,
    diskSourceOptions,
    diskRoleOptions,
    diskGroupOptions,
    filteredRecords,
    groupedRecords,
  } = useStoragePageData({
    state: () => state,
    resources: storageResources.resources,
    activeAlerts,
    alertsEnabled,
    nodes,
    physicalDisks,
    cephResources,
    search,
    sourceFilter,
    healthFilter,
    selectedNodeId,
    sortKey,
    sortDirection,
    storageGrowthBySeriesId,
    groupBy,
  });

  const surfaceInitialDataReceived = createMemo(
    () => records().length > 0 || !storageResources.loading() || Boolean(storageResources.error()),
  );
  const surfaceConnected = createMemo(
    () => storageResources.loading() || records().length > 0 || !storageResources.error(),
  );
  const reconnectSurface = () => {
    void storageResources.refetch();
    reconnect();
  };
  const { expandedGroups, expandedPoolId, setExpandedPoolId, toggleGroup } =
    useStorageExpansionState({
      groupBy,
      groupedKeys: () => groupedRecords().map((group) => group.key),
      view,
    });
  const storageRecordMetricIds = createMemo(() => {
    const ids = new Map<string, string>();
    for (const record of records()) {
      ids.set(record.id, resolveStorageRecordMetricResourceId(record));
    }
    return ids;
  });
  const physicalDiskMetricIds = createMemo(() => {
    const ids = new Map<string, string>();
    for (const disk of physicalDisks()) {
      ids.set(disk.id, resolvePhysicalDiskMetricResourceId(disk));
    }
    return ids;
  });
  const hoveredStorageResourceId = createMemo(() => {
    const hoveredId = hoveredStorageRowId();
    if (!hoveredId) return null;
    if (view() === 'disks') {
      return physicalDiskMetricIds().get(hoveredId) ?? hoveredId;
    }
    return storageRecordMetricIds().get(hoveredId) ?? hoveredId;
  });
  const focusedStorageResourceId = createMemo(() => {
    if (view() === 'disks') {
      const selectedId = selectedDiskId();
      if (!selectedId) return null;
      return physicalDiskMetricIds().get(selectedId) ?? selectedId;
    }
    const expandedId = expandedPoolId();
    if (!expandedId) return null;
    return storageRecordMetricIds().get(expandedId) ?? expandedId;
  });
  const storageGroupKeyByMetricSeriesId = createMemo(() => {
    const keys = new Map<string, string>();
    for (const group of groupedRecords()) {
      for (const record of group.items) {
        keys.set(resolveStorageRecordMetricResourceId(record), group.key);
      }
    }
    return keys;
  });
  const clearPinnedSummaryScope = () => {
    setExpandedPoolId(null);
    setSelectedDiskId(null);
  };
  const clearStorageFilters = () => {
    setSearch('');
    setSourceFilter(DEFAULT_STORAGE_SOURCE_FILTER);
    setDiskRoleFilter(DEFAULT_STORAGE_DISK_ROLE_FILTER);
    setDiskGroupFilter(DEFAULT_STORAGE_DISK_GROUP_FILTER);
    setStorageFilterStatus('all');
    setSelectedNodeId(DEFAULT_STORAGE_SELECTED_NODE_ID);
  };
  const clearAllPageStateOnEscape = () => {
    clearPinnedSummaryScope();
    clearStorageFilters();
  };

  createEffect(() => {
    view();
    setHoveredStorageResourceId(null);
  });

  const {
    nodeFilterOptions,
    sourceFilterOptions,
    diskRoleFilterOptions,
    diskGroupFilterOptions,
    storageFilterGroupBy,
    storageFilterStatus,
    setStorageFilterStatus,
  } = useStorageFilterState({
    view,
    nodeOptions,
    diskNodeOptions,
    selectedNodeId,
    setSelectedNodeId,
    sourceOptions,
    diskSourceOptions,
    diskRoleOptions,
    diskGroupOptions,
    sourceFilter,
    setSourceFilter,
    lockedSourceFilter: options.forcedSourceFilter,
    healthFilter,
    setHealthFilter,
    diskRoleFilter,
    setDiskRoleFilter,
    diskGroupFilter,
    setDiskGroupFilter,
    groupBy,
  });

  const { isLoadingPools } = useStoragePageStatus({
    loading: storageResources.loading,
    filteredRecordCount: () => filteredRecords().length,
    view,
  });

  const highlightedRecordId = useStorageResourceHighlight({
    locationPathname: () => location.pathname,
    locationSearch: () => location.search,
    navigate,
    records,
    expandedPoolId,
    setExpandedPoolId,
    active: options.routeActive,
  });
  const summaryInteraction = useSummaryPageInteractionState({
    clearPinnedScope: clearPinnedSummaryScope,
    hoveredSeriesId: hoveredStorageResourceId,
    focusedSeriesId: focusedStorageResourceId,
    onEscapeClear: clearAllPageStateOnEscape,
    revealActiveSeries: (seriesId) => {
      // Focus only ever names a row in the active view, so reveal never
      // switches views; it reopens a focused pool's collapsed group.
      if (view() !== 'pools') {
        return;
      }
      const groupKey = storageGroupKeyByMetricSeriesId().get(seriesId);
      if (groupKey && !expandedGroups().has(groupKey)) {
        toggleGroup(groupKey);
      }
    },
  });

  return {
    activeSummaryStorageResourceId: summaryInteraction.activeSeriesId,
    clearPinnedSummaryScope,
    kioskMode,
    reconnect: reconnectSurface,
    storageGrowthBySeriesId,
    storageGrowthColumnLabel,
    selectedNodeId,
    setSelectedNodeId,
    view,
    setView,
    search,
    setSearch,
    sourceFilter,
    setSourceFilter,
    healthFilter,
    diskRoleFilter,
    setDiskRoleFilter,
    diskRoleOptions: diskRoleFilterOptions,
    diskGroupFilter,
    setDiskGroupFilter,
    diskGroupOptions: diskGroupFilterOptions,
    sortKey,
    setSortKey,
    sortDirection,
    setSortDirection,
    groupBy,
    setGroupBy,
    storageFilterStatus,
    setStorageFilterStatus,
    storageFilterGroupBy,
    sourceFilterOptions,
    nodeFilterOptions,
    connected: surfaceConnected,
    filteredRecords,
    initialDataReceived: surfaceInitialDataReceived,
    nodeOptions,
    physicalDisks,
    getDiskAlertResourceIds,
    getDiskAlerts,
    nodes,
    groupedRecords,
    expandedGroups,
    toggleGroup,
    expandedPoolId,
    setExpandedPoolId,
    nodeOnlineByLabel,
    highlightedRecordId,
    getRecordAlertState,
    getRecordAlerts,
    hoveredStorageResourceId,
    isLoadingPools,
    selectedDiskId,
    setClearSurfaceRootRef: summaryInteraction.setClearSurfaceRootRef,
    setHoveredStorageResourceId,
    setSelectedDiskId,
    setSummaryTableRootRef: summaryInteraction.setTableRootRef,
  };
};