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 { Show, createMemo, type Component } from 'solid-js';
import { TableCell, TableRow } from '@/components/shared/Table';
import { InlineDetailTableRow } from '@/components/shared/InlineDetailTableRow';
import { asTrimmedString } from '@/utils/stringUtils';
import {
PlatformWindowedRows,
PLATFORM_HEALTH_FILTER_OPTIONS,
PlatformResponsiveTableLabel,
PlatformSortableTableHead,
PlatformTableEmptyState,
PlatformTableToolbar,
createPlatformTableFilterState,
createPlatformTableSortState,
getPlatformTableCellClassForKind,
PlatformTableShell,
type PlatformTableSortValue,
withPlatformStatusCounts,
} from '@/features/platformPage/sharedPlatformPage';
import {
PlatformResourceDetailToggleButton,
createPlatformResourceDetailState,
getPlatformResourceDetailRowClass,
} from '@/features/platformPage/PlatformResourceDetailTableRow';
import {
compactDetailRows,
makeDetailRow,
type DetailSection,
} from '@/components/shared/DetailSectionTable';
import { titleCaseDelimitedLabel } from '@/utils/textPresentation';
import {
DockerNativeDetailPanel,
DockerResourceNameCell,
dockerDetailToneForVariant,
dockerLabelsSection,
dockerReportedBySection,
dockerByteValue,
dockerCpuValue,
dockerResourceName,
dockerStateTextToneClass,
dockerTextValue,
type DockerNativeTableProps,
} from './DockerNativeTableShared';
import {
compareDockerSwarmNodes,
filterDockerResources,
mapDockerSwarmNodeStatus,
type DockerResourceStatusFilter,
} from './dockerPageModel';
import type { Resource } from '@/types/resource';
const DOCKER_SWARM_NODE_SORT_KEYS = [
'node',
'role',
'availability',
'reachability',
'engine',
'cpus',
'memory',
'address',
] as const;
type DockerSwarmNodeSortKey = (typeof DOCKER_SWARM_NODE_SORT_KEYS)[number];
const getDockerSwarmNodeSortValue = (
resource: Resource,
key: DockerSwarmNodeSortKey,
): PlatformTableSortValue => {
switch (key) {
case 'node':
return dockerResourceName(resource);
case 'role':
return asTrimmedString(resource.docker?.nodeRole) || null;
case 'availability':
return asTrimmedString(resource.docker?.availability) || null;
case 'reachability':
return (
asTrimmedString(
resource.docker?.leader ? 'leader' : resource.docker?.managerReachability,
) || null
);
case 'engine':
return (
asTrimmedString(resource.docker?.engineVersion || resource.docker?.runtimeVersion) || null
);
case 'cpus':
return typeof resource.docker?.nanoCpus === 'number' && resource.docker.nanoCpus > 0
? resource.docker.nanoCpus
: null;
case 'memory':
return typeof resource.docker?.memoryBytes === 'number' && resource.docker.memoryBytes > 0
? resource.docker.memoryBytes
: null;
case 'address':
return asTrimmedString(resource.docker?.address || resource.docker?.managerAddress) || null;
default:
key satisfies never;
return null;
}
};
const nodeReachability = (resource: Resource): string =>
asTrimmedString(resource.docker?.leader ? 'leader' : resource.docker?.managerReachability) ?? '';
// A node's role, whether it takes work, and for a manager whether the others
// can reach it: the three things the row dot weighs.
const nodeSummary = (resource: Resource): string =>
[
titleCaseDelimitedLabel(resource.docker?.nodeRole, { fallback: '' }),
resource.docker?.leader ? 'leader' : '',
asTrimmedString(resource.docker?.availability)
? `availability ${asTrimmedString(resource.docker?.availability)}`
: '',
!resource.docker?.leader && asTrimmedString(resource.docker?.managerReachability)
? `manager ${asTrimmedString(resource.docker?.managerReachability)}`
: '',
]
.filter(Boolean)
.join(' · ');
const buildSwarmNodeDetailSections = (resource: Resource): Array<DetailSection | null> => {
const verdict = mapDockerSwarmNodeStatus(resource);
const cpus = dockerCpuValue(resource.docker?.nanoCpus);
const memory = dockerByteValue(resource.docker?.memoryBytes);
return [
{
label: 'Node',
rows: compactDetailRows([
makeDetailRow('Role', asTrimmedString(resource.docker?.nodeRole)),
makeDetailRow('Availability', asTrimmedString(resource.docker?.availability), {
tone:
verdict.label === 'Drained' || verdict.label === 'Paused'
? dockerDetailToneForVariant(verdict.variant)
: undefined,
}),
makeDetailRow('Reachability', nodeReachability(resource), {
tone:
verdict.label === 'Manager unreachable'
? dockerDetailToneForVariant(verdict.variant)
: undefined,
}),
makeDetailRow('Address', asTrimmedString(resource.docker?.address), { wrap: true }),
makeDetailRow('Manager address', asTrimmedString(resource.docker?.managerAddress), {
wrap: true,
}),
makeDetailRow('Node ID', asTrimmedString(resource.docker?.nodeId), { wrap: true }),
]),
},
{
label: 'Engine',
rows: compactDetailRows([
makeDetailRow(
'Version',
asTrimmedString(resource.docker?.engineVersion || resource.docker?.runtimeVersion),
),
makeDetailRow('CPUs', cpus === '—' ? null : cpus),
makeDetailRow('Memory', memory === '—' ? null : memory),
]),
},
dockerReportedBySection(resource),
dockerLabelsSection('Engine labels', resource.docker?.engineLabels),
dockerLabelsSection('Node labels', resource.docker?.labels),
];
};
export const DockerSwarmNodesTable: Component<DockerNativeTableProps> = (props) => {
const tableState = createPlatformTableFilterState({
resources: () => props.resources,
initialStatus: 'all' as DockerResourceStatusFilter,
filter: filterDockerResources,
});
const sort = createPlatformTableSortState({
storageKey: 'dockerSwarmNodes',
sortKeys: DOCKER_SWARM_NODE_SORT_KEYS,
descendingFirst: ['cpus', 'memory'],
});
const sortedRows = createMemo(() =>
sort.sortRows(
[...tableState.filtered()].sort(compareDockerSwarmNodes),
getDockerSwarmNodeSortValue,
),
);
const drawer = createPlatformResourceDetailState({ idPrefix: 'docker-swarm-node-detail' });
return (
<Show
when={props.resources.length > 0}
fallback={
<PlatformTableEmptyState
icon={props.emptyIcon}
title={props.emptyTitle}
description={props.emptyDescription}
/>
}
>
<div class="space-y-3">
<Show when={props.showToolbar !== false}>
<PlatformTableToolbar
search={tableState.search}
onSearchChange={tableState.setSearch}
searchPlaceholder="Search Swarm nodes"
searchSuggestions={tableState.searchSuggestions}
status={tableState.status()}
onStatusChange={tableState.setStatus}
statusOptions={withPlatformStatusCounts(
PLATFORM_HEALTH_FILTER_OPTIONS,
tableState.countForStatus,
)}
visible={tableState.visible()}
total={tableState.total()}
rowNoun="nodes"
/>
</Show>
<Show
when={tableState.filtered().length > 0}
fallback={
<PlatformTableEmptyState
icon={props.emptyIcon}
title="No Swarm nodes match current filters"
description="Adjust the search or status filter to see more Docker Swarm nodes."
/>
}
>
<PlatformTableShell
title={props.title ?? 'Swarm Nodes'}
tableClass="min-w-full table-fixed text-xs md:min-w-[1120px]"
header={
<>
<PlatformSortableTableHead
kind="name"
sort={sort}
sortKey="node"
class="platform-table-mobile-w-30 w-[32%] md:w-[20%]"
>
Node
</PlatformSortableTableHead>
<PlatformSortableTableHead
kind="text"
sort={sort}
sortKey="role"
class="platform-table-mobile-w-15 w-[15%] md:w-[10%]"
>
Role
</PlatformSortableTableHead>
<PlatformSortableTableHead
kind="text"
sort={sort}
sortKey="availability"
class="platform-table-phone-hidden md:w-[12%]"
>
<PlatformResponsiveTableLabel compact="Avail" full="Availability" />
</PlatformSortableTableHead>
<PlatformSortableTableHead
kind="text"
sort={sort}
sortKey="reachability"
class="platform-table-mobile-w-15 w-[15%] md:w-[14%]"
>
Reachability
</PlatformSortableTableHead>
<PlatformSortableTableHead
kind="text"
sort={sort}
sortKey="engine"
class="hidden md:table-cell md:w-[16%]"
>
Engine
</PlatformSortableTableHead>
<PlatformSortableTableHead
kind="numeric-value"
sort={sort}
sortKey="cpus"
class="platform-table-narrow-hidden w-[12%] sm:hidden md:table-cell md:w-[8%]"
>
CPUs
</PlatformSortableTableHead>
<PlatformSortableTableHead
kind="numeric-value"
sort={sort}
sortKey="memory"
class="platform-table-mobile-w-15 w-[15%] md:w-[10%]"
>
<PlatformResponsiveTableLabel compact="Mem" full="Memory" />
</PlatformSortableTableHead>
<PlatformSortableTableHead
kind="text"
sort={sort}
sortKey="address"
class="hidden sm:table-cell md:w-[10%]"
>
Address
</PlatformSortableTableHead>
</>
}
body={
<>
<PlatformWindowedRows items={sortedRows} estimatedRowHeight={32}>
{(resource) => {
const managerReachability = () => nodeReachability(resource) || '—';
// The cell behind the dot's verdict reads in its colour: an
// unreachable manager in Reachability, a drained or paused
// node in Availability.
const verdict = () => mapDockerSwarmNodeStatus(resource);
const reachabilityTone = () =>
verdict().label === 'Manager unreachable'
? dockerStateTextToneClass(verdict().variant)
: '';
const availabilityTone = () =>
verdict().label === 'Drained' || verdict().label === 'Paused'
? dockerStateTextToneClass(verdict().variant)
: '';
const detailRowId = () => drawer.detailRowId(resource);
const isExpanded = () => drawer.isExpanded(resource);
return (
<>
<TableRow
class={`${getPlatformResourceDetailRowClass(isExpanded())} text-[11px] sm:text-xs`}
data-docker-swarm-node-row={resource.id}
onClick={() => drawer.toggle(resource)}
>
<DockerResourceNameCell
resource={resource}
indicator={verdict()}
detailToggle={
<PlatformResourceDetailToggleButton
expanded={isExpanded()}
resourceLabel={dockerResourceName(resource)}
controlsId={detailRowId()}
onToggle={() => drawer.toggle(resource)}
/>
}
/>
<TableCell
class={`${getPlatformTableCellClassForKind('text')} text-base-content`}
>
{dockerTextValue(resource.docker?.nodeRole)}
</TableCell>
<TableCell
class={`${getPlatformTableCellClassForKind('text')} platform-table-phone-hidden ${availabilityTone() || 'text-base-content'}`}
>
{dockerTextValue(resource.docker?.availability)}
</TableCell>
<TableCell
class={`${getPlatformTableCellClassForKind('text')} ${reachabilityTone() || 'text-base-content'}`}
data-docker-node-reachability-tone={
reachabilityTone() ? 'danger' : 'none'
}
>
{managerReachability()}
</TableCell>
<TableCell
class={`${getPlatformTableCellClassForKind('text')} hidden text-base-content md:table-cell`}
>
{dockerTextValue(
resource.docker?.engineVersion || resource.docker?.runtimeVersion,
)}
</TableCell>
<TableCell
class={`${getPlatformTableCellClassForKind('numeric-value')} platform-table-narrow-hidden sm:hidden text-base-content md:table-cell`}
>
{dockerCpuValue(resource.docker?.nanoCpus)}
</TableCell>
<TableCell
class={`${getPlatformTableCellClassForKind('numeric-value')} text-base-content`}
>
{dockerByteValue(resource.docker?.memoryBytes)}
</TableCell>
<TableCell
class={`${getPlatformTableCellClassForKind('text')} hidden text-base-content sm:table-cell`}
>
{dockerTextValue(
resource.docker?.address || resource.docker?.managerAddress,
)}
</TableCell>
</TableRow>
<Show when={isExpanded()}>
<InlineDetailTableRow
cellId={detailRowId()}
colspan={8}
data-inline-docker-swarm-node-detail-for={resource.id}
>
<DockerNativeDetailPanel
testId="docker-swarm-node-detail"
resource={resource}
status={verdict()}
summary={nodeSummary(resource)}
sections={() => buildSwarmNodeDetailSections(resource)}
onClose={() => drawer.close(resource)}
/>
</InlineDetailTableRow>
</Show>
</>
);
}}
</PlatformWindowedRows>
</>
}
/>
</Show>
</div>
</Show>
);
};
export default DockerSwarmNodesTable;