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.

11.9 KB
Raw Blame
import {
  createMemo,
  createEffect,
  createSignal,
  onCleanup,
  untrack,
  type Accessor,
  type Setter,
} from 'solid-js';
import { useLocation, useNavigate } from '@solidjs/router';
import type { ViewMode } from '@/types/workloads';
import { createRouteStateNavigateScheduler } from '@/utils/routeStateNavigation';
import { isContainerWorkloadViewMode } from '@/utils/workloads';
import { resolveWorkloadNodeHint, type WorkloadNodeOption } from './workloadRouteModel';
import {
  parseWorkloadsWorkloadUrlParams,
  resolveWorkloadsManagedWorkloadsNavigateTarget,
  resolveWorkloadsWorkloadRuntimeParam,
  resolveWorkloadsWorkloadTypeParam,
} from './workloadUrlSyncModel';

export interface WorkloadsWorkloadUrlSyncOptions {
  containerRuntime: Accessor<string>;
  containerRuntimeOptions: Accessor<string[]>;
  routeStateEnabled: Accessor<boolean>;
  kubernetesNamespaceOptions: Accessor<string[]>;
  selectedHostHint: Accessor<string | null>;
  selectedPlatform: Accessor<string | null>;
  selectedKubernetesContext: Accessor<string | null>;
  selectedKubernetesNamespace: Accessor<string | null>;
  selectedCluster: Accessor<string | null>;
  clusterOptions: Accessor<string[]>;
  selectedNode: Accessor<string | null>;
  setContainerRuntime: Setter<string>;
  setSelectedHostHint: Setter<string | null>;
  setSelectedPlatform: Setter<string | null>;
  setSelectedKubernetesContext: Setter<string | null>;
  setSelectedKubernetesNamespace: Setter<string | null>;
  setSelectedCluster: Setter<string | null>;
  setSelectedNode: Setter<string | null>;
  setShowFilters: Setter<boolean>;
  setViewMode: Setter<ViewMode>;
  showFilters: Accessor<boolean>;
  viewMode: Accessor<ViewMode>;
  // Forced ?? raw view mode. The cluster facet keys off this because vSphere
  // forces vm view while leaving the raw viewMode signal at 'all', and the
  // facet must persist/validate against what is actually displayed.
  effectiveViewMode: Accessor<ViewMode>;
  workloadNodeOptions: Accessor<WorkloadNodeOption[]>;
}

export function useWorkloadUrlSync(options: WorkloadsWorkloadUrlSyncOptions) {
  const navigate = useNavigate();
  const location = useLocation();
  const isWorkloadsRoute = () => options.routeStateEnabled();
  const workloadUrlParams = createMemo(() => parseWorkloadsWorkloadUrlParams(location.search));
  const routeStateNavigate = createRouteStateNavigateScheduler(
    navigate,
    () => `${untrack(() => location.pathname)}${untrack(() => location.search)}`,
  );

  const [handledTypeParam, setHandledTypeParam] = createSignal('');
  const [handledRuntimeParam, setHandledRuntimeParam] = createSignal('');
  const [handledContextParam, setHandledContextParam] = createSignal('');
  const [handledNamespaceParam, setHandledNamespaceParam] = createSignal('');
  const [handledClusterParam, setHandledClusterParam] = createSignal('');
  const [handledAgentParam, setHandledAgentParam] = createSignal('');
  const [handledPlatformParam, setHandledPlatformParam] = createSignal('');

  onCleanup(() => {
    routeStateNavigate.cleanup();
  });

  createEffect(() => {
    if (options.viewMode() === 'pod') return;
    const hostHint = options.selectedHostHint();
    if (!hostHint || options.selectedNode() !== null) return;
    const workloadNode = resolveWorkloadNodeHint(options.workloadNodeOptions(), hostHint);
    if (!workloadNode) return;
    options.setSelectedNode(workloadNode.value);
    options.setSelectedHostHint(null);
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    if (options.viewMode() !== 'pod') return;
    const selected = (options.selectedKubernetesNamespace() || '').trim();
    if (!selected) return;
    // While guests haven't loaded the options list is empty; skipping prevents
    // the cleanup from stripping a perfectly valid URL value (e.g. one opened
    // from a bookmark) before data arrives.
    const candidates = options.kubernetesNamespaceOptions();
    if (candidates.length === 0) return;
    const normalized = selected.toLowerCase();
    const exists = candidates.some((value) => value.toLowerCase() === normalized);
    if (!exists) {
      options.setSelectedKubernetesNamespace(null);
    }
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    if (options.effectiveViewMode() !== 'vm') return;
    const selected = (options.selectedCluster() || '').trim();
    if (!selected) return;
    // While guests haven't loaded the options list is empty; skipping prevents
    // the cleanup from stripping a perfectly valid URL value (e.g. one opened
    // from a bookmark) before data arrives.
    const candidates = options.clusterOptions();
    if (candidates.length === 0) return;
    const normalized = selected.toLowerCase();
    const exists = candidates.some((value) => value.toLowerCase() === normalized);
    if (!exists) {
      options.setSelectedCluster(null);
    }
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    if (!isContainerWorkloadViewMode(options.viewMode())) return;
    const selected = options.containerRuntime().trim();
    if (!selected) return;
    const candidates = options.containerRuntimeOptions();
    if (candidates.length === 0) return;
    const normalized = selected.toLowerCase();
    const exists = candidates.some((value) => value.toLowerCase() === normalized);
    if (!exists) {
      options.setContainerRuntime('');
    }
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    if (options.viewMode() === 'pod') {
      if (options.selectedNode() !== null) {
        options.setSelectedNode(null);
      }
      if (options.selectedHostHint() !== null) {
        options.setSelectedHostHint(null);
      }
      return;
    }
    if (options.selectedKubernetesContext() !== null) {
      options.setSelectedKubernetesContext(null);
    }
    if (options.selectedKubernetesNamespace() !== null) {
      options.setSelectedKubernetesNamespace(null);
    }
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    if (options.effectiveViewMode() !== 'vm' && options.selectedCluster() !== null) {
      options.setSelectedCluster(null);
    }
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    if (
      !isContainerWorkloadViewMode(options.viewMode()) &&
      options.containerRuntime().trim() !== ''
    ) {
      options.setContainerRuntime('');
    }
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    const parsed = workloadUrlParams();
    const normalizedType = parsed.type;
    if (normalizedType === handledTypeParam()) return;

    if (!normalizedType) {
      setHandledTypeParam('');
      return;
    }

    const nextMode = resolveWorkloadsWorkloadTypeParam(parsed);
    if (!nextMode) {
      setHandledTypeParam(normalizedType);
      return;
    }

    options.setViewMode(nextMode);
    setHandledTypeParam(normalizedType);
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    const normalized = workloadUrlParams().platform;
    if (normalized === handledPlatformParam()) return;
    const currentSelected = untrack(() => options.selectedPlatform());

    if (normalized) {
      if (currentSelected !== normalized) {
        options.setSelectedPlatform(normalized);
      }
      if (!options.showFilters()) {
        options.setShowFilters(true);
      }
      if (handledPlatformParam() !== normalized) {
        setHandledPlatformParam(normalized);
      }
      return;
    }

    if (currentSelected !== null) {
      options.setSelectedPlatform(null);
    }
    if (handledPlatformParam() !== '') {
      setHandledPlatformParam('');
    }
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    const normalized = workloadUrlParams().context;
    if (normalized === handledContextParam()) return;

    if (normalized) {
      if (options.viewMode() !== 'pod') {
        options.setViewMode('pod');
      }
      options.setSelectedKubernetesContext(normalized);
      if (!options.showFilters()) {
        options.setShowFilters(true);
      }
      setHandledContextParam(normalized);
      return;
    }

    options.setSelectedKubernetesContext(null);
    setHandledContextParam('');
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    const normalized = workloadUrlParams().namespace;
    if (normalized === handledNamespaceParam()) return;

    if (normalized) {
      if (options.viewMode() !== 'pod') {
        options.setViewMode('pod');
      }
      options.setSelectedKubernetesNamespace(normalized);
      if (!options.showFilters()) {
        options.setShowFilters(true);
      }
      setHandledNamespaceParam(normalized);
      return;
    }

    options.setSelectedKubernetesNamespace(null);
    setHandledNamespaceParam('');
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    const normalized = workloadUrlParams().cluster;
    if (normalized === handledClusterParam()) return;

    if (normalized) {
      if (options.effectiveViewMode() !== 'vm') {
        options.setViewMode('vm');
      }
      options.setSelectedCluster(normalized);
      if (!options.showFilters()) {
        options.setShowFilters(true);
      }
      setHandledClusterParam(normalized);
      return;
    }

    options.setSelectedCluster(null);
    setHandledClusterParam('');
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    const normalized = workloadUrlParams().agent;
    if (normalized === handledAgentParam()) return;

    if (normalized) {
      options.setSelectedHostHint(normalized);
      if (!options.showFilters()) {
        options.setShowFilters(true);
      }
      setHandledAgentParam(normalized);
      return;
    }

    options.setSelectedHostHint(null);
    if (options.selectedNode() !== null) {
      options.setSelectedNode(null);
    }
    setHandledAgentParam('');
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;
    const parsed = workloadUrlParams();
    const urlRuntime = parsed.runtime;
    if (urlRuntime === handledRuntimeParam()) return;

    const resolution = resolveWorkloadsWorkloadRuntimeParam(parsed);
    if (!resolution.shouldApply) {
      setHandledRuntimeParam(urlRuntime);
      return;
    }

    if (resolution.forceViewMode && options.viewMode() !== resolution.forceViewMode) {
      options.setViewMode(resolution.forceViewMode);
    }
    options.setContainerRuntime(resolution.runtime);
    if (resolution.runtime && !options.showFilters()) {
      options.setShowFilters(true);
    }
    setHandledRuntimeParam(urlRuntime);
  });

  createEffect(() => {
    if (!isWorkloadsRoute()) return;

    const parsed = workloadUrlParams();
    const urlType = parsed.type;
    const urlRuntime = parsed.runtime;
    const urlContext = parsed.context;
    const urlNamespace = parsed.namespace;
    const urlCluster = parsed.cluster;
    const urlAgent = parsed.agent;
    const urlPlatform = parsed.platform;
    const urlResource = parsed.resource;

    if (handledTypeParam() !== urlType) return;
    if (handledPlatformParam() !== urlPlatform) return;
    if (handledRuntimeParam() !== urlRuntime) return;
    if (handledContextParam() !== urlContext) return;
    if (handledNamespaceParam() !== urlNamespace) return;
    if (handledClusterParam() !== urlCluster) return;
    if (handledAgentParam() !== urlAgent) return;
    if (urlResource) return;

    const nextPath = resolveWorkloadsManagedWorkloadsNavigateTarget({
      currentPathname: location.pathname,
      currentSearch: location.search,
      viewMode: options.viewMode(),
      effectiveViewMode: options.effectiveViewMode(),
      containerRuntime: options.containerRuntime(),
      selectedKubernetesContext: options.selectedKubernetesContext(),
      selectedKubernetesNamespace: options.selectedKubernetesNamespace(),
      selectedCluster: options.selectedCluster(),
      selectedNode: options.selectedNode(),
      selectedHostHint: options.selectedHostHint(),
      selectedPlatform: options.selectedPlatform(),
    });
    if (nextPath) {
      routeStateNavigate.schedule(nextPath);
    }
  });

  return {
    isWorkloadsRoute,
  } as const;
}