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.

21.4 KB
Raw Blame
import { useLocation, useSearchParams } from '@solidjs/router';
import { Show, createEffect, createMemo, createSignal } from 'solid-js';
import BoxIcon from 'lucide-solid/icons/box';
import { ButtonLink } from '@/components/shared/Button';
import { getPlatformIcon } from '@/features/platformPage/platformIcon';
import { useUnifiedResources, type UnifiedResourceFacets } from '@/hooks/useUnifiedResources';
import {
  PLATFORM_HEALTH_FILTER_OPTIONS,
  PlatformErrorState,
  PlatformSectionTabs,
  PlatformTableEmptyState,
  PlatformTableLoadingState,
  PlatformTableToolbar,
  withPlatformStatusCounts,
} from '@/features/platformPage/sharedPlatformPage';
import { DockerAlertsTable } from './DockerAlertsTable';
import { DockerConfigsTable } from './DockerConfigsTable';
import { DockerContainersTable } from './DockerContainersTable';
import { DockerHostsTable } from './DockerHostsTable';
import { DockerImagesTable } from './DockerImagesTable';
import { DockerNetworksTable } from './DockerNetworksTable';
import { DockerSecretsTable } from './DockerSecretsTable';
import { DockerServicesTable } from './DockerServicesTable';
import { DockerStorageUsageTable } from './DockerStorageUsageTable';
import { DockerSwarmNodesTable } from './DockerSwarmNodesTable';
import { DockerTasksTable } from './DockerTasksTable';
import { DockerVolumesTable } from './DockerVolumesTable';
import {
  DOCKER_TAB_SPECS,
  buildDockerPageModel,
  filterDockerResources,
  getDockerPageTabSpecs,
  hasDockerEngineStorageUsage,
  hasDockerStorageInventory,
  hasDockerSwarmEvidence,
  hasDockerSwarmInventory,
  resolveDockerPageTabId,
  type DockerPageModel,
  type DockerPageTabId,
  type DockerResourceStatusFilter,
} from './dockerPageModel';
import {
  collectOutdatedAgentHosts,
  formatAgentVersionDisplay,
} from '@/features/platformPage/agentVersion';
import { PlatformOutdatedAgentNotice } from '@/features/platformPage/PlatformOutdatedAgentNotice';
import {
  PlatformHostScopedTableTitle,
  createPlatformHostScopeFocus,
} from '@/features/platformPage/PlatformHostScope';
import { collectIdentityConflictHosts } from './dockerIdentityConflict';
import { DockerIdentityConflictNotice } from './DockerIdentityConflictNotice';
import { updateStore } from '@/stores/updates';
import {
  buildInfrastructureAgentUpdatesPath,
  buildInfrastructureOnboardingPath,
} from '@/components/Settings/infrastructureWorkspaceModel';
import { DOCKER_QUERY_PARAMS, buildStandalonePath } from '@/routing/resourceLinks';
import { asTrimmedString } from '@/utils/stringUtils';
import { isPulseAgentPlatformResource } from '@/utils/agentResources';
import type { Resource } from '@/types/resource';
import { buildPlatformResourceSearchSuggestions } from '@/features/platformPage/platformSearchSuggestions';

const DOCKER_RESOURCE_QUERY_BY_TAB: Record<DockerPageTabId, string> = {
  overview: 'type=agent,docker-host,app-container&source=docker',
  images: 'type=agent,docker-host,app-container,docker-image&source=docker',
  storage: 'type=agent,docker-host,docker-volume&source=docker',
  networks:
    'type=agent,docker-host,app-container,docker-service,docker-task,docker-network&source=docker',
  swarm:
    'type=agent,docker-host,docker-service,docker-task,docker-swarm-node,docker-secret,docker-config&source=docker',
};

const DockerIcon = getPlatformIcon('docker');
const dockerIcon = () => <DockerIcon class="h-6 w-6 text-slate-400" />;

export function DockerPageSurface() {
  const location = useLocation();
  const [searchParams] = useSearchParams();
  const requestedTab = createMemo<DockerPageTabId>(() => {
    const segment = location.pathname.split('/').filter(Boolean)[1];
    return resolveDockerPageTabId(segment);
  });
  const [navigationResources, setNavigationResources] = createSignal<Resource[]>([]);
  const [resourceFacets, setResourceFacets] = createSignal<UnifiedResourceFacets | null>(null);
  const navigationModel = createMemo(() => buildDockerPageModel(navigationResources()));
  const tabs = createMemo(() => {
    const facets = resourceFacets();
    return facets
      ? getDockerPageTabSpecs(navigationModel(), facets.byType)
      : navigationResources().length > 0
        ? getDockerPageTabSpecs(navigationModel())
        : DOCKER_TAB_SPECS;
  });
  const activeTab = createMemo<DockerPageTabId>(() =>
    tabs().some((tab) => tab.id === requestedTab()) ? requestedTab() : 'overview',
  );
  const shouldHydrateTab = (tab: DockerPageTabId) => activeTab() === tab;
  const overviewResources = useUnifiedResources({
    query: DOCKER_RESOURCE_QUERY_BY_TAB.overview,
    cacheKey: 'docker-overview',
    initialHydration: 'prefer-ws-then-rest',
    enabled: () => shouldHydrateTab('overview'),
    realtimeEnabled: () => shouldHydrateTab('overview'),
  });
  const imageResources = useUnifiedResources({
    query: DOCKER_RESOURCE_QUERY_BY_TAB.images,
    cacheKey: 'docker-images',
    initialHydration: 'prefer-ws-then-rest',
    enabled: () => shouldHydrateTab('images'),
    realtimeEnabled: () => shouldHydrateTab('images'),
  });
  const storageResources = useUnifiedResources({
    query: DOCKER_RESOURCE_QUERY_BY_TAB.storage,
    cacheKey: 'docker-storage',
    initialHydration: 'prefer-ws-then-rest',
    enabled: () => shouldHydrateTab('storage'),
    realtimeEnabled: () => shouldHydrateTab('storage'),
  });
  const networkResources = useUnifiedResources({
    query: DOCKER_RESOURCE_QUERY_BY_TAB.networks,
    cacheKey: 'docker-networks',
    initialHydration: 'prefer-ws-then-rest',
    enabled: () => shouldHydrateTab('networks'),
    realtimeEnabled: () => shouldHydrateTab('networks'),
  });
  const swarmResources = useUnifiedResources({
    query: DOCKER_RESOURCE_QUERY_BY_TAB.swarm,
    cacheKey: 'docker-swarm',
    initialHydration: 'prefer-ws-then-rest',
    enabled: () => shouldHydrateTab('swarm'),
    realtimeEnabled: () => shouldHydrateTab('swarm'),
  });
  const resourceState = createMemo(() => {
    switch (activeTab()) {
      case 'images':
        return imageResources;
      case 'storage':
        return storageResources;
      case 'networks':
        return networkResources;
      case 'swarm':
        return swarmResources;
      default:
        return overviewResources;
    }
  });
  const resources = () => resourceState().resources();
  const loading = () => resourceState().loading();
  const error = () => resourceState().error();
  const refetch = () => resourceState().refetch();
  createEffect(() => {
    const state = resourceState();
    setNavigationResources(state.resources());
    const nextFacets = state.facets?.();
    if (nextFacets) setResourceFacets(nextFacets);
  });
  const model = createMemo(() => buildDockerPageModel(resources()));

  const hostFilter = createMemo(() => {
    const rawHost = searchParams[DOCKER_QUERY_PARAMS.host];
    return typeof rawHost === 'string' ? rawHost.trim() : '';
  });
  const agentUpdateTargetVersion = createMemo(
    () => updateStore.versionInfo()?.agentUpdateTargetVersion,
  );
  const outdatedAgentHosts = createMemo(() =>
    collectOutdatedAgentHosts(model().hosts, agentUpdateTargetVersion()),
  );
  const identityConflictHosts = createMemo(() => collectIdentityConflictHosts(model().hosts));
  const outdatedAgentUpdatePath = createMemo(() =>
    buildInfrastructureAgentUpdatesPath(outdatedAgentHosts().map((host) => host.agentId)),
  );
  const serverVersionDisplay = createMemo(() =>
    formatAgentVersionDisplay(agentUpdateTargetVersion()),
  );
  const refreshDockerResources = async () => {
    await refetch();
  };

  return (
    <div data-testid="docker-page" class="pulse-wide-data-surface space-y-3">
      <PlatformSectionTabs
        tabs={tabs()}
        active={activeTab()}
        ariaLabel="Container runtime sections"
      />

      <Show
        when={!loading() || model().resources.length > 0}
        fallback={
          <PlatformTableLoadingState
            title="Loading container runtime resources"
            description="Pulse is loading the Docker / Podman resource snapshot."
          />
        }
      >
        <Show
          when={!error()}
          fallback={
            <PlatformErrorState
              title="Could not load container runtime resources"
              description="Refresh the resource snapshot or check the API connection state."
              onRefresh={() => void refetch()}
            />
          }
        >
          <Show
            when={model().resources.length > 0}
            fallback={
              <PlatformTableEmptyState
                icon={dockerIcon()}
                title="No Docker or Podman hosts"
                description="Connect a runtime host with the Pulse agent, or enable guest Docker inventory for a Proxmox LXC."
                actions={
                  <ButtonLink
                    href={buildInfrastructureOnboardingPath('docker')}
                    variant="primary"
                    size="sm"
                    class="gap-2"
                  >
                    <BoxIcon class="h-3.5 w-3.5" aria-hidden="true" />
                    Set up Docker or Podman
                  </ButtonLink>
                }
              />
            }
          >
            <DockerIdentityConflictNotice hosts={identityConflictHosts()} />
            <PlatformOutdatedAgentNotice
              hosts={outdatedAgentHosts()}
              targetVersion={serverVersionDisplay()}
              missingLabel="images, networks, storage, and Swarm details"
              actionHref={outdatedAgentUpdatePath()}
              actionLabel="Open agent upgrade commands"
            />
            <Show when={activeTab() === 'overview'}>
              <div class="space-y-4">
                <DockerOverview
                  hosts={model().hosts}
                  hostSourceCount={model().hosts.length}
                  hostFilter={hostFilter()}
                  containers={model().containers}
                  incidents={model().incidents}
                  onLifecycleActionSettled={refreshDockerResources}
                />
              </div>
            </Show>
            <Show when={activeTab() === 'images'}>
              <DockerImagesTable
                resources={model().images}
                relatedContainers={model().containers}
                emptyIcon={dockerIcon()}
                emptyTitle="No images"
                emptyDescription="Images appear here when a Docker or Podman host reports local image inventory."
              />
            </Show>
            <Show when={activeTab() === 'networks'}>
              <DockerNetworksTable
                resources={model().networks}
                relatedResources={model().resources}
                emptyIcon={dockerIcon()}
                emptyTitle="No networks"
                emptyDescription="Networks appear here when the container runtime reports network inventory."
              />
            </Show>
            <Show when={activeTab() === 'storage'}>
              <DockerStorage model={model()} />
            </Show>
            <Show when={activeTab() === 'swarm'}>
              <DockerSwarm model={model()} />
            </Show>
          </Show>
        </Show>
      </Show>
    </div>
  );
}

export default DockerPageSurface;

function DockerStorage(props: { model: DockerPageModel }) {
  const hasEngineUsage = createMemo(() => props.model.hosts.some(hasDockerEngineStorageUsage));
  const [search, setSearch] = createSignal('');
  const [status, setStatus] = createSignal<DockerResourceStatusFilter>('all');
  const storageHosts = createMemo(() => props.model.hosts.filter(hasDockerEngineStorageUsage));
  const searchSuggestions = createMemo(() =>
    buildPlatformResourceSearchSuggestions([...storageHosts(), ...props.model.volumes]),
  );
  const totalRows = createMemo(() => storageHosts().length + props.model.volumes.length);
  // The toolbar governs both stacked tables, so visible rows and chip counts
  // sum the same per-section predicate.
  const countForStatus = (value: DockerResourceStatusFilter): number =>
    filterDockerResources(storageHosts(), search(), value).length +
    filterDockerResources(props.model.volumes, search(), value).length;
  const visibleRows = createMemo(() => countForStatus(status()));
  const hasActiveFilters = createMemo(() => search().trim().length > 0 || status() !== 'all');
  const resetFilters = () => {
    setSearch('');
    setStatus('all');
  };

  return (
    <Show
      when={hasDockerStorageInventory(props.model)}
      fallback={
        <PlatformTableEmptyState
          icon={dockerIcon()}
          title="No Docker or Podman storage inventory"
          description="Engine disk-usage snapshots and volumes appear here when Docker or Podman hosts report storage inventory."
        />
      }
    >
      <div class="space-y-4">
        <PlatformTableToolbar
          search={search}
          onSearchChange={setSearch}
          searchPlaceholder="Search storage usage and volumes"
          searchSuggestions={searchSuggestions}
          status={status()}
          onStatusChange={setStatus}
          statusOptions={withPlatformStatusCounts(PLATFORM_HEALTH_FILTER_OPTIONS, countForStatus)}
          visible={visibleRows()}
          total={totalRows()}
          rowNoun="rows"
          hasActiveFilters={hasActiveFilters()}
          onResetFilters={resetFilters}
        />
        <Show when={hasEngineUsage()}>
          <DockerStorageUsageTable
            hosts={props.model.hosts}
            sourceCount={props.model.hosts.length}
            emptyIcon={dockerIcon()}
            emptyTitle="No Docker or Podman storage usage"
            emptyDescription="Engine disk-usage snapshots appear here when a Docker or Podman host reports them."
            showToolbar={false}
            externalSearch={search}
            externalStatus={status}
          />
        </Show>
        <Show when={props.model.volumes.length > 0}>
          <DockerVolumesTable
            resources={props.model.volumes}
            emptyIcon={dockerIcon()}
            emptyTitle="No volumes"
            emptyDescription="Volumes appear here when the container runtime reports volume inventory."
            showToolbar={false}
            externalSearch={search}
            externalStatus={status}
          />
        </Show>
      </div>
    </Show>
  );
}

function DockerSwarm(props: { model: DockerPageModel }) {
  const hasSwarmInventory = createMemo(() => hasDockerSwarmInventory(props.model));
  const swarmHosts = createMemo(() => props.model.hosts.filter(hasDockerSwarmEvidence));
  const hasManagerInventory = createMemo(
    () =>
      props.model.services.length > 0 ||
      props.model.tasks.length > 0 ||
      props.model.nodes.length > 0 ||
      props.model.secrets.length > 0 ||
      props.model.configs.length > 0,
  );

  return (
    <Show
      when={hasSwarmInventory()}
      fallback={
        <PlatformTableEmptyState
          icon={dockerIcon()}
          title="No Swarm inventory"
          description="Docker Swarm services, tasks, nodes, secrets, and configs appear here when a Swarm manager reports them."
        />
      }
    >
      <div class="space-y-4">
        <DockerHostsTable
          resources={swarmHosts()}
          sourceCount={swarmHosts().length}
          emptyIcon={dockerIcon()}
          emptyTitle="No Swarm hosts"
          emptyDescription="Hosts appear here when an active Docker Swarm node reports its cluster membership."
          title="Swarm hosts"
        />
        <Show when={!hasManagerInventory()}>
          <PlatformTableEmptyState
            icon={dockerIcon()}
            title="No Swarm manager inventory"
            description="Pulse can see active Swarm hosts, but no manager has reported services, tasks, nodes, secrets, or configs. Check manager connectivity and enable Swarm inventory collection."
          />
        </Show>
        <Show when={props.model.services.length > 0}>
          <DockerServicesTable
            resources={props.model.services}
            sourceCount={props.model.services.length}
            emptyIcon={dockerIcon()}
            emptyTitle="No Swarm services"
            emptyDescription="Docker Swarm services appear here when a Swarm manager reports them."
          />
        </Show>
        <Show when={props.model.tasks.length > 0}>
          <DockerTasksTable
            resources={props.model.tasks}
            emptyIcon={dockerIcon()}
            emptyTitle="No Swarm tasks"
            emptyDescription="Docker Swarm tasks appear here when a Swarm manager reports task state."
          />
        </Show>
        <Show when={props.model.nodes.length > 0}>
          <DockerSwarmNodesTable
            resources={props.model.nodes}
            emptyIcon={dockerIcon()}
            emptyTitle="No Swarm nodes"
            emptyDescription="Swarm nodes appear here when a Swarm manager reports cluster membership."
          />
        </Show>
        <Show when={props.model.secrets.length > 0}>
          <DockerSecretsTable
            resources={props.model.secrets}
            emptyIcon={dockerIcon()}
            emptyTitle="No Swarm secrets"
            emptyDescription="Docker Swarm secrets appear here when a Swarm manager reports secret metadata."
          />
        </Show>
        <Show when={props.model.configs.length > 0}>
          <DockerConfigsTable
            resources={props.model.configs}
            emptyIcon={dockerIcon()}
            emptyTitle="No Swarm configs"
            emptyDescription="Docker Swarm configs appear here when a Swarm manager reports config metadata."
          />
        </Show>
      </div>
    </Show>
  );
}

const DOCKER_CONTAINERS_SECTION_ID = 'docker-containers-section';

function DockerOverview(props: {
  hosts: ReturnType<typeof buildDockerPageModel>['hosts'];
  hostSourceCount: number;
  hostFilter: string;
  containers: ReturnType<typeof buildDockerPageModel>['containers'];
  incidents: ReturnType<typeof buildDockerPageModel>['incidents'];
  onLifecycleActionSettled?: () => void | Promise<void>;
}) {
  const hostMatchesFilter = (resource: Resource, hostFilter: string): boolean => {
    const normalized = hostFilter.trim();
    if (!normalized) return true;
    return [
      resource.docker?.hostname,
      resource.name,
      resource.displayName,
      resource.id,
      resource.docker?.hostSourceId,
    ].some((candidate) => asTrimmedString(candidate) === normalized);
  };
  const hasMachineInventory = createMemo(() => props.hosts.some(isPulseAgentPlatformResource));
  // A host row narrows the containers table to that host through the URL host
  // scope the table already reads, as a Proxmox node row does for its guests.
  // Every host stays listed so another can be picked; the scoped one is marked.
  const [, setSearchParams] = useSearchParams();
  const isScopedHost = (host: Resource) =>
    props.hostFilter.trim() !== '' && hostMatchesFilter(host, props.hostFilter);
  const scopedHostLabel = createMemo(() => {
    const filter = props.hostFilter.trim();
    if (!filter) return null;
    return asTrimmedString(props.hosts.find(isScopedHost)?.name) || filter;
  });
  const containersFocus = createPlatformHostScopeFocus();
  const showHostContainers = (host: Resource) => {
    // Containers name their host by its Docker hostname.
    const value = asTrimmedString(host.docker?.hostname) || asTrimmedString(host.name) || host.id;
    const next = isScopedHost(host) ? null : value;
    setSearchParams({ [DOCKER_QUERY_PARAMS.host]: next });
    if (next) {
      requestAnimationFrame(() => {
        if (props.hostFilter.trim() === next) containersFocus.reveal();
      });
    }
  };
  const clearHostScope = () => {
    setSearchParams({ [DOCKER_QUERY_PARAMS.host]: null });
    containersFocus.focus();
  };

  return (
    <div class="space-y-4">
      <DockerHostsTable
        resources={props.hosts}
        sourceCount={props.hostSourceCount}
        emptyIcon={dockerIcon()}
        emptyTitle="No Docker or Podman hosts"
        emptyDescription="Container hosts appear here once a Pulse agent registers them."
        actions={
          <Show when={hasMachineInventory()}>
            <ButtonLink href={buildStandalonePath()} variant="secondary" size="sm">
              View all machines
            </ButtonLink>
          </Show>
        }
        showToolbar={false}
        containerScope={{
          sectionId: DOCKER_CONTAINERS_SECTION_ID,
          isSelected: isScopedHost,
          onShow: showHostContainers,
        }}
      />
      <section
        id={DOCKER_CONTAINERS_SECTION_ID}
        aria-label="Containers"
        class="scroll-mt-4"
        data-testid="docker-containers-section"
      >
        <DockerContainersTable
          resources={props.containers}
          hosts={props.hosts}
          title={
            <PlatformHostScopedTableTitle
              noun="Containers"
              hostLabel={scopedHostLabel()}
              clearLabel="Show all hosts"
              onClear={clearHostScope}
              headingId="docker-containers-heading"
              headingRef={containersFocus.setHeading}
            />
          }
          emptyIcon={dockerIcon()}
          emptyTitle="No Docker or Podman containers"
          emptyDescription="Containers appear here when a Docker or Podman host reports workload inventory."
          onLifecycleActionSettled={props.onLifecycleActionSettled}
        />
      </section>
      <Show when={props.incidents.length > 0}>
        <DockerAlertsTable
          incidents={props.incidents}
          emptyIcon={dockerIcon()}
          emptyTitle="No active Docker alerts"
          emptyDescription="Docker health alerts appear here when the Pulse alert engine reports active container, host, or Swarm incidents."
        />
      </Show>
    </div>
  );
}