Mitchell-JohnsonandClaude Opus 5
e0625be684
Disks: one row per physical drive with its model, size, temperature and IO, and a usage bar built from the filesystems the sampler can attribute to it. Attribution is new — a mount's source device is resolved through sysfs to the drive behind it, following one layer of device-mapper or md and folding NVMe namespaces the way the sampler does. A pool member gets no usage bar, because one drive's share of a raidz pool is not a real number. Net: every interface that is up is listed and tappable, defaulting to the one that has actually carried traffic rather than whichever the kernel listed first. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
65 lines
4.8 KiB
TypeScript
65 lines
4.8 KiB
TypeScript
// The stock Dashboard modules were written against one Sample object. They now read the
|
|
// sensor API like everything else; this file is the seam — it rebuilds that object from
|
|
// sensor values (the live stream) and sensor metadata (the catalog: labels, thresholds).
|
|
import { Sample } from './api'
|
|
import { Sensor } from './sensors'
|
|
|
|
export type Values = Record<string, number | boolean | string>
|
|
export type Catalog = Map<string, Sensor>
|
|
|
|
// Everything the modules draw, as one stream query.
|
|
export const MONITOR_SHAPE = ['cpu.*', 'load.*', 'uptime', 'hamlab.*', 'mem.*', 'swap.*', 'temp.*', 'fan.*', 'net.*', 'disk.*', 'fs.*', 'ups.*']
|
|
// The stream answers a list with a list; the modules want one flat map.
|
|
export function mergeValues(parts: unknown[]): Values {
|
|
const out: Values = {}
|
|
parts.forEach((part, i) => {
|
|
if (part && typeof part === 'object') Object.assign(out, part)
|
|
else if (part !== null && part !== undefined) out[MONITOR_SHAPE[i]] = part as Values[string]
|
|
})
|
|
return out
|
|
}
|
|
// The curves they keep: CPU, memory, per-NIC and per-disk rates, every temperature.
|
|
|
|
const num = (v: Values, id: string) => (typeof v[id] === 'number' ? (v[id] as number) : 0)
|
|
const str = (v: Values, id: string) => (typeof v[id] === 'string' ? (v[id] as string) : '')
|
|
|
|
// Groups ids like net.<x>.rx by the real name in the catalog's labels, keeping catalog order.
|
|
function groups(v: Values, cat: Catalog, prefix: string, label: string): Map<string, string> {
|
|
const out = new Map<string, string>() // real name → id stem ("net.enp3s0")
|
|
for (const id of Object.keys(v)) {
|
|
if (!id.startsWith(prefix)) continue
|
|
const real = cat.get(id)?.labels?.[label]
|
|
if (real && !out.has(real)) out.set(real, id.slice(0, id.lastIndexOf('.')))
|
|
}
|
|
return new Map([...out].sort((a, b) => a[0].localeCompare(b[0]))) // by real name: "/" leads the filesystems
|
|
}
|
|
|
|
// Every id in the values must be known to the catalog, or the catalog is stale (a disk
|
|
// or interface appeared) and wants refetching.
|
|
export const stale = (v: Values, cat: Catalog) => Object.keys(v).some((id) => !cat.has(id))
|
|
|
|
export function sampleOf(v: Values, cat: Catalog): Sample {
|
|
const cores = Object.keys(v).map((id) => /^cpu\.core\.(\d+)\.usage$/.exec(id)).filter(Boolean).map((m) => [Number(m![1]), v[m![0]] as number] as const).sort((a, b) => a[0] - b[0]).map((x) => x[1])
|
|
const mem = (p: string) => ({ total: num(v, p + '.total'), used: num(v, p + '.used'), avail: num(v, p + '.avail'), free: num(v, p + '.free'), cached: num(v, p + '.cached'), buffers: num(v, p + '.buffers') })
|
|
const hw = (prefix: string) => Object.keys(v).filter((id) => id.startsWith(prefix) && cat.get(id)?.labels?.chip !== undefined).map((id) => ({ id, s: cat.get(id)! }))
|
|
.sort((a, b) => a.s.labels!.chip.localeCompare(b.s.labels!.chip) || a.s.labels!.label.localeCompare(b.s.labels!.label))
|
|
return {
|
|
t: Date.now(), interval_ms: num(v, 'hamlab.sample_interval'),
|
|
cpu: num(v, 'cpu.usage'), cores, load: [num(v, 'load.1'), num(v, 'load.5'), num(v, 'load.15')],
|
|
mem: mem('mem'), swap: mem('swap'), uptime: num(v, 'uptime'),
|
|
temps: hw('temp.').map(({ id, s }) => ({ chip: s.labels!.chip, label: s.labels!.label, c: num(v, id), max: s.warn, crit: s.crit })),
|
|
fans: hw('fan.').map(({ id, s }) => ({ chip: s.labels!.chip, label: s.labels!.label, rpm: num(v, id) })),
|
|
net: [...groups(v, cat, 'net.', 'iface')].map(([iface, p]) => ({ iface, up: v[p + '.up'] === true, rx_bps: num(v, p + '.rx'), tx_bps: num(v, p + '.tx'), rx_total: num(v, p + '.rx_total'), tx_total: num(v, p + '.tx_total') })),
|
|
disks: [...groups(v, cat, 'disk.', 'device')].map(([name, p]) => ({ name, model: cat.get(p + '.size')?.labels?.model || undefined, size: num(v, p + '.size'), read_bps: num(v, p + '.read'), write_bps: num(v, p + '.write'), util_pct: num(v, p + '.util'), temp: num(v, p + '.temp') || undefined })),
|
|
fs: [...groups(v, cat, 'fs.', 'mount')].map(([mount, p]) => ({ mount, type: cat.get(p + '.size')?.labels?.fstype ?? '', size: num(v, p + '.size'), used: num(v, p + '.used'), remote: cat.get(p + '.size')?.labels?.remote === '1', disk: cat.get(p + '.size')?.labels?.disk })),
|
|
ups: v['ups.battery'] === undefined ? null : {
|
|
driver: cat.get('ups.last_event')?.labels?.driver ?? '', model: cat.get('ups.battery')?.labels?.model ?? '', state: str(v, 'ups.state'), source: str(v, 'ups.source'),
|
|
on_battery: v['ups.on_battery'] === true, in_v: num(v, 'ups.in_v'), out_v: num(v, 'ups.out_v'), battery_pct: num(v, 'ups.battery'), runtime_min: num(v, 'ups.runtime'),
|
|
load_w: num(v, 'ups.load'), load_pct: num(v, 'ups.load_pct'), last_event: str(v, 'ups.last_event') || undefined,
|
|
},
|
|
}
|
|
}
|
|
|
|
// The modules' history: one shared time axis (the CPU's), every other curve right-aligned
|
|
// to it and zero-padded on the left where the sensor is younger than the ring.
|