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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
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>
);
}