605 lines
20 KiB
TypeScript
605 lines
20 KiB
TypeScript
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>
|
||
)}
|
||
</>
|
||
);
|
||
}
|