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.

18.3 KB
Raw Blame
import { Accessor, Setter, createEffect, createSignal, onCleanup, onMount } from 'solid-js';
import { notificationStore } from '@/stores/notifications';
import { logger } from '@/utils/logger';
import { SettingsAPI } from '@/api/settings';
import type { EventDataMap, EventType } from '@/stores/events';
import type { NodeConfigWithStatus } from '@/types/nodes';
import {
  filterRepresentedDiscoveredServers,
  type DiscoveryScanStatus,
  type DiscoveredServer,
} from './infrastructureSettingsModel';
import {
  getDiscoveryScanStartErrorMessage,
  getDiscoverySettingUpdateErrorMessage,
  getDiscoverySubnetInvalidFormatMessage,
  getDiscoverySubnetInvalidValuesMessage,
  getDiscoverySubnetRequiredMessage,
  getDiscoverySubnetUpdateErrorMessage,
  getDiscoverySubnetValidEntryRequiredMessage,
  getDiscoverySubnetValuesRequiredMessage,
} from '@/utils/infrastructureSettingsPresentation';

type InfrastructureEventBus = {
  on<T extends EventType>(event: T, handler: (data?: EventDataMap[T]) => void): () => void;
};

type RawDiscoveredServer = {
  ip?: string;
  port?: number;
  type?: string;
  version?: string;
  hostname?: string;
  name?: string;
  release?: string;
};

interface UseInfrastructureDiscoveryRuntimeStateParams {
  eventBus: InfrastructureEventBus;
  nodes: Accessor<NodeConfigWithStatus[]>;
  // /api/discover is RequireAdmin + settings:write. Settings.tsx mounts this
  // hook for every settings tab, so without the gate a non-admin session polls
  // an endpoint it can never reach for as long as Settings stays open.
  canReadInfrastructure: Accessor<boolean>;
  discoveryEnabled: Accessor<boolean>;
  setDiscoveryEnabled: Setter<boolean>;
  discoverySubnet: Accessor<string>;
  discoveryMode: Accessor<'auto' | 'custom'>;
  setDiscoveryMode: Setter<'auto' | 'custom'>;
  discoverySubnetDraft: Accessor<string>;
  setDiscoverySubnetDraft: Setter<string>;
  lastCustomSubnet: Accessor<string>;
  setLastCustomSubnet: Setter<string>;
  setDiscoverySubnetError: Setter<string | undefined>;
  savingDiscoverySettings: Accessor<boolean>;
  setSavingDiscoverySettings: Setter<boolean>;
  envOverrides: Accessor<Record<string, boolean>>;
  normalizeSubnetList: (value: string) => string;
  isValidCIDR: (value: string) => boolean;
  applySavedDiscoverySubnet: (subnet?: string | null) => void;
  getDiscoverySubnetInputRef?: () => HTMLInputElement | undefined;
}

export const useInfrastructureDiscoveryRuntimeState = ({
  eventBus,
  nodes,
  canReadInfrastructure,
  discoveryEnabled,
  setDiscoveryEnabled,
  discoverySubnet,
  discoveryMode,
  setDiscoveryMode,
  discoverySubnetDraft,
  setDiscoverySubnetDraft,
  lastCustomSubnet,
  setLastCustomSubnet,
  setDiscoverySubnetError,
  savingDiscoverySettings,
  setSavingDiscoverySettings,
  envOverrides,
  normalizeSubnetList,
  isValidCIDR,
  applySavedDiscoverySubnet,
  getDiscoverySubnetInputRef,
}: UseInfrastructureDiscoveryRuntimeStateParams) => {
  const [discoveredNodes, setDiscoveredNodes] = createSignal<DiscoveredServer[]>([]);
  const [discoveryScanStatus, setDiscoveryScanStatus] = createSignal<DiscoveryScanStatus>({
    scanning: false,
  });
  let disposed = false;

  onCleanup(() => {
    disposed = true;
  });

  const normalizeDiscoveryTimestamp = (value: unknown): number | undefined => {
    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
      return undefined;
    }
    return value < 1_000_000_000_000 ? value * 1000 : value;
  };

  const updateDiscoveredNodesFromServers = (
    servers: RawDiscoveredServer[] | undefined | null,
    options: { merge?: boolean } = {},
  ) => {
    const { merge = false } = options;

    if (!servers || servers.length === 0) {
      if (!merge) {
        setDiscoveredNodes([]);
      }
      return;
    }

    const recognizedTypes = ['pve', 'pbs', 'pmg'] as const;
    type RecognizedType = (typeof recognizedTypes)[number];
    const isRecognizedType = (value: string): value is RecognizedType =>
      (recognizedTypes as readonly string[]).includes(value);

    const normalized = servers
      .map((server): DiscoveredServer | null => {
        const ip = (server.ip || '').trim();
        let type = (server.type || '').toLowerCase();
        const hostname = (server.hostname || server.name || '').trim();
        const version = (server.version || '').trim();
        const release = (server.release || '').trim();

        if (!isRecognizedType(type)) {
          const metadata = `${hostname} ${version} ${release}`.toLowerCase();
          if (metadata.includes('pmg') || metadata.includes('mail gateway')) {
            type = 'pmg';
          } else if (metadata.includes('pbs') || metadata.includes('backup server')) {
            type = 'pbs';
          } else if (metadata.includes('pve') || metadata.includes('virtual environment')) {
            type = 'pve';
          }
        }

        if (!ip || !isRecognizedType(type)) {
          return null;
        }

        return {
          ip,
          port: typeof server.port === 'number' ? server.port : type === 'pbs' ? 8007 : 8006,
          type,
          version: version || 'Unknown',
          hostname: hostname || undefined,
          release: release || undefined,
        };
      })
      .filter((server): server is DiscoveredServer => server !== null);

    const filtered = filterRepresentedDiscoveredServers(normalized, nodes());

    if (merge) {
      setDiscoveredNodes((previous) => {
        const existingMap = new Map(previous.map((item) => [`${item.ip}:${item.port}`, item]));
        filtered.forEach((server) => {
          existingMap.set(`${server.ip}:${server.port}`, server);
        });
        return Array.from(existingMap.values());
      });
    } else {
      setDiscoveredNodes(filtered);
    }
  };

  const loadDiscoveredNodes = async () => {
    if (!canReadInfrastructure()) {
      return;
    }
    try {
      const { apiFetch } = await import('@/utils/apiClient');
      const response = await apiFetch('/api/discover');
      if (!response.ok) {
        return;
      }
      if (disposed) {
        return;
      }

      const data = await response.json();
      if (disposed) {
        return;
      }
      const responseTimestamp = normalizeDiscoveryTimestamp(data?.timestamp ?? data?.updated);
      if (Array.isArray(data.servers)) {
        updateDiscoveredNodesFromServers(data.servers as RawDiscoveredServer[]);
        // Loading the stored result is not a scan. A fresh install answers
        // `updated: 0`, and dating that "now" reads as "Last scanned 0s ago".
        setDiscoveryScanStatus((previous) => ({
          ...previous,
          scanning: false,
          lastResultAt: responseTimestamp ?? previous.lastResultAt,
          errors: Array.isArray(data.errors) && data.errors.length > 0 ? data.errors : undefined,
        }));
        return;
      }

      updateDiscoveredNodesFromServers([]);
      setDiscoveryScanStatus((previous) => ({
        ...previous,
        scanning: false,
        lastResultAt: responseTimestamp ?? previous.lastResultAt,
        errors: Array.isArray(data?.errors) && data.errors.length > 0 ? data.errors : undefined,
      }));
    } catch (error) {
      if (disposed) {
        return;
      }
      logger.warn('Failed to load discovered nodes', error);
    }
  };

  const triggerDiscoveryScan = async (options: { quiet?: boolean } = {}) => {
    const { quiet = false } = options;

    setDiscoveryScanStatus((previous) => ({
      ...previous,
      scanning: true,
      subnet: discoverySubnet() || previous.subnet,
      lastScanStartedAt: Date.now(),
      errors: undefined,
    }));

    try {
      const { apiFetch } = await import('@/utils/apiClient');
      const response = await apiFetch('/api/discover', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ subnet: discoverySubnet() || 'auto' }),
      });
      if (disposed) {
        return;
      }

      if (!response.ok) {
        const message = await response.text();
        throw new Error(message || 'Discovery request failed');
      }

      const data = await response.json().catch(() => null);
      if (disposed) {
        return;
      }
      const responseTimestamp = normalizeDiscoveryTimestamp(
        data && typeof data === 'object'
          ? ((data as { timestamp?: unknown; updated?: unknown }).timestamp ??
              (data as { timestamp?: unknown; updated?: unknown }).updated)
          : undefined,
      );
      if (
        data &&
        typeof data === 'object' &&
        Array.isArray((data as { servers?: unknown }).servers)
      ) {
        updateDiscoveredNodesFromServers((data as { servers: RawDiscoveredServer[] }).servers);
      }
      setDiscoveryScanStatus((previous) => ({
        ...previous,
        scanning: false,
        lastResultAt: responseTimestamp ?? Date.now(),
        errors:
          data &&
          typeof data === 'object' &&
          Array.isArray((data as { errors?: unknown }).errors) &&
          (data as { errors: unknown[] }).errors.length > 0
            ? ((data as { errors: string[] }).errors ?? undefined)
            : undefined,
      }));

      if (!quiet) {
        notificationStore.success('Discovery scan complete', 2000);
      }
    } catch (error) {
      if (disposed) {
        return;
      }
      logger.error('Failed to start discovery scan', error);
      notificationStore.error(getDiscoveryScanStartErrorMessage());
      setDiscoveryScanStatus((previous) => ({
        ...previous,
        scanning: false,
      }));
    }
  };

  const handleDiscoveryEnabledChange = async (enabled: boolean): Promise<boolean> => {
    if (envOverrides().discoveryEnabled || savingDiscoverySettings()) {
      return false;
    }

    const previousEnabled = discoveryEnabled();
    const previousSubnet = discoverySubnet();
    let subnetToSend = discoverySubnet();

    if (enabled) {
      if (discoveryMode() === 'custom') {
        const trimmedDraft = discoverySubnetDraft().trim();
        if (!trimmedDraft) {
          setDiscoverySubnetError(getDiscoverySubnetValuesRequiredMessage());
          notificationStore.error(getDiscoverySubnetValuesRequiredMessage());
          return false;
        }
        if (!isValidCIDR(trimmedDraft)) {
          setDiscoverySubnetError(getDiscoverySubnetInvalidFormatMessage());
          notificationStore.error(getDiscoverySubnetInvalidValuesMessage());
          return false;
        }
        subnetToSend = normalizeSubnetList(trimmedDraft);
        setDiscoverySubnetDraft(subnetToSend);
        setDiscoverySubnetError(undefined);
      } else {
        subnetToSend = 'auto';
        setDiscoverySubnetError(undefined);
      }
    }

    setDiscoveryEnabled(enabled);
    setSavingDiscoverySettings(true);

    try {
      await SettingsAPI.updateSystemSettings({
        discoveryEnabled: enabled,
        discoverySubnet: subnetToSend,
      });
      applySavedDiscoverySubnet(subnetToSend);
      if (enabled && subnetToSend !== 'auto') {
        setLastCustomSubnet(subnetToSend);
      }

      if (enabled) {
        await triggerDiscoveryScan({ quiet: true });
        notificationStore.success('Discovery enabled — scanning network...', 2000);
      } else {
        notificationStore.info('Discovery disabled', 2000);
        setDiscoveryScanStatus((previous) => ({
          ...previous,
          scanning: false,
        }));
      }

      return true;
    } catch (error) {
      logger.error('Failed to update discovery setting', error);
      notificationStore.error(getDiscoverySettingUpdateErrorMessage());
      setDiscoveryEnabled(previousEnabled);
      applySavedDiscoverySubnet(previousSubnet);
      return false;
    } finally {
      setSavingDiscoverySettings(false);
      await loadDiscoveredNodes();
    }
  };

  const commitDiscoverySubnet = async (rawValue: string): Promise<boolean> => {
    if (envOverrides().discoverySubnet) {
      return false;
    }

    const value = rawValue.trim();
    if (!value) {
      setDiscoverySubnetError(getDiscoverySubnetRequiredMessage());
      return false;
    }
    if (!isValidCIDR(value)) {
      setDiscoverySubnetError(getDiscoverySubnetInvalidFormatMessage());
      return false;
    }

    const normalizedValue = normalizeSubnetList(value);
    if (!normalizedValue) {
      setDiscoverySubnetError(getDiscoverySubnetValidEntryRequiredMessage());
      return false;
    }

    const previousSubnet = discoverySubnet();
    const previousNormalized =
      previousSubnet.toLowerCase() === 'auto' ? '' : normalizeSubnetList(previousSubnet);

    if (normalizedValue === previousNormalized) {
      setDiscoverySubnetDraft(normalizedValue);
      setDiscoverySubnetError(undefined);
      setLastCustomSubnet(normalizedValue);
      return true;
    }

    setSavingDiscoverySettings(true);

    try {
      setDiscoverySubnetError(undefined);
      await SettingsAPI.updateSystemSettings({
        discoveryEnabled: discoveryEnabled(),
        discoverySubnet: normalizedValue,
      });
      setLastCustomSubnet(normalizedValue);
      applySavedDiscoverySubnet(normalizedValue);
      if (discoveryEnabled()) {
        await triggerDiscoveryScan({ quiet: true });
        notificationStore.success('Discovery subnet updated — scanning network...', 2000);
      } else {
        notificationStore.success('Discovery subnet saved', 2000);
      }
      return true;
    } catch (error) {
      logger.error('Failed to update discovery subnet', error);
      notificationStore.error(getDiscoverySubnetUpdateErrorMessage());
      applySavedDiscoverySubnet(previousSubnet);
      setDiscoverySubnetDraft(previousSubnet === 'auto' ? '' : normalizeSubnetList(previousSubnet));
      return false;
    } finally {
      setDiscoverySubnetError(undefined);
      setSavingDiscoverySettings(false);
      await loadDiscoveredNodes();
    }
  };

  const handleDiscoveryModeChange = async (mode: 'auto' | 'custom') => {
    if (envOverrides().discoverySubnet || savingDiscoverySettings()) {
      return;
    }
    if (mode === discoveryMode()) {
      return;
    }

    if (mode === 'auto') {
      const previousSubnet = discoverySubnet();
      setDiscoveryMode('auto');
      setDiscoverySubnetDraft('');
      setDiscoverySubnetError(undefined);
      setSavingDiscoverySettings(true);
      try {
        await SettingsAPI.updateSystemSettings({
          discoveryEnabled: discoveryEnabled(),
          discoverySubnet: 'auto',
        });
        applySavedDiscoverySubnet('auto');
        if (discoveryEnabled()) {
          await triggerDiscoveryScan({ quiet: true });
        }
        notificationStore.info(
          'Auto discovery scans each network phase. Large networks may take longer.',
          4000,
        );
      } catch (error) {
        logger.error('Failed to update discovery subnet', error);
        notificationStore.error(getDiscoverySubnetUpdateErrorMessage());
        applySavedDiscoverySubnet(previousSubnet);
      } finally {
        setSavingDiscoverySettings(false);
        await loadDiscoveredNodes();
      }
      return;
    }

    setDiscoveryMode('custom');
    const rawDraft = discoverySubnet() !== 'auto' ? discoverySubnet() : lastCustomSubnet() || '';
    const normalizedDraft = normalizeSubnetList(rawDraft);
    setDiscoverySubnetDraft(normalizedDraft);
    setDiscoverySubnetError(undefined);
    queueMicrotask(() => {
      getDiscoverySubnetInputRef?.()?.focus();
      getDiscoverySubnetInputRef?.()?.select();
    });
  };

  onMount(() => {
    const unsubscribeDiscovery = eventBus.on('discovery_updated', (data) => {
      if (!data) {
        updateDiscoveredNodesFromServers([]);
        setDiscoveryScanStatus((previous) => ({
          ...previous,
          scanning: false,
        }));
        return;
      }

      if (Array.isArray(data.servers)) {
        updateDiscoveredNodesFromServers(data.servers as RawDiscoveredServer[], {
          merge: !!data.immediate,
        });
        setDiscoveryScanStatus((previous) => ({
          ...previous,
          scanning: data.scanning ?? previous.scanning,
          lastResultAt: data.timestamp ?? Date.now(),
          errors: Array.isArray(data.errors) && data.errors.length > 0 ? data.errors : undefined,
        }));
      } else if (!data.immediate) {
        updateDiscoveredNodesFromServers([]);
        setDiscoveryScanStatus((previous) => ({
          ...previous,
          scanning: data.scanning ?? previous.scanning,
          lastResultAt: data.timestamp ?? previous.lastResultAt,
          errors: Array.isArray(data.errors) && data.errors.length > 0 ? data.errors : undefined,
        }));
      } else {
        setDiscoveryScanStatus((previous) => ({
          ...previous,
          scanning: data.scanning ?? previous.scanning,
          errors: Array.isArray(data.errors) && data.errors.length > 0 ? data.errors : undefined,
        }));
      }
    });

    const unsubscribeDiscoveryStatus = eventBus.on('discovery_status', (data) => {
      if (!data) {
        setDiscoveryScanStatus((previous) => ({
          ...previous,
          scanning: false,
        }));
        return;
      }

      setDiscoveryScanStatus((previous) => ({
        ...previous,
        scanning: !!data.scanning,
        subnet: data.subnet || previous.subnet,
        lastScanStartedAt: data.scanning
          ? (data.timestamp ?? Date.now())
          : previous.lastScanStartedAt,
        lastResultAt: !data.scanning && data.timestamp ? data.timestamp : previous.lastResultAt,
      }));

      if (typeof data.subnet === 'string' && data.subnet !== discoverySubnet()) {
        applySavedDiscoverySubnet(data.subnet);
      }
    });

    let discoveryInterval: ReturnType<typeof setInterval> | undefined;
    createEffect(() => {
      if (discoveryInterval) {
        clearInterval(discoveryInterval);
        discoveryInterval = undefined;
      }

      // Reading the accessor here makes the effect re-run once the security
      // status resolves, so an admin still gets the poller armed on load.
      if (!canReadInfrastructure()) {
        return;
      }

      discoveryInterval = setInterval(() => {
        void loadDiscoveredNodes();
      }, 30000);
    });

    onCleanup(() => {
      unsubscribeDiscovery();
      unsubscribeDiscoveryStatus();
      if (discoveryInterval) {
        clearInterval(discoveryInterval);
      }
    });
  });

  return {
    discoveredNodes,
    discoveryScanStatus,
    updateDiscoveredNodesFromServers,
    loadDiscoveredNodes,
    triggerDiscoveryScan,
    handleDiscoveryEnabledChange,
    commitDiscoverySubnet,
    handleDiscoveryModeChange,
  };
};