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.

14.7 KB
Raw Blame
import { Accessor, Setter, createEffect, createMemo, createSignal, on } from 'solid-js';
import { notificationStore } from '@/stores/notifications';
import { logger } from '@/utils/logger';
import { NodesAPI } from '@/api/nodes';
import { useUnifiedResources } from '@/hooks/useUnifiedResources';
import { getPreferredConfiguredNodeLabel } from '@/utils/resourceIdentity';
import type { Temperature } from '@/types/api';
import type { ResourceType } from '@/types/resource';
import type {
  ClusterEndpointOverridePayload,
  ClusterEndpointTrustOverridePayload,
  ClusterNodeDisplayNameOverridePayload,
  NodeConfig,
  NodeConfigWithStatus,
} from '@/types/nodes';
import { settingsAgentNodeLabel } from './settingsRouting';
import {
  applyClusterEndpointOverridesLocally,
  applyClusterNodeDisplayNamesLocally,
} from './nodeModalModel';
import { matchConfiguredNodeToResource, type NodeType } from './infrastructureSettingsModel';
import {
  getNodeDeleteErrorMessage,
  getNodeTemperatureMonitoringUpdateErrorMessage,
} from '@/utils/infrastructureSettingsPresentation';

interface UseInfrastructureConfiguredNodesStateParams {
  canReadInfrastructure: Accessor<boolean>;
  temperatureMonitoringEnabled: Accessor<boolean>;
  savingTemperatureSetting: Accessor<boolean>;
  setSavingTemperatureSetting: Setter<boolean>;
}

export const useInfrastructureConfiguredNodesState = ({
  canReadInfrastructure,
  temperatureMonitoringEnabled,
  savingTemperatureSetting,
  setSavingTemperatureSetting,
}: UseInfrastructureConfiguredNodesStateParams) => {
  // Settings.tsx retains this state owner across every settings route. Keep
  // its background inventory bounded to the agent rows needed for configured
  // node status; the response's global aggregation supplies license counts
  // without hydrating every guest, container, storage object, and network.
  const configuredNodeResources = useUnifiedResources({
    query: 'type=agent',
    cacheKey: 'settings-configured-nodes',
    initialHydration: 'prefer-ws-then-rest',
    enabled: canReadInfrastructure,
  });
  const agentResources = createMemo(() => configuredNodeResources.resources());
  const typeCount = (type: ResourceType) =>
    configuredNodeResources.aggregations()?.byType[type] ?? 0;
  const [nodes, setNodes] = createSignal<NodeConfigWithStatus[]>([]);
  const [showNodeModal, setShowNodeModal] = createSignal(false);
  const [editingNode, setEditingNode] = createSignal<NodeConfigWithStatus | null>(null);
  const [currentNodeType, setCurrentNodeType] = createSignal<NodeType>('pve');
  const [modalResetKey, setModalResetKey] = createSignal(0);
  const [showDeleteNodeModal, setShowDeleteNodeModal] = createSignal(false);
  const [nodePendingDelete, setNodePendingDelete] = createSignal<NodeConfigWithStatus | null>(null);
  const [deleteNodeLoading, setDeleteNodeLoading] = createSignal(false);

  const isNodeModalVisible = (type: NodeType) =>
    Boolean(showNodeModal() && currentNodeType() === type);

  const pveNodes = createMemo(() => nodes().filter((node) => node.type === 'pve'));
  const pbsNodes = createMemo(() => nodes().filter((node) => node.type === 'pbs'));
  const pmgNodes = createMemo(() => nodes().filter((node) => node.type === 'pmg'));

  const orgNodeUsage = createMemo(
    () =>
      typeCount('agent') +
      typeCount('docker-host') +
      typeCount('k8s-cluster') +
      typeCount('pbs') +
      typeCount('pmg'),
  );
  const orgGuestUsage = createMemo(
    () => typeCount('vm') + typeCount('system-container') + typeCount('oci-container'),
  );

  let pendingLoadNodesRetry: ReturnType<typeof setTimeout> | undefined;
  let loadNodesRetryAttempts = 0;

  const clearLoadNodesRetry = () => {
    if (!pendingLoadNodesRetry) return;
    clearTimeout(pendingLoadNodesRetry);
    pendingLoadNodesRetry = undefined;
  };

  const loadNodes = async () => {
    try {
      clearLoadNodesRetry();
      const nodesList = await NodesAPI.getNodes();
      const nodeResources = agentResources();
      const nodesWithStatus = nodesList.map((node) => {
        const stateNode = matchConfiguredNodeToResource(node, nodeResources);
        const tempValue = stateNode?.temperature;
        const temperature: Temperature | undefined =
          typeof tempValue === 'number' && tempValue > 0
            ? {
                cpuPackage: tempValue,
                cpuMax: tempValue,
                available: true,
                hasCPU: true,
                lastUpdate: new Date(stateNode!.lastSeen).toISOString(),
              }
            : node.temperature;

        return {
          ...node,
          hasPassword: node.hasPassword ?? !!node.password,
          hasToken: node.hasToken ?? !!node.tokenValue,
          status: node.status || ('pending' as const),
          temperature,
        };
      });

      loadNodesRetryAttempts = 0;
      setNodes(nodesWithStatus);
    } catch (error) {
      logger.error('Failed to load nodes', error);
      if (
        error instanceof Error &&
        (error.message.includes('429') || error.message.includes('fetch'))
      ) {
        if (pendingLoadNodesRetry) {
          return;
        }

        const delayMs = Math.min(3000 * Math.pow(2, Math.min(loadNodesRetryAttempts, 2)), 12000);
        loadNodesRetryAttempts++;
        logger.info('Retrying node load after delay', { delayMs, attempt: loadNodesRetryAttempts });
        pendingLoadNodesRetry = setTimeout(() => {
          pendingLoadNodesRetry = undefined;
          void loadNodes();
        }, delayMs);
      }
    }
  };

  const handleNodeTemperatureMonitoringChange = async (
    nodeId: string,
    enabled: boolean | null,
  ): Promise<void> => {
    if (savingTemperatureSetting()) {
      return;
    }

    const node = nodes().find((item) => item.id === nodeId);
    if (!node) {
      return;
    }

    const previous = node.temperatureMonitoringEnabled;
    setSavingTemperatureSetting(true);

    setNodes(
      nodes().map((item) =>
        item.id === nodeId ? { ...item, temperatureMonitoringEnabled: enabled } : item,
      ),
    );

    if (editingNode()?.id === nodeId) {
      setEditingNode({ ...editingNode()!, temperatureMonitoringEnabled: enabled });
    }

    try {
      await NodesAPI.updateNode(nodeId, { temperatureMonitoringEnabled: enabled } as NodeConfig);
      if (enabled === true) {
        notificationStore.success('Temperature monitoring enabled for this node', 2000);
      } else if (enabled === false) {
        notificationStore.info('Temperature monitoring disabled for this node', 2000);
      } else {
        notificationStore.info('Using global temperature monitoring setting', 2000);
      }
    } catch (error) {
      logger.error('Failed to update node temperature monitoring setting', error);
      notificationStore.error(
        getNodeTemperatureMonitoringUpdateErrorMessage(
          error instanceof Error ? error.message : undefined,
        ),
      );
      setNodes(
        nodes().map((item) =>
          item.id === nodeId ? { ...item, temperatureMonitoringEnabled: previous } : item,
        ),
      );
      if (editingNode()?.id === nodeId) {
        setEditingNode({ ...editingNode()!, temperatureMonitoringEnabled: previous });
      }
    } finally {
      setSavingTemperatureSetting(false);
    }
  };

  const resolveTemperatureMonitoringEnabled = (node?: NodeConfigWithStatus | null) => {
    if (node && typeof node.temperatureMonitoringEnabled === 'boolean') {
      return node.temperatureMonitoringEnabled;
    }
    return temperatureMonitoringEnabled();
  };

  const nodePendingDeleteLabel = () => {
    const node = nodePendingDelete();
    if (!node) return '';
    return getPreferredConfiguredNodeLabel(node);
  };

  const nodePendingDeleteHost = () => nodePendingDelete()?.host || '';
  const nodePendingDeleteType = () => nodePendingDelete()?.type || '';

  const nodePendingDeleteTypeLabel = () => {
    const type = nodePendingDeleteType();
    if (type === 'pve' || type === 'pbs' || type === 'pmg') {
      return settingsAgentNodeLabel(type);
    }
    return 'Pulse node';
  };

  const requestDeleteNode = (node: NodeConfigWithStatus) => {
    setNodePendingDelete(node);
    setShowDeleteNodeModal(true);
  };

  const cancelDeleteNode = () => {
    if (deleteNodeLoading()) return;
    setShowDeleteNodeModal(false);
    setNodePendingDelete(null);
  };

  const deleteNode = async () => {
    const pending = nodePendingDelete();
    if (!pending) return;

    setDeleteNodeLoading(true);
    try {
      await NodesAPI.deleteNode(pending.id);
      setNodes(nodes().filter((node) => node.id !== pending.id));
      notificationStore.success(`${getPreferredConfiguredNodeLabel(pending)} removed successfully`);
    } catch (error) {
      notificationStore.error(
        getNodeDeleteErrorMessage(error instanceof Error ? error.message : undefined),
      );
    } finally {
      setDeleteNodeLoading(false);
      setShowDeleteNodeModal(false);
      setNodePendingDelete(null);
    }
  };

  const testNodeConnection = async (nodeId: string) => {
    try {
      const node = nodes().find((item) => item.id === nodeId);
      if (!node) {
        throw new Error('Node not found');
      }

      const result = await NodesAPI.testExistingNode(nodeId);
      if (result.status === 'success') {
        if (result.warnings && Array.isArray(result.warnings) && result.warnings.length > 0) {
          const warningMessage =
            result.message +
            '\n\nWarnings:\n' +
            result.warnings.map((warning: string) => '• ' + warning).join('\n');
          notificationStore.warning(warningMessage);
        } else {
          notificationStore.success(result.message || 'Connection successful');
        }
        return;
      }

      throw new Error(result.message || 'Connection failed');
    } catch (error) {
      notificationStore.error(error instanceof Error ? error.message : 'Connection test failed');
    }
  };

  const refreshClusterNodes = async (nodeId: string) => {
    try {
      notificationStore.info('Refreshing cluster membership...', 2000);
      const result = await NodesAPI.refreshClusterNodes(nodeId);
      if (result.status === 'success') {
        if (result.nodesAdded && result.nodesAdded > 0) {
          notificationStore.success(
            `Found ${result.nodesAdded} new node(s) in cluster "${result.clusterName}"`,
          );
        } else {
          notificationStore.success(
            `Cluster "${result.clusterName}" membership verified (${result.newNodeCount} nodes)`,
          );
        }
        await loadNodes();
        return;
      }

      throw new Error('Failed to refresh cluster');
    } catch (error) {
      notificationStore.error(
        error instanceof Error ? error.message : 'Failed to refresh cluster membership',
      );
    }
  };

  const saveNode = async (
    nodeData: Partial<NodeConfig>,
    existingNodeOverride?: NodeConfigWithStatus | null,
  ): Promise<boolean> => {
    try {
      const existingNode = existingNodeOverride ?? editingNode();
      if (existingNode?.id) {
        await NodesAPI.updateNode(existingNode.id, nodeData as NodeConfig);
        // clusterEndpointOverrides is a write-only payload field: mirror it
        // onto the cached endpoints instead of spreading it onto the node.
        const {
          clusterEndpointOverrides,
          clusterNodeDisplayNameOverrides,
          clusterEndpointTrustOverrides,
          ...nodePatch
        } = nodeData as Partial<NodeConfig> & {
          clusterEndpointOverrides?: ClusterEndpointOverridePayload[];
          clusterEndpointTrustOverrides?: ClusterEndpointTrustOverridePayload[];
          clusterNodeDisplayNameOverrides?: ClusterNodeDisplayNameOverridePayload[];
        };
        setNodes(
          nodes().map((node) => {
            if (node.id !== existingNode.id) return node;
            const endpointPatch =
              (clusterEndpointOverrides?.length || clusterNodeDisplayNameOverrides?.length) &&
              'clusterEndpoints' in node
                ? {
                    clusterEndpoints: applyClusterNodeDisplayNamesLocally(
                      applyClusterEndpointOverridesLocally(
                        node.clusterEndpoints,
                        clusterEndpointOverrides,
                      ),
                      clusterNodeDisplayNameOverrides,
                    ),
                  }
                : undefined;
            return {
              ...node,
              ...nodePatch,
              ...endpointPatch,
              hasPassword: nodeData.password ? true : node.hasPassword,
              hasToken: nodeData.tokenValue ? true : node.hasToken,
              status: 'pending',
            };
          }),
        );
        // Read back the effective scoped TLS policy instead of guessing how
        // primary/member URL aliases resolve on the server.
        if (clusterEndpointTrustOverrides?.length || 'fingerprint' in nodeData) await loadNodes();
        notificationStore.success('Node updated successfully');
      } else {
        await NodesAPI.addNode(nodeData as NodeConfig);
        await loadNodes();
        notificationStore.success('Node added successfully');
      }

      setShowNodeModal(false);
      setEditingNode(null);
      return true;
    } catch (error) {
      notificationStore.error(error instanceof Error ? error.message : 'Operation failed');
      return false;
    }
  };

  createEffect(
    on(agentResources, (nodeResources) => {
      const currentNodes = nodes();
      if (!nodeResources || nodeResources.length === 0 || currentNodes.length === 0) {
        return;
      }

      setNodes(
        currentNodes.map((node) => {
          const stateNode = matchConfiguredNodeToResource(node, nodeResources);
          const tempValue = stateNode?.temperature;
          if (typeof tempValue !== 'number' || tempValue <= 0) {
            return node;
          }

          const temperature: Temperature = {
            cpuPackage: tempValue,
            cpuMax: tempValue,
            available: true,
            hasCPU: true,
            lastUpdate: new Date(stateNode!.lastSeen).toISOString(),
          };
          return { ...node, temperature };
        }),
      );
    }),
  );

  return {
    nodes,
    pveNodes,
    pbsNodes,
    pmgNodes,
    orgNodeUsage,
    orgGuestUsage,
    showNodeModal,
    setShowNodeModal,
    editingNode,
    setEditingNode,
    currentNodeType,
    setCurrentNodeType,
    modalResetKey,
    setModalResetKey,
    showDeleteNodeModal,
    deleteNodeLoading,
    isNodeModalVisible,
    resolveTemperatureMonitoringEnabled,
    loadNodes,
    clearLoadNodesRetry,
    handleNodeTemperatureMonitoringChange,
    requestDeleteNode,
    cancelDeleteNode,
    deleteNode,
    testNodeConnection,
    refreshClusterNodes,
    nodePendingDeleteLabel,
    nodePendingDeleteHost,
    nodePendingDeleteType,
    nodePendingDeleteTypeLabel,
    saveNode,
  };
};