Public changes compared with the previous published export: 89 files changed. Affected areas: - backend/app: 21 files - dependencies: 5 files - deployment and CI: 6 files - documentation: 2 files - frontend: 3 files - frontend/src: 20 files - project files: 1 file - tests: 30 files - unraid: 1 file Changed files: - Updated: ".env.example" - Updated: "Dockerfile.unraid" - Updated: "README.md" - Updated: "backend/Dockerfile" - Added: "backend/app/alerts.py" - Updated: "backend/app/auth.py" - Added: "backend/app/backups.py" - Updated: "backend/app/config_io.py" - Updated: "backend/app/demo.py" - Updated: "backend/app/discovery.py" - Updated: "backend/app/discovery_store.py" - Updated: "backend/app/docker_discovery.py" - Updated: "backend/app/events.py" - Updated: "backend/app/evidence.py" - Updated: "backend/app/health.py" - Updated: "backend/app/incidents.py" - Added: "backend/app/loops.py" - Updated: "backend/app/main.py" - Updated: "backend/app/models.py" - Updated: "backend/app/observation.py" - Updated: "backend/app/probes.py" - Added: "backend/app/response_cache.py" - Updated: "backend/app/scheduler.py" - Updated: "backend/app/semantic.py" - Updated: "backend/app/store.py" - Updated: "backend/pyproject.toml" - Updated: "backend/tests/test_api.py" - Updated: "backend/tests/test_config_io.py" - Updated: "backend/tests/test_demo.py" - Updated: "backend/tests/test_discovery_v120.py" - Updated: "backend/tests/test_health.py" - Updated: "backend/tests/test_probes.py" - Updated: "backend/tests/test_scheduler.py" - Updated: "backend/tests/test_v130_probe_reachability.py" - Updated: "backend/tests/test_v160_evidence_changes.py" - Added: "backend/tests/test_v163_alerts.py" - Added: "backend/tests/test_v163_backups.py" - Added: "backend/tests/test_v163_data_integrity.py" - Added: "backend/tests/test_v163_efficiency.py" - Added: "backend/tests/test_v163_health_performance.py" - Added: "backend/tests/test_v163_loops.py" - Added: "backend/tests/test_v163_management.py" - Added: "backend/tests/test_v163_realtime.py" - Added: "backend/tests/test_v163_security.py" - Added: "backend/tests/test_v163_semantic_etag.py" - Added: "compose.demo.yaml" - Updated: "compose.yaml" - Added: "docker-compose.broker.yml" - Updated: "docker-compose.yml" - Updated: "docs/ARCHITECTURE.md" - Added: "frontend/e2e/a11y.spec.ts" - Updated: "frontend/e2e/demo.spec.ts" - Updated: "frontend/index.html" - Updated: "frontend/nginx.conf" - Updated: "frontend/package-lock.json" - Updated: "frontend/package.json" - Updated: "frontend/playwright.config.ts" - Updated: "frontend/src/App.tsx" - Updated: "frontend/src/LivingEdge.tsx" - Added: "frontend/src/activityView.test.ts" - Added: "frontend/src/activityView.ts" - Updated: "frontend/src/api.ts" - Added: "frontend/src/apiAuth.test.ts" - Added: "frontend/src/components/ActionsMenu.tsx" - Added: "frontend/src/components/ConfirmDialog.test.tsx" - Added: "frontend/src/components/ConfirmDialog.tsx" - Added: "frontend/src/components/StatusIcon.tsx" - Updated: "frontend/src/demo/DemoWalkthrough.test.ts" - Updated: "frontend/src/demo/DemoWalkthrough.tsx" - Added: "frontend/src/elk-worker-url.d.ts" - Added: "frontend/src/labels.ts" - Updated: "frontend/src/main.tsx" - Added: "frontend/src/realtime/refreshPlan.test.ts" - Added: "frontend/src/realtime/refreshPlan.ts" - Updated: "frontend/src/realtime/useRealtimeEvents.ts" - Added: "frontend/src/routing/urlState.test.ts" - Added: "frontend/src/routing/urlState.ts" - Updated: "frontend/src/styles.css" - Added: "frontend/src/topology/GraphListView.test.tsx" - Added: "frontend/src/topology/GraphListView.tsx" - Updated: "frontend/src/topology/ServiceNode.tsx" - Updated: "frontend/src/topology/TopologyCommandBar.tsx" - Added: "frontend/src/topology/semanticGraph.test.ts" - Updated: "frontend/src/topology/semanticGraph.ts" - Added: "frontend/src/topologyLayout.test.ts" - Updated: "frontend/src/topologyLayout.ts" - Updated: "package-lock.json" - Updated: "package.json" - Updated: "unraid/my-servicemap.xml" Export provenance/manifests refreshed; excluded from the change summary. Publish curated ServiceMap source from af46f684e468dffd3a5190e28d3b572d4c26bfd7
4989 lines
186 KiB
TypeScript
4989 lines
186 KiB
TypeScript
import {
|
||
FormEvent,
|
||
type KeyboardEvent as ReactKeyboardEvent,
|
||
useCallback,
|
||
useEffect,
|
||
useMemo,
|
||
useRef,
|
||
useState,
|
||
} from "react";
|
||
import {
|
||
Background,
|
||
Controls,
|
||
MarkerType,
|
||
MiniMap,
|
||
ReactFlow,
|
||
type Connection,
|
||
type Edge,
|
||
type Node,
|
||
type NodeChange,
|
||
type ReactFlowInstance,
|
||
} from "@xyflow/react";
|
||
import "@xyflow/react/dist/style.css";
|
||
|
||
import {
|
||
api,
|
||
ApiError,
|
||
AUTH_REQUIRED_EVENT,
|
||
downloadBackupFile,
|
||
type BackupInfo,
|
||
hasApiAccessToken,
|
||
type AlertSettings,
|
||
setApiAccessToken,
|
||
type AvailabilitySummary,
|
||
type ComponentRole,
|
||
type Criticality,
|
||
type DiscoveryResult,
|
||
type DiscoveryRun,
|
||
type DiscoveryStatus,
|
||
type DiscoveryObservation,
|
||
type RelationEvidence,
|
||
type ProbeRepairReport,
|
||
type TopologySuggestion,
|
||
type TopologyDiff,
|
||
type TopologySnapshot,
|
||
type ProviderStatus,
|
||
type DemoState,
|
||
type DockerCandidate,
|
||
type EventRecord,
|
||
type HealthStatus,
|
||
type IncidentDetail,
|
||
type IncidentOverview,
|
||
type IncidentRecord,
|
||
type MonitoringState,
|
||
type ServiceInput,
|
||
type ServiceKind,
|
||
type ServiceSnapshot,
|
||
type SemanticTopology,
|
||
} from "./api";
|
||
import { LivingEdge } from "./LivingEdge";
|
||
import { DemoWalkthrough } from "./demo/DemoWalkthrough";
|
||
import { ServiceNodeView, type ServiceNode, type ServiceNodeData } from "./topology/ServiceNode";
|
||
import {
|
||
applicationEdges,
|
||
applicationName,
|
||
applicationTopologyLayout,
|
||
topologyLayout,
|
||
type LegacyTopologyMode,
|
||
} from "./topology/legacyLayout";
|
||
export {
|
||
applicationEdges,
|
||
applicationTopologyLayout,
|
||
landscapeGroups,
|
||
topologyLayout,
|
||
} from "./topology/legacyLayout";
|
||
import {
|
||
matchesStatusFilter,
|
||
semanticTopologyGraph,
|
||
type SemanticView,
|
||
} from "./topology/semanticGraph";
|
||
import { TopologyCommandBar } from "./topology/TopologyCommandBar";
|
||
import { GraphListView, nodeAriaLabel } from "./topology/GraphListView";
|
||
import { ConfirmDialog } from "./components/ConfirmDialog";
|
||
import { StatusIcon } from "./components/StatusIcon";
|
||
import { PANEL_LABELS, criticalityText, formatDateTime, formatNumber, formatTime, modeText, providerHealthText, providerText, statusText } from "./labels";
|
||
import { eventMeta, groupActivity, timeOf } from "./activityView";
|
||
import { ActionsMenu } from "./components/ActionsMenu";
|
||
import {
|
||
Activity,
|
||
Circle,
|
||
CircleCheck,
|
||
Download,
|
||
Eye,
|
||
FileCode,
|
||
FlaskConical,
|
||
History,
|
||
LayoutDashboard,
|
||
Lock,
|
||
LockOpen,
|
||
Menu,
|
||
MessageSquare,
|
||
Network,
|
||
Plus,
|
||
Radar,
|
||
RefreshCw,
|
||
Server,
|
||
Settings,
|
||
Siren,
|
||
Wrench,
|
||
X,
|
||
Zap,
|
||
type LucideIcon,
|
||
} from "lucide-react";
|
||
import { arrangeTopology, topologyStructureKey } from "./topologyLayout";
|
||
import {
|
||
createRefreshScheduler,
|
||
type RealtimeEvent,
|
||
type RefreshScheduler,
|
||
} from "./realtime/refreshPlan";
|
||
import { useRealtimeEvents } from "./realtime/useRealtimeEvents";
|
||
import { changedFields, filterSuggestions } from "./auditViewModel";
|
||
import {
|
||
applicationLocation,
|
||
domainLocation,
|
||
isTopologyRoot,
|
||
topologyRoot,
|
||
topologyUp,
|
||
type TopologyLocation,
|
||
} from "./topologyNavigation";
|
||
import {
|
||
navigationKey,
|
||
parseUrlState,
|
||
serializeUrlState,
|
||
type Panel,
|
||
type UrlState,
|
||
} from "./routing/urlState";
|
||
|
||
type FilterStatus = "all" | "unresolved" | "problems" | HealthStatus;
|
||
type TopologyMode = LegacyTopologyMode;
|
||
type ServiceForm = Omit<ServiceInput, "tags"> & {
|
||
depends_on: string[];
|
||
tags: string;
|
||
};
|
||
type MonitoringFilter = "all" | MonitoringState;
|
||
|
||
const emptyForm = (): ServiceForm => ({
|
||
name: "",
|
||
kind: "http",
|
||
url: "",
|
||
host: "",
|
||
port: undefined,
|
||
depends_on: [],
|
||
tags: "",
|
||
group: "",
|
||
environment: "production",
|
||
application: "",
|
||
domain: "",
|
||
component_role: "unknown",
|
||
application_locked: false,
|
||
domain_locked: false,
|
||
component_role_locked: false,
|
||
criticality: "medium",
|
||
description: "",
|
||
category: "unknown",
|
||
visibility: "visible",
|
||
lifecycle: "active",
|
||
enabled: true,
|
||
monitoring_enabled: true,
|
||
interval_seconds: undefined,
|
||
timeout_seconds: undefined,
|
||
retries: undefined,
|
||
failure_threshold: 1,
|
||
recovery_threshold: 1,
|
||
availability_target: undefined,
|
||
maintenance_enabled: false,
|
||
});
|
||
|
||
const effectiveStatus = (snapshot: ServiceSnapshot): HealthStatus =>
|
||
snapshot.effective_status ?? snapshot.latest_probe?.status ?? "unknown";
|
||
const statusLabel = (status: HealthStatus) =>
|
||
status === "unknown" ? "Gezondheid onbekend" : statusText(status);
|
||
/** Spoken summary of the history strip; the dots alone are colour-only. */
|
||
function historySummary(history: { status: string }[]): string {
|
||
if (!history.length) return "Geen controlegeschiedenis";
|
||
const tally = new Map<string, number>();
|
||
for (const item of history) tally.set(item.status, (tally.get(item.status) ?? 0) + 1);
|
||
const parts = [...tally].map(([status, count]) => `${count} ${status}`).join(", ");
|
||
return `Laatste ${history.length} controles: ${parts}. Meest recent: ${history[0].status}.`;
|
||
}
|
||
|
||
/** Shown in the mobile bottom bar; the rest sits behind "More". */
|
||
const PRIMARY_PANELS: Panel[] = ["overview", "topology", "incidents", "services"];
|
||
|
||
const ACTIVITY_ICONS: Record<string, LucideIcon> = {
|
||
"incident.opened": Siren,
|
||
"incident.resolved": CircleCheck,
|
||
"incident.duplicate_resolved": CircleCheck,
|
||
"incident.acknowledged": Eye,
|
||
"incident.updated": RefreshCw,
|
||
"incident.note": MessageSquare,
|
||
"service.state_changed": Activity,
|
||
"service.runtime_observed": Server,
|
||
"service.maintenance_changed": Wrench,
|
||
"topology.changed": Network,
|
||
"flapping.detected": Activity,
|
||
};
|
||
|
||
const PANEL_ICONS: Record<Panel, LucideIcon> = {
|
||
overview: LayoutDashboard,
|
||
topology: Network,
|
||
incidents: Siren,
|
||
services: Server,
|
||
discovery: Radar,
|
||
changes: History,
|
||
activity: Activity,
|
||
config: FileCode,
|
||
settings: Settings,
|
||
};
|
||
|
||
const formatDate = (value: string | null | undefined) =>
|
||
value ? formatDateTime(value) : "—";
|
||
const monitoringLabel = (state: MonitoringState) =>
|
||
({
|
||
active_probe: "Actieve controle",
|
||
docker_health: "Docker-gezondheid",
|
||
appops_observation: "Waargenomen via AppOps",
|
||
observed: "Runtime waargenomen",
|
||
unmonitored: "Niet bewaakt",
|
||
disabled: "Bewaking uitgeschakeld",
|
||
})[state];
|
||
const hasCurrentNetworkProbe = (snapshot: ServiceSnapshot) =>
|
||
snapshot.service.monitoring_state === "active_probe";
|
||
|
||
const nodeTypes = { service: ServiceNodeView };
|
||
const edgeTypes = { living: LivingEdge };
|
||
|
||
function downloadText(filename: string, content: string, type: string) {
|
||
const url = URL.createObjectURL(new Blob([content], { type }));
|
||
const anchor = document.createElement("a");
|
||
anchor.href = url;
|
||
anchor.download = filename;
|
||
anchor.click();
|
||
URL.revokeObjectURL(url);
|
||
}
|
||
|
||
/** End of a maintenance window ``minutes`` from now; 0 means open-ended. */
|
||
function maintenanceEnd(minutes: number): string | null {
|
||
return minutes > 0 ? new Date(Date.now() + minutes * 60_000).toISOString() : null;
|
||
}
|
||
|
||
export default function App() {
|
||
// The URL is the source of the initial navigation and filter state, so a
|
||
// refresh, Back/Forward and shared links restore the same view.
|
||
const [initialUrl] = useState<UrlState>(() => parseUrlState(window.location.hash));
|
||
const [services, setServices] = useState<ServiceSnapshot[]>([]);
|
||
const [loading, setLoading] = useState(true);
|
||
const [lastUpdatedAt, setLastUpdatedAt] = useState<Date | null>(null);
|
||
const [selectedId, setSelectedId] = useState<string | null>(initialUrl.serviceId);
|
||
const [busyId, setBusyId] = useState<string | null>(null);
|
||
const [busyAll, setBusyAll] = useState(false);
|
||
const [error, setError] = useState<string | null>(null);
|
||
const [notice, setNotice] = useState<string | null>(null);
|
||
const [incidentSearch, setIncidentSearch] = useState("");
|
||
const [incidentStatusFilter, setIncidentStatusFilter] = useState("active");
|
||
const [suggestionSearch, setSuggestionSearch] = useState("");
|
||
const [suggestionConfidence, setSuggestionConfidence] = useState("actionable");
|
||
const [suggestionType, setSuggestionType] = useState("all");
|
||
const [suggestionLimit, setSuggestionLimit] = useState(30);
|
||
const [changeLimit, setChangeLimit] = useState(30);
|
||
const [reconcileConfirm, setReconcileConfirm] = useState(false);
|
||
const [panel, setPanel] = useState<Panel>(initialUrl.panel);
|
||
const [form, setForm] = useState<ServiceForm>(emptyForm);
|
||
const [editingId, setEditingId] = useState<string | null>(null);
|
||
// Management: hidden services, bulk selection, maintenance windows, notes.
|
||
const [showHidden, setShowHidden] = useState(false);
|
||
const [hiddenSnapshots, setHiddenSnapshots] = useState<ServiceSnapshot[]>([]);
|
||
const [bulkSelection, setBulkSelection] = useState<string[]>([]);
|
||
const [bulkBusy, setBulkBusy] = useState(false);
|
||
const [maintenanceFormOpen, setMaintenanceFormOpen] = useState(false);
|
||
const [maintenanceReason, setMaintenanceReason] = useState("");
|
||
const [maintenanceMinutes, setMaintenanceMinutes] = useState("60");
|
||
const [incidentNote, setIncidentNote] = useState("");
|
||
const [incidentBusy, setIncidentBusy] = useState(false);
|
||
const [activityEvents, setActivityEvents] = useState<EventRecord[]>([]);
|
||
const [activityFamily, setActivityFamily] = useState("");
|
||
const [activityBusy, setActivityBusy] = useState(false);
|
||
const [activityExhausted, setActivityExhausted] = useState(false);
|
||
const [alertSettings, setAlertSettings] = useState<AlertSettings | null>(null);
|
||
const [alertToken, setAlertToken] = useState("");
|
||
const [alertBusy, setAlertBusy] = useState(false);
|
||
const [alertMessage, setAlertMessage] = useState<string | null>(null);
|
||
const [backups, setBackups] = useState<BackupInfo[] | null>(null);
|
||
const [backupBusy, setBackupBusy] = useState(false);
|
||
const [backupMessage, setBackupMessage] = useState<string | null>(null);
|
||
// Admin-token mode: reads are open, changes need the token for this tab.
|
||
const [writeAuth, setWriteAuth] = useState<"none" | "admin_token" | "oidc">("none");
|
||
const [editUnlocked, setEditUnlocked] = useState(() => hasApiAccessToken());
|
||
const [unlockOpen, setUnlockOpen] = useState(false);
|
||
const [navMoreOpen, setNavMoreOpen] = useState(false);
|
||
const [unlockValue, setUnlockValue] = useState("");
|
||
const [unlockBusy, setUnlockBusy] = useState(false);
|
||
const [unlockError, setUnlockError] = useState<string | null>(null);
|
||
const [formOpen, setFormOpen] = useState(false);
|
||
const [history, setHistory] = useState<import("./api").ProbeResult[]>([]);
|
||
const [historyServiceId, setHistoryServiceId] = useState<string | null>(null);
|
||
const [availability, setAvailability] = useState<
|
||
Record<number, AvailabilitySummary | null>
|
||
>({ 24: null, 168: null, 720: null });
|
||
const [incident, setIncident] = useState<IncidentOverview | null>(null);
|
||
const [overview, setOverview] = useState<
|
||
import("./api").OverviewSummary | null
|
||
>(null);
|
||
const [semanticTopology, setSemanticTopology] =
|
||
useState<SemanticTopology | null>(null);
|
||
const [events, setEvents] = useState<EventRecord[]>([]);
|
||
const [demo, setDemo] = useState<DemoState | null>(null);
|
||
const [demoConfirm, setDemoConfirm] = useState(false);
|
||
const [demoBusy, setDemoBusy] = useState(false);
|
||
const [demoStep, setDemoStep] = useState(0);
|
||
const [configText, setConfigText] = useState("version: 1\nservices: []\n");
|
||
const [configFormat, setConfigFormat] = useState<"yaml" | "json">("yaml");
|
||
const [configMode, setConfigMode] = useState<"merge" | "replace">("merge");
|
||
const [dockerHost, setDockerHost] = useState("unix:///var/run/docker.sock");
|
||
const [dockerCandidates, setDockerCandidates] = useState<DockerCandidate[]>(
|
||
[],
|
||
);
|
||
const [dockerBusy, setDockerBusy] = useState(false);
|
||
const [appopsUrl, setAppopsUrl] = useState("");
|
||
const [discoveryRun, setDiscoveryRun] = useState<DiscoveryRun | null>(null);
|
||
const [discoveryStatus, setDiscoveryStatus] =
|
||
useState<DiscoveryStatus | null>(null);
|
||
const [discoveryItems, setDiscoveryItems] = useState<DiscoveryObservation[]>(
|
||
[],
|
||
);
|
||
const [discoverySuggestions, setDiscoverySuggestions] = useState<
|
||
TopologySuggestion[]
|
||
>([]);
|
||
const [discoveryBusy, setDiscoveryBusy] = useState(false);
|
||
const [probeRepair, setProbeRepair] = useState<ProbeRepairReport | null>(
|
||
null,
|
||
);
|
||
const [editMode, setEditMode] = useState(false);
|
||
const [graphListView, setGraphListView] = useState(false);
|
||
const mainRef = useRef<HTMLElement | null>(null);
|
||
const [showMiniMap, setShowMiniMap] = useState(false);
|
||
const [edgeEvidence, setEdgeEvidence] = useState<RelationEvidence[]>([]);
|
||
const [providerStatuses, setProviderStatuses] = useState<ProviderStatus[]>([]);
|
||
const [topologySnapshots, setTopologySnapshots] = useState<TopologySnapshot[]>([]);
|
||
const [topologyDiff, setTopologyDiff] = useState<TopologyDiff | null>(null);
|
||
const [selectedSnapshotId, setSelectedSnapshotId] = useState<string | null>(initialUrl.snapshotId);
|
||
const [snapshotCheckedAt, setSnapshotCheckedAt] = useState(0);
|
||
const [selectedEdgeId, setSelectedEdgeId] = useState<string | null>(initialUrl.edgeId);
|
||
const [search, setSearch] = useState(initialUrl.filters.search);
|
||
const [statusFilter, setStatusFilter] = useState<FilterStatus>(
|
||
initialUrl.filters.status as FilterStatus,
|
||
);
|
||
const [monitoringFilter, setMonitoringFilter] = useState<MonitoringFilter>(
|
||
initialUrl.filters.monitoring as MonitoringFilter,
|
||
);
|
||
const [groupFilter, setGroupFilter] = useState(initialUrl.filters.group);
|
||
const [environmentFilter, setEnvironmentFilter] = useState(initialUrl.filters.environment);
|
||
const [criticalityFilter, setCriticalityFilter] = useState(initialUrl.filters.criticality);
|
||
const [domainFilter, setDomainFilter] = useState(initialUrl.filters.domain);
|
||
const [serviceApplicationFilter, setServiceApplicationFilter] = useState(
|
||
initialUrl.filters.application,
|
||
);
|
||
const [lifecycleFilter, setLifecycleFilter] = useState(initialUrl.filters.lifecycle);
|
||
const [focusMode, setFocusMode] = useState(false);
|
||
const [blastRadius, setBlastRadius] = useState(false);
|
||
const [topologyMode, setTopologyMode] = useState<TopologyMode>(
|
||
initialUrl.filters.mode as TopologyMode,
|
||
);
|
||
const [applicationFilter, setApplicationFilter] = useState("all");
|
||
const [componentScope, setComponentScope] = useState<{
|
||
label: string;
|
||
memberIds: string[];
|
||
} | null>(null);
|
||
const [topologyLocation, setTopologyLocation] = useState<TopologyLocation>(
|
||
initialUrl.topology,
|
||
);
|
||
// Compatibility adapter for legacy non-semantic controls. Navigation state
|
||
// itself remains the single TopologyLocation value above.
|
||
const semanticScope = topologyLocation;
|
||
const setSemanticScope = (
|
||
update:
|
||
| Pick<TopologyLocation, "domainId" | "applicationId">
|
||
| ((scope: TopologyLocation) => Pick<TopologyLocation, "domainId" | "applicationId">),
|
||
) => {
|
||
setTopologyLocation((current) => {
|
||
const next = typeof update === "function" ? update(current) : update;
|
||
if (!next.domainId) return topologyRoot();
|
||
return next.applicationId
|
||
? applicationLocation(next.domainId, next.applicationId)
|
||
: domainLocation(next.domainId);
|
||
});
|
||
};
|
||
// The drawer covers part of the graph: open it for a deep link or an explicit
|
||
// selection, not for the service the app auto-selects on load.
|
||
const [inspectorOpen, setInspectorOpen] = useState(() => Boolean(initialUrl.serviceId || initialUrl.incidentId));
|
||
const [filtersOpen, setFiltersOpen] = useState(false);
|
||
const [hoveredNodeId, setHoveredNodeId] = useState<string | null>(null);
|
||
const [selectedIncident, setSelectedIncident] =
|
||
useState<IncidentRecord | null>(null);
|
||
const [incidentDetail, setIncidentDetail] = useState<IncidentDetail | null>(
|
||
null,
|
||
);
|
||
const flowInstance = useRef<ReactFlowInstance<ServiceNode, Edge> | null>(
|
||
null,
|
||
);
|
||
const sidePanelRef = useRef<HTMLElement | null>(null);
|
||
const demoFocusApplied = useRef(false);
|
||
const [layoutPositions, setLayoutPositions] = useState<
|
||
Record<string, { x: number; y: number }>
|
||
>({});
|
||
const [layoutRoutes, setLayoutRoutes] = useState<
|
||
Record<string, { x: number; y: number }[]>
|
||
>({});
|
||
|
||
const refreshDiscovery = useCallback(async () => {
|
||
try {
|
||
const [status, items, suggestions, evidence, providers, snapshots] = await Promise.all([
|
||
api.discoveryStatus(),
|
||
api.discoveryItems(),
|
||
api.discoverySuggestions("open"),
|
||
api.topologyEdges(),
|
||
api.providers(),
|
||
api.topologySnapshots(),
|
||
]);
|
||
setDiscoveryStatus(status);
|
||
setDiscoveryRun(status.current ?? status.last_completed);
|
||
setDiscoveryItems(items);
|
||
setDiscoverySuggestions(suggestions);
|
||
setEdgeEvidence(evidence);
|
||
setProviderStatuses(providers);
|
||
setTopologySnapshots(snapshots);
|
||
setSnapshotCheckedAt(Date.now());
|
||
if (!snapshots.length) setTopologyDiff(null);
|
||
setSelectedSnapshotId((current) =>
|
||
current && snapshots.some((item) => item.id === current)
|
||
? current
|
||
: snapshots[0]?.id ?? null,
|
||
);
|
||
} catch (err) {
|
||
// Discovery is an optional enrichment path. Keep the primary topology usable
|
||
// when an older API or an unavailable source is encountered during rollout.
|
||
setError(
|
||
err instanceof Error ? err.message : "Detectiestatus laden mislukt",
|
||
);
|
||
}
|
||
}, []);
|
||
useEffect(() => {
|
||
if (!selectedSnapshotId) return;
|
||
const index = topologySnapshots.findIndex((item) => item.id === selectedSnapshotId);
|
||
if (index < 0) return;
|
||
let active = true;
|
||
void api.topologyDiff(selectedSnapshotId, topologySnapshots[index + 1]?.id)
|
||
.then((diff) => { if (active) setTopologyDiff(diff); })
|
||
.catch(() => { if (active) setTopologyDiff(null); });
|
||
return () => { active = false; };
|
||
}, [selectedSnapshotId, topologySnapshots]);
|
||
|
||
const refreshCore = useCallback(async () => {
|
||
try {
|
||
const semantic = api
|
||
.semanticTopology()
|
||
.then(setSemanticTopology)
|
||
.catch(() => {
|
||
// The component-level graph remains available while a rolling deploy
|
||
// brings older API instances forward.
|
||
setSemanticTopology(null);
|
||
});
|
||
const [nextServices, nextIncident, nextDemo, nextOverview, nextEvents] =
|
||
await Promise.all([
|
||
api.listServices(),
|
||
api.incidents(),
|
||
api.demoState(),
|
||
api.overview(),
|
||
api.events(30),
|
||
]);
|
||
setServices(nextServices);
|
||
setSelectedId((current) =>
|
||
current && !nextServices.some((item) => item.service.id === current)
|
||
? null
|
||
: current,
|
||
);
|
||
setIncident(nextIncident);
|
||
setDemo(nextDemo);
|
||
if (!nextDemo.active) {
|
||
demoFocusApplied.current = false;
|
||
} else if (!demoFocusApplied.current && nextDemo.root_cause_service_id) {
|
||
setSelectedId(nextDemo.root_cause_service_id);
|
||
setPanel("topology");
|
||
demoFocusApplied.current = true;
|
||
}
|
||
if (!nextDemo.active && nextIncident.candidates[0]) {
|
||
setSelectedId((current) => current ?? nextIncident.candidates[0].service_id);
|
||
}
|
||
setOverview(nextOverview);
|
||
setEvents(nextEvents);
|
||
setError(null);
|
||
setLastUpdatedAt(new Date());
|
||
await semantic;
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "ServiceMap vernieuwen mislukt",
|
||
);
|
||
} finally {
|
||
setLoading(false);
|
||
}
|
||
}, []);
|
||
|
||
const refreshProviders = useCallback(async () => {
|
||
try {
|
||
setProviderStatuses(await api.providers());
|
||
} catch {
|
||
// Provider status is enrichment; the next full refresh retries it.
|
||
}
|
||
}, []);
|
||
|
||
useEffect(() => {
|
||
let active = true;
|
||
void api
|
||
.meta()
|
||
.then((meta) => {
|
||
if (active) setWriteAuth(meta.write_auth ?? "none");
|
||
})
|
||
.catch(() => undefined);
|
||
const onAuthRequired = () => {
|
||
setEditUnlocked(false);
|
||
setUnlockOpen(true);
|
||
};
|
||
window.addEventListener(AUTH_REQUIRED_EVENT, onAuthRequired);
|
||
return () => {
|
||
active = false;
|
||
window.removeEventListener(AUTH_REQUIRED_EVENT, onAuthRequired);
|
||
};
|
||
}, []);
|
||
|
||
const unlockEditing = async (event: FormEvent) => {
|
||
event.preventDefault();
|
||
setUnlockBusy(true);
|
||
setUnlockError(null);
|
||
try {
|
||
await api.verifyWriteAccess(unlockValue);
|
||
setApiAccessToken(unlockValue);
|
||
setEditUnlocked(true);
|
||
setUnlockOpen(false);
|
||
setUnlockValue("");
|
||
setError(null);
|
||
setNotice("Bewerken ontgrendeld voor dit tabblad.");
|
||
} catch (err) {
|
||
setUnlockError(err instanceof Error ? err.message : "Het token werd niet aanvaard");
|
||
} finally {
|
||
setUnlockBusy(false);
|
||
}
|
||
};
|
||
const lockEditing = () => {
|
||
setApiAccessToken(null);
|
||
setEditUnlocked(false);
|
||
setNotice("Bewerken vergrendeld.");
|
||
};
|
||
|
||
/** Full reload: initial load, user mutations and recovery after a gap. */
|
||
const refresh = useCallback(async () => {
|
||
await Promise.all([refreshCore(), refreshDiscovery()]);
|
||
}, [refreshCore, refreshDiscovery]);
|
||
|
||
// Bumped when the selected service's probe history may have changed, so the
|
||
// history/availability reads no longer follow every topology refresh.
|
||
const [historyRevision, setHistoryRevision] = useState(0);
|
||
const selectedIdRef = useRef<string | null>(null);
|
||
useEffect(() => {
|
||
selectedIdRef.current = selectedId;
|
||
}, [selectedId]);
|
||
|
||
const refreshersRef = useRef({ refreshCore, refreshDiscovery, refreshProviders });
|
||
useEffect(() => {
|
||
refreshersRef.current = { refreshCore, refreshDiscovery, refreshProviders };
|
||
}, [refreshCore, refreshDiscovery, refreshProviders]);
|
||
|
||
const schedulerRef = useRef<RefreshScheduler | null>(null);
|
||
useEffect(() => {
|
||
const scheduler = createRefreshScheduler(async ({ scopes, serviceIds }) => {
|
||
const { refreshCore: core, refreshDiscovery: discovery, refreshProviders: providers } =
|
||
refreshersRef.current;
|
||
const tasks: Promise<void>[] = [];
|
||
if (scopes.has("core")) tasks.push(core());
|
||
if (scopes.has("discovery")) tasks.push(discovery());
|
||
else if (scopes.has("providers")) tasks.push(providers());
|
||
await Promise.all(tasks);
|
||
const selected = selectedIdRef.current;
|
||
if (scopes.has("history") && selected && serviceIds.has(selected)) {
|
||
setHistoryRevision((value) => value + 1);
|
||
}
|
||
});
|
||
schedulerRef.current = scheduler;
|
||
return () => {
|
||
scheduler.dispose();
|
||
schedulerRef.current = null;
|
||
};
|
||
}, []);
|
||
|
||
const onRealtimeEvent = useCallback(
|
||
(event: RealtimeEvent) => schedulerRef.current?.requestForEvent(event),
|
||
[],
|
||
);
|
||
const onRealtimeResync = useCallback(
|
||
() =>
|
||
schedulerRef.current?.request(["core", "discovery", "history"], selectedIdRef.current),
|
||
[],
|
||
);
|
||
const realtimeStatus = useRealtimeEvents({
|
||
onEvent: onRealtimeEvent,
|
||
onResync: onRealtimeResync,
|
||
onFallback: onRealtimeResync,
|
||
});
|
||
|
||
useEffect(() => {
|
||
// This starts async API reads; refresh applies its state only after those reads settle.
|
||
// eslint-disable-next-line react-hooks/set-state-in-effect
|
||
void refresh();
|
||
}, [refresh]);
|
||
|
||
useEffect(() => {
|
||
if (selectedId || selectedEdgeId)
|
||
sidePanelRef.current?.scrollTo({ top: 0 });
|
||
}, [selectedId, selectedEdgeId, demo?.active]);
|
||
|
||
const selectedKnown = Boolean(
|
||
selectedId && services.some((item) => item.service.id === selectedId),
|
||
);
|
||
|
||
useEffect(() => {
|
||
if (!selectedId || !selectedKnown) return;
|
||
let active = true;
|
||
void Promise.all([
|
||
api.history(selectedId, 48),
|
||
api.availability(selectedId, 24),
|
||
api.availability(selectedId, 168),
|
||
api.availability(selectedId, 720),
|
||
])
|
||
.then(([nextHistory, day, week, month]) => {
|
||
if (!active) return;
|
||
setHistory(nextHistory);
|
||
setAvailability({ 24: day, 168: week, 720: month });
|
||
setHistoryServiceId(selectedId);
|
||
})
|
||
.catch((err) => {
|
||
if (active)
|
||
setError(
|
||
err instanceof Error
|
||
? err.message
|
||
: "Servicegeschiedenis laden mislukt",
|
||
);
|
||
});
|
||
return () => {
|
||
active = false;
|
||
};
|
||
}, [selectedId, selectedKnown, historyRevision]);
|
||
|
||
const groups = useMemo(
|
||
() =>
|
||
[
|
||
...new Set(
|
||
services
|
||
.map((item) => item.service.group)
|
||
.filter(Boolean) as string[],
|
||
),
|
||
].sort(),
|
||
[services],
|
||
);
|
||
const applications = useMemo(
|
||
() => [...new Set(services.map(applicationName))].sort(),
|
||
[services],
|
||
);
|
||
const semanticDomainByService = useMemo(() => {
|
||
const names = new Map(
|
||
(semanticTopology?.domains ?? []).map((item) => [item.id, item.name]),
|
||
);
|
||
return new Map(
|
||
(semanticTopology?.components ?? []).map((item) => [
|
||
item.service_id,
|
||
names.get(item.domain_id) ?? null,
|
||
]),
|
||
);
|
||
}, [semanticTopology]);
|
||
const domains = useMemo(
|
||
() =>
|
||
[
|
||
...new Set(
|
||
services
|
||
.map(
|
||
(item) =>
|
||
item.service.domain ?? semanticDomainByService.get(item.service.id),
|
||
)
|
||
.filter(Boolean) as string[],
|
||
),
|
||
].sort(),
|
||
[semanticDomainByService, services],
|
||
);
|
||
const environments = useMemo(
|
||
() =>
|
||
[
|
||
...new Set(
|
||
services
|
||
.map((item) => item.service.environment)
|
||
.filter(Boolean) as string[],
|
||
),
|
||
].sort(),
|
||
[services],
|
||
);
|
||
// Filters other than search/status, shared by the Services table and the
|
||
// semantic topology (which applies search and status per node itself).
|
||
const matchesAttributeFilters = useCallback(
|
||
(snapshot: ServiceSnapshot) =>
|
||
(monitoringFilter === "all" ||
|
||
snapshot.service.monitoring_state === monitoringFilter) &&
|
||
(groupFilter === "all" || snapshot.service.group === groupFilter) &&
|
||
(environmentFilter === "all" ||
|
||
snapshot.service.environment === environmentFilter) &&
|
||
(criticalityFilter === "all" ||
|
||
snapshot.service.criticality === criticalityFilter) &&
|
||
(domainFilter === "all" ||
|
||
(snapshot.service.domain ?? semanticDomainByService.get(snapshot.service.id)) ===
|
||
domainFilter) &&
|
||
(serviceApplicationFilter === "all" ||
|
||
applicationName(snapshot) === serviceApplicationFilter) &&
|
||
(lifecycleFilter === "all" ||
|
||
snapshot.service.lifecycle === lifecycleFilter),
|
||
[
|
||
monitoringFilter,
|
||
groupFilter,
|
||
environmentFilter,
|
||
criticalityFilter,
|
||
domainFilter,
|
||
serviceApplicationFilter,
|
||
lifecycleFilter,
|
||
semanticDomainByService,
|
||
],
|
||
);
|
||
const attributeFiltersActive = [
|
||
monitoringFilter,
|
||
groupFilter,
|
||
environmentFilter,
|
||
criticalityFilter,
|
||
domainFilter,
|
||
serviceApplicationFilter,
|
||
lifecycleFilter,
|
||
].some((value) => value !== "all");
|
||
const filterSnapshots = useCallback(
|
||
(list: ServiceSnapshot[]) => {
|
||
const needle = search.toLowerCase();
|
||
return list.filter((snapshot) => {
|
||
const name =
|
||
`${snapshot.service.name} ${snapshot.service.description ?? ""} ${snapshot.service.tags.join(" ")}`.toLowerCase();
|
||
return (
|
||
(!search || name.includes(needle)) &&
|
||
matchesStatusFilter(effectiveStatus(snapshot), statusFilter) &&
|
||
matchesAttributeFilters(snapshot)
|
||
);
|
||
});
|
||
},
|
||
[search, statusFilter, matchesAttributeFilters],
|
||
);
|
||
const filteredServices = useMemo(() => filterSnapshots(services), [services, filterSnapshots]);
|
||
// "Show hidden & ignored" lists every service, including the ones the
|
||
// default views exclude, so they can be found and restored.
|
||
const tableServices = useMemo(
|
||
() => (showHidden ? filterSnapshots(hiddenSnapshots) : filteredServices),
|
||
[showHidden, hiddenSnapshots, filteredServices, filterSnapshots],
|
||
);
|
||
useEffect(() => {
|
||
if (!showHidden) return;
|
||
let active = true;
|
||
void api
|
||
.listServices(true)
|
||
.then((list) => {
|
||
if (active) setHiddenSnapshots(list);
|
||
})
|
||
.catch(() => undefined);
|
||
return () => {
|
||
active = false;
|
||
};
|
||
}, [showHidden, services]);
|
||
const serviceById = useMemo(
|
||
() => new Map(services.map((item) => [item.service.id, item])),
|
||
[services],
|
||
);
|
||
const directDependents = useMemo(() => {
|
||
const result = new Map<string, string[]>();
|
||
for (const snapshot of services)
|
||
for (const dependencyId of snapshot.service.depends_on)
|
||
result.set(dependencyId, [
|
||
...(result.get(dependencyId) ?? []),
|
||
snapshot.service.id,
|
||
]);
|
||
return result;
|
||
}, [services]);
|
||
const relatedIds = useMemo(() => {
|
||
if (!selectedId || !focusMode) return null;
|
||
const result = new Set([selectedId]);
|
||
const visit = (id: string, depth: number) => {
|
||
if (depth <= 0) return;
|
||
const service = services.find((item) => item.service.id === id)?.service;
|
||
for (const dependencyId of service?.depends_on ?? []) {
|
||
result.add(dependencyId);
|
||
visit(dependencyId, depth - 1);
|
||
}
|
||
for (const dependentId of directDependents.get(id) ?? []) {
|
||
result.add(dependentId);
|
||
visit(dependentId, depth - 1);
|
||
}
|
||
};
|
||
visit(selectedId, 2);
|
||
return result;
|
||
}, [selectedId, focusMode, services, directDependents]);
|
||
const impactIds = useMemo(
|
||
() =>
|
||
new Set(
|
||
demo?.affected_service_ids ??
|
||
selectedIncident?.affected_service_ids ??
|
||
[],
|
||
),
|
||
[demo?.affected_service_ids, selectedIncident?.affected_service_ids],
|
||
);
|
||
const graphServices = useMemo(() => {
|
||
const base = filteredServices.filter(
|
||
(item) => !relatedIds || relatedIds.has(item.service.id),
|
||
);
|
||
if (!blastRadius) return base;
|
||
const allowed = new Set(
|
||
[
|
||
demo?.root_cause_service_id ?? selectedIncident?.root_service_id,
|
||
...impactIds,
|
||
].filter(Boolean),
|
||
);
|
||
return base.filter((item) => allowed.has(item.service.id));
|
||
}, [
|
||
filteredServices,
|
||
relatedIds,
|
||
blastRadius,
|
||
demo?.root_cause_service_id,
|
||
selectedIncident?.root_service_id,
|
||
impactIds,
|
||
]);
|
||
const componentServices = useMemo(() => {
|
||
if (topologyLocation.level !== "components") return graphServices;
|
||
if (componentScope) {
|
||
const members = new Set(componentScope.memberIds);
|
||
return graphServices.filter((item) => members.has(item.service.id));
|
||
}
|
||
return applicationFilter !== "all"
|
||
? graphServices.filter(
|
||
(item) => applicationName(item) === applicationFilter,
|
||
)
|
||
: graphServices;
|
||
}, [topologyLocation.level, applicationFilter, componentScope, graphServices]);
|
||
const activeGraphServices =
|
||
topologyLocation.level === "components" ? componentServices : graphServices;
|
||
const rootCauseId =
|
||
demo?.root_cause_service_id ?? selectedIncident?.root_service_id ?? null;
|
||
const legacyNodes = useMemo(
|
||
() =>
|
||
topologyLocation.level === "components"
|
||
? topologyLayout(activeGraphServices, rootCauseId, impactIds)
|
||
: applicationTopologyLayout(
|
||
activeGraphServices,
|
||
rootCauseId,
|
||
impactIds,
|
||
),
|
||
[topologyLocation.level, activeGraphServices, rootCauseId, impactIds],
|
||
);
|
||
const legacyEdges = useMemo<Edge[]>(
|
||
() =>
|
||
topologyLocation.level !== "components"
|
||
? applicationEdges(
|
||
activeGraphServices,
|
||
topologyMode,
|
||
impactIds,
|
||
rootCauseId,
|
||
)
|
||
: activeGraphServices.flatMap((snapshot) =>
|
||
snapshot.service.depends_on
|
||
.filter((dependencyId) =>
|
||
activeGraphServices.some(
|
||
(item) => item.service.id === dependencyId,
|
||
),
|
||
)
|
||
.map((dependencyId) => ({
|
||
id: `${dependencyId}-${snapshot.service.id}`,
|
||
source: dependencyId,
|
||
target: snapshot.service.id,
|
||
animated: effectiveStatus(snapshot) !== "healthy",
|
||
className: `edge-${effectiveStatus(snapshot)}${blastRadius && !impactIds.has(snapshot.service.id) ? " edge-dimmed" : ""}`,
|
||
markerEnd: { type: MarkerType.ArrowClosed },
|
||
})),
|
||
),
|
||
[
|
||
topologyLocation.level,
|
||
activeGraphServices,
|
||
impactIds,
|
||
blastRadius,
|
||
rootCauseId,
|
||
topologyMode,
|
||
],
|
||
);
|
||
const semanticView: SemanticView = topologyLocation.level;
|
||
const semanticGraph = useMemo(
|
||
() =>
|
||
semanticTopology
|
||
? semanticTopologyGraph(
|
||
semanticTopology,
|
||
semanticView,
|
||
semanticView === "components"
|
||
? topologyLocation.applicationId
|
||
: topologyLocation.domainId,
|
||
topologyMode === "impact" || blastRadius,
|
||
search,
|
||
statusFilter,
|
||
{
|
||
serviceFacts: (id) => {
|
||
const item = serviceById.get(id);
|
||
return item
|
||
? { criticality: item.service.criticality, flapping: item.flapping }
|
||
: undefined;
|
||
},
|
||
serviceFilter: attributeFiltersActive
|
||
? (id) => {
|
||
const item = serviceById.get(id);
|
||
return item ? matchesAttributeFilters(item) : false;
|
||
}
|
||
: undefined,
|
||
},
|
||
)
|
||
: null,
|
||
[
|
||
semanticTopology,
|
||
semanticView,
|
||
topologyLocation.domainId,
|
||
topologyLocation.applicationId,
|
||
topologyMode,
|
||
blastRadius,
|
||
search,
|
||
statusFilter,
|
||
serviceById,
|
||
attributeFiltersActive,
|
||
matchesAttributeFilters,
|
||
],
|
||
);
|
||
const graphNodes = semanticGraph?.nodes ?? legacyNodes;
|
||
const baseEdges = semanticGraph?.edges ?? legacyEdges;
|
||
// Positions while a node is being dragged; cleared once the saved layout
|
||
// comes back from the server.
|
||
const [dragPositions, setDragPositions] = useState<Record<string, { x: number; y: number }>>({});
|
||
const onNodesChange = useCallback((changes: NodeChange<ServiceNode>[]) => {
|
||
const moved: Record<string, { x: number; y: number }> = {};
|
||
for (const change of changes) {
|
||
if (change.type === "position" && change.position) moved[change.id] = change.position;
|
||
}
|
||
if (Object.keys(moved).length) setDragPositions((current) => ({ ...current, ...moved }));
|
||
}, []);
|
||
// Nodes drawn somewhere other than the automatic layout: their ELK routes
|
||
// point at the old place, so edges touching them use a plain path.
|
||
const movedNodeIds = useMemo(() => {
|
||
const ids = new Set(Object.keys(dragPositions));
|
||
for (const item of services) {
|
||
if (item.service.layout_pinned && item.service.layout_x != null) ids.add(item.service.id);
|
||
}
|
||
return ids;
|
||
}, [dragPositions, services]);
|
||
const edges = useMemo<Edge[]>(
|
||
() =>
|
||
baseEdges.map((edge) => {
|
||
const touchesSelected = Boolean(
|
||
selectedId && (edge.source === selectedId || edge.target === selectedId),
|
||
);
|
||
const touchesHovered = Boolean(
|
||
hoveredNodeId &&
|
||
(edge.source === hoveredNodeId || edge.target === hoveredNodeId),
|
||
);
|
||
const incidentPath = Boolean(
|
||
rootCauseId &&
|
||
(edge.source === rootCauseId || edge.target === rootCauseId) &&
|
||
(impactIds.has(edge.source) || impactIds.has(edge.target)),
|
||
);
|
||
return {
|
||
...edge,
|
||
type: "living",
|
||
data: {
|
||
relation: edge.className?.includes("routes")
|
||
? "routes_to"
|
||
: edge.className?.includes("review") || edge.className?.includes("communicates")
|
||
? "review"
|
||
: "depends_on",
|
||
selected: edge.id === selectedEdgeId,
|
||
route:
|
||
movedNodeIds.has(edge.source) || movedNodeIds.has(edge.target)
|
||
? undefined
|
||
: layoutRoutes[edge.id],
|
||
signal:
|
||
edge.id === selectedEdgeId ||
|
||
touchesSelected ||
|
||
touchesHovered ||
|
||
incidentPath,
|
||
// Hovering a node fades every relation that does not touch it.
|
||
dimmed: Boolean(hoveredNodeId) && !touchesHovered,
|
||
},
|
||
};
|
||
}),
|
||
[
|
||
baseEdges,
|
||
hoveredNodeId,
|
||
impactIds,
|
||
layoutRoutes,
|
||
movedNodeIds,
|
||
rootCauseId,
|
||
selectedEdgeId,
|
||
selectedId,
|
||
],
|
||
);
|
||
const graphLayoutKey = useMemo(
|
||
() => topologyStructureKey(graphNodes, edges),
|
||
[graphNodes, edges],
|
||
);
|
||
const autoArrangeGraph = async () => {
|
||
const layout = await arrangeTopology(graphNodes, edges);
|
||
setLayoutPositions(layout.positions);
|
||
setLayoutRoutes(layout.routes);
|
||
};
|
||
useEffect(() => {
|
||
if (!graphNodes.length) return;
|
||
let active = true;
|
||
void arrangeTopology(graphNodes, edges).then((layout) => {
|
||
if (!active) return;
|
||
setLayoutPositions(layout.positions);
|
||
setLayoutRoutes(layout.routes);
|
||
});
|
||
return () => {
|
||
active = false;
|
||
};
|
||
// Layout work is keyed only by structure; health updates retain positions.
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [graphLayoutKey]);
|
||
const nodes = useMemo(
|
||
() =>
|
||
graphNodes.map((node): ServiceNode => {
|
||
const service = serviceById.get(node.id)?.service;
|
||
// An operator-pinned position wins over the automatic layout.
|
||
const pinned =
|
||
service?.layout_pinned && service.layout_x != null && service.layout_y != null
|
||
? { x: service.layout_x, y: service.layout_y }
|
||
: undefined;
|
||
return {
|
||
...node,
|
||
ariaLabel: nodeAriaLabel(node.data),
|
||
position: dragPositions[node.id] ?? pinned ?? layoutPositions[node.id] ?? node.position,
|
||
};
|
||
}),
|
||
[graphNodes, layoutPositions, dragPositions, serviceById],
|
||
);
|
||
function openGraphNode(node: ServiceNode | Node) {
|
||
setSelectedEdgeId(null);
|
||
const data = node.data as ServiceNodeData;
|
||
if (data.nodeKind === "domain") {
|
||
setTopologyLocation(domainLocation(node.id));
|
||
setComponentScope(null);
|
||
setTopologyMode("landscape");
|
||
} else if (
|
||
data.nodeKind === "application" ||
|
||
node.id.startsWith("app:")
|
||
) {
|
||
const members = data.memberIds ?? [];
|
||
setComponentScope({ label: data.name, memberIds: members });
|
||
setTopologyLocation(applicationLocation(data.domainId ?? null, node.id));
|
||
setApplicationFilter("all");
|
||
setTopologyMode("landscape");
|
||
const member =
|
||
members.find((id) => id === rootCauseId) ?? members[0];
|
||
if (member) setSelectedId(member);
|
||
} else setSelectedId(node.id);
|
||
setInspectorOpen(true);
|
||
setPanel("topology");
|
||
}
|
||
|
||
function onGraphKeyDown(event: ReactKeyboardEvent<HTMLDivElement>) {
|
||
// React Flow focuses node wrappers (Tab) but Enter/Space only toggles
|
||
// its internal selection; open the node like a click does.
|
||
if (event.key !== "Enter" && event.key !== " ") return;
|
||
const target = (event.target as HTMLElement).closest<HTMLElement>(".react-flow__node");
|
||
const node = target?.dataset.id ? nodes.find((item) => item.id === target.dataset.id) : undefined;
|
||
if (!node) return;
|
||
event.preventDefault();
|
||
openGraphNode(node);
|
||
}
|
||
|
||
const selected =
|
||
services.find((item) => item.service.id === selectedId) ?? null;
|
||
const hasCurrentHistory = Boolean(
|
||
selectedId && historyServiceId === selectedId,
|
||
);
|
||
const selectedEdge =
|
||
edgeEvidence.find((item) => item.id === selectedEdgeId) ?? null;
|
||
const selectedIsRootCause = Boolean(
|
||
selected &&
|
||
(demo?.root_cause_service_id === selected.service.id ||
|
||
selectedIncident?.root_service_id === selected.service.id),
|
||
);
|
||
const counts = useMemo(
|
||
() =>
|
||
services.reduce(
|
||
(result, item) => {
|
||
const key = effectiveStatus(item);
|
||
result[key] = (result[key] ?? 0) + 1;
|
||
return result;
|
||
},
|
||
{} as Record<string, number>,
|
||
),
|
||
[services],
|
||
);
|
||
const monitoredCount = useMemo(
|
||
() =>
|
||
services.filter((item) =>
|
||
["active_probe", "docker_health", "appops_observation", "observed"].includes(
|
||
item.service.monitoring_state,
|
||
),
|
||
).length,
|
||
[services],
|
||
);
|
||
const resolvedComponentCount = useMemo(
|
||
() =>
|
||
semanticTopology?.components.filter(
|
||
(item) => !["unknown", "unmonitored"].includes(item.direct_status),
|
||
).length ?? monitoredCount,
|
||
[monitoredCount, semanticTopology],
|
||
);
|
||
const unresolvedComponentCount = useMemo(
|
||
() =>
|
||
semanticTopology?.components.filter((item) =>
|
||
["unknown", "unmonitored"].includes(item.direct_status),
|
||
).length ?? Math.max(0, services.length - monitoredCount),
|
||
[monitoredCount, semanticTopology, services.length],
|
||
);
|
||
const coverageCounts = useMemo(
|
||
() =>
|
||
services.reduce<Record<string, number>>((result, item) => {
|
||
const state = item.service.monitoring_state;
|
||
result[state] = (result[state] ?? 0) + 1;
|
||
return result;
|
||
}, {}),
|
||
[services],
|
||
);
|
||
const visibleSuggestions = useMemo(
|
||
() => filterSuggestions(discoverySuggestions, {
|
||
query: suggestionSearch,
|
||
confidence: suggestionConfidence,
|
||
type: suggestionType,
|
||
}),
|
||
[discoverySuggestions, suggestionSearch, suggestionConfidence, suggestionType],
|
||
);
|
||
const visibleIncidents = useMemo(
|
||
() => (incident?.incidents ?? []).filter((item) =>
|
||
(incidentStatusFilter === "all" ||
|
||
(incidentStatusFilter === "active" ? item.status !== "resolved" : item.status === incidentStatusFilter)) &&
|
||
(!incidentSearch.trim() || `${item.title} ${item.root_service_name} ${item.root_cause_reason}`
|
||
.toLowerCase().includes(incidentSearch.trim().toLowerCase())),
|
||
),
|
||
[incident, incidentSearch, incidentStatusFilter],
|
||
);
|
||
const selectedDomain = semanticTopology?.domains.find(
|
||
(item) => item.id === topologyLocation.domainId,
|
||
);
|
||
const selectedApplication = semanticTopology?.applications.find(
|
||
(item) => item.id === topologyLocation.applicationId,
|
||
);
|
||
const activeTopologyFilters: Array<{
|
||
label: string;
|
||
value: string;
|
||
clear: () => void;
|
||
}> = [
|
||
{ label: "Status", value: statusFilter, clear: () => setStatusFilter("all") },
|
||
{ label: "Bewaking", value: monitoringFilter, clear: () => setMonitoringFilter("all") },
|
||
{ label: "Domein", value: domainFilter, clear: () => setDomainFilter("all") },
|
||
{ label: "Applicatie", value: serviceApplicationFilter, clear: () => setServiceApplicationFilter("all") },
|
||
{ label: "Omgeving", value: environmentFilter, clear: () => setEnvironmentFilter("all") },
|
||
{ label: "Kritiek", value: criticalityFilter, clear: () => setCriticalityFilter("all") },
|
||
{ label: "Levenscyclus", value: lifecycleFilter, clear: () => setLifecycleFilter("all") },
|
||
];
|
||
|
||
useEffect(() => {
|
||
const onKeyDown = (event: KeyboardEvent) => {
|
||
const target = event.target as HTMLElement | null;
|
||
if (
|
||
!target ||
|
||
panel !== "topology" ||
|
||
["INPUT", "TEXTAREA", "SELECT"].includes(target.tagName) ||
|
||
target.isContentEditable ||
|
||
isTopologyRoot(topologyLocation)
|
||
)
|
||
return;
|
||
if (event.key === "Escape" || event.key === "Backspace") {
|
||
event.preventDefault();
|
||
setTopologyLocation((location) => topologyUp(location));
|
||
}
|
||
};
|
||
window.addEventListener("keydown", onKeyDown);
|
||
return () => window.removeEventListener("keydown", onKeyDown);
|
||
}, [panel, topologyLocation]);
|
||
|
||
// Fit once per view (navigation, mode, demo) after its layout is ready.
|
||
// Health refreshes and services arriving over SSE keep the user's zoom.
|
||
const fittedViewKey = useRef<string | null>(null);
|
||
const viewKey = JSON.stringify([
|
||
panel,
|
||
topologyLocation.level,
|
||
topologyLocation.domainId,
|
||
topologyLocation.applicationId,
|
||
topologyMode,
|
||
focusMode,
|
||
blastRadius,
|
||
Boolean(demo?.active),
|
||
]);
|
||
const layoutReady =
|
||
graphNodes.length > 0 && graphNodes.every((node) => layoutPositions[node.id]);
|
||
useEffect(() => {
|
||
if (panel !== "topology" || !layoutReady || !flowInstance.current) return;
|
||
if (fittedViewKey.current === viewKey) return;
|
||
fittedViewKey.current = viewKey;
|
||
const frame = window.requestAnimationFrame(() =>
|
||
flowInstance.current?.fitView({
|
||
padding: 0.16,
|
||
duration: demo?.active ? 240 : 0,
|
||
}),
|
||
);
|
||
return () => window.cancelAnimationFrame(frame);
|
||
}, [viewKey, layoutReady, panel, demo?.active]);
|
||
|
||
const clearMessages = () => {
|
||
setError(null);
|
||
setNotice(null);
|
||
};
|
||
const resetForm = () => {
|
||
setEditingId(null);
|
||
setForm(emptyForm());
|
||
setFormOpen(false);
|
||
};
|
||
const payloadFromForm = (): ServiceInput => {
|
||
const common = {
|
||
name: form.name,
|
||
kind: form.kind,
|
||
depends_on: form.depends_on,
|
||
description: form.description,
|
||
tags: form.tags
|
||
.split(",")
|
||
.map((item) => item.trim())
|
||
.filter(Boolean),
|
||
group: form.group,
|
||
environment: form.environment,
|
||
criticality: form.criticality,
|
||
interval_seconds: form.interval_seconds,
|
||
timeout_seconds: form.timeout_seconds,
|
||
retries: form.retries,
|
||
failure_threshold: form.failure_threshold,
|
||
recovery_threshold: form.recovery_threshold,
|
||
availability_target: form.availability_target,
|
||
enabled: form.enabled,
|
||
monitoring_enabled: form.monitoring_enabled,
|
||
application: form.application || undefined,
|
||
domain: form.domain || undefined,
|
||
component_role: form.component_role,
|
||
application_locked: form.application_locked,
|
||
domain_locked: form.domain_locked,
|
||
component_role_locked: form.component_role_locked,
|
||
source_type: form.source_type,
|
||
source_ref: form.source_ref,
|
||
category: form.category,
|
||
visibility: form.visibility,
|
||
lifecycle: form.lifecycle,
|
||
first_seen_at: form.first_seen_at,
|
||
last_seen_at: form.last_seen_at,
|
||
last_discovery_status: form.last_discovery_status,
|
||
container_image: form.container_image,
|
||
compose_project: form.compose_project,
|
||
layout_x: form.layout_x,
|
||
layout_y: form.layout_y,
|
||
layout_pinned: form.layout_pinned,
|
||
maintenance_enabled: form.maintenance_enabled,
|
||
maintenance_reason: form.maintenance_reason,
|
||
};
|
||
// Endpoint fields of the other kinds are cleared explicitly, so switching
|
||
// kind on an existing service cannot leave a stale URL or port behind.
|
||
if (form.kind === "http")
|
||
return { ...common, kind: "http", url: form.url, host: undefined, port: undefined };
|
||
if (form.kind === "dns")
|
||
return { ...common, kind: "dns", host: form.host, url: undefined, port: undefined };
|
||
const port = Number(form.port);
|
||
return {
|
||
...common,
|
||
kind: form.kind,
|
||
host: form.host,
|
||
url: undefined,
|
||
// An empty field must not become port 0 (or NaN, serialized as null).
|
||
port: form.port === undefined || !Number.isFinite(port) ? undefined : port,
|
||
};
|
||
};
|
||
const payloadFromService = (
|
||
service: ServiceSnapshot["service"],
|
||
overrides: Partial<ServiceInput> = {},
|
||
): ServiceInput => ({
|
||
name: service.name,
|
||
kind: service.kind,
|
||
url: service.url ?? undefined,
|
||
host: service.host ?? undefined,
|
||
port: service.port ?? undefined,
|
||
depends_on: [...service.depends_on],
|
||
description: service.description ?? undefined,
|
||
tags: [...service.tags],
|
||
group: service.group ?? undefined,
|
||
environment: service.environment ?? undefined,
|
||
owner: service.owner ?? undefined,
|
||
enabled: service.enabled,
|
||
monitoring_enabled: service.monitoring_enabled,
|
||
application: service.application ?? undefined,
|
||
domain: service.domain ?? undefined,
|
||
component_role: service.component_role,
|
||
application_locked: service.application_locked,
|
||
domain_locked: service.domain_locked,
|
||
component_role_locked: service.component_role_locked,
|
||
criticality: service.criticality,
|
||
category: service.category,
|
||
visibility: service.visibility,
|
||
lifecycle: service.lifecycle,
|
||
source_type: service.source_type ?? undefined,
|
||
source_ref: service.source_ref ?? undefined,
|
||
first_seen_at: service.first_seen_at ?? undefined,
|
||
last_seen_at: service.last_seen_at ?? undefined,
|
||
last_discovery_status: service.last_discovery_status ?? undefined,
|
||
container_image: service.container_image ?? undefined,
|
||
compose_project: service.compose_project ?? undefined,
|
||
layout_x: service.layout_x ?? undefined,
|
||
layout_y: service.layout_y ?? undefined,
|
||
layout_pinned: service.layout_pinned,
|
||
interval_seconds: service.interval_seconds ?? undefined,
|
||
timeout_seconds: service.timeout_seconds ?? undefined,
|
||
retries: service.retries ?? undefined,
|
||
failure_threshold: service.failure_threshold,
|
||
recovery_threshold: service.recovery_threshold,
|
||
expected_status_min: service.expected_status_min ?? undefined,
|
||
expected_status_max: service.expected_status_max ?? undefined,
|
||
availability_target: service.availability_target ?? undefined,
|
||
maintenance_enabled: service.maintenance_enabled,
|
||
maintenance_reason: service.maintenance_reason ?? undefined,
|
||
...overrides,
|
||
});
|
||
const submit = async (event: FormEvent) => {
|
||
event.preventDefault();
|
||
clearMessages();
|
||
try {
|
||
// Updates replace the whole record. Start from the stored service so
|
||
// fields the form does not show (owner, expected status range, …) are
|
||
// kept instead of silently reset.
|
||
const existing = editingId
|
||
? services.find((item) => item.service.id === editingId)?.service
|
||
: undefined;
|
||
const payload = existing
|
||
? payloadFromService(existing, payloadFromForm())
|
||
: payloadFromForm();
|
||
const service = editingId
|
||
? await api.updateService(editingId, payload)
|
||
: await api.createService(payload);
|
||
setSelectedId(service.id);
|
||
setNotice(editingId ? "Service bijgewerkt." : "Service toegevoegd.");
|
||
resetForm();
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Service opslaan mislukt");
|
||
}
|
||
};
|
||
const beginEdit = (snapshot: ServiceSnapshot) => {
|
||
const service = snapshot.service;
|
||
setEditingId(service.id);
|
||
setForm({
|
||
name: service.name,
|
||
kind: service.kind,
|
||
url: service.url ?? "",
|
||
host: service.host ?? "",
|
||
port: service.port ?? undefined,
|
||
depends_on: [...service.depends_on],
|
||
tags: service.tags.join(", "),
|
||
group: service.group ?? "",
|
||
environment: service.environment ?? "",
|
||
application: service.application ?? "",
|
||
domain: service.domain ?? "",
|
||
component_role: service.component_role,
|
||
application_locked: service.application_locked,
|
||
domain_locked: service.domain_locked,
|
||
component_role_locked: service.component_role_locked,
|
||
criticality: service.criticality,
|
||
category: service.category,
|
||
visibility: service.visibility,
|
||
lifecycle: service.lifecycle,
|
||
description: service.description ?? "",
|
||
interval_seconds: service.interval_seconds ?? undefined,
|
||
timeout_seconds: service.timeout_seconds ?? undefined,
|
||
retries: service.retries ?? undefined,
|
||
failure_threshold: service.failure_threshold,
|
||
recovery_threshold: service.recovery_threshold,
|
||
availability_target: service.availability_target ?? undefined,
|
||
enabled: service.enabled,
|
||
monitoring_enabled: service.monitoring_enabled,
|
||
source_type: service.source_type ?? undefined,
|
||
source_ref: service.source_ref ?? undefined,
|
||
first_seen_at: service.first_seen_at ?? undefined,
|
||
last_seen_at: service.last_seen_at ?? undefined,
|
||
last_discovery_status: service.last_discovery_status ?? undefined,
|
||
container_image: service.container_image ?? undefined,
|
||
compose_project: service.compose_project ?? undefined,
|
||
maintenance_enabled: service.maintenance_enabled,
|
||
maintenance_reason: service.maintenance_reason ?? undefined,
|
||
layout_x: service.layout_x ?? undefined,
|
||
layout_y: service.layout_y ?? undefined,
|
||
layout_pinned: service.layout_pinned,
|
||
});
|
||
setFormOpen(true);
|
||
setInspectorOpen(true);
|
||
setPanel("services");
|
||
};
|
||
const probe = async (serviceId: string) => {
|
||
clearMessages();
|
||
setBusyId(serviceId);
|
||
try {
|
||
await api.probeService(serviceId);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Controle mislukt");
|
||
} finally {
|
||
setBusyId(null);
|
||
}
|
||
};
|
||
const probeAll = async () => {
|
||
clearMessages();
|
||
setBusyAll(true);
|
||
try {
|
||
const result = await api.probeAll();
|
||
setNotice(`${result.completed}/${result.requested} controles voltooid.`);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Bulkcontrole mislukt");
|
||
} finally {
|
||
setBusyAll(false);
|
||
}
|
||
};
|
||
const removeSelected = async () => {
|
||
if (!selected) return;
|
||
const dependents = services
|
||
.filter((item) => item.service.depends_on.includes(selected.service.id))
|
||
.map((item) => item.service.name);
|
||
const impact = dependents.length
|
||
? `
|
||
|
||
${dependents.length} service(s) zijn ervan afhankelijk en verliezen die afhankelijkheid: ${dependents.join(", ")}.`
|
||
: "";
|
||
if (
|
||
!window.confirm(
|
||
`${selected.service.name} verwijderen?${impact} De controlegeschiedenis wordt ook verwijderd. Dit kan niet ongedaan worden gemaakt.`,
|
||
)
|
||
)
|
||
return;
|
||
clearMessages();
|
||
try {
|
||
await api.deleteService(selected.service.id);
|
||
setSelectedId(null);
|
||
setNotice(`${selected.service.name} verwijderd.`);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Verwijderen mislukt");
|
||
}
|
||
};
|
||
const focusDemo = (result: DemoState) => {
|
||
setSelectedId(result.root_cause_service_id);
|
||
// The demo story starts at the root cause, so show it in the inspector.
|
||
setInspectorOpen(true);
|
||
setDemoStep(0);
|
||
setTopologyLocation(topologyRoot());
|
||
setTopologyMode("landscape");
|
||
setBlastRadius(false);
|
||
setPanel("topology");
|
||
demoFocusApplied.current = true;
|
||
};
|
||
const startDemo = async () => {
|
||
clearMessages();
|
||
setDemoBusy(true);
|
||
try {
|
||
const result = await api.loadDemo();
|
||
setDemoConfirm(false);
|
||
await refresh();
|
||
focusDemo(result);
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Demo laden mislukt");
|
||
} finally {
|
||
setDemoBusy(false);
|
||
}
|
||
};
|
||
const loadDemo = async () => {
|
||
clearMessages();
|
||
if (demo?.active) {
|
||
await resetDemo();
|
||
return;
|
||
}
|
||
if (services.length) {
|
||
setDemoConfirm(true);
|
||
return;
|
||
}
|
||
await startDemo();
|
||
};
|
||
const resetDemo = async () => {
|
||
clearMessages();
|
||
setDemoBusy(true);
|
||
try {
|
||
const result = await api.resetDemo();
|
||
await refresh();
|
||
focusDemo(result);
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Demo opnieuw starten mislukt");
|
||
} finally {
|
||
setDemoBusy(false);
|
||
}
|
||
};
|
||
const exitDemo = async () => {
|
||
clearMessages();
|
||
setDemoBusy(true);
|
||
try {
|
||
const result = await api.exitDemo();
|
||
demoFocusApplied.current = false;
|
||
setDemoStep(0);
|
||
setSelectedId(null);
|
||
setNotice(
|
||
result.restored
|
||
? "Demo afgesloten. Je vorige topologie is hersteld."
|
||
: "Geen actieve demosessie.",
|
||
);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Demo afsluiten mislukt");
|
||
} finally {
|
||
setDemoBusy(false);
|
||
}
|
||
};
|
||
const setDemoWalkthroughStep = (step: number) => {
|
||
setDemoStep(step);
|
||
setPanel("topology");
|
||
setInspectorOpen(true);
|
||
if (step === 0) {
|
||
setTopologyLocation(topologyRoot());
|
||
setTopologyMode("landscape");
|
||
setBlastRadius(false);
|
||
return;
|
||
}
|
||
if (step === 1) {
|
||
const dataDomain = semanticTopology?.domains.find(
|
||
(item) => item.name === "Data",
|
||
);
|
||
if (dataDomain) setTopologyLocation(domainLocation(dataDomain.id));
|
||
setTopologyMode("landscape");
|
||
setBlastRadius(false);
|
||
return;
|
||
}
|
||
if (step === 2) {
|
||
setTopologyLocation(topologyRoot());
|
||
setTopologyMode("impact");
|
||
setBlastRadius(true);
|
||
return;
|
||
}
|
||
setSelectedId(demo?.root_cause_service_id ?? null);
|
||
setTopologyLocation(topologyRoot());
|
||
setTopologyMode("impact");
|
||
setBlastRadius(true);
|
||
};
|
||
const exportConfig = async (format: "yaml" | "json") => {
|
||
clearMessages();
|
||
try {
|
||
const content = await api.exportConfig(format);
|
||
downloadText(
|
||
`servicemap.${format}`,
|
||
content,
|
||
format === "json" ? "application/json" : "application/yaml",
|
||
);
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Exporteren mislukt");
|
||
}
|
||
};
|
||
const importConfig = async () => {
|
||
if (
|
||
configMode === "replace" &&
|
||
!window.confirm(
|
||
`Vervangen verwijdert alle ${services.length} huidige services, samen met elk incident en elke gebeurtenis, ` +
|
||
"en houdt alleen de services uit dit document over. Dit kan niet ongedaan worden gemaakt. Doorgaan?",
|
||
)
|
||
)
|
||
return;
|
||
clearMessages();
|
||
try {
|
||
const result = await api.importConfig(
|
||
configText,
|
||
configFormat,
|
||
configMode,
|
||
);
|
||
setNotice(
|
||
`Configuratie toegepast: ${result.created} aangemaakt, ${result.updated} bijgewerkt.`,
|
||
);
|
||
setSelectedId(null);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Importeren mislukt");
|
||
}
|
||
};
|
||
const discoverDocker = async () => {
|
||
clearMessages();
|
||
setDockerBusy(true);
|
||
try {
|
||
const result = await api.discoverDocker(dockerHost);
|
||
setDockerCandidates(result.candidates);
|
||
setNotice(
|
||
`${result.candidates.length} Docker-containers gevonden om na te kijken.`,
|
||
);
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Docker-detectie mislukt");
|
||
} finally {
|
||
setDockerBusy(false);
|
||
}
|
||
};
|
||
const runProductionDiscovery = async () => {
|
||
clearMessages();
|
||
setDiscoveryBusy(true);
|
||
try {
|
||
const result: DiscoveryResult = await api.runDiscovery(
|
||
dockerHost,
|
||
appopsUrl || undefined,
|
||
false,
|
||
);
|
||
setDiscoveryRun(result.run);
|
||
setDiscoveryItems(result.observations);
|
||
setDiscoverySuggestions(
|
||
result.suggestions.filter((item) => item.status === "open"),
|
||
);
|
||
setDockerCandidates(result.candidates);
|
||
setDiscoveryStatus({
|
||
current: null,
|
||
last_completed: result.run,
|
||
active: false,
|
||
});
|
||
setNotice(
|
||
`Detectie klaar: ${result.run.diff.new} nieuw, ${result.run.diff.changed} gewijzigd, ${result.run.diff.missing} ontbrekend, ${result.run.diff.new_suggestions} nieuwe voorstellen.`,
|
||
);
|
||
await refreshDiscovery();
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "Productiedetectie mislukt",
|
||
);
|
||
} finally {
|
||
setDiscoveryBusy(false);
|
||
}
|
||
};
|
||
const reconcileProduction = async () => {
|
||
clearMessages();
|
||
setDiscoveryBusy(true);
|
||
try {
|
||
const result = await api.reconcileDiscovery(discoveryRun?.id, true);
|
||
setReconcileConfirm(false);
|
||
setDiscoveryRun(result.run);
|
||
setNotice(
|
||
`Canonieke topologie bijgewerkt: ${result.created} services aangemaakt, ${result.updated} gewijzigd, ${result.accepted_relations} relaties met hoge zekerheid aanvaard.`,
|
||
);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "Detectie verwerken mislukt",
|
||
);
|
||
} finally {
|
||
setDiscoveryBusy(false);
|
||
}
|
||
};
|
||
const repairDiscoveredProbes = async (dryRun: boolean) => {
|
||
clearMessages();
|
||
setDiscoveryBusy(true);
|
||
try {
|
||
const report = await api.repairDiscoveredProbes(dryRun, discoveryRun?.id);
|
||
setProbeRepair(report);
|
||
setNotice(
|
||
dryRun
|
||
? `Voorbeeld controleveiligheid: ${report.changed} services zouden wijzigen; ${report.disabled_unsafe} onveilige controles zouden worden uitgeschakeld.`
|
||
: `Controleveiligheid toegepast: ${report.changed} services bijgewerkt; ${report.resolved_incidents} valse incidenten opgelost.`,
|
||
);
|
||
if (!dryRun) await refresh();
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error
|
||
? err.message
|
||
: "Gevonden controles herstellen mislukt",
|
||
);
|
||
} finally {
|
||
setDiscoveryBusy(false);
|
||
}
|
||
};
|
||
const reviewSuggestion = async (
|
||
suggestionId: string,
|
||
action: "accept" | "reject",
|
||
) => {
|
||
clearMessages();
|
||
setDiscoveryBusy(true);
|
||
try {
|
||
if (action === "accept") await api.acceptSuggestion(suggestionId);
|
||
else await api.rejectSuggestion(suggestionId);
|
||
await refresh();
|
||
setNotice(
|
||
action === "accept"
|
||
? "Detectievoorstel aanvaard."
|
||
: "Detectievoorstel afgewezen.",
|
||
);
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error
|
||
? err.message
|
||
: "Detectievoorstel bijwerken mislukt",
|
||
);
|
||
} finally {
|
||
setDiscoveryBusy(false);
|
||
}
|
||
};
|
||
const prefillDockerCandidate = (
|
||
candidate: DockerCandidate,
|
||
suggestion = candidate.suggestions[0],
|
||
) => {
|
||
if (!suggestion) return;
|
||
setEditingId(null);
|
||
setForm({
|
||
...emptyForm(),
|
||
name: suggestion.name,
|
||
kind: suggestion.kind,
|
||
url: suggestion.url ?? "",
|
||
host: suggestion.host ?? "",
|
||
port: suggestion.port ?? undefined,
|
||
group: suggestion.group ?? "",
|
||
category: suggestion.category,
|
||
depends_on: [],
|
||
tags: "docker-discovery",
|
||
source_type: suggestion.source_type ?? "docker",
|
||
source_ref:
|
||
suggestion.stable_source_ref ??
|
||
suggestion.source_ref ??
|
||
`docker:${candidate.container_id}`,
|
||
});
|
||
setFormOpen(true);
|
||
setPanel("services");
|
||
setNotice(
|
||
"Docker-voorstel overgenomen in het serviceformulier. Kijk het na voor je opslaat.",
|
||
);
|
||
};
|
||
const persistNodePosition = async (node: ServiceNode) => {
|
||
const snapshot = services.find((item) => item.service.id === node.id);
|
||
if (!snapshot || !editMode) return;
|
||
try {
|
||
await api.updateService(
|
||
node.id,
|
||
payloadFromService(snapshot.service, {
|
||
layout_x: node.position.x,
|
||
layout_y: node.position.y,
|
||
layout_pinned: true,
|
||
}),
|
||
);
|
||
setNotice(`Positie van ${snapshot.service.name} opgeslagen.`);
|
||
await refresh();
|
||
setDragPositions((current) => {
|
||
const next = { ...current };
|
||
delete next[node.id];
|
||
return next;
|
||
});
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "Positie opslaan mislukt",
|
||
);
|
||
}
|
||
};
|
||
const createManualEdge = async (connection: Connection) => {
|
||
if (
|
||
!editMode ||
|
||
!connection.source ||
|
||
!connection.target ||
|
||
connection.source === connection.target
|
||
)
|
||
return;
|
||
clearMessages();
|
||
try {
|
||
// Edges render dependency -> dependent, so a connection drawn from A to
|
||
// B means "B depends on A": the new arrow appears exactly as drawn.
|
||
const dependency = services.find(
|
||
(item) => item.service.id === connection.source,
|
||
)?.service;
|
||
const dependent = services.find(
|
||
(item) => item.service.id === connection.target,
|
||
)?.service;
|
||
if (!dependent || !dependency) return;
|
||
await api.createEdge({
|
||
source_service_id: dependent.id,
|
||
target_service_id: dependency.id,
|
||
relation_type: "depends_on",
|
||
lock: true,
|
||
explanation: "Handmatige afhankelijkheid aangemaakt in de bewerkmodus van de topologie",
|
||
});
|
||
setNotice(`${dependent.name} is nu afhankelijk van ${dependency.name}.`);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "Afhankelijkheid aanmaken mislukt",
|
||
);
|
||
}
|
||
};
|
||
const handleEdgeAction = async (
|
||
action: "confirm" | "reject" | "lock" | "remove",
|
||
) => {
|
||
if (!selectedEdgeId) return;
|
||
if (
|
||
(action === "remove" || action === "reject") &&
|
||
!window.confirm(
|
||
action === "remove"
|
||
? "Deze relatie uit de topologie verwijderen? Gezondheid wordt er dan niet meer langs doorgegeven."
|
||
: "Deze relatie afwijzen? Ze wordt uit de topologie verwijderd en niet opnieuw voorgesteld.",
|
||
)
|
||
)
|
||
return;
|
||
clearMessages();
|
||
try {
|
||
await api.edgeAction(selectedEdgeId, action);
|
||
setSelectedEdgeId(null);
|
||
await refresh();
|
||
const label = {
|
||
confirm: "confirmed",
|
||
reject: "rejected",
|
||
lock: "locked",
|
||
remove: "removed",
|
||
}[action];
|
||
setNotice(`Relatie ${label}.`);
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "Relatie bijwerken mislukt",
|
||
);
|
||
}
|
||
};
|
||
const toggleDependency = (dependencyId: string) =>
|
||
setForm((current) => ({
|
||
...current,
|
||
depends_on: current.depends_on.includes(dependencyId)
|
||
? current.depends_on.filter((item) => item !== dependencyId)
|
||
: [...current.depends_on, dependencyId],
|
||
}));
|
||
const openIncident = async (item: IncidentRecord) => {
|
||
setSelectedIncident(item);
|
||
setSelectedId(item.root_service_id);
|
||
setPanel("incidents");
|
||
try {
|
||
setIncidentDetail(await api.incident(item.id));
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "Incidenttijdlijn laden mislukt",
|
||
);
|
||
}
|
||
};
|
||
// --- URL synchronisation -------------------------------------------------
|
||
const [pendingIncidentId, setPendingIncidentId] = useState<string | null>(
|
||
initialUrl.incidentId,
|
||
);
|
||
const urlState: UrlState = useMemo(
|
||
() => ({
|
||
panel,
|
||
serviceId: selectedId,
|
||
edgeId: selectedEdgeId,
|
||
incidentId: selectedIncident?.id ?? pendingIncidentId,
|
||
// The latest snapshot is selected automatically; it only belongs in a
|
||
// link when the Changes workspace is open.
|
||
snapshotId: panel === "changes" ? selectedSnapshotId : null,
|
||
topology: topologyLocation,
|
||
filters: {
|
||
search,
|
||
status: statusFilter,
|
||
monitoring: monitoringFilter,
|
||
group: groupFilter,
|
||
environment: environmentFilter,
|
||
criticality: criticalityFilter,
|
||
domain: domainFilter,
|
||
application: serviceApplicationFilter,
|
||
lifecycle: lifecycleFilter,
|
||
mode: topologyMode,
|
||
},
|
||
}),
|
||
[
|
||
panel,
|
||
selectedId,
|
||
selectedEdgeId,
|
||
selectedIncident,
|
||
pendingIncidentId,
|
||
selectedSnapshotId,
|
||
topologyLocation,
|
||
search,
|
||
statusFilter,
|
||
monitoringFilter,
|
||
groupFilter,
|
||
environmentFilter,
|
||
criticalityFilter,
|
||
domainFilter,
|
||
serviceApplicationFilter,
|
||
lifecycleFilter,
|
||
topologyMode,
|
||
],
|
||
);
|
||
const lastNavigationKey = useRef(navigationKey(initialUrl));
|
||
useEffect(() => {
|
||
const hash = serializeUrlState(urlState);
|
||
if (hash === window.location.hash) return;
|
||
const key = navigationKey(urlState);
|
||
if (key !== lastNavigationKey.current) window.history.pushState(null, "", hash);
|
||
else window.history.replaceState(null, "", hash);
|
||
lastNavigationKey.current = key;
|
||
}, [urlState]);
|
||
useEffect(() => {
|
||
const onPopState = () => {
|
||
const next = parseUrlState(window.location.hash);
|
||
lastNavigationKey.current = navigationKey(next);
|
||
setPanel(next.panel);
|
||
setSelectedId(next.serviceId);
|
||
setSelectedEdgeId(next.edgeId);
|
||
setSelectedSnapshotId(next.snapshotId);
|
||
setTopologyLocation(next.topology);
|
||
setSearch(next.filters.search);
|
||
setStatusFilter(next.filters.status as FilterStatus);
|
||
setMonitoringFilter(next.filters.monitoring as MonitoringFilter);
|
||
setGroupFilter(next.filters.group);
|
||
setEnvironmentFilter(next.filters.environment);
|
||
setCriticalityFilter(next.filters.criticality);
|
||
setDomainFilter(next.filters.domain);
|
||
setServiceApplicationFilter(next.filters.application);
|
||
setLifecycleFilter(next.filters.lifecycle);
|
||
setTopologyMode(next.filters.mode as TopologyMode);
|
||
if (!next.incidentId) {
|
||
setSelectedIncident(null);
|
||
setIncidentDetail(null);
|
||
}
|
||
setPendingIncidentId(next.incidentId);
|
||
};
|
||
window.addEventListener("popstate", onPopState);
|
||
return () => window.removeEventListener("popstate", onPopState);
|
||
}, []);
|
||
// An incident named in the URL opens once the incident journal is loaded.
|
||
const resolvePendingIncident = async (record: IncidentRecord | undefined) => {
|
||
setPendingIncidentId(null);
|
||
if (record && selectedIncident?.id !== record.id) await openIncident(record);
|
||
};
|
||
useEffect(() => {
|
||
if (!pendingIncidentId || !incident) return;
|
||
// Hydrating external state (an incident id from the URL) once its data
|
||
// has loaded is exactly what this effect is for.
|
||
// eslint-disable-next-line react-hooks/set-state-in-effect
|
||
void resolvePendingIncident(incident.incidents.find((item) => item.id === pendingIncidentId));
|
||
// resolvePendingIncident only closes over stable setters and the current selection.
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [pendingIncidentId, incident]);
|
||
|
||
const acknowledge = async () => {
|
||
if (!selectedIncident) return;
|
||
try {
|
||
const detail = await api.acknowledgeIncident(selectedIncident.id);
|
||
setSelectedIncident(detail.incident);
|
||
setIncidentDetail(detail);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error ? err.message : "Incident bevestigen mislukt",
|
||
);
|
||
}
|
||
};
|
||
const toggleMaintenance = async () => {
|
||
if (!selected) return;
|
||
if (!selected.service.maintenance_enabled) {
|
||
setMaintenanceFormOpen(true);
|
||
return;
|
||
}
|
||
try {
|
||
await api.maintenance(selected.service.id, false);
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(
|
||
err instanceof Error
|
||
? err.message
|
||
: "Onderhoudsstatus wijzigen mislukt",
|
||
);
|
||
}
|
||
};
|
||
|
||
const startMaintenance = async (event: FormEvent) => {
|
||
event.preventDefault();
|
||
if (!selected) return;
|
||
const minutes = Number(maintenanceMinutes);
|
||
const until = maintenanceEnd(minutes);
|
||
try {
|
||
await api.maintenance(
|
||
selected.service.id,
|
||
true,
|
||
maintenanceReason.trim() || "Gepland onderhoud",
|
||
until,
|
||
);
|
||
setMaintenanceFormOpen(false);
|
||
setMaintenanceReason("");
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Onderhoud starten mislukt");
|
||
}
|
||
};
|
||
|
||
// ---- bulk actions ---------------------------------------------------------
|
||
const toggleBulk = (serviceId: string) =>
|
||
setBulkSelection((current) =>
|
||
current.includes(serviceId)
|
||
? current.filter((item) => item !== serviceId)
|
||
: [...current, serviceId],
|
||
);
|
||
const runBulk = async (
|
||
label: string,
|
||
action: (snapshot: ServiceSnapshot) => Promise<unknown>,
|
||
confirmText?: string,
|
||
) => {
|
||
const targets = [...services, ...hiddenSnapshots].filter(
|
||
(item, index, list) =>
|
||
bulkSelection.includes(item.service.id) &&
|
||
list.findIndex((other) => other.service.id === item.service.id) === index,
|
||
);
|
||
if (!targets.length) return;
|
||
if (confirmText && !window.confirm(confirmText.replace("{n}", String(targets.length)))) return;
|
||
clearMessages();
|
||
setBulkBusy(true);
|
||
let failed = 0;
|
||
for (const item of targets) {
|
||
try {
|
||
await action(item);
|
||
} catch {
|
||
failed += 1;
|
||
}
|
||
}
|
||
setBulkBusy(false);
|
||
setBulkSelection([]);
|
||
if (failed) setError(`${label}: ${failed} van ${targets.length} mislukt.`);
|
||
else setNotice(`${label}: ${targets.length} service(s) klaar.`);
|
||
await refresh();
|
||
};
|
||
|
||
// ---- incident lifecycle ---------------------------------------------------
|
||
const resolveSelectedIncident = async () => {
|
||
if (!selectedIncident) return;
|
||
if (
|
||
!window.confirm(
|
||
"Dit incident handmatig oplossen? Als de hoofdoorzaak nog steeds uitgevallen is, opent er bij de volgende controle een nieuw incident.",
|
||
)
|
||
)
|
||
return;
|
||
setIncidentBusy(true);
|
||
try {
|
||
const detail = await api.resolveIncident(selectedIncident.id, incidentNote.trim() || undefined);
|
||
setSelectedIncident(detail.incident);
|
||
setIncidentDetail(detail);
|
||
setIncidentNote("");
|
||
await refresh();
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Incident oplossen mislukt");
|
||
} finally {
|
||
setIncidentBusy(false);
|
||
}
|
||
};
|
||
const addNoteToIncident = async () => {
|
||
if (!selectedIncident || !incidentNote.trim()) return;
|
||
setIncidentBusy(true);
|
||
try {
|
||
const detail = await api.addIncidentNote(selectedIncident.id, incidentNote.trim());
|
||
setIncidentDetail(detail);
|
||
setIncidentNote("");
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Notitie toevoegen mislukt");
|
||
} finally {
|
||
setIncidentBusy(false);
|
||
}
|
||
};
|
||
|
||
// ---- activity journal -----------------------------------------------------
|
||
const loadActivity = useCallback(
|
||
async (older: boolean) => {
|
||
setActivityBusy(true);
|
||
try {
|
||
const before = older ? activityEvents[activityEvents.length - 1]?.created_at : undefined;
|
||
const page = await api.events(100, { eventType: activityFamily || undefined, before });
|
||
setActivityEvents((current) => (older ? [...current, ...page] : page));
|
||
setActivityExhausted(page.length < 100);
|
||
} catch (err) {
|
||
setError(err instanceof Error ? err.message : "Activiteit laden mislukt");
|
||
} finally {
|
||
setActivityBusy(false);
|
||
}
|
||
},
|
||
[activityEvents, activityFamily],
|
||
);
|
||
useEffect(() => {
|
||
if (panel !== "activity") return;
|
||
// Loads the journal page for the chosen family when the workspace opens.
|
||
// eslint-disable-next-line react-hooks/set-state-in-effect
|
||
void loadActivity(false);
|
||
// Only a workspace or filter change reloads; paging appends explicitly.
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [panel, activityFamily]);
|
||
|
||
const loadAlertSettings = useCallback(async () => {
|
||
// Without the token every read here is a 401, which used to pop the unlock
|
||
// form open on its own; the panel offers the unlock button instead.
|
||
if (writeAuth === "admin_token" && !editUnlocked) return;
|
||
try {
|
||
const [settings, backupList] = await Promise.all([api.alertSettings(), api.backups()]);
|
||
setBackups(backupList);
|
||
setAlertSettings(settings);
|
||
} catch (err) {
|
||
// 401 opens the unlock form via AUTH_REQUIRED_EVENT; keep it quiet here.
|
||
if (!(err instanceof ApiError && err.status === 401)) {
|
||
setError(err instanceof Error ? err.message : "Instellingen laden mislukt");
|
||
}
|
||
}
|
||
}, [writeAuth, editUnlocked]);
|
||
useEffect(() => {
|
||
if (panel !== "settings") return;
|
||
// Settings are read when the workspace opens or editing is unlocked.
|
||
// eslint-disable-next-line react-hooks/set-state-in-effect
|
||
void loadAlertSettings();
|
||
}, [panel, editUnlocked, loadAlertSettings]);
|
||
const saveAlerts = async (event: FormEvent) => {
|
||
event.preventDefault();
|
||
if (!alertSettings) return;
|
||
setAlertBusy(true);
|
||
setAlertMessage(null);
|
||
try {
|
||
setAlertSettings(await api.saveAlertSettings(alertSettings, alertToken || undefined));
|
||
setAlertToken("");
|
||
setAlertMessage("Meldingsinstellingen opgeslagen.");
|
||
} catch (err) {
|
||
setAlertMessage(err instanceof Error ? err.message : "Opslaan mislukt");
|
||
} finally {
|
||
setAlertBusy(false);
|
||
}
|
||
};
|
||
const sendTestAlert = async () => {
|
||
setAlertBusy(true);
|
||
setAlertMessage(null);
|
||
try {
|
||
const result = await api.testAlert();
|
||
setAlertMessage(result.ok ? `Test verstuurd. ${result.detail}` : `Test mislukt: ${result.detail}`);
|
||
} catch (err) {
|
||
setAlertMessage(err instanceof Error ? err.message : "Test mislukt");
|
||
} finally {
|
||
setAlertBusy(false);
|
||
}
|
||
};
|
||
const backupNow = async () => {
|
||
setBackupBusy(true);
|
||
setBackupMessage(null);
|
||
try {
|
||
const info = await api.createBackup();
|
||
setBackups(await api.backups());
|
||
setBackupMessage(`Back-up ${info.name} geschreven en gecontroleerd.`);
|
||
} catch (err) {
|
||
setBackupMessage(err instanceof Error ? err.message : "Back-up mislukt");
|
||
} finally {
|
||
setBackupBusy(false);
|
||
}
|
||
};
|
||
const downloadBackup = async (name: string) => {
|
||
try {
|
||
const blob = await downloadBackupFile(name);
|
||
const url = URL.createObjectURL(blob);
|
||
const anchor = document.createElement("a");
|
||
anchor.href = url;
|
||
anchor.download = name;
|
||
document.body.append(anchor);
|
||
anchor.click();
|
||
anchor.remove();
|
||
window.setTimeout(() => URL.revokeObjectURL(url), 1000);
|
||
} catch (err) {
|
||
setBackupMessage(err instanceof Error ? err.message : "Downloaden mislukt");
|
||
}
|
||
};
|
||
const restoreFromBackup = async (info: BackupInfo) => {
|
||
const answer = window.prompt(
|
||
`${info.name} terugzetten? Elke wijziging sinds ${formatDate(info.created_at)} wordt vervangen. ` +
|
||
"Eerst wordt een veiligheidsback-up van de huidige gegevens gemaakt. Typ RESTORE om door te gaan.",
|
||
);
|
||
if (answer !== "RESTORE") return;
|
||
setBackupBusy(true);
|
||
setBackupMessage(null);
|
||
try {
|
||
const safety = await api.restoreBackup(info.name);
|
||
setBackups(await api.backups());
|
||
setBackupMessage(`${info.name} teruggezet. De vorige gegevens zijn bewaard als ${safety.name}.`);
|
||
await refresh();
|
||
} catch (err) {
|
||
setBackupMessage(err instanceof Error ? err.message : "Terugzetten mislukt");
|
||
} finally {
|
||
setBackupBusy(false);
|
||
}
|
||
};
|
||
const updateAlert = <K extends keyof AlertSettings>(key: K, value: AlertSettings[K]) =>
|
||
setAlertSettings((current) => (current ? { ...current, [key]: value } : current));
|
||
|
||
const renderSettings = () => (
|
||
<section className="panel-section settings-panel">
|
||
<span className="eyebrow">Instellingen</span>
|
||
<h2>Incidentmeldingen (ntfy)</h2>
|
||
{writeAuth === "admin_token" && !editUnlocked ? (
|
||
<div className="locked-note">
|
||
<p className="muted">Meldingsinstellingen en back-ups vragen het beheerderstoken.</p>
|
||
<button className="primary" onClick={() => setUnlockOpen(true)}>
|
||
<LockOpen size={16} aria-hidden="true" />
|
||
Bewerken ontgrendelen
|
||
</button>
|
||
</div>
|
||
) : !alertSettings ? (
|
||
<p className="muted">Instellingen laden…</p>
|
||
) : (
|
||
<form className="settings-form" onSubmit={(event) => void saveAlerts(event)}>
|
||
<label className="checkbox-field">
|
||
<input
|
||
type="checkbox"
|
||
checked={alertSettings.enabled}
|
||
onChange={(event) => updateAlert("enabled", event.target.checked)}
|
||
/>
|
||
Incidentmeldingen versturen
|
||
</label>
|
||
<label>
|
||
ntfy-server
|
||
<input
|
||
type="url"
|
||
value={alertSettings.ntfy_server}
|
||
onChange={(event) => updateAlert("ntfy_server", event.target.value)}
|
||
/>
|
||
</label>
|
||
<label>
|
||
Topic
|
||
<input
|
||
value={alertSettings.ntfy_topic}
|
||
pattern="[A-Za-z0-9_-]+"
|
||
placeholder="servicemap-alerts"
|
||
onChange={(event) => updateAlert("ntfy_topic", event.target.value)}
|
||
/>
|
||
<small>Op een publieke server is de topicnaam het geheim: kies iets dat moeilijk te raden is.</small>
|
||
</label>
|
||
<label>
|
||
Toegangstoken (optioneel)
|
||
<input
|
||
type="password"
|
||
autoComplete="off"
|
||
value={alertToken}
|
||
placeholder={alertSettings.ntfy_token_set ? "Opgeslagen — laat leeg om te behouden" : "Geen"}
|
||
onChange={(event) => setAlertToken(event.target.value)}
|
||
/>
|
||
</label>
|
||
<label>
|
||
Melden vanaf ernst
|
||
<select
|
||
value={alertSettings.min_severity}
|
||
onChange={(event) => updateAlert("min_severity", event.target.value as Criticality)}
|
||
>
|
||
<option value="low">Laag en hoger</option>
|
||
<option value="medium">Gemiddeld en hoger</option>
|
||
<option value="high">Hoog en hoger</option>
|
||
<option value="critical">Alleen kritiek</option>
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Wachten voor melden (seconden)
|
||
<input
|
||
type="number"
|
||
min={0}
|
||
max={3600}
|
||
value={alertSettings.delay_seconds}
|
||
onChange={(event) => updateAlert("delay_seconds", Number(event.target.value))}
|
||
/>
|
||
<small>Incidenten die binnen deze tijd herstellen, blijven stil.</small>
|
||
</label>
|
||
<label>
|
||
Herinneren om de (minuten, 0 = nooit)
|
||
<input
|
||
type="number"
|
||
min={0}
|
||
max={1440}
|
||
value={alertSettings.reminder_minutes}
|
||
onChange={(event) => updateAlert("reminder_minutes", Number(event.target.value))}
|
||
/>
|
||
</label>
|
||
<label className="checkbox-field">
|
||
<input
|
||
type="checkbox"
|
||
checked={alertSettings.notify_resolved}
|
||
onChange={(event) => updateAlert("notify_resolved", event.target.checked)}
|
||
/>
|
||
Ook melden als een incident is opgelost
|
||
</label>
|
||
<label>
|
||
ServiceMap-adres voor links (optioneel)
|
||
<input
|
||
type="url"
|
||
value={alertSettings.public_url}
|
||
placeholder="http://127.0.0.1:1253"
|
||
onChange={(event) => updateAlert("public_url", event.target.value)}
|
||
/>
|
||
</label>
|
||
{alertMessage && <p className="muted" role="status">{alertMessage}</p>}
|
||
<div className="button-row">
|
||
<button className="primary" type="submit" disabled={alertBusy}>Opslaan</button>
|
||
<button type="button" className="ghost" disabled={alertBusy} onClick={() => void sendTestAlert()}>
|
||
Testmelding versturen
|
||
</button>
|
||
</div>
|
||
</form>
|
||
)}
|
||
<h2>Back-ups</h2>
|
||
{backups === null ? (
|
||
<p className="muted">
|
||
{writeAuth === "admin_token" && !editUnlocked ? "Ontgrendel bewerken om back-ups te beheren." : "Back-ups laden…"}
|
||
</p>
|
||
) : (
|
||
<>
|
||
<p className="muted compact">
|
||
Gecontroleerde kopieën in /data/backups, dagelijks geschreven en geroteerd. Bij terugzetten wordt eerst een veiligheidskopie van de huidige gegevens bewaard.
|
||
</p>
|
||
<div className="button-row">
|
||
<button disabled={backupBusy} onClick={() => void backupNow()}>
|
||
{backupBusy ? "Bezig…" : "Nu back-uppen"}
|
||
</button>
|
||
</div>
|
||
{backupMessage && <p className="muted" role="status">{backupMessage}</p>}
|
||
<ul className="backup-list">
|
||
{backups.map((item) => (
|
||
<li key={item.name}>
|
||
<span>
|
||
<strong>{formatDate(item.created_at)}</strong>
|
||
<small>
|
||
{item.kind === "pre-restore" ? "Voor een terugzetting" : "Back-up"} ·{" "}
|
||
{formatNumber(item.size_bytes / 1024 / 1024, 1)} MB
|
||
</small>
|
||
</span>
|
||
<button className="ghost compact-button" onClick={() => void downloadBackup(item.name)}>
|
||
Downloaden
|
||
</button>
|
||
<button
|
||
className="danger compact-button"
|
||
disabled={backupBusy}
|
||
onClick={() => void restoreFromBackup(item)}
|
||
>
|
||
Terugzetten
|
||
</button>
|
||
</li>
|
||
))}
|
||
{!backups.length && <li className="muted">Nog geen back-ups.</li>}
|
||
</ul>
|
||
</>
|
||
)}
|
||
</section>
|
||
);
|
||
|
||
const renderActivity = () => (
|
||
<section className="panel-section activity-panel">
|
||
<div className="panel-heading">
|
||
<div>
|
||
<span className="eyebrow">Activiteit</span>
|
||
<h2>Gebeurtenissenlogboek</h2>
|
||
</div>
|
||
<label>
|
||
Type
|
||
<select value={activityFamily} onChange={(event) => setActivityFamily(event.target.value)}>
|
||
<option value="">Alle gebeurtenissen</option>
|
||
<option value="incident.">Incidenten</option>
|
||
<option value="service.">Servicestatus en onderhoud</option>
|
||
<option value="topology.">Topologiewijzigingen</option>
|
||
<option value="flapping.">Wisselvallig</option>
|
||
</select>
|
||
</label>
|
||
</div>
|
||
<div className="activity-days">
|
||
{groupActivity(activityEvents).map((day) => (
|
||
<section key={day.key} className="activity-day" aria-label={day.label}>
|
||
<h3>{day.label}</h3>
|
||
<ol className="activity-list">
|
||
{day.rows.map((row) => {
|
||
const meta = eventMeta(row.type);
|
||
const Icon = ACTIVITY_ICONS[row.type] ?? Circle;
|
||
const rowServices = row.serviceIds
|
||
.map((id) => serviceById.get(id)?.service)
|
||
.filter((item): item is NonNullable<typeof item> => Boolean(item));
|
||
return (
|
||
<li key={row.id} className={`activity-row tone-${meta.tone}`}>
|
||
<time dateTime={row.createdAt}>{timeOf(row.createdAt)}</time>
|
||
<span className="activity-icon">
|
||
<Icon size={15} aria-hidden="true" />
|
||
</span>
|
||
<span className="activity-text">
|
||
<strong>{meta.label}</strong>
|
||
{row.count > 1 && <span className="activity-count">×{row.count}</span>}
|
||
<span className="activity-message">{row.message}</span>
|
||
</span>
|
||
{rowServices.length > 0 && (
|
||
<span className="activity-services">
|
||
{rowServices.slice(0, 6).map((service) => (
|
||
<button
|
||
key={service.id}
|
||
className="ghost compact-button"
|
||
onClick={() => {
|
||
setSelectedId(service.id);
|
||
setPanel("services");
|
||
}}
|
||
>
|
||
{service.name}
|
||
</button>
|
||
))}
|
||
{rowServices.length > 6 && (
|
||
<span className="activity-more">+{rowServices.length - 6} meer</span>
|
||
)}
|
||
</span>
|
||
)}
|
||
</li>
|
||
);
|
||
})}
|
||
</ol>
|
||
</section>
|
||
))}
|
||
</div>
|
||
{!activityEvents.length && !activityBusy && <p className="muted">Geen gebeurtenissen geregistreerd.</p>}
|
||
{!activityExhausted && activityEvents.length > 0 && (
|
||
<button className="ghost" disabled={activityBusy} onClick={() => void loadActivity(true)}>
|
||
{activityBusy ? "Laden…" : "Oudere gebeurtenissen laden"}
|
||
</button>
|
||
)}
|
||
</section>
|
||
);
|
||
|
||
const renderEdgeInspector = () => {
|
||
if (!selectedEdge) return null;
|
||
const source = services.find(
|
||
(item) => item.service.id === selectedEdge.source_service_id,
|
||
)?.service;
|
||
const target = selectedEdge.target_service_id
|
||
? services.find(
|
||
(item) => item.service.id === selectedEdge.target_service_id,
|
||
)?.service
|
||
: null;
|
||
return (
|
||
<section
|
||
className="panel-section edge-inspector"
|
||
aria-label="Relatie-inspector"
|
||
>
|
||
<div className="inspector-title">
|
||
<div>
|
||
<span className="eyebrow">Relatie-inspector</span>
|
||
<h3>
|
||
{source?.name ?? "Onbekend"} →{" "}
|
||
{target?.name ?? selectedEdge.target_ref ?? "Onbekend"}
|
||
</h3>
|
||
</div>
|
||
<span
|
||
className={`health-pill status-${selectedEdge.active ? "healthy" : "unknown"}`}
|
||
>
|
||
{selectedEdge.active ? "actief" : "inactief"}
|
||
</span>
|
||
</div>
|
||
<dl className="detail-grid">
|
||
<div>
|
||
<dt>Richting</dt>
|
||
<dd>
|
||
{source?.name ?? selectedEdge.source_service_id} hangt af van{" "}
|
||
{target?.name ?? selectedEdge.target_ref ?? "unknown"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Zekerheid</dt>
|
||
<dd>{selectedEdge.confidence}</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Bewijs</dt>
|
||
<dd>{selectedEdge.evidence_type}</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Vergrendeld</dt>
|
||
<dd>{selectedEdge.locked ? "Ja" : "Nee"}</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Eerst gezien</dt>
|
||
<dd>{formatDate(selectedEdge.first_seen_at)}</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Laatst gezien</dt>
|
||
<dd>{formatDate(selectedEdge.last_seen_at)}</dd>
|
||
</div>
|
||
</dl>
|
||
<p className="probe-detail">{selectedEdge.explanation}</p>
|
||
<div className="button-row wrap">
|
||
<button
|
||
onClick={() => void handleEdgeAction("confirm")}
|
||
disabled={!selectedEdge.active}
|
||
>
|
||
Bevestigen
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void handleEdgeAction("lock")}
|
||
disabled={!selectedEdge.active || selectedEdge.locked}
|
||
>
|
||
Vergrendelen
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void handleEdgeAction("reject")}
|
||
disabled={!selectedEdge.active}
|
||
>
|
||
Afwijzen
|
||
</button>
|
||
<button
|
||
className="danger"
|
||
onClick={() => void handleEdgeAction("remove")}
|
||
disabled={!selectedEdge.active}
|
||
>
|
||
Verwijderen
|
||
</button>
|
||
</div>
|
||
</section>
|
||
);
|
||
};
|
||
|
||
const renderInspector = () => (
|
||
<section className="panel-section inspector-section">
|
||
<div className="inspector-title">
|
||
<div>
|
||
<span className="eyebrow">Inspector</span>
|
||
<h3>{selected?.service.name ?? "Selecteer een service"}</h3>
|
||
</div>
|
||
{selected && (
|
||
<span className={`health-pill status-${effectiveStatus(selected)}`}>
|
||
<StatusIcon status={effectiveStatus(selected)} />{" "}
|
||
{statusLabel(effectiveStatus(selected))}
|
||
</span>
|
||
)}
|
||
</div>
|
||
{!selected ? (
|
||
<p className="muted compact">
|
||
Selecteer een node om gezondheid, geschiedenis, afhankelijkheden en incidentcontext te bekijken.
|
||
</p>
|
||
) : (
|
||
<>
|
||
<div className="inspector-callout current-evidence-callout">
|
||
<strong>Waarom {statusLabel(effectiveStatus(selected))} nu?</strong>
|
||
<span>{selected.health_resolution.explanation || "Er is geen actuele verklaring voor de gezondheid beschikbaar."}</span>
|
||
<small>
|
||
{selected.health_resolution.selected_provider?.replaceAll("_", " ") ?? "Geen geselecteerd bewijs"}
|
||
{selected.health_resolution.selected_evidence_id
|
||
? ` · ${formatDate(selected.health_evidence.find((item) => item.id === selected.health_resolution.selected_evidence_id)?.observed_at)}`
|
||
: ""}
|
||
</small>
|
||
</div>
|
||
{panel === "topology" && !nodes.some((node) => node.id === selected.service.id) && (
|
||
<p className="muted compact">De geselecteerde service valt buiten dit grafiekniveau. Open de applicatie of gebruik Services om de component in context te bekijken.</p>
|
||
)}
|
||
{selectedIsRootCause && (
|
||
<div className="inspector-callout root-cause-callout">
|
||
<strong>Waarschijnlijke hoofdoorzaak</strong>
|
||
<span>
|
||
{demo?.affected_count ??
|
||
selectedIncident?.affected_service_ids.length ??
|
||
0}{" "}
|
||
afhankelijke services worden geraakt.
|
||
</span>
|
||
<small>
|
||
{(
|
||
demo?.affected_service_names ??
|
||
selectedIncident?.affected_service_names ??
|
||
[]
|
||
).join(" · ")}
|
||
</small>
|
||
</div>
|
||
)}
|
||
{!selectedIsRootCause && impactIds.has(selected.service.id) && (
|
||
<div className="inspector-callout impacted-callout">
|
||
<strong>Impact via afhankelijkheid</strong>
|
||
<span>
|
||
Deze service wordt geraakt via de huidige hoofdoorzaak.
|
||
</span>
|
||
</div>
|
||
)}
|
||
{!hasCurrentNetworkProbe(selected) && (
|
||
<div className="inspector-callout observation-callout">
|
||
<strong>{monitoringLabel(selected.service.monitoring_state)}</strong>
|
||
<span>
|
||
{selected.service.monitoring_state === "docker_health"
|
||
? "Docker levert het huidige gezondheidssignaal; er is geen netwerkcontrole ingesteld."
|
||
: selected.service.monitoring_state === "appops_observation"
|
||
? "AppOps levert een alleen-lezen gezondheidswaarneming van de applicatie; er is geen netwerkcontrole ingesteld."
|
||
: selected.service.monitoring_state === "observed"
|
||
? "De Docker-runtime wordt waargenomen, maar er is geen gecontroleerd extern bereikbaar endpoint gevonden."
|
||
: "Voor deze service is geen actueel bewakingssignaal ingesteld."}
|
||
</span>
|
||
{selected.service.probe_reachability === "internal_only" && (
|
||
<small>
|
||
Bewijs van interne Docker-endpoints wordt bewaard voor detectie en nooit als actieve controle gebruikt.
|
||
</small>
|
||
)}
|
||
</div>
|
||
)}
|
||
<dl className="detail-grid">
|
||
<div>
|
||
<dt>Effectieve gezondheid</dt>
|
||
<dd className={`status-${effectiveStatus(selected)}`}>
|
||
<StatusIcon status={effectiveStatus(selected)} />{" "}
|
||
{statusLabel(effectiveStatus(selected))}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Directe gezondheid</dt>
|
||
<dd>
|
||
<StatusIcon status={selected.direct_status} />{" "}
|
||
{statusLabel(selected.direct_status)}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Bewaking</dt>
|
||
<dd>
|
||
{selected.service.monitoring_state.replace("_", " ")} ·{" "}
|
||
{selected.service.probe_source.replace("_", " ")}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Bereikbaarheid</dt>
|
||
<dd>
|
||
{selected.service.probe_reachability.replace("_", " ")} ·{" "}
|
||
{selected.service.probe_confidence}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Runtime</dt>
|
||
<dd>
|
||
{selected.service.runtime_state ?? "—"}
|
||
{selected.service.runtime_health
|
||
? ` · ${selected.service.monitoring_state === "appops_observation" ? "AppOps" : "Docker"} ${selected.service.runtime_health}`
|
||
: ""}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Applicatie</dt>
|
||
<dd>
|
||
{selected.service.application ?? selected.service.group ?? "—"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Doel</dt>
|
||
<dd>
|
||
{selected.service.url ??
|
||
`${selected.service.host ?? "—"}${selected.service.port ? `:${selected.service.port}` : ""}`}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Controle</dt>
|
||
<dd>
|
||
{selected.service.kind.toUpperCase()} ·{" "}
|
||
{hasCurrentNetworkProbe(selected) &&
|
||
selected.latest_probe?.latency_ms != null
|
||
? `${selected.latest_probe.latency_ms} ms`
|
||
: selected.latest_probe
|
||
? "Historische controlegegevens"
|
||
: "—"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>{hasCurrentNetworkProbe(selected) ? "Laatste controle" : "Controlegeschiedenis"}</dt>
|
||
<dd>
|
||
{selected.latest_probe
|
||
? `${hasCurrentNetworkProbe(selected) ? "Actueel" : "Historisch"} · ${formatDate(selected.latest_probe.checked_at)}`
|
||
: "—"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Volgende gepland</dt>
|
||
<dd>{hasCurrentNetworkProbe(selected) ? formatDate(selected.next_probe_at) : "Geen actieve controle"}</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Beschikbaarheid</dt>
|
||
<dd>
|
||
{hasCurrentNetworkProbe(selected) &&
|
||
hasCurrentHistory &&
|
||
availability[24]?.uptime_percent != null
|
||
? `${availability[24]?.uptime_percent}% (24h)`
|
||
: selected.latest_probe
|
||
? "Historische controlegegevens"
|
||
: "—"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>7d / 30d</dt>
|
||
<dd>
|
||
{hasCurrentNetworkProbe(selected) && hasCurrentHistory
|
||
? `${availability[168]?.uptime_percent ?? "—"}% / ${availability[720]?.uptime_percent ?? "—"}%`
|
||
: "Niet actueel"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Storingen / herstel</dt>
|
||
<dd>
|
||
{selected.service.failure_streak} /{" "}
|
||
{selected.service.recovery_streak}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Afhankelijkheden</dt>
|
||
<dd>{selected.service.depends_on.length}</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Directe afhankelijken</dt>
|
||
<dd>{directDependents.get(selected.service.id)?.length ?? 0}</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Groep / omgeving</dt>
|
||
<dd>
|
||
{selected.service.group ?? "—"} /{" "}
|
||
{selected.service.environment ?? "—"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Categorie / levenscyclus</dt>
|
||
<dd>
|
||
{selected.service.category.replace("_", " ")} /{" "}
|
||
{selected.service.lifecycle}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Detectiebron</dt>
|
||
<dd>
|
||
{selected.service.source_type
|
||
? `${selected.service.source_type} · ${selected.service.source_ref ?? "—"}`
|
||
: "Handmatig"}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Laatst gezien</dt>
|
||
<dd>{formatDate(selected.service.last_seen_at)}</dd>
|
||
</div>
|
||
</dl>
|
||
{hasCurrentNetworkProbe(selected) && selected.latest_probe && <p className="probe-detail">{selected.latest_probe.detail}</p>}
|
||
<div className="evidence-list health-evidence-list">
|
||
<strong>Gezondheidsbewijs</strong>
|
||
<small>
|
||
{selected.health_resolution.selected_provider
|
||
? `${selected.health_resolution.selected_provider} geselecteerd${selected.health_resolution.conflict ? " · tegenstrijdige signalen bewaard" : ""}`
|
||
: `No current component signal selected · ${selected.health_resolution.reason_code.replaceAll("_", " ")}`}
|
||
</small>
|
||
<small>{selected.health_resolution.explanation}</small>
|
||
{selected.health_evidence.slice(0, 8).map((item) => (
|
||
<small key={item.id}>
|
||
{item.scope} · {item.provider} · {statusLabel(item.status)} · {item.freshness} · {formatNumber(item.confidence * 100)}% · {formatDate(item.observed_at)}
|
||
</small>
|
||
))}
|
||
</div>
|
||
{!!selected.sources.length && (
|
||
<div className="evidence-list">
|
||
<strong>Bronnen</strong>
|
||
{selected.sources.map((source) => (
|
||
<small key={source.id}>
|
||
{source.source_type}: {source.source_name ?? source.source_id}{" "}
|
||
· {source.lifecycle}
|
||
</small>
|
||
))}
|
||
</div>
|
||
)}
|
||
{!!selected.evidence.length && (
|
||
<div className="evidence-list">
|
||
<strong>Bewijs voor relaties</strong>
|
||
{selected.evidence
|
||
.filter((item) => item.active)
|
||
.map((item) => (
|
||
<small key={item.id}>
|
||
{item.confidence} · {item.explanation}
|
||
</small>
|
||
))}
|
||
</div>
|
||
)}
|
||
{hasCurrentHistory && !!history.length && (
|
||
<div
|
||
className="history-strip"
|
||
title="Controlegeschiedenis, van oud naar nieuw"
|
||
role="img"
|
||
aria-label={historySummary(history)}
|
||
>
|
||
{[...history].reverse().map((item) => (
|
||
<i
|
||
key={item.id}
|
||
className={`history-dot status-${item.status}`}
|
||
title={`${item.status} · ${formatDate(item.checked_at)}`}
|
||
aria-hidden="true"
|
||
/>
|
||
))}
|
||
</div>
|
||
)}
|
||
<div className="button-row wrap">
|
||
<button
|
||
onClick={() => void probe(selected.service.id)}
|
||
disabled={
|
||
busyId === selected.service.id ||
|
||
Boolean(demo?.active) ||
|
||
!hasCurrentNetworkProbe(selected)
|
||
}
|
||
>
|
||
{demo?.active
|
||
? "Synthetische gegevens"
|
||
: busyId === selected.service.id
|
||
? "Controleren…"
|
||
: hasCurrentNetworkProbe(selected)
|
||
? "Nu controleren"
|
||
: "Geen actieve controle"}
|
||
</button>
|
||
{!hasCurrentNetworkProbe(selected) && (
|
||
<button className="ghost" onClick={() => beginEdit(selected)}>
|
||
Endpoint instellen
|
||
</button>
|
||
)}
|
||
<button className="ghost" onClick={() => beginEdit(selected)}>
|
||
Bewerken
|
||
</button>
|
||
<button className="ghost" onClick={() => void toggleMaintenance()}>
|
||
{selected.service.maintenance_enabled
|
||
? "Onderhoud beëindigen"
|
||
: "Onderhoud"}
|
||
</button>
|
||
<button className="danger" onClick={() => void removeSelected()}>
|
||
Verwijderen
|
||
</button>
|
||
</div>
|
||
{selected.service.maintenance_enabled && selected.maintenance_until && (
|
||
<p className="muted compact">
|
||
Onderhoud stopt automatisch om {formatDate(selected.maintenance_until)}.
|
||
</p>
|
||
)}
|
||
{maintenanceFormOpen && !selected.service.maintenance_enabled && (
|
||
<form className="inline-form" onSubmit={(event) => void startMaintenance(event)}>
|
||
<label>
|
||
Reden
|
||
<input
|
||
value={maintenanceReason}
|
||
maxLength={240}
|
||
placeholder="Gepland onderhoud"
|
||
onChange={(event) => setMaintenanceReason(event.target.value)}
|
||
/>
|
||
</label>
|
||
<label>
|
||
Duur
|
||
<select value={maintenanceMinutes} onChange={(event) => setMaintenanceMinutes(event.target.value)}>
|
||
<option value="30">30 minuten</option>
|
||
<option value="60">1 uur</option>
|
||
<option value="240">4 uur</option>
|
||
<option value="1440">24 uur</option>
|
||
<option value="0">Tot ik het beëindig</option>
|
||
</select>
|
||
</label>
|
||
<div className="button-row">
|
||
<button className="primary" type="submit">Onderhoud starten</button>
|
||
<button type="button" className="ghost" onClick={() => setMaintenanceFormOpen(false)}>
|
||
Annuleren
|
||
</button>
|
||
</div>
|
||
</form>
|
||
)}
|
||
</>
|
||
)}
|
||
</section>
|
||
);
|
||
|
||
const renderServiceForm = () => (
|
||
<details
|
||
className="panel-section form-section"
|
||
open={formOpen}
|
||
onToggle={(event) => setFormOpen((event.target as HTMLDetailsElement).open)}
|
||
>
|
||
<summary className="panel-heading">
|
||
<span className="eyebrow">
|
||
{editingId ? "Service bewerken" : "Service toevoegen"}
|
||
</span>
|
||
</summary>
|
||
<form className="service-form" onSubmit={(event) => void submit(event)}>
|
||
<label>
|
||
Naam
|
||
<input
|
||
required
|
||
value={form.name}
|
||
onChange={(event) => setForm({ ...form, name: event.target.value })}
|
||
/>
|
||
</label>
|
||
<div className="field-row">
|
||
<label>
|
||
Controletype
|
||
<select
|
||
value={form.kind}
|
||
onChange={(event) =>
|
||
setForm({ ...form, kind: event.target.value as ServiceKind })
|
||
}
|
||
>
|
||
<option value="http">HTTP(S)</option>
|
||
<option value="tcp">TCP</option>
|
||
<option value="dns">DNS</option>
|
||
<option value="tls">TLS-certificaat</option>
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Kritiek
|
||
<select
|
||
value={form.criticality}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
criticality: event.target.value as Criticality,
|
||
})
|
||
}
|
||
>
|
||
<option value="low">Laag</option>
|
||
<option value="medium">Gemiddeld</option>
|
||
<option value="high">Hoog</option>
|
||
<option value="critical">Kritiek</option>
|
||
</select>
|
||
</label>
|
||
</div>
|
||
{form.kind === "http" ? (
|
||
<label>
|
||
URL
|
||
<input
|
||
required
|
||
value={form.url}
|
||
onChange={(event) =>
|
||
setForm({ ...form, url: event.target.value })
|
||
}
|
||
placeholder="https://service.local/health"
|
||
/>
|
||
</label>
|
||
) : (
|
||
<div className="field-row">
|
||
<label>
|
||
{form.kind === "dns" ? "Hostnaam" : "Host"}
|
||
<input
|
||
required
|
||
value={form.host}
|
||
onChange={(event) =>
|
||
setForm({ ...form, host: event.target.value })
|
||
}
|
||
/>
|
||
</label>
|
||
{form.kind !== "dns" && (
|
||
<label>
|
||
Port
|
||
<input
|
||
required
|
||
type="number"
|
||
min="1"
|
||
max="65535"
|
||
value={form.port ?? ""}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
port: event.target.value === "" ? undefined : Number(event.target.value),
|
||
})
|
||
}
|
||
/>
|
||
</label>
|
||
)}
|
||
</div>
|
||
)}
|
||
<div className="field-row">
|
||
<label>
|
||
Groep
|
||
<input
|
||
value={form.group}
|
||
onChange={(event) =>
|
||
setForm({ ...form, group: event.target.value })
|
||
}
|
||
placeholder="Applicaties"
|
||
/>
|
||
</label>
|
||
<label>
|
||
Omgeving
|
||
<input
|
||
value={form.environment}
|
||
onChange={(event) =>
|
||
setForm({ ...form, environment: event.target.value })
|
||
}
|
||
/>
|
||
</label>
|
||
</div>
|
||
<fieldset className="semantic-fields">
|
||
<legend>Topologie-identiteit</legend>
|
||
<div className="field-row">
|
||
<label>
|
||
Applicatie
|
||
<input
|
||
value={form.application ?? ""}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
application: event.target.value,
|
||
application_locked: Boolean(event.target.value),
|
||
})
|
||
}
|
||
placeholder="Afgeleid indien leeg"
|
||
/>
|
||
</label>
|
||
<label>
|
||
Domein
|
||
<input
|
||
value={form.domain ?? ""}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
domain: event.target.value,
|
||
domain_locked: Boolean(event.target.value),
|
||
})
|
||
}
|
||
placeholder="Afgeleid indien leeg"
|
||
/>
|
||
</label>
|
||
</div>
|
||
<div className="field-row">
|
||
<label>
|
||
Componentrol
|
||
<select
|
||
value={form.component_role ?? "unknown"}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
component_role: event.target.value as ComponentRole,
|
||
component_role_locked: event.target.value !== "unknown",
|
||
})
|
||
}
|
||
>
|
||
{(
|
||
[
|
||
"unknown",
|
||
"frontend",
|
||
"api",
|
||
"database",
|
||
"cache",
|
||
"proxy",
|
||
"worker",
|
||
"storage",
|
||
"monitoring",
|
||
"agent",
|
||
"scheduler",
|
||
"auxiliary",
|
||
] as ComponentRole[]
|
||
).map((role) => (
|
||
<option key={role} value={role}>
|
||
{role}
|
||
</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
<p className="muted compact">
|
||
Vul een waarde in om de handmatige keuze vast te zetten; laat leeg/onbekend voor de metadata uit detectie.
|
||
</p>
|
||
</div>
|
||
</fieldset>
|
||
<div className="field-row">
|
||
<label>
|
||
Categorie
|
||
<select
|
||
value={form.category ?? "unknown"}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
category: event.target.value as ServiceInput["category"],
|
||
})
|
||
}
|
||
>
|
||
{[
|
||
"application",
|
||
"database",
|
||
"cache",
|
||
"proxy",
|
||
"monitoring",
|
||
"development",
|
||
"storage",
|
||
"infrastructure",
|
||
"background_worker",
|
||
"system",
|
||
"unknown",
|
||
].map((item) => (
|
||
<option key={item} value={item}>
|
||
{item.replace("_", " ")}
|
||
</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Zichtbaarheid
|
||
<select
|
||
value={form.visibility ?? "visible"}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
visibility: event.target.value as ServiceInput["visibility"],
|
||
})
|
||
}
|
||
>
|
||
<option value="visible">Zichtbaar</option>
|
||
<option value="hidden">Verborgen</option>
|
||
<option value="ignored">Genegeerd</option>
|
||
</select>
|
||
</label>
|
||
</div>
|
||
<label>
|
||
Beschrijving
|
||
<input
|
||
value={form.description}
|
||
onChange={(event) =>
|
||
setForm({ ...form, description: event.target.value })
|
||
}
|
||
/>
|
||
</label>
|
||
<label>
|
||
Tags
|
||
<input
|
||
value={form.tags}
|
||
onChange={(event) => setForm({ ...form, tags: event.target.value })}
|
||
placeholder="api, customer-facing"
|
||
/>
|
||
</label>
|
||
<div className="field-row">
|
||
<label>
|
||
Interval (s)
|
||
<input
|
||
type="number"
|
||
min="1"
|
||
value={form.interval_seconds ?? ""}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
interval_seconds: event.target.value
|
||
? Number(event.target.value)
|
||
: undefined,
|
||
})
|
||
}
|
||
/>
|
||
</label>
|
||
<label>
|
||
Time-out (s)
|
||
<input
|
||
type="number"
|
||
min="0.1"
|
||
step="0.1"
|
||
value={form.timeout_seconds ?? ""}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
timeout_seconds: event.target.value
|
||
? Number(event.target.value)
|
||
: undefined,
|
||
})
|
||
}
|
||
/>
|
||
</label>
|
||
</div>
|
||
<div className="field-row">
|
||
<label>
|
||
Storingsdrempel
|
||
<input
|
||
type="number"
|
||
min="1"
|
||
value={form.failure_threshold ?? 1}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
failure_threshold: Number(event.target.value),
|
||
})
|
||
}
|
||
/>
|
||
</label>
|
||
<label>
|
||
Hersteldrempel
|
||
<input
|
||
type="number"
|
||
min="1"
|
||
value={form.recovery_threshold ?? 1}
|
||
onChange={(event) =>
|
||
setForm({
|
||
...form,
|
||
recovery_threshold: Number(event.target.value),
|
||
})
|
||
}
|
||
/>
|
||
</label>
|
||
</div>
|
||
<fieldset className="dependency-fieldset">
|
||
<legend>Afhankelijkheden</legend>
|
||
{services
|
||
.filter((item) => item.service.id !== editingId)
|
||
.map((item) => (
|
||
<label className="check-row" key={item.service.id}>
|
||
<input
|
||
type="checkbox"
|
||
checked={form.depends_on.includes(item.service.id)}
|
||
onChange={() => toggleDependency(item.service.id)}
|
||
/>
|
||
{item.service.name}
|
||
</label>
|
||
))}
|
||
{!services.length && (
|
||
<span className="muted compact">Nog geen services.</span>
|
||
)}
|
||
</fieldset>
|
||
<div className="button-row">
|
||
<button className="primary" type="submit">
|
||
{editingId ? "Wijzigingen opslaan" : "Service toevoegen"}
|
||
</button>
|
||
{editingId && (
|
||
<button type="button" className="ghost" onClick={resetForm}>
|
||
Annuleren
|
||
</button>
|
||
)}
|
||
</div>
|
||
</form>
|
||
</details>
|
||
);
|
||
|
||
const renderOverview = () => (
|
||
<div className="overview-grid">
|
||
<section className="panel-section overview-lead">
|
||
<span className="eyebrow">Service-inzicht</span>
|
||
<h2>
|
||
{demo?.active
|
||
? "Northstar-incident in één oogopslag"
|
||
: "Operationeel overzicht"}
|
||
</h2>
|
||
<p className="muted">
|
||
{demo?.active
|
||
? "Synthetische gegevens tonen hoe één onbeschikbare afhankelijkheid zich door een productietopologie verspreidt."
|
||
: "Een compact beeld van de echte infrastructuurtopologie, gezondheidsbewijs en actieve incidenten."}
|
||
</p>
|
||
<div className="summary-cards">
|
||
<button onClick={() => { setStatusFilter("all"); setPanel("services"); }}>
|
||
<strong>{services.length}</strong>
|
||
<span>zichtbare services</span>
|
||
</button>
|
||
<button className="status-healthy" onClick={() => { setStatusFilter("healthy"); setPanel("services"); }}>
|
||
<strong>{counts.healthy ?? 0}</strong>
|
||
<span>gezond</span>
|
||
</button>
|
||
<button className="status-degraded" onClick={() => { setStatusFilter("degraded"); setPanel("services"); }}>
|
||
<strong>{counts.degraded ?? 0}</strong>
|
||
<span>verminderd</span>
|
||
</button>
|
||
<button className="status-down" onClick={() => { setStatusFilter("down"); setPanel("services"); }}>
|
||
<strong>{counts.down ?? 0}</strong>
|
||
<span>uitgevallen</span>
|
||
</button>
|
||
</div>
|
||
{(overview?.total_services ?? services.length) > services.length && (
|
||
<p className="muted compact">{(overview?.total_services ?? services.length) - services.length} verborgen services zijn uitgesloten van dit operationele overzicht.</p>
|
||
)}
|
||
{!!providerStatuses.length && (
|
||
<div className="provider-statuses" aria-label="Bronnen van gezondheidsgegevens">
|
||
{providerStatuses.map((provider) => (
|
||
<small key={provider.provider} className={`status-${provider.status}`}>
|
||
{providerText(provider.provider)}: {providerHealthText(provider.status)}
|
||
</small>
|
||
))}
|
||
</div>
|
||
)}
|
||
</section>
|
||
<section className="panel-section overview-incident">
|
||
<span className="eyebrow">Incidentbeeld</span>
|
||
<h3>
|
||
{incident?.active
|
||
? `${incident.candidates.length} waarschijnlijke ${incident.candidates.length === 1 ? "hoofdoorzaak" : "hoofdoorzaken"}`
|
||
: "Geen actief incident"}
|
||
</h3>
|
||
{incident?.candidates.length ? (
|
||
<div className="candidate-list overview-root-list">
|
||
{incident.candidates.map((candidate) => (
|
||
<button key={candidate.service_id} className="candidate" onClick={() => {
|
||
const record = incident.incidents.find((item) =>
|
||
item.root_service_id === candidate.service_id && item.status !== "resolved");
|
||
if (record) void openIncident(record);
|
||
else { setSelectedId(candidate.service_id); setPanel("topology"); }
|
||
}}>
|
||
<strong>{candidate.service_name}</strong>
|
||
<small>Raakt {candidate.affected_service_ids.length} afhankelijke services</small>
|
||
<small>{candidate.reason}</small>
|
||
</button>
|
||
))}
|
||
</div>
|
||
) : (
|
||
<p className="muted compact">
|
||
Gezonde afhankelijkheidsgrafiek. Gebeurtenissen verschijnen hier zodra de status wijzigt.
|
||
</p>
|
||
)}
|
||
</section>
|
||
<section className="panel-section coverage-overview">
|
||
<div className="panel-heading">
|
||
<div>
|
||
<span className="eyebrow">Bewakingsdekking</span>
|
||
<h3>
|
||
{services.length
|
||
? `${resolvedComponentCount}/${services.length} met actueel gezondheidsbewijs`
|
||
: "Nog geen services"}
|
||
</h3>
|
||
</div>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => {
|
||
setStatusFilter("unresolved");
|
||
setMonitoringFilter("all");
|
||
setPanel("services");
|
||
}}
|
||
disabled={unresolvedComponentCount === 0}
|
||
>
|
||
Onopgeloste nakijken
|
||
</button>
|
||
</div>
|
||
<div className="coverage-breakdown">
|
||
{(
|
||
[
|
||
"active_probe",
|
||
"docker_health",
|
||
"appops_observation",
|
||
"observed",
|
||
"unmonitored",
|
||
] as MonitoringState[]
|
||
).map((state) => (
|
||
<div key={state}>
|
||
<strong>{coverageCounts[state] ?? 0}</strong>
|
||
<span>{monitoringLabel(state)}</span>
|
||
</div>
|
||
))}
|
||
</div>
|
||
<p className="muted compact">
|
||
{unresolvedComponentCount} services hebben nog een onopgeloste gezondheid. Runtimewaarneming bevestigt alleen dat iets draait, niet dat het gezond is. Actieve controles vragen een gecontroleerd endpoint.
|
||
</p>
|
||
</section>
|
||
<section className="panel-section discovery-overview">
|
||
<span className="eyebrow">Infrastructuurdetectie</span>
|
||
<h3>
|
||
{discoverySuggestions.length
|
||
? `${discoverySuggestions.length} open bevindingen over alle runs`
|
||
: "Detectie is bijgewerkt"}
|
||
</h3>
|
||
<p className="muted compact">
|
||
{discoveryRun
|
||
? `Meest recente run ${formatDate(discoveryRun.completed_at ?? discoveryRun.started_at)}: ${discoveryRun.diff.new} nieuw, ${discoveryRun.diff.changed} gewijzigd en ${discoveryRun.diff.missing} ontbrekend in die run.`
|
||
: "Voer een detectie uit om Docker- en AppOps-waarnemingen met de canonieke topologie te vergelijken."}
|
||
</p>
|
||
<div className="button-row wrap">
|
||
<button onClick={() => setPanel("discovery")}>Detectie openen</button>
|
||
{!demo?.active && (
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void runProductionDiscovery()}
|
||
disabled={discoveryBusy}
|
||
>
|
||
Nu uitvoeren
|
||
</button>
|
||
)}
|
||
</div>
|
||
</section>
|
||
<section className="panel-section event-panel">
|
||
<div className="panel-heading">
|
||
<span className="eyebrow">Recente gebeurtenissen</span>
|
||
<button className="text-button" onClick={() => setPanel("incidents")}>
|
||
Logboek openen
|
||
</button>
|
||
</div>
|
||
<div className="event-list">
|
||
{(overview?.recent_events ?? events.slice(0, 8)).map((item) => (
|
||
<div className="event-row" key={item.id}>
|
||
<span className="event-dot" />
|
||
<div>
|
||
<strong>{item.message}</strong>
|
||
<small>{formatDate(item.created_at)}</small>
|
||
</div>
|
||
</div>
|
||
))}
|
||
{!(overview?.recent_events.length || events.length) && (
|
||
<div className="empty-inline">Nog geen gebeurtenissen.</div>
|
||
)}
|
||
</div>
|
||
</section>
|
||
</div>
|
||
);
|
||
|
||
const renderIncidents = () => (
|
||
<div className="incident-workspace">
|
||
<section className="panel-section incident-list-panel">
|
||
<div className="panel-heading">
|
||
<div>
|
||
<span className="eyebrow">Blijvend incidentlogboek</span>
|
||
<h3>
|
||
{incident?.active
|
||
? "Actieve en eerdere incidenten"
|
||
: "Incidentgeschiedenis"}
|
||
</h3>
|
||
</div>
|
||
<span className="health-pill">
|
||
{incident?.incidents.length ?? 0} items
|
||
</span>
|
||
</div>
|
||
<div className="review-filters">
|
||
<label>Incidenten zoeken<input value={incidentSearch} onChange={(event) => setIncidentSearch(event.target.value)} placeholder="Service of oorzaak" /></label>
|
||
<label>Status<select value={incidentStatusFilter} onChange={(event) => setIncidentStatusFilter(event.target.value)}>
|
||
<option value="active">Actief</option><option value="all">Alle</option><option value="open">Open</option><option value="acknowledged">Bevestigd</option><option value="resolved">Opgelost</option>
|
||
</select></label>
|
||
</div>
|
||
<p className="muted compact">Toont {visibleIncidents.length} van {incident?.incidents.length ?? 0} items.</p>
|
||
<div className="candidate-list">
|
||
{visibleIncidents.map((item) => (
|
||
<button
|
||
className={`candidate incident-card ${item.status}`}
|
||
key={item.id}
|
||
onClick={() => void openIncident(item)}
|
||
>
|
||
<div className="incident-card-top">
|
||
<span
|
||
className={`health-pill status-${item.status === "resolved" ? "healthy" : item.status === "acknowledged" ? "degraded" : "down"}`}
|
||
>
|
||
{item.status}
|
||
</span>
|
||
<span>{item.severity}</span>
|
||
</div>
|
||
<strong>{item.title}</strong>
|
||
<small>Hoofdoorzaak · {item.root_service_name}</small>
|
||
<small>
|
||
{item.affected_service_ids.length} afhankelijke geraakt · gestart{" "}
|
||
{formatDate(item.started_at)}
|
||
</small>
|
||
</button>
|
||
))}
|
||
{!visibleIncidents.length && (
|
||
<div className="empty-inline">Geen incidenten voor deze filters.</div>
|
||
)}
|
||
</div>
|
||
</section>
|
||
<section className="panel-section incident-detail-panel">
|
||
{incidentDetail ? (
|
||
<>
|
||
<span className="eyebrow">Incidenttijdlijn</span>
|
||
<h3>{incidentDetail.incident.title}</h3>
|
||
<div className="button-row wrap">
|
||
<span
|
||
className={`health-pill status-${incidentDetail.incident.status === "resolved" ? "healthy" : incidentDetail.incident.status === "acknowledged" ? "degraded" : "down"}`}
|
||
>
|
||
{incidentDetail.incident.status}
|
||
</span>
|
||
{incidentDetail.incident.status === "open" && (
|
||
<button className="primary" onClick={() => void acknowledge()}>
|
||
Incident bevestigen
|
||
</button>
|
||
)}
|
||
{incidentDetail.incident.status !== "resolved" && (
|
||
<button className="ghost" disabled={incidentBusy} onClick={() => void resolveSelectedIncident()}>
|
||
Oplossen
|
||
</button>
|
||
)}
|
||
<button
|
||
className="ghost"
|
||
onClick={() => {
|
||
setPanel("topology");
|
||
setBlastRadius(true);
|
||
}}
|
||
>
|
||
Impact tonen
|
||
</button>
|
||
</div>
|
||
<p className="muted compact">
|
||
{incidentDetail.incident.root_cause_reason}
|
||
</p>
|
||
<div className="inline-form">
|
||
<label>
|
||
Notitie
|
||
<textarea
|
||
rows={2}
|
||
maxLength={2000}
|
||
value={incidentNote}
|
||
placeholder="Wat heb je gevonden of gewijzigd?"
|
||
onChange={(event) => setIncidentNote(event.target.value)}
|
||
/>
|
||
</label>
|
||
<button
|
||
className="ghost"
|
||
disabled={incidentBusy || !incidentNote.trim()}
|
||
onClick={() => void addNoteToIncident()}
|
||
>
|
||
Notitie toevoegen
|
||
</button>
|
||
</div>
|
||
<div className="timeline">
|
||
{incidentDetail.timeline.map((item) => (
|
||
<div className="timeline-row" key={item.id}>
|
||
<span className="timeline-line" />
|
||
<div>
|
||
<strong>{item.message}</strong>
|
||
<small>{formatDate(item.created_at)}</small>
|
||
</div>
|
||
</div>
|
||
))}
|
||
</div>
|
||
</>
|
||
) : (
|
||
<p className="muted compact">
|
||
Selecteer een incident om de hoofdoorzaak, bevestiging, tijdlijn en impact te bekijken.
|
||
</p>
|
||
)}
|
||
</section>
|
||
</div>
|
||
);
|
||
|
||
// Latency and 24h columns only earn their space when some service has a
|
||
// current network probe; otherwise every cell would read "—".
|
||
const tableHasMetrics = tableServices.some((item) => hasCurrentNetworkProbe(item) || item.latest_probe);
|
||
const renderServicesTable = () => (
|
||
<div className="services-workspace">
|
||
<section className="panel-section table-panel">
|
||
<div className="table-toolbar">
|
||
<label className="search-field">
|
||
Zoeken
|
||
<input
|
||
value={search}
|
||
onChange={(event) => setSearch(event.target.value)}
|
||
placeholder="Naam, tag of beschrijving"
|
||
/>
|
||
</label>
|
||
<label className="checkbox-field">
|
||
<input
|
||
type="checkbox"
|
||
checked={showHidden}
|
||
onChange={(event) => {
|
||
setShowHidden(event.target.checked);
|
||
setBulkSelection([]);
|
||
}}
|
||
/>
|
||
Verborgen en genegeerde tonen
|
||
</label>
|
||
<label>
|
||
Status
|
||
<select
|
||
value={statusFilter}
|
||
onChange={(event) =>
|
||
setStatusFilter(event.target.value as FilterStatus)
|
||
}
|
||
>
|
||
<option value="all">Alle statussen</option>
|
||
<option value="problems">Problemen (uitgevallen, verminderd, herstellend)</option>
|
||
<option value="unresolved">Onopgeloste gezondheid</option>
|
||
{(
|
||
[
|
||
"healthy",
|
||
"degraded",
|
||
"down",
|
||
"recovering",
|
||
"unknown",
|
||
"unmonitored",
|
||
"maintenance",
|
||
] as HealthStatus[]
|
||
).map((item) => (
|
||
<option key={item} value={item}>
|
||
{statusLabel(item)}
|
||
</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Bewaking
|
||
<select
|
||
value={monitoringFilter}
|
||
onChange={(event) =>
|
||
setMonitoringFilter(event.target.value as MonitoringFilter)
|
||
}
|
||
>
|
||
<option value="all">Elke bron</option>
|
||
{(
|
||
[
|
||
"active_probe",
|
||
"docker_health",
|
||
"appops_observation",
|
||
"observed",
|
||
"unmonitored",
|
||
] as MonitoringState[]
|
||
).map((item) => (
|
||
<option key={item} value={item}>
|
||
{monitoringLabel(item)}
|
||
</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Groep
|
||
<select
|
||
value={groupFilter}
|
||
onChange={(event) => setGroupFilter(event.target.value)}
|
||
>
|
||
<option value="all">Alle groepen</option>
|
||
{groups.map((item) => (
|
||
<option key={item}>{item}</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Omgeving
|
||
<select
|
||
value={environmentFilter}
|
||
onChange={(event) => setEnvironmentFilter(event.target.value)}
|
||
>
|
||
<option value="all">Alle omgevingen</option>
|
||
{environments.map((item) => (
|
||
<option key={item}>{item}</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Kritiek
|
||
<select
|
||
value={criticalityFilter}
|
||
onChange={(event) => setCriticalityFilter(event.target.value)}
|
||
>
|
||
<option value="all">Alle kritiekniveaus</option>
|
||
{(["low", "medium", "high", "critical"] as Criticality[]).map(
|
||
(item) => (
|
||
<option key={item} value={item}>
|
||
{item}
|
||
</option>
|
||
),
|
||
)}
|
||
</select>
|
||
</label>
|
||
<button className="primary toolbar-end"
|
||
type="button"
|
||
onClick={() => {
|
||
resetForm();
|
||
setSelectedId(null);
|
||
setFormOpen(true);
|
||
}}
|
||
>
|
||
<Plus size={16} aria-hidden="true" />
|
||
Service toevoegen
|
||
</button>
|
||
</div>
|
||
{bulkSelection.length > 0 && (
|
||
<div className="bulk-bar" role="region" aria-label="Bulkacties">
|
||
<strong>{bulkSelection.length} geselecteerd</strong>
|
||
<button
|
||
className="ghost compact-button"
|
||
disabled={bulkBusy}
|
||
onClick={() =>
|
||
void runBulk("Onderhoud gestart", (item) =>
|
||
api.maintenance(item.service.id, true, "Bulkonderhoud"),
|
||
)
|
||
}
|
||
>
|
||
Onderhoud starten
|
||
</button>
|
||
<button
|
||
className="ghost compact-button"
|
||
disabled={bulkBusy}
|
||
onClick={() => void runBulk("Onderhoud beëindigd", (item) => api.maintenance(item.service.id, false))}
|
||
>
|
||
Onderhoud beëindigen
|
||
</button>
|
||
<button
|
||
className="ghost compact-button"
|
||
disabled={bulkBusy}
|
||
onClick={() => void runBulk("Gecontroleerd", (item) => api.probeService(item.service.id))}
|
||
>
|
||
Nu controleren
|
||
</button>
|
||
<button
|
||
className="ghost compact-button"
|
||
disabled={bulkBusy}
|
||
onClick={() =>
|
||
void runBulk("Verborgen", (item) =>
|
||
api.updateService(item.service.id, payloadFromService(item.service, { visibility: "hidden" })),
|
||
)
|
||
}
|
||
>
|
||
Verbergen
|
||
</button>
|
||
<button
|
||
className="ghost compact-button"
|
||
disabled={bulkBusy}
|
||
onClick={() =>
|
||
void runBulk("Getoond", (item) =>
|
||
api.updateService(
|
||
item.service.id,
|
||
payloadFromService(item.service, { visibility: "visible", lifecycle: "active" }),
|
||
),
|
||
)
|
||
}
|
||
>
|
||
Tonen
|
||
</button>
|
||
<button
|
||
className="danger compact-button"
|
||
disabled={bulkBusy}
|
||
onClick={() =>
|
||
void runBulk(
|
||
"Verwijderd",
|
||
(item) => api.deleteService(item.service.id),
|
||
"{n} services en hun controlegeschiedenis verwijderen? Afhankelijke services verliezen deze afhankelijkheden. Dit kan niet ongedaan worden gemaakt.",
|
||
)
|
||
}
|
||
>
|
||
Verwijderen
|
||
</button>
|
||
<button className="ghost compact-button" onClick={() => setBulkSelection([])}>
|
||
Wissen
|
||
</button>
|
||
</div>
|
||
)}
|
||
<div className={`service-table${tableHasMetrics ? "" : " no-metrics"}`}>
|
||
<div className="service-row-wrap">
|
||
<input
|
||
type="checkbox"
|
||
aria-label="Alle getoonde services selecteren"
|
||
checked={tableServices.length > 0 && tableServices.every((item) => bulkSelection.includes(item.service.id))}
|
||
onChange={(event) =>
|
||
setBulkSelection(event.target.checked ? tableServices.map((item) => item.service.id) : [])
|
||
}
|
||
/>
|
||
<div className="service-table-head">
|
||
<span>Service</span>
|
||
<span>Applicatie</span>
|
||
<span>Runtime</span>
|
||
<span>Bewaking</span>
|
||
<span>Gezondheid</span>
|
||
<span>Latentie</span>
|
||
<span>24h</span>
|
||
</div>
|
||
</div>
|
||
{tableServices.map((item) => (
|
||
<div className="service-row-wrap" key={item.service.id}>
|
||
<input
|
||
type="checkbox"
|
||
aria-label={`${item.service.name} selecteren`}
|
||
checked={bulkSelection.includes(item.service.id)}
|
||
onChange={() => toggleBulk(item.service.id)}
|
||
/>
|
||
<button
|
||
className="service-table-row"
|
||
key={item.service.id}
|
||
aria-pressed={selectedId === item.service.id}
|
||
onClick={() => setSelectedId(item.service.id)}
|
||
>
|
||
<span>
|
||
<strong>{item.service.name}</strong>
|
||
<small>
|
||
{item.service.group ?? "Zonder groep"} ·{" "}
|
||
{item.service.environment ?? "—"} · {criticalityText(item.service.criticality)}
|
||
{item.service.visibility !== "visible" ? ` · ${item.service.visibility}` : ""}
|
||
{item.service.lifecycle !== "active" ? ` · ${item.service.lifecycle}` : ""}
|
||
</small>
|
||
</span>
|
||
<span>
|
||
{item.service.application ?? item.service.group ?? "—"}
|
||
</span>
|
||
<span>
|
||
{item.service.runtime_state ?? "—"}
|
||
{item.service.runtime_health
|
||
? ` · ${item.service.runtime_health}`
|
||
: ""}
|
||
</span>
|
||
<span className="monitoring-cell">
|
||
{monitoringLabel(item.service.monitoring_state)}
|
||
<small>{item.service.probe_source.replace("_", " ")}</small>
|
||
</span>
|
||
<span className={`status-${effectiveStatus(item)}`}>
|
||
<StatusIcon status={effectiveStatus(item)} />{" "}
|
||
{statusLabel(effectiveStatus(item))}
|
||
</span>
|
||
<span>
|
||
{hasCurrentNetworkProbe(item) && item.latest_probe?.latency_ms != null
|
||
? `${item.latest_probe.latency_ms} ms`
|
||
: "—"}
|
||
</span>
|
||
<span>
|
||
{hasCurrentNetworkProbe(item) && item.availability_24h?.uptime_percent != null
|
||
? `${formatNumber(item.availability_24h.uptime_percent, 1)}%`
|
||
: item.latest_probe
|
||
? "Historisch"
|
||
: "—"}
|
||
</span>
|
||
</button>
|
||
</div>
|
||
))}
|
||
{loading && !services.length ? (
|
||
<div className="table-skeleton" role="status">
|
||
{Array.from({ length: 6 }, (_, index) => (
|
||
<span key={index} className="skeleton-row" aria-hidden="true" />
|
||
))}
|
||
<span className="sr-only">Services laden…</span>
|
||
</div>
|
||
) : (
|
||
!tableServices.length && (
|
||
<div className="empty-inline">
|
||
Geen services voor de huidige filters.
|
||
</div>
|
||
)
|
||
)}
|
||
</div>
|
||
</section>
|
||
{(selected || formOpen) && (
|
||
<aside className="service-drawer" aria-label="Servicedetails">
|
||
<div className="drawer-header">
|
||
<span className="eyebrow">Servicedetails</span>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => {
|
||
setSelectedId(null);
|
||
resetForm();
|
||
}}
|
||
>
|
||
Sluiten
|
||
</button>
|
||
</div>
|
||
{selected && renderInspector()}
|
||
{formOpen && renderServiceForm()}
|
||
</aside>
|
||
)}
|
||
</div>
|
||
);
|
||
|
||
const renderDiscovery = () => {
|
||
const diff = discoveryRun?.diff;
|
||
const currentRun = discoveryStatus?.current;
|
||
return (
|
||
<div className="discovery-workspace">
|
||
<section className="panel-section discovery-panel">
|
||
<span className="eyebrow">Productie-infrastructuur</span>
|
||
<h2>Ontdek de echte omgeving</h2>
|
||
<p className="muted compact">
|
||
Read-only discovery inspects Docker metadata and optional AppOps
|
||
enrichment. A run records observations and suggestions; it does not
|
||
change the canonical topology until you explicitly reconcile it.
|
||
</p>
|
||
<div className="field-row">
|
||
<label>
|
||
Docker-host
|
||
<input
|
||
value={dockerHost}
|
||
onChange={(event) => setDockerHost(event.target.value)}
|
||
placeholder="unix:///var/run/docker.sock"
|
||
/>
|
||
</label>
|
||
<label>
|
||
AppOps-URL
|
||
<input
|
||
value={appopsUrl}
|
||
onChange={(event) => setAppopsUrl(event.target.value)}
|
||
placeholder="optionele alleen-lezen-URL"
|
||
/>
|
||
</label>
|
||
</div>
|
||
<div className="button-row wrap">
|
||
<button className="primary"
|
||
onClick={() => void runProductionDiscovery()}
|
||
disabled={discoveryBusy}
|
||
>
|
||
{discoveryBusy ? "Detecteren…" : "Detectie uitvoeren"}
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void refreshDiscovery()}
|
||
disabled={discoveryBusy}
|
||
>
|
||
Status vernieuwen
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void discoverDocker()}
|
||
disabled={dockerBusy}
|
||
>
|
||
Voorbeeld Docker-kandidaten
|
||
</button>
|
||
</div>
|
||
{currentRun && (
|
||
<p className="notice-inline">
|
||
Detectie is momenteel {currentRun.status}.
|
||
</p>
|
||
)}
|
||
{discoveryRun && (
|
||
<div className="discovery-summary">
|
||
<div>
|
||
<strong>{discoveryRun.status}</strong>
|
||
<span>laatste run</span>
|
||
</div>
|
||
<div>
|
||
<strong>{diff?.new ?? 0}</strong>
|
||
<span>nieuw</span>
|
||
</div>
|
||
<div>
|
||
<strong>{diff?.changed ?? 0}</strong>
|
||
<span>gewijzigd</span>
|
||
</div>
|
||
<div>
|
||
<strong>{diff?.missing ?? 0}</strong>
|
||
<span>ontbrekend</span>
|
||
</div>
|
||
<div>
|
||
<strong>{diff?.new_suggestions ?? 0}</strong>
|
||
<span>nieuwe voorstellen</span>
|
||
</div>
|
||
</div>
|
||
)}
|
||
<div className="discovery-callout">
|
||
<strong>De canonieke topologie is bewust.</strong>
|
||
<span>
|
||
Services en relaties met hoge zekerheid importeer je expliciet. Netwerkhints met lage zekerheid blijven alleen ter controle en beïnvloeden de gezondheid nooit.
|
||
</span>
|
||
</div>
|
||
<div className="probe-safety-callout">
|
||
<strong>Bewakingsdekking herstellen</strong>
|
||
<span>
|
||
Published endpoints are preflighted before activation. Container-only
|
||
Docker DNS is discovery evidence only; AppOps, Docker health and
|
||
runtime observations retain their own provenance.
|
||
</span>
|
||
<div className="button-row wrap">
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void repairDiscoveredProbes(true)}
|
||
disabled={discoveryBusy || !discoveryRun}
|
||
>
|
||
Voorbeeld dekkingsherstel
|
||
</button>
|
||
<button
|
||
onClick={() => void repairDiscoveredProbes(false)}
|
||
disabled={
|
||
discoveryBusy || !probeRepair || probeRepair.dry_run === false || probeRepair.changed === 0
|
||
}
|
||
>
|
||
Gecontroleerde wijzigingen toepassen
|
||
</button>
|
||
</div>
|
||
{probeRepair && (
|
||
<small>
|
||
{probeRepair.dry_run ? "Voorbeeld" : "Toegepast"} ·{" "}
|
||
{probeRepair.changed} gewijzigd · {probeRepair.disabled_unsafe}{" "}
|
||
onveilig uitgeschakeld · {probeRepair.enabled_published} gepubliceerde endpoints gecontroleerd · {probeRepair.docker_health_observed} Docker-gezondheid · {probeRepair.appops_observed} AppOps ·{" "}
|
||
{probeRepair.runtime_observed} runtime waargenomen ·{" "}
|
||
{probeRepair.unmonitored} niet bewaakt
|
||
</small>
|
||
)}
|
||
{!!probeRepair?.changes.length && (
|
||
<div className="coverage-change-list">
|
||
{probeRepair.changes.slice(0, 12).map((change) => (
|
||
<div key={change.service_id}>
|
||
<strong>{change.service_name}</strong>
|
||
<small>
|
||
{monitoringLabel(change.next_monitoring_state)} ·{" "}
|
||
{change.next_probe_source
|
||
? change.next_probe_source.replace("_", " ")
|
||
: "geen bron"}
|
||
{change.next_endpoint ? ` · ${change.next_endpoint}` : ""}
|
||
{change.next_probe_confidence
|
||
? ` · ${change.next_probe_confidence}`
|
||
: ""}
|
||
</small>
|
||
<small>{change.reason}</small>
|
||
</div>
|
||
))}
|
||
</div>
|
||
)}
|
||
</div>
|
||
<div className="button-row wrap">
|
||
<button
|
||
onClick={() => setReconcileConfirm(true)}
|
||
disabled={
|
||
discoveryBusy ||
|
||
!discoveryRun ||
|
||
discoveryRun.status !== "completed"
|
||
}
|
||
>
|
||
Import nakijken
|
||
</button>
|
||
<span className="muted compact">
|
||
{discoverySuggestions.length} open voorstellen ·{" "}
|
||
{discoveryItems.length} waarnemingen
|
||
</span>
|
||
</div>
|
||
<ConfirmDialog
|
||
open={reconcileConfirm}
|
||
title="Detectiebevindingen importeren?"
|
||
confirmLabel="Import toepassen"
|
||
onConfirm={() => void reconcileProduction()}
|
||
onCancel={() => setReconcileConfirm(false)}
|
||
busy={discoveryBusy}
|
||
>
|
||
<p>Laatste run: {formatDate(discoveryRun?.completed_at ?? discoveryRun?.started_at)}. {discoveryRun?.diff.new ?? 0} nieuw en {discoveryRun?.diff.changed ?? 0} gewijzigde kandidaten; {discoverySuggestions.filter((item) => ["high", "confirmed"].includes(item.confidence)).length} open voorstellen met hoge zekerheid. Verwerken kan ook de levenscyclus bijwerken en ontbrekende services uitfaseren. Kijk de kandidaten na voor je toepast.</p>
|
||
</ConfirmDialog>
|
||
</section>
|
||
<section className="panel-section suggestion-panel">
|
||
<div className="panel-heading">
|
||
<div>
|
||
<span className="eyebrow">Bewijs nakijken</span>
|
||
<h3>Open detectievoorstellen</h3>
|
||
</div>
|
||
<span className="health-pill">
|
||
{discoverySuggestions.length} open
|
||
</span>
|
||
</div>
|
||
<p className="muted compact">
|
||
Aanvaard een bevinding pas nadat je het bewijs hebt nagekeken. Afgewezen bevindingen worden bewaard en komen niet bij elke scan terug.
|
||
</p>
|
||
<div className="review-filters">
|
||
<label>Bevindingen zoeken<input value={suggestionSearch} onChange={(event) => { setSuggestionSearch(event.target.value); setSuggestionLimit(30); }} placeholder="Service, bron of bewijs" /></label>
|
||
<label>Zekerheid<select value={suggestionConfidence} onChange={(event) => { setSuggestionConfidence(event.target.value); setSuggestionLimit(30); }}><option value="actionable">Hoog + bevestigd</option><option value="all">Alle</option><option value="confirmed">Bevestigd</option><option value="high">Hoog</option><option value="medium">Gemiddeld</option><option value="low">Laag</option></select></label>
|
||
<label>Type<select value={suggestionType} onChange={(event) => { setSuggestionType(event.target.value); setSuggestionLimit(30); }}><option value="all">Alle</option><option value="service">Service</option><option value="relation">Relatie</option></select></label>
|
||
</div>
|
||
<p className="muted compact">Toont {Math.min(suggestionLimit, visibleSuggestions.length)} van {visibleSuggestions.length} overeenkomende bevindingen ({discoverySuggestions.length} open).</p>
|
||
<div className="suggestion-list">
|
||
{visibleSuggestions.slice(0, suggestionLimit).map((suggestion) => {
|
||
const source = services.find(
|
||
(item) => item.service.id === suggestion.source_service_id,
|
||
)?.service;
|
||
const target = services.find(
|
||
(item) => item.service.id === suggestion.target_service_id,
|
||
)?.service;
|
||
return (
|
||
<article className="suggestion-card" key={suggestion.id}>
|
||
<div className="suggestion-card-heading">
|
||
<div>
|
||
<span className="eyebrow">
|
||
{suggestion.suggestion_type}
|
||
</span>
|
||
<strong>
|
||
{source?.name ??
|
||
suggestion.proposed_name ??
|
||
suggestion.source_ref ??
|
||
"Gevonden item"}
|
||
{suggestion.suggestion_type === "relation" && (
|
||
<>
|
||
{" "}
|
||
<span aria-hidden="true">→</span>{" "}
|
||
{target?.name ?? suggestion.target_ref ?? "target"}
|
||
</>
|
||
)}
|
||
</strong>
|
||
</div>
|
||
<span
|
||
className={`health-pill status-${suggestion.confidence === "low" ? "unknown" : suggestion.confidence === "medium" ? "degraded" : "healthy"}`}
|
||
>
|
||
{suggestion.confidence}
|
||
</span>
|
||
</div>
|
||
{suggestion.suggestion_type === "service" && (
|
||
<small>
|
||
{suggestion.proposed_category.replace("_", " ")} ·{" "}
|
||
{suggestion.proposed_url ??
|
||
`${suggestion.proposed_host ?? "geen endpoint"}${suggestion.proposed_port ? `:${suggestion.proposed_port}` : ""}`}
|
||
</small>
|
||
)}
|
||
{suggestion.suggestion_type === "relation" && (
|
||
<small>
|
||
{suggestion.relation_type ?? "relationship"} · pas na aanvaarding een canonieke gezondheidsrelatie
|
||
</small>
|
||
)}
|
||
<div className="evidence-list">
|
||
<strong>Bewijs</strong>
|
||
{suggestion.evidence.map((item) => (
|
||
<small key={item}>{item}</small>
|
||
))}
|
||
</div>
|
||
<div className="button-row wrap">
|
||
<button className="primary"
|
||
onClick={() =>
|
||
void reviewSuggestion(suggestion.id, "accept")
|
||
}
|
||
disabled={discoveryBusy}
|
||
>
|
||
Aanvaarden
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() =>
|
||
void reviewSuggestion(suggestion.id, "reject")
|
||
}
|
||
disabled={discoveryBusy}
|
||
>
|
||
Afwijzen
|
||
</button>
|
||
{suggestion.suggestion_type === "service" && (
|
||
<button
|
||
className="ghost"
|
||
onClick={() => {
|
||
const candidate = dockerCandidates.find(
|
||
(item) =>
|
||
item.stable_source_ref === suggestion.source_ref,
|
||
);
|
||
if (candidate) prefillDockerCandidate(candidate);
|
||
}}
|
||
>
|
||
Controle bekijken
|
||
</button>
|
||
)}
|
||
</div>
|
||
</article>
|
||
);
|
||
})}
|
||
{!visibleSuggestions.length && (
|
||
<div className="empty-inline">
|
||
Geen bevindingen voor deze filters.
|
||
</div>
|
||
)}
|
||
</div>
|
||
{visibleSuggestions.length > suggestionLimit && <button className="ghost show-more" onClick={() => setSuggestionLimit((current) => current + 30)}>30 bevindingen meer tonen</button>}
|
||
</section>
|
||
<section className="panel-section discovery-observations">
|
||
<div className="panel-heading">
|
||
<div>
|
||
<span className="eyebrow">Waargenomen infrastructuur</span>
|
||
<h3>Laatste bronwaarnemingen</h3>
|
||
</div>
|
||
<span className="health-pill">
|
||
{dockerCandidates.length} Docker-kandidaten
|
||
</span>
|
||
</div>
|
||
<div className="observation-list">
|
||
{discoveryItems.slice(0, 24).map((item) => (
|
||
<div className="observation-row" key={item.id}>
|
||
<strong>{item.source_name}</strong>
|
||
<span>{item.change_type}</span>
|
||
<small>
|
||
{item.lifecycle} · {formatDate(item.observed_at)}
|
||
</small>
|
||
</div>
|
||
))}
|
||
{!discoveryItems.length && (
|
||
<div className="empty-inline">
|
||
Nog geen afgeronde detectierun.
|
||
</div>
|
||
)}
|
||
</div>
|
||
<details className="candidate-details">
|
||
<summary>
|
||
Kandidatenlijst tonen ({dockerCandidates.length})
|
||
</summary>
|
||
<div className="docker-list compact-list">
|
||
{dockerCandidates.slice(0, 80).map((candidate) => (
|
||
<article
|
||
className="docker-card"
|
||
key={`${candidate.container_id}-${candidate.stable_source_ref}`}
|
||
>
|
||
<div>
|
||
<strong>{candidate.name}</strong>
|
||
<span>
|
||
{candidate.category.replace("_", " ")} · {candidate.state}
|
||
{candidate.health ? ` · ${candidate.health}` : ""}
|
||
</span>
|
||
</div>
|
||
<small>
|
||
{candidate.image} · {candidate.import_state}
|
||
</small>
|
||
<small>
|
||
{candidate.stable_source_ref ?? "geen stabiele identiteit"}
|
||
{candidate.compose_project
|
||
? ` · compose ${candidate.compose_project}`
|
||
: ""}
|
||
</small>
|
||
{candidate.proxy_route_evidence.map((item) => (
|
||
<small key={item}>{item}</small>
|
||
))}
|
||
{candidate.probe_candidates.map((probe) => (
|
||
<small key={`${probe.source}-${probe.url ?? probe.host ?? "none"}-${probe.port ?? ""}`}>
|
||
{probe.source.replace("_", " ")} · {probe.reachability}
|
||
{probe.url ??
|
||
(probe.host
|
||
? ` · ${probe.host}${probe.port ? `:${probe.port}` : ""}`
|
||
: "")}
|
||
{probe.preflight_detail ? ` · ${probe.preflight_detail}` : ""}
|
||
</small>
|
||
))}
|
||
</article>
|
||
))}
|
||
</div>
|
||
</details>
|
||
</section>
|
||
</div>
|
||
);
|
||
};
|
||
|
||
const renderChanges = () => {
|
||
const snapshotIndex = topologySnapshots.findIndex((item) => item.id === selectedSnapshotId);
|
||
const selectedSnapshot = topologySnapshots[snapshotIndex] ?? topologySnapshots[0];
|
||
const previousSnapshot = topologySnapshots[snapshotIndex + 1];
|
||
const changes = topologyDiff
|
||
? [...topologyDiff.added, ...topologyDiff.changed, ...topologyDiff.removed]
|
||
: [];
|
||
const inspectChange = (entityId: string, after: Record<string, unknown> | null) => {
|
||
const serviceId =
|
||
services.some((item) => item.service.id === entityId)
|
||
? entityId
|
||
: typeof after?.source_service_id === "string"
|
||
? after.source_service_id
|
||
: null;
|
||
if (!serviceId) return;
|
||
setSelectedId(serviceId);
|
||
setPanel("topology");
|
||
setInspectorOpen(true);
|
||
};
|
||
return (
|
||
<section className="panel-section change-intelligence">
|
||
<span className="eyebrow">Wijzigingsinzicht</span>
|
||
<h3>Topologiebewijs door de tijd</h3>
|
||
<p className="muted compact">
|
||
Snapshots are compact canonical topology captures. They compare service identity, lifecycle, semantic metadata and dependencies without changing your topology.
|
||
</p>
|
||
{selectedSnapshot && (
|
||
<label className="snapshot-picker">Snapshot vergelijken
|
||
<select value={selectedSnapshot.id} onChange={(event) => { setSelectedSnapshotId(event.target.value); setTopologyDiff(null); setChangeLimit(30); }}>
|
||
{topologySnapshots.map((item) => <option key={item.id} value={item.id}>{formatDate(item.created_at)} · {item.service_count} services</option>)}
|
||
</select>
|
||
</label>
|
||
)}
|
||
{selectedSnapshot && snapshotCheckedAt - new Date(selectedSnapshot.created_at).getTime() > 24 * 60 * 60 * 1000 && (
|
||
<p className="notice-inline">This topology snapshot is more than 24 hours old. Snapshots update after discovery reconciliation; current health evidence is shown in Overview and Services. <button className="text-button" onClick={() => setPanel("discovery")}>Detectie openen</button></p>
|
||
)}
|
||
{selectedSnapshot ? (
|
||
<dl className="detail-grid">
|
||
<div><dt>Geselecteerde topologiesnapshot</dt><dd>{formatDate(selectedSnapshot.created_at)}</dd></div>
|
||
<div><dt>Vergeleken met</dt><dd>{formatDate(previousSnapshot?.created_at)}</dd></div>
|
||
<div><dt>Services / relaties</dt><dd>{selectedSnapshot.service_count} / {selectedSnapshot.relationship_count}</dd></div>
|
||
<div><dt>Toegevoegd</dt><dd>{topologyDiff?.summary.added ?? 0}</dd></div>
|
||
<div><dt>Gewijzigd</dt><dd>{topologyDiff?.summary.changed ?? 0}</dd></div>
|
||
<div><dt>Verwijderd</dt><dd>{topologyDiff?.summary.removed ?? 0}</dd></div>
|
||
</dl>
|
||
) : <p className="muted compact">Na de volgende verwerking wordt een topologiesnapshot gemaakt.</p>}
|
||
{changes.length ? (
|
||
<>
|
||
<p className="muted compact">Toont {Math.min(changeLimit, changes.length)} van {changes.length} wijzigingen. Klap een item open om de gewijzigde velden te bekijken.</p>
|
||
<div className="change-list">
|
||
{changes.slice(0, changeLimit).map((change) => {
|
||
const fields = changedFields(change.before, change.after);
|
||
return <details key={`${change.change_type}-${change.entity_type}-${change.entity_id}`} className="change-card">
|
||
<summary><strong>{change.name}</strong><small>{change.change_type} {change.entity_type} · {fields.length ? `${fields.length} ${fields.length === 1 ? "veld" : "velden"} gewijzigd` : "item toegevoegd of verwijderd"}</small></summary>
|
||
{fields.length > 0 && <div className="change-fields">{fields.map((item) => <div key={item.field}><strong>{item.field.replaceAll("_", " ")}</strong><small>{item.before} → {item.after}</small></div>)}</div>}
|
||
{change.after && <button className="ghost" onClick={() => inspectChange(change.entity_id, change.after)}>Bekijken in topologie</button>}
|
||
</details>;
|
||
})}
|
||
</div>
|
||
{changes.length > changeLimit && <button className="ghost show-more" onClick={() => setChangeLimit((current) => current + 30)}>30 wijzigingen meer tonen</button>}
|
||
</>
|
||
) : (
|
||
<p className="muted compact">Er is geen topologieverschil geregistreerd tussen de twee laatste snapshots.</p>
|
||
)}
|
||
</section>
|
||
);
|
||
};
|
||
|
||
const renderConfig = () => (
|
||
<section className="panel-section config-panel">
|
||
<span className="eyebrow">Configuratie v2</span>
|
||
<h3>Importeren / exporteren</h3>
|
||
<p className="muted compact">
|
||
Een import controleert eerst de volledige grafiek in één keer voor hij iets opslaat. Bestaande v1-documenten blijven importeerbaar.
|
||
</p>
|
||
<div className="field-row">
|
||
<label>
|
||
Formaat
|
||
<select
|
||
value={configFormat}
|
||
onChange={(event) =>
|
||
setConfigFormat(event.target.value as "yaml" | "json")
|
||
}
|
||
>
|
||
<option value="yaml">YAML</option>
|
||
<option value="json">JSON</option>
|
||
</select>
|
||
</label>
|
||
<label>
|
||
Modus
|
||
<select
|
||
value={configMode}
|
||
onChange={(event) =>
|
||
setConfigMode(event.target.value as "merge" | "replace")
|
||
}
|
||
>
|
||
<option value="merge">Samenvoegen</option>
|
||
<option value="replace">Vervangen</option>
|
||
</select>
|
||
</label>
|
||
</div>
|
||
<label className="config-label">
|
||
Configuratie
|
||
<textarea
|
||
value={configText}
|
||
onChange={(event) => setConfigText(event.target.value)}
|
||
spellCheck={false}
|
||
/>
|
||
</label>
|
||
<div className="button-row wrap">
|
||
<button className="primary" onClick={() => void importConfig()}>Configuratie toepassen</button>
|
||
<button className="ghost" onClick={() => void exportConfig("yaml")}>
|
||
YAML
|
||
</button>
|
||
<button className="ghost" onClick={() => void exportConfig("json")}>
|
||
JSON
|
||
</button>
|
||
</div>
|
||
</section>
|
||
);
|
||
|
||
return (
|
||
<div className={`shell ${demo?.active ? "demo-mode" : ""}`}>
|
||
<a className="skip-link" href="#main-content" onClick={(event) => { event.preventDefault(); mainRef.current?.focus(); }}>
|
||
Naar inhoud springen
|
||
</a>
|
||
<header className="topbar">
|
||
<div className="topbar-inner">
|
||
<div className="brand-lockup">
|
||
<img src="/brand/servicemap-mark.svg" alt="" />
|
||
<h1>ServiceMap</h1>
|
||
</div>
|
||
<nav className={`panel-tabs ${navMoreOpen ? "nav-more-open" : ""}`} aria-label="ServiceMap-werkruimtes">
|
||
{(
|
||
[
|
||
"overview",
|
||
"topology",
|
||
"incidents",
|
||
"services",
|
||
"discovery",
|
||
"changes",
|
||
"activity",
|
||
"config",
|
||
"settings",
|
||
] as Panel[]
|
||
).map((item) => (
|
||
<button
|
||
key={item}
|
||
className={`${panel === item ? "active" : ""} ${PRIMARY_PANELS.includes(item) ? "" : "nav-secondary"}`}
|
||
aria-current={panel === item ? "page" : undefined}
|
||
onClick={() => { setPanel(item); setNotice(null); setReconcileConfirm(false); setNavMoreOpen(false); }}
|
||
>
|
||
{(() => {
|
||
const TabIcon = PANEL_ICONS[item];
|
||
return <TabIcon size={16} aria-hidden="true" />;
|
||
})()}
|
||
{item === "incidents" ? (
|
||
<>
|
||
Incidenten
|
||
{incident?.active && (
|
||
<>
|
||
<span aria-hidden="true"> •</span>
|
||
<span className="sr-only"> (actief incident)</span>
|
||
</>
|
||
)}
|
||
</>
|
||
) : (
|
||
PANEL_LABELS[item]
|
||
)}
|
||
</button>
|
||
))}
|
||
<button
|
||
className={`nav-more ${PRIMARY_PANELS.includes(panel) ? "" : "active"}`}
|
||
aria-expanded={navMoreOpen}
|
||
onClick={() => setNavMoreOpen(!navMoreOpen)}
|
||
>
|
||
<Menu size={16} aria-hidden="true" />
|
||
Meer
|
||
</button>
|
||
</nav>
|
||
<div className="topbar-status">
|
||
{lastUpdatedAt && (
|
||
<span
|
||
className={`freshness ${realtimeStatus === "live" ? "" : "is-stale"}`}
|
||
title={`Laatst volledig bijgewerkt: ${formatDateTime(lastUpdatedAt)}`}
|
||
>
|
||
bijgewerkt {formatTime(lastUpdatedAt)}
|
||
</span>
|
||
)}
|
||
<span
|
||
className={`live-status live-status-${realtimeStatus}`}
|
||
role="status"
|
||
aria-live="polite"
|
||
>
|
||
{realtimeStatus === "live"
|
||
? "● Live"
|
||
: realtimeStatus === "connecting"
|
||
? "Verbinden…"
|
||
: "Updates gepauzeerd — opnieuw verbinden"}
|
||
</span>
|
||
<div className="kpi-chips" role="group" aria-label="Gezondheidsoverzicht">
|
||
{(["healthy", "degraded", "down", "unknown"] as HealthStatus[]).map((item) => (
|
||
<span key={item} className={`kpi-chip status-${item}`} title={`${counts[item] ?? 0} ${item}`}>
|
||
<StatusIcon status={item} />
|
||
<strong>{counts[item] ?? 0}</strong>
|
||
<span className="sr-only"> {item}</span>
|
||
</span>
|
||
))}
|
||
</div>
|
||
</div>
|
||
<div className="toolbar">
|
||
<button
|
||
className="primary"
|
||
onClick={() => void probeAll()}
|
||
disabled={busyAll || Boolean(demo?.active)}
|
||
>
|
||
<Zap size={16} aria-hidden="true" />
|
||
<span className="toolbar-label">
|
||
{demo?.active
|
||
? "Synthetische controles"
|
||
: busyAll
|
||
? "Alles controleren…"
|
||
: "Alles controleren"}
|
||
</span>
|
||
</button>
|
||
<ActionsMenu label="Meer acties" footer={<small>ServiceMap v1.6.3</small>}>
|
||
{(close) => (
|
||
<>
|
||
{writeAuth === "admin_token" &&
|
||
(editUnlocked ? (
|
||
<button className="ghost" onClick={() => { close(); lockEditing(); }}>
|
||
<Lock size={16} aria-hidden="true" />
|
||
Bewerken vergrendelen
|
||
</button>
|
||
) : (
|
||
<button className="ghost" onClick={() => { close(); setUnlockOpen(true); }}>
|
||
<LockOpen size={16} aria-hidden="true" />
|
||
Bewerken ontgrendelen
|
||
</button>
|
||
))}
|
||
{demo?.enabled && (
|
||
<button
|
||
className="ghost"
|
||
onClick={() => { close(); void loadDemo(); }}
|
||
disabled={demoBusy || loading}
|
||
>
|
||
<FlaskConical size={16} aria-hidden="true" />
|
||
{demo.active ? "Demo opnieuw starten" : "Demo verkennen"}
|
||
</button>
|
||
)}
|
||
<button className="ghost" onClick={() => { close(); void exportConfig("yaml"); }}>
|
||
<Download size={16} aria-hidden="true" />
|
||
YAML exporteren
|
||
</button>
|
||
</>
|
||
)}
|
||
</ActionsMenu>
|
||
</div>
|
||
</div>
|
||
{unlockOpen && (
|
||
<form
|
||
className="unlock-panel unlock-popover"
|
||
aria-label="Bewerken ontgrendelen"
|
||
onSubmit={(event) => void unlockEditing(event)}
|
||
onKeyDown={(event) => {
|
||
if (event.key === "Escape") {
|
||
setUnlockOpen(false);
|
||
setUnlockError(null);
|
||
setUnlockValue("");
|
||
}
|
||
}}
|
||
>
|
||
<label>
|
||
Beheerderstoken
|
||
<input
|
||
type="password"
|
||
autoComplete="off"
|
||
autoFocus
|
||
required
|
||
value={unlockValue}
|
||
onChange={(event) => setUnlockValue(event.target.value)}
|
||
/>
|
||
</label>
|
||
<small>
|
||
Wijzigingen vragen het ServiceMap-beheerderstoken. Lees het op de host met{" "}
|
||
<code>docker exec servicemap cat /data/admin-token</code>. Het wordt alleen voor dit tabblad bewaard.
|
||
</small>
|
||
{unlockError && (
|
||
<span className="unlock-error" role="alert">
|
||
{unlockError}
|
||
</span>
|
||
)}
|
||
<div className="unlock-actions">
|
||
<button className="primary" type="submit" disabled={unlockBusy || !unlockValue.trim()}>
|
||
{unlockBusy ? "Controleren…" : "Ontgrendelen"}
|
||
</button>
|
||
<button
|
||
type="button"
|
||
className="ghost"
|
||
onClick={() => {
|
||
setUnlockOpen(false);
|
||
setUnlockError(null);
|
||
setUnlockValue("");
|
||
}}
|
||
>
|
||
Annuleren
|
||
</button>
|
||
</div>
|
||
</form>
|
||
)}
|
||
</header>
|
||
{(incident?.active || realtimeStatus === "offline") && (
|
||
<section
|
||
className={`status-line ${incident?.active ? "status-line-incident" : "status-line-offline"}`}
|
||
aria-label="Huidig operationeel beeld"
|
||
>
|
||
<strong>
|
||
{incident?.active ? "Actief afhankelijkheidsincident" : "Laatst bekende toestand"}
|
||
</strong>
|
||
<span>
|
||
{services.length} services · {resolvedComponentCount} met actueel componentbewijs ·{" "}
|
||
{unresolvedComponentCount} onopgelost
|
||
</span>
|
||
{incident?.active && panel !== "incidents" && (
|
||
<button className="text-button" onClick={() => setPanel("incidents")}>
|
||
Incidenten bekijken
|
||
</button>
|
||
)}
|
||
</section>
|
||
)}
|
||
{error && (
|
||
<div className="error-banner" role="alert">
|
||
{error}
|
||
</div>
|
||
)}
|
||
{notice && (
|
||
<div className="notice-banner" role="status">
|
||
<span>{notice}</span><button className="text-button" aria-label="Melding sluiten" onClick={() => setNotice(null)}>Sluiten</button>
|
||
</div>
|
||
)}
|
||
{demo?.active && (
|
||
<section
|
||
className="demo-banner"
|
||
role="status"
|
||
aria-label="Demoscenario verkennen"
|
||
aria-live="polite"
|
||
aria-busy={demoBusy}
|
||
>
|
||
<div>
|
||
<span className="eyebrow">
|
||
Demoscenario · synthetische bewakingsgegevens
|
||
</span>
|
||
<strong>PostgreSQL is niet beschikbaar.</strong>
|
||
<p>
|
||
ServiceMap wijst het aan als waarschijnlijke hoofdoorzaak; het raakt{" "}
|
||
{demo.affected_count} afhankelijke services. Selecteer een node om gezondheid en geschiedenis te bekijken.
|
||
</p>
|
||
</div>
|
||
<div className="demo-actions">
|
||
<button
|
||
className="ghost"
|
||
onClick={() => {
|
||
setPanel("topology");
|
||
setTopologyMode("impact");
|
||
setBlastRadius(true);
|
||
}}
|
||
>
|
||
Impact volgen
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => {
|
||
const dataDomain = semanticTopology?.domains.find(
|
||
(item) => item.name === "Data",
|
||
);
|
||
if (dataDomain) setTopologyLocation(domainLocation(dataDomain.id));
|
||
setPanel("topology");
|
||
}}
|
||
>
|
||
Data verkennen
|
||
</button>
|
||
<button className="ghost" onClick={() => setPanel("incidents")}>
|
||
Incident bekijken
|
||
</button>
|
||
{demo.enabled && (
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void resetDemo()}
|
||
disabled={demoBusy}
|
||
>
|
||
Demo opnieuw starten
|
||
</button>
|
||
)}
|
||
</div>
|
||
<DemoWalkthrough
|
||
step={demoStep}
|
||
affectedCount={demo.affected_count}
|
||
busy={demoBusy}
|
||
onStepChange={setDemoWalkthroughStep}
|
||
onExit={() => void exitDemo()}
|
||
/>
|
||
</section>
|
||
)}
|
||
<ConfirmDialog
|
||
open={demoConfirm}
|
||
title="De demo vervangt deze topologie tijdelijk."
|
||
confirmLabel="Snapshot maken en verkennen"
|
||
onConfirm={() => void startDemo()}
|
||
onCancel={() => setDemoConfirm(false)}
|
||
busy={demoBusy}
|
||
>
|
||
<p>
|
||
Je huidige services, controles, incidenten en gebeurtenissen worden vastgelegd en teruggezet zodra je Demo afsluiten kiest.
|
||
</p>
|
||
</ConfirmDialog>
|
||
<main id="main-content" ref={mainRef} tabIndex={-1} aria-label={`Werkruimte ${PANEL_LABELS[panel]}`}>
|
||
{panel === "overview" && renderOverview()}
|
||
{panel === "incidents" && renderIncidents()}
|
||
{panel === "services" && renderServicesTable()}
|
||
{panel === "discovery" && renderDiscovery()}
|
||
{panel === "changes" && renderChanges()}
|
||
{panel === "activity" && renderActivity()}
|
||
{panel === "settings" && renderSettings()}
|
||
{panel === "config" && renderConfig()}
|
||
{panel === "topology" && (
|
||
<>
|
||
<TopologyCommandBar
|
||
location={topologyLocation}
|
||
setLocation={setTopologyLocation}
|
||
selectedDomain={selectedDomain ?? null}
|
||
selectedApplication={selectedApplication ?? null}
|
||
mode={topologyMode}
|
||
setMode={setTopologyMode}
|
||
setImpact={setBlastRadius}
|
||
showImpact={Boolean(demo?.active || selectedIncident)}
|
||
search={search}
|
||
setSearch={setSearch}
|
||
statusFilter={statusFilter}
|
||
setStatusFilter={setStatusFilter}
|
||
monitoringFilter={monitoringFilter}
|
||
setMonitoringFilter={setMonitoringFilter}
|
||
groupFilter={groupFilter}
|
||
environmentFilter={environmentFilter}
|
||
setEnvironmentFilter={setEnvironmentFilter}
|
||
criticalityFilter={criticalityFilter}
|
||
setCriticalityFilter={setCriticalityFilter}
|
||
domainFilter={domainFilter}
|
||
setDomainFilter={setDomainFilter}
|
||
applicationFilter={serviceApplicationFilter}
|
||
setApplicationFilter={setServiceApplicationFilter}
|
||
lifecycleFilter={lifecycleFilter}
|
||
setLifecycleFilter={setLifecycleFilter}
|
||
filtersOpen={filtersOpen}
|
||
setFiltersOpen={setFiltersOpen}
|
||
domains={domains}
|
||
applications={applications}
|
||
environments={environments}
|
||
activeFilters={activeTopologyFilters}
|
||
onFit={() => flowInstance.current?.fitView({ padding: 0.16 })}
|
||
onArrange={() => void autoArrangeGraph()}
|
||
inspectorOpen={inspectorOpen}
|
||
onToggleInspector={() => setInspectorOpen(!inspectorOpen)}
|
||
/> <section
|
||
className="workspace topology-workspace"
|
||
>
|
||
<div className="canvas-card">
|
||
{loading && !services.length ? (
|
||
<div className="graph-skeleton" role="status">
|
||
{Array.from({ length: 8 }, (_, index) => (
|
||
<span key={index} className="skeleton-card" aria-hidden="true" />
|
||
))}
|
||
<span className="sr-only">Topologie laden…</span>
|
||
</div>
|
||
) : services.length ? (
|
||
<>
|
||
{(
|
||
<div className="canvas-toolbar">
|
||
<button
|
||
className={graphListView ? "compact-button" : "ghost compact-button"}
|
||
aria-pressed={graphListView}
|
||
onClick={() => setGraphListView(!graphListView)}
|
||
>
|
||
{graphListView ? "Grafiek tonen" : "Als lijst tonen"}
|
||
</button>
|
||
{(semanticGraph?.hiddenEdgeCount ?? 0) > 0 && (
|
||
<span className="canvas-note">
|
||
Toont de sterkste {edges.length} van{" "}
|
||
{edges.length + (semanticGraph?.hiddenEdgeCount ?? 0)} relaties op dit niveau
|
||
</span>
|
||
)}
|
||
{topologyLocation.level === "components" && (
|
||
<>
|
||
{editMode && (
|
||
<span className="canvas-note">
|
||
Sleep nodes om ze vast te zetten. Trek een lijn van een afhankelijkheid naar de service die ze gebruikt.
|
||
</span>
|
||
)}
|
||
<button
|
||
className={editMode ? "compact-button" : "ghost compact-button"}
|
||
aria-pressed={editMode}
|
||
onClick={() => setEditMode(!editMode)}
|
||
>
|
||
{editMode ? "Klaar met bewerken" : "Indeling bewerken"}
|
||
</button>
|
||
</>
|
||
)}
|
||
</div>
|
||
)}
|
||
{graphListView ? (
|
||
<GraphListView nodes={nodes} edges={edges} onOpen={openGraphNode} />
|
||
) : (
|
||
<div className="flow-host" onKeyDown={onGraphKeyDown}>
|
||
<ReactFlow
|
||
nodes={nodes}
|
||
edges={edges}
|
||
onNodesChange={onNodesChange}
|
||
nodeTypes={nodeTypes}
|
||
edgeTypes={edgeTypes}
|
||
minZoom={0.2}
|
||
nodesDraggable={editMode && topologyLocation.level === "components"}
|
||
nodesConnectable={editMode && topologyLocation.level === "components"}
|
||
onInit={(instance) => {
|
||
flowInstance.current = instance;
|
||
instance.fitView({ padding: 0.16 });
|
||
}}
|
||
onNodeClick={(_, node) => openGraphNode(node)}
|
||
onNodeMouseEnter={(_, node) => setHoveredNodeId(node.id)}
|
||
onNodeMouseLeave={() => setHoveredNodeId(null)}
|
||
onPaneClick={() => setSelectedEdgeId(null)}
|
||
onEdgeClick={(_, edge) => {
|
||
const evidence = edgeEvidence.find(
|
||
(item) =>
|
||
item.source_service_id === edge.target &&
|
||
item.target_service_id === edge.source,
|
||
);
|
||
setSelectedEdgeId(evidence?.id ?? null);
|
||
setInspectorOpen(true);
|
||
}}
|
||
onConnect={(connection) => void createManualEdge(connection)}
|
||
onNodeDragStop={(_, node) =>
|
||
void persistNodePosition(node as ServiceNode)
|
||
}
|
||
>
|
||
<Background color="#2a333f" gap={22} size={1.2} />
|
||
<Controls />
|
||
{showMiniMap && <MiniMap pannable zoomable />}
|
||
</ReactFlow>
|
||
</div>
|
||
)}
|
||
</>
|
||
) : (
|
||
<div className="empty-state">
|
||
<strong>Nog geen services</strong>
|
||
<span>
|
||
Voeg een endpoint toe, importeer een configuratie of verken de synthetische demo.
|
||
</span>
|
||
</div>
|
||
)}
|
||
</div>
|
||
{inspectorOpen && (selected || selectedEdge) && (
|
||
<aside ref={sidePanelRef} className="side-panel topology-drawer" aria-label="Inspector">
|
||
<button
|
||
className="ghost icon-button drawer-close"
|
||
aria-label="Inspector sluiten"
|
||
onClick={() => setInspectorOpen(false)}
|
||
>
|
||
<X size={18} aria-hidden="true" />
|
||
</button>
|
||
{selectedEdge ? renderEdgeInspector() : renderInspector()}
|
||
<div className="graph-tools panel-section">
|
||
<div className="panel-heading">
|
||
<span className="eyebrow">Topologiebediening</span>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => setInspectorOpen(!inspectorOpen)}
|
||
>
|
||
{inspectorOpen ? "Inspector verbergen" : "Inspector tonen"}
|
||
</button>
|
||
</div>
|
||
<div className="mode-tabs" aria-label="Topologiemodus">
|
||
{(
|
||
[
|
||
"landscape",
|
||
"dependencies",
|
||
"impact",
|
||
] as TopologyMode[]
|
||
).map((mode) => (
|
||
<button
|
||
key={mode}
|
||
className={topologyMode === mode ? "active" : "ghost"}
|
||
onClick={() => {
|
||
setTopologyMode(mode);
|
||
if (mode === "impact") setBlastRadius(true);
|
||
else {
|
||
setBlastRadius(false);
|
||
setComponentScope(null);
|
||
if (mode === "landscape") {
|
||
setSemanticScope({
|
||
domainId: null,
|
||
applicationId: null,
|
||
});
|
||
}
|
||
}
|
||
}}
|
||
>
|
||
{mode === "impact"
|
||
? "Incidentimpact"
|
||
: modeText(mode)}
|
||
</button>
|
||
))}
|
||
</div>
|
||
{semanticTopology &&
|
||
(semanticScope.domainId || semanticScope.applicationId) && (
|
||
<div
|
||
className="topology-breadcrumbs"
|
||
aria-label="Topologiehiërarchie"
|
||
>
|
||
<button
|
||
className="text-button"
|
||
onClick={() => {
|
||
setSemanticScope({
|
||
domainId: null,
|
||
applicationId: null,
|
||
});
|
||
setTopologyMode("landscape");
|
||
}}
|
||
>
|
||
Domeinen
|
||
</button>
|
||
{semanticScope.domainId && (
|
||
<>
|
||
<span>›</span>
|
||
<button
|
||
className="text-button"
|
||
onClick={() =>
|
||
setSemanticScope((scope) => ({
|
||
...scope,
|
||
applicationId: null,
|
||
}))
|
||
}
|
||
>
|
||
{semanticTopology.domains.find(
|
||
(item) => item.id === semanticScope.domainId,
|
||
)?.name ?? "Domein"}
|
||
</button>
|
||
</>
|
||
)}
|
||
{semanticScope.applicationId && (
|
||
<>
|
||
<span>›</span>
|
||
<span>
|
||
{semanticTopology.applications.find(
|
||
(item) => item.id === semanticScope.applicationId,
|
||
)?.name ?? "Applicatie"}
|
||
</span>
|
||
</>
|
||
)}
|
||
</div>
|
||
)}
|
||
{topologyLocation.level === "components" && !semanticTopology && (
|
||
<>
|
||
<label className="scope-label">
|
||
{componentScope
|
||
? `Landschapsgroep: ${componentScope.label}`
|
||
: "Applicatiecomponenten"}
|
||
</label>
|
||
<select
|
||
aria-label="Applicatiecomponenten"
|
||
value={applicationFilter}
|
||
onChange={(event) => {
|
||
setComponentScope(null);
|
||
setApplicationFilter(event.target.value);
|
||
}}
|
||
>
|
||
<option value="all">Alle applicaties</option>
|
||
{applications.map((item) => (
|
||
<option key={item}>{item}</option>
|
||
))}
|
||
</select>
|
||
</>
|
||
)}
|
||
<div className="button-row wrap">
|
||
<button
|
||
className={focusMode ? "" : "ghost"}
|
||
onClick={() => setFocusMode(!focusMode)}
|
||
disabled={
|
||
!selectedId ||
|
||
topologyLocation.level !== "components" ||
|
||
Boolean(semanticTopology)
|
||
}
|
||
>
|
||
Focus op selectie
|
||
</button>
|
||
<button
|
||
className={blastRadius ? "" : "ghost"}
|
||
onClick={() => {
|
||
setBlastRadius(!blastRadius);
|
||
setTopologyMode("impact");
|
||
}}
|
||
disabled={!demo?.active && !selectedIncident}
|
||
>
|
||
Impact tonen
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() => void autoArrangeGraph()}
|
||
>
|
||
Automatisch schikken
|
||
</button>
|
||
<button
|
||
className="ghost"
|
||
onClick={() =>
|
||
flowInstance.current?.fitView({ padding: 0.16 })
|
||
}
|
||
>
|
||
Passend tonen
|
||
</button>
|
||
<button
|
||
className={showMiniMap ? "" : "ghost"}
|
||
onClick={() => setShowMiniMap(!showMiniMap)}
|
||
>
|
||
Minikaart
|
||
</button>
|
||
</div>
|
||
<div className="filter-row">
|
||
<input
|
||
aria-label="Topologie doorzoeken"
|
||
value={search}
|
||
onChange={(event) => setSearch(event.target.value)}
|
||
placeholder="Alle services doorzoeken"
|
||
/>
|
||
<select
|
||
aria-label="Filter op status"
|
||
value={statusFilter}
|
||
onChange={(event) =>
|
||
setStatusFilter(event.target.value as FilterStatus)
|
||
}
|
||
>
|
||
<option value="all">Alle statussen</option>
|
||
{(
|
||
[
|
||
"healthy",
|
||
"degraded",
|
||
"down",
|
||
"recovering",
|
||
"unmonitored",
|
||
"unknown",
|
||
"maintenance",
|
||
] as HealthStatus[]
|
||
).map((item) => (
|
||
<option key={item} value={item}>
|
||
{statusLabel(item)}
|
||
</option>
|
||
))}
|
||
</select>
|
||
<select
|
||
aria-label="Filter op groep"
|
||
value={groupFilter}
|
||
onChange={(event) => setGroupFilter(event.target.value)}
|
||
>
|
||
<option value="all">Alle groepen</option>
|
||
{groups.map((item) => (
|
||
<option key={item}>{item}</option>
|
||
))}
|
||
</select>
|
||
</div>
|
||
<p className="muted compact">
|
||
{topologyMode === "landscape"
|
||
? semanticScope.domainId
|
||
? "Applicatieweergave voor het geselecteerde operationele domein. Selecteer een applicatie om de componenten te bekijken."
|
||
: "Het landschap is geordend per operationeel domein. Selecteer een domein om de applicaties te verkennen."
|
||
: editMode
|
||
? "Sleep componentnodes om hun plaats vast te zetten. Nieuwe semantische relaties worden bevestigd als handmatige afhankelijkheden."
|
||
: focusMode
|
||
? "Toont twee afhankelijkheidsniveaus rond de geselecteerde service."
|
||
: blastRadius
|
||
? "Toont de hoofdoorzaak en de impact op afhankelijke services."
|
||
: "Pijlen wijzen van een afhankelijkheid naar de service die ervan afhangt. Selecteer een relatie voor het bewijs."}
|
||
</p>
|
||
<button
|
||
className={editMode ? "" : "ghost"}
|
||
onClick={() => setEditMode(!editMode)}
|
||
disabled={topologyLocation.level !== "components"}
|
||
>
|
||
{editMode ? "Klaar met bewerken" : "Componenten bewerken"}
|
||
</button>
|
||
</div>
|
||
{formOpen && renderServiceForm()}
|
||
</aside>
|
||
)}
|
||
</section>
|
||
</>
|
||
)}
|
||
</main>
|
||
</div>
|
||
);
|
||
}
|