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

710 lines
27 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 {
ApiError,
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 { devicePlatform } from './script-catalog';
import { DeviceInventoryPanels, systemDetails } from './device-inventory';
import { DeviceCustomerTransfer } from './device-customer-transfer';
import { HypervisorAssignment, HypervisorLabel } from './device-hypervisor';
import { ErrorBox, errorText, useResource } from './resource';
import { NavIcon, orderDetailRoute } from './navigation';
import { orderTitle, Status } from './order-presentation';
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 cpuUsage(value: unknown) {
return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100
? `${number.format(value)} %`
: unknown;
}
function measuredAt(value: unknown) {
const observed = time(value);
return observed === unknown ? undefined : `Gemessen am ${observed}`;
}
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 Capacity({ free, total }: { free: unknown; total: unknown }) {
return (
<>
<span>{capacity(free, total)}</span>
{typeof free === 'number' &&
typeof total === 'number' &&
Number.isFinite(total) &&
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, jobId: string) => void;
};
function devicePath(customer: string, asset: string) {
return tenantPath(customer, '/devices/' + encodeURIComponent(asset));
}
function reportedScriptProfiles(device: RecordValue) {
const os = devicePlatform(device);
if (!os || !Array.isArray(device.capabilities)) return 'Nicht gemeldet';
const caps = new Set(device.capabilities);
if (!caps.has('run_script')) return 'Nicht gemeldet';
const windows = os === 'windows';
const identity = windows ? 'system' : 'root';
const service = windows ? 'PowerShell als Dienstkonto' : 'Shell als Dienstkonto';
if (!caps.has(os + '.base/1') || caps.has(windows ? 'linux.base/1' : 'windows.base/1')) return 'Nicht gemeldet';
if (windows && !['rmm.sync.v1', 'script.powershell/1', 'script.powershell.process_remote_signed/1'].every(cap => caps.has(cap)))
return 'Nicht gemeldet';
const admin = ['rmm.sync.v1', 'script.full_maintenance/1', 'helper.' + identity + '.v1', identity + ':run_script']
.every(capability => caps.has(capability));
return admin ? service + ' und als Administrator (' + (windows ? 'SYSTEM' : 'root') + ')' : service;
}
function DeviceDetail({
customer,
asset,
agent,
auth,
customers,
back,
openOperation,
changed
}: {
customer: string;
asset: string;
agent: string;
auth: Session;
customers: Tenant[];
back: () => void;
openOperation: (id: string, jobId: string) => void;
changed: (notice?: string) => 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 [confirmDelete, setConfirmDelete] = useState(false);
const [managing, setManaging] = useState(false);
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)],
['Type', label(d.device_type)],
['Betriebssystem', label(d.os)],
...systemDetails(d, time),
['RAM frei / gesamt', capacity(d.ram_available_bytes, d.ram_total_bytes)],
['CPU', [cpu(d).primary, cpu(d).secondary].filter(Boolean).join(' · ')],
['CPU-Auslastung', [cpuUsage(d.cpu_usage_percent), measuredAt(d.cpu_usage_observed_at)].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)],
['Vom Agenten gemeldete Skriptausführung', reportedScriptProfiles(d)]
];
return (
<div className="device-detail">
<button className="quiet" onClick={back}>
<NavIcon name="zurueck" /> Zur Geräteliste
</button>
<ErrorBox error={detail.error ?? membership.error} />
{!d && !detail.error && <p>Inventar wird geladen …</p>}
{d && (
<>
<div className="page-title">
<div>
<h1>{label(d.hostname)}</h1>
<Presence d={d} />
<HypervisorLabel device={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>
<DeviceInventoryPanels device={d} />
{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((job) => {
const id = objectId(job, 'operation'), jobId = objectId(job, 'job');
const title = orderTitle(job);
return <li className="job-row" key={jobId}>
<div className="device-job-name"><strong>{title}</strong><small>{time(job.created_at)}</small></div>
<Status value={job.state}/>
<a className="quiet" href={'#auftraege/' + orderDetailRoute(customer, id, jobId)}
aria-label={'Ergebnis öffnen · ' + title + ' · ' + time(job.created_at)}
onClick={event => {
if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
event.preventDefault();
openOperation(id, jobId);
}}>Ergebnis öffnen</a>
</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') &&
d.tenant_id === customer && d.asset_id === asset && d.agent_id === agent && (
<details open={managing} onToggle={e => setManaging(e.currentTarget.open)}>
<summary>Gerät verwalten</summary>
<ErrorBox error={error} />
{d.device_type === 'virtual' && d.lifecycle === 'current' &&
<HypervisorAssignment device={d} customer={customer} asset={asset} agent={agent} auth={scoped} />}
<DeviceCustomerTransfer auth={scoped} customer={customer} asset={asset} agent={agent}
customers={customers} active={d.lifecycle === 'current'}
supported={Array.isArray(d.capabilities) && d.capabilities.includes('device.customer_transfer/1')} />
{['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 !== 'revoked' && (
<AdminControl
auth={scoped}
path={path + '/revocation?agent_id=' + encodeURIComponent(agent)}
permission="devices:revoke"
title="Geräteidentität widerrufen"
warning="Der Widerruf unterbricht die Geräteverwaltung und sperrt neue Starts. Danach können Sie diese Kopplung endgültig löschen. Eine Wiederaufnahme erfordert eine neue Registrierung."
done={detail.reload}
/>
)}
{d.lifecycle === 'revoked' && (confirmDelete ? (
<div>
<p className="warning">
Die Kopplung von <strong>{label(d.hostname)}</strong> bei <strong>{label(d.customer_name)}</strong>
{' '}wird mit ihrem Inventar und ihren Geräteergebnissen dauerhaft gelöscht.
Andere Installationen bleiben erhalten.
</p>
<p>Kopplungs-ID <code>{agent}</code></p>
<button className="danger" disabled={busy} onClick={async () => {
setBusy(true);
setError(null);
try {
await request(path + '?agent_id=' + encodeURIComponent(agent), {
method: 'DELETE', csrf: scoped.csrf_token, tenantId: customer
});
changed(`Kopplung von „${label(d.hostname)}“ bei „${label(d.customer_name)}“ gelöscht.`);
} catch (e) {
if (e instanceof ApiError && e.code === 'DEVICE_HAS_OPEN_WORK') {
setError('Für diese Kopplung gibt es offene Aufträge oder Genehmigungen. Prüfen Sie diese vor dem Löschen.');
} else if (e instanceof ApiError && e.code === 'DEVICE_REVOCATION_REQUIRED') {
setError('Widerrufen Sie diese Geräteidentität vor dem Löschen.');
} else {
setError(errorText(e));
}
} finally {
setBusy(false);
}
}}>Endgültig löschen</button>
<button className="quiet" disabled={busy} onClick={() => {
setConfirmDelete(false);
setError(null);
}}>Abbrechen</button>
</div>
) : (
<button className="danger" onClick={() => setConfirmDelete(true)}>Kopplung löschen</button>
))}
</details>
)}
</section>
{scoped?.principal.simulated &&
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 [deletionNotice, setDeletionNotice] = useState('');
const [trail, setTrail] = useState<{ filter: string; routes: string[] }>({ filter, routes: [] });
const routes = trail.filter === filter ? trail.routes : [];
function setRoutes(next: string[] | ((old: string[]) => string[])) {
setTrail(old => ({ filter, routes: typeof next === 'function' ? next(old.filter === filter ? old.routes : []) : next }));
}
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]);
useEffect(() => setTrail({ filter, routes: [] }), [filter]);
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={detailPath}
{...target}
auth={auth}
customers={customers}
back={back}
openOperation={(id, jobId) => onOperation(target.customer, id, jobId)}
changed={(notice) => {
setDeletionNotice(notice ?? '');
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>
{deletionNotice && <p role="status">{deletionNotice}</p>}
<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 im Gerätebestand</span>
<select
aria-label="Kunde im Gerätebestand"
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', 'Type', 'OS', 'Status', 'Speicher frei / gesamt', 'RAM frei / gesamt', '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 = () => {
setDeletionNotice('');
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>
<HypervisorLabel device={d} />
</td>
<td data-label="Type">{label(d.device_type)}</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="capacity-cell">
<Capacity free={d.disk_free_bytes} total={d.disk_total_bytes} />
</td>
<td data-label="RAM frei / gesamt" className="capacity-cell" title={measuredAt(d.ram_observed_at)}>
<Capacity free={d.ram_available_bytes} total={d.ram_total_bytes} />
</td>
<td data-label="CPU">
{model.primary}
{model.secondary && <small>{model.secondary}</small>}
<small title={measuredAt(d.cpu_usage_observed_at)}>
Auslastung {cpuUsage(d.cpu_usage_percent)}
</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') || !allowed(auth, 'scripts:execute')} onClick={onCreateOrder}>Auftrag erstellen</button>
</div>
)}
</>
);
}