Files
rust-discovery/web/src/devices.tsx
T

605 lines
20 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { useEffect, useState } from 'react';
import {
objectId,
page,
pretty,
record,
request,
session,
tenantPath,
type RecordValue,
type Session,
type Tenant
} from './api';
import { AdminControl } from './management';
import { allowed } from './safety';
import { CatalogCheckNotice } from './catalog-check';
import { ErrorBox, errorText, useResource } from './resource';
import { NavIcon } from './navigation';
import { RecoveryReview, recoveryAsset, recoveryTenant } from './recovery-review';
import { EchoProbeReview } from './echo-probe-review';
import { EchoCompletionReview } from './echo-completion-review';
import { SyncAlignmentReview } from './sync-alignment-review';
import { SystemNonstartReview } from './system-nonstart-review';
const unknown = 'Nicht gemeldet';
const number = new Intl.NumberFormat('de-DE', { maximumFractionDigits: 1 });
const date = new Intl.DateTimeFormat('de-DE', { dateStyle: 'medium', timeStyle: 'short' });
function label(value: unknown) {
return typeof value === 'string' && value.trim() ? value : unknown;
}
function time(value: unknown) {
const t = typeof value === 'string' ? Date.parse(value) : NaN;
return Number.isFinite(t) ? date.format(t) : unknown;
}
function gib(v: unknown) {
return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? number.format(v / 2 ** 30) : null;
}
function capacity(free: unknown, total: unknown) {
const f = gib(free),
t = gib(total);
return f === null && t === null ? unknown : `${f ?? '–'} / ${t ?? '–'} GiB`;
}
function cpu(d: RecordValue) {
const model = label(d.cpu_model),
count = d.cpu_logical_count;
const threads =
typeof count === 'number' && count > 0 ? `${count} log. CPU${count === 1 ? '' : 's'}` : '';
return {
primary: model === unknown ? threads || unknown : model,
secondary: model === unknown ? '' : threads
};
}
const states: Record<string, string> = {
online: 'Online',
offline: 'Offline',
never_seen: 'Ohne Erstkontakt',
revoked: 'Widerrufen',
archived: 'Archiviert',
replaced: 'Ersetzt',
unverified: 'Identität unbestätigt'
};
function Presence({ d }: { d: RecordValue }) {
const state =
typeof d.lifecycle === 'string' && d.lifecycle !== 'current' ? d.lifecycle : String(d.status);
return (
<span
className={
'presence ' + (state === 'online' ? 'online' : state === 'offline' ? 'offline' : 'historic')
}
>
<i />
{states[state] ?? 'Unbekannt'}
</span>
);
}
function Storage({ d }: { d: RecordValue }) {
const free = d.disk_free_bytes,
total = d.disk_total_bytes;
return (
<>
<span>{capacity(free, total)}</span>
{typeof free === 'number' &&
typeof total === 'number' &&
free >= 0 &&
free <= total &&
total > 0 && (
<span
className="capacity-track"
title={`${number.format((100 * free) / total)} % frei`}
aria-hidden="true"
>
<i style={{ width: `${(100 * (total - free)) / total}%` }} />
</span>
)}
</>
);
}
type Target = { customer: string; ids: string[] };
type Props = {
detailPath: string;
auth: Session;
customers: Tenant[];
filter: string;
onFilter: (id: string) => void;
selection: Target;
onSelection: (s: Target) => void;
onCreateOrder: () => void;
onEnroll: () => void;
onOperation: (customer: string, id: string) => void;
};
function devicePath(customer: string, asset: string) {
return tenantPath(customer, '/devices/' + encodeURIComponent(asset));
}
function DeviceDetail({
customer,
asset,
agent,
auth,
back,
openOperation,
changed
}: {
customer: string;
asset: string;
agent: string;
auth: Session;
back: () => void;
openOperation: (id: string) => void;
changed: () => void;
}) {
const path = devicePath(customer, asset);
const detail = useResource(
async (signal) => record(await request(path + '?agent_id=' + encodeURIComponent(agent), { signal })),
[customer, asset, agent],
true
);
const membership = useResource(
async (signal) => session(await request('/auth/session', { signal, tenantId: customer })),
[customer, auth.principal.id]
);
const [busy, setBusy] = useState(false),
[error, setError] = useState<string | null>(null);
const d = detail.data;
const scoped = membership.data;
const volumes = Array.isArray(d?.volumes) ? d.volumes.map((v) => record(v)) : [];
const jobs = Array.isArray(d?.recent_jobs) ? d.recent_jobs.map((v) => record(v)) : null;
const facts = d && [
['Kunde', label(d.customer_name)],
['Betriebssystem', label(d.os)],
['RAM', gib(d.ram_total_bytes) === null ? unknown : gib(d.ram_total_bytes) + ' GiB'],
['CPU', [cpu(d).primary, cpu(d).secondary].filter(Boolean).join(' · ')],
['Speicher frei / gesamt', capacity(d.disk_free_bytes, d.disk_total_bytes)],
['Letzter Kontakt', time(d.last_contact_at)],
['Inventar erhoben', time(d.observed_at)],
['Agentversion', label(d.agent_version)]
];
return (
<div className="device-detail">
<button className="quiet" onClick={back}>
<NavIcon name="zurueck" /> Zur Geräteliste
</button>
<ErrorBox error={detail.error ?? membership.error ?? error} />
{!d && !detail.error && <p>Inventar wird geladen …</p>}
{d && (
<>
<div className="page-title">
<div>
<h1>{label(d.hostname)}</h1>
<Presence d={d} />
</div>
</div>
<section>
<h2>Geräteinformationen</h2>
<dl className="facts">
{facts?.map(([k, v]) => (
<div key={k}>
<dt>{k}</dt>
<dd>{v}</dd>
</div>
))}
</dl>
</section>
{volumes.length > 0 && (
<section>
<h2>Laufwerke</h2>
<div className="table">
<table>
<thead>
<tr>
<th>Laufwerk</th>
<th>Speicher frei / gesamt</th>
</tr>
</thead>
<tbody>
{volumes.map((v, i) => (
<tr key={i}>
<td>{label(v.name)}</td>
<td>{capacity(v.free_bytes, v.total_bytes)}</td>
</tr>
))}
</tbody>
</table>
</div>
</section>
)}
{jobs && (
<section>
<h2>Letzte Aufträge</h2>
{jobs.length === 0 ? (
<p className="muted">Keine Aufträge für dieses Gerät.</p>
) : (
<ul className="job-list">
{jobs.map((j) => (
<li key={objectId(j, 'job')}>
<button className="link" onClick={() => openOperation(objectId(j, 'operation'))}>
Auftrag vom {time(j.created_at)}
</button>
<span>{label(j.state)}</span>
</li>
))}
</ul>
)}
</section>
)}
<section>
<details>
<summary>Technische Daten</summary>
<CatalogCheckNotice device={d} />
<pre aria-label="Vollständiges Geräteinventar">{pretty(d)}</pre>
</details>
{scoped && allowed(scoped, 'devices:revoke') && (
<details>
<summary>Gerät verwalten</summary>
{['archived', 'current'].includes(String(d.lifecycle)) && (
<button
disabled={busy}
onClick={async () => {
setBusy(true);
setError(null);
try {
await request(path + '/archive', {
csrf: scoped.csrf_token,
body: { archived: d.lifecycle !== 'archived' }
});
changed();
} catch (e) {
setError(errorText(e));
} finally {
setBusy(false);
}
}}
>
{d.lifecycle === 'archived'
? 'Zurück in den Bestand'
: 'In die Historie verschieben'}
</button>
)}
{d.lifecycle === 'current' && (
<AdminControl
auth={scoped}
path={path + '/revocation'}
permission="devices:revoke"
title="Geräteidentität widerrufen"
warning="Der Widerruf unterbricht die Geräteverwaltung und sperrt neue Starts. Die Wiederaufnahme erfordert eine neue Registrierung."
done={changed}
/>
)}
</details>
)}
</section>
{scoped &&
customer === recoveryTenant &&
asset === recoveryAsset &&
allowed(scoped, 'inventory:read') && (
<details>
<summary>Entwicklungsabnahmen</summary>
<SystemNonstartReview auth={scoped} />
<SyncAlignmentReview auth={scoped} />
<EchoProbeReview auth={scoped} />
<EchoCompletionReview auth={scoped} />
<RecoveryReview auth={scoped} />
</details>
)}
</>
)}
</div>
);
}
export function Devices({
detailPath,
auth,
customers,
filter,
onFilter,
selection,
onSelection,
onEnroll,
onCreateOrder,
onOperation
}: Props) {
const [search, setSearch] = useState(''),
[query, setQuery] = useState(''),
[status, setStatus] = useState(''),
[history, setHistory] = useState(false);
const [routes, setRoutes] = useState<string[]>([]);
const [customerId, assetId, agentId] = detailPath.split('/');
const target =
customerId && assetId && agentId ? { customer: customerId, asset: assetId, agent: agentId } : null;
const back = () => {
window.location.hash = 'geraete';
};
const cursor = routes[routes.length - 1];
useEffect(() => {
const timer = setTimeout(() => {
setQuery(search.trim());
setRoutes([]);
}, 200);
return () => clearTimeout(timer);
}, [search]);
const list = useResource(
async (signal) => {
if (target) return null;
const params = new URLSearchParams({ view: history ? 'history' : 'current', limit: '40' });
if (query) params.set('q', query);
if (status && !history) params.set('status', status);
if (cursor) params.set('cursor', cursor);
const path = filter ? tenantPath(filter, '/devices') : '/api/v1/devices';
return page(await request(path + '?' + params, { signal }));
},
[filter, query, history, status, cursor, detailPath],
true
);
function setView(historic: boolean) {
setRoutes([]);
setHistory(historic);
onSelection({ customer: '', ids: [] });
}
function select(d: RecordValue, checked: boolean) {
const asset = objectId(d, 'asset'),
customer = objectId(d, 'tenant');
if (checked && selection.ids.length && customer !== selection.customer) return;
const ids = checked ? [...selection.ids, asset] : selection.ids.filter((id) => id !== asset);
onSelection({ customer: ids.length ? customer : '', ids });
}
if (target)
return (
<DeviceDetail
key={target.agent}
{...target}
auth={auth}
back={back}
openOperation={(id) => onOperation(target.customer, id)}
changed={() => {
back();
setRoutes([]);
onSelection({ customer: '', ids: [] });
list.reload();
}}
/>
);
return (
<>
<div className="page-title">
<div>
<h1>Geräte</h1>
</div>
{allowed(auth, 'devices:enroll') && (
<button className="primary" onClick={onEnroll}>
<NavIcon name="plus" /> Gerät aufnehmen
</button>
)}
</div>
<section className="fleet" aria-label="Gerätebestand">
<div className="fleet-tabs">
<button
aria-pressed={!history}
onClick={() => {
if (history) setView(false);
}}
>
Bestand
</button>
<button
aria-pressed={history}
onClick={() => {
if (!history) setView(true);
}}
>
Historie
</button>
</div>
<div className="filters">
<label className="search-box">
<span className="sr-only">Hostname suchen</span>
<NavIcon name="suchen" />
<input
type="search"
placeholder="Hostname suchen …"
maxLength={120}
value={search}
onChange={(e) => setSearch(e.target.value)}
/>
</label>
<label>
<span>Kunde</span>
<select
aria-label="Kunde"
value={filter}
onChange={(e) => {
setRoutes([]);
onFilter(e.target.value);
}}
>
<option value="">Alle Kunden</option>
{customers.map((c) => (
<option value={c.tenant_id} key={c.tenant_id}>
{c.name}
</option>
))}
</select>
</label>
{!history && (
<label>
<span>Status</span>
<select
aria-label="Status"
value={status}
onChange={(e) => {
setRoutes([]);
setStatus(e.target.value);
}}
>
<option value="">Jeder Status</option>
<option value="online">Online</option>
<option value="offline">Offline</option>
</select>
</label>
)}
</div>
<ErrorBox error={list.error} />
{history && (
<p className="history-hint">
Ausgemusterte Geräte und Registrierungen ohne bestätigte Identität.
</p>
)}
{!list.data && !list.error && <p className="list-message">Geräte werden geladen …</p>}
{list.data && (
<>
<div className="table fleet-table">
<table>
<thead>
<tr>
{!history && (
<th className="target-col">
<span className="sr-only">Ziel auswählen</span>
</th>
)}
{['Hostname', 'OS', 'Status', 'Speicher frei / gesamt', 'RAM', 'CPU', 'Kunde'].map(
(h) => (
<th scope="col" key={h}>
{h}
</th>
)
)}
</tr>
</thead>
<tbody>
{list.data.items.map((d) => {
const asset = objectId(d, 'asset'),
agent = objectId(d, 'agent'),
customer = objectId(d, 'tenant'),
model = cpu(d);
const show = () => {
window.location.hash = ['geraete', customer, asset, agent]
.map(encodeURIComponent)
.join('/');
};
const another = selection.ids.length > 0 && selection.customer !== customer;
return (
<tr key={agent} onClick={show}>
{!history && (
<td className="target-col" onClick={(e) => e.stopPropagation()}>
<input
type="checkbox"
aria-label={'Ziel ' + asset}
title={
another ? 'Aufträge werden je Kunde geplant' : 'Für Auftrag auswählen'
}
disabled={another}
checked={selection.customer === customer && selection.ids.includes(asset)}
onChange={(e) => select(d, e.target.checked)}
/>
</td>
)}
<td className="hostname">
<button
className="host-link"
onClick={(e) => {
e.stopPropagation();
show();
}}
>
{label(d.hostname)}
</button>
</td>
<td data-label="OS">{label(d.os)}</td>
<td data-label="Status" className="device-presence">
<Presence d={d} />
{d.status === 'offline' && d.lifecycle === 'current' && (
<small>Zuletzt {time(d.last_contact_at)}</small>
)}
</td>
<td data-label="Speicher frei / gesamt" className="storage">
<Storage d={d} />
</td>
<td data-label="RAM">
{gib(d.ram_total_bytes) === null ? unknown : gib(d.ram_total_bytes) + ' GiB'}
</td>
<td data-label="CPU">
{model.primary}
{model.secondary && <small>{model.secondary}</small>}
</td>
<td data-label="Kunde">{label(d.customer_name)}</td>
</tr>
);
})}
</tbody>
</table>
</div>
{!list.data.items.length && (
<div className="empty-list">
<NavIcon name="geraete" />
<h3>
{query || filter || status
? 'Keine passenden Geräte'
: 'Keine Geräte in dieser Ansicht'}
</h3>
{(query || filter || status) && (
<button
className="quiet"
onClick={() => {
setSearch('');
setQuery('');
setRoutes([]);
setStatus('');
onFilter('');
}}
>
Filter zurücksetzen
</button>
)}
</div>
)}
<div className="list-footer">
<span>
{list.data.items.length} {list.data.items.length === 1 ? 'Gerät' : 'Geräte'}
{cursor || list.data.next_cursor ? ' auf dieser Seite' : ''} · Stand{' '}
{time(list.data.as_of)}
</span>
{(cursor || list.data.next_cursor) && (
<div>
<button
className="quiet"
disabled={!cursor}
onClick={() => setRoutes((old) => old.slice(0, -1))}
>
Zurück
</button>
<button
className="quiet"
disabled={!list.data.next_cursor}
onClick={() => {
const next = list.data?.next_cursor;
if (next) setRoutes((old) => [...old, next]);
}}
>
Weiter
</button>
</div>
)}
</div>
</>
)}
</section>
{!!selection.ids.length && (
<div className="selection">
<div>
<strong>
{selection.ids.length} {selection.ids.length === 1 ? 'Gerät' : 'Geräte'} ausgewählt
</strong>
<small>{customers.find((c) => c.tenant_id === selection.customer)?.name}</small>
</div>
<button className="quiet" onClick={() => onSelection({ customer: '', ids: [] })}>
Auswahl aufheben
</button>
<button disabled={!allowed(auth, 'operations:plan')} onClick={onCreateOrder}>Auftrag erstellen</button>
</div>
)}
</>
);
}