Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Explain the limits of restore-point evidence beside its state

pulse-triage[bot]c678ed1cb484
diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.md
index 48f6215cd6..19dc7fd20c 100644
--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md
+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md
@@ -21,6 +21,27 @@
## Purpose
+### Restore-point inspection states what its evidence cannot confirm
+
+The existing By date record detail places a visible, wrapping evidence-limits
+note beside State. A guest snapshot shares the guest's storage and is not a
+separate backup; it does not count towards backup protection. Provider-reported
+verification is not a tested restore, and prune retention establishes neither
+verification nor workload protection. A running or failed point explicitly
+remains incomplete. Guest records do not establish thaw or filesystem writes;
+host backup records must not invent a guest. The note follows the current
+same-ID point during refresh without retaining an obsolete assurance.
+
+Normal-suite `ProxmoxBackupsTable.test.tsx` consumes raw PBS/PVE inventory for
+snapshot, verified/unverified/missing verification, PBS-backed file, running,
+failed, prune-retained and host cases, plus open-record refresh continuity.
+Actual-App browser proof must inspect desktop and 320px pixels and native
+keyboard/touch disclosure, including same-point activity and verification
+changes. No route, provider operation, auth, policy, count, classification,
+identity, collection or polling behaviour changes. This is truthful recovery
+inspection, not proof of a restore, guest recovery or published availability.
+
+
### Guest SMART inspection withdraws a failed scoped read
A failed guest physical-disk resource read must not leave cached health words,
diff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.md
index 01aa648446..825235c090 100644
--- a/docs/release-control/v6/internal/subsystems/unified-resources.md
+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md
@@ -23,6 +23,27 @@ and sort the complete canonical change table while startup and ingestion wait.
## Purpose
+### Restore-point inspection states what its evidence cannot confirm
+
+The existing By date record detail places a visible, wrapping evidence-limits
+note beside State. A guest snapshot shares the guest's storage and is not a
+separate backup; it does not count towards backup protection. Provider-reported
+verification is not a tested restore, and prune retention establishes neither
+verification nor workload protection. A running or failed point explicitly
+remains incomplete. Guest records do not establish thaw or filesystem writes;
+host backup records must not invent a guest. The note follows the current
+same-ID point during refresh without retaining an obsolete assurance.
+
+Normal-suite `ProxmoxBackupsTable.test.tsx` consumes raw PBS/PVE inventory for
+snapshot, verified/unverified/missing verification, PBS-backed file, running,
+failed, prune-retained and host cases, plus open-record refresh continuity.
+Actual-App browser proof must inspect desktop and 320px pixels and native
+keyboard/touch disclosure, including same-point activity and verification
+changes. No route, provider operation, auth, policy, count, classification,
+identity, collection or polling behaviour changes. This is truthful recovery
+inspection, not proof of a restore, guest recovery or published availability.
+
+
### Guest SMART inspection withdraws a failed scoped read
A failed guest physical-disk resource read must not leave cached health words,
diff --git a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
index 920c18f81d..845830e101 100644
--- a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
+++ b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
@@ -109,6 +109,27 @@ const artifactVerificationText = (artifact: RecoverableArtifact): string => {
return artifact.sourceKind === 'snapshot' ? '' : 'Not reported';
};
+// State badges report provider evidence, not a tested recovery. Keep those
+// limits beside the open point's state, where keyboard and touch readers can
+// read them without hovering a badge or leaving for workload coverage.
+const artifactEvidenceLimit = (artifact: RecoverableArtifact): string => {
+ if (artifact.sourceKind === 'snapshot') {
+ return "This guest snapshot shares the guest's storage. It is not a separate backup and does not count towards backup protection.";
+ }
+ if (artifact.running) {
+ return 'This backup is still being written. It is not a completed restore point.';
+ }
+ if (artifact.failed) {
+ return 'This backup is incomplete after a failed task. It is not a completed restore point.';
+ }
+ if (artifact.verified === true) {
+ return "Verified is the provider's reported backup check, not a tested restore.";
+ }
+ return artifact.verified === false
+ ? 'This backup is not reported as verified. Its presence does not establish a successful restore.'
+ : 'Backup verification is not reported. Its presence does not establish a successful restore.';
+};
+
// Size and provider identifiers remain progressive detail. Workload and
// repository identity must also be readable before choosing a point on a phone.
const buildRecoverableDetailSections = (artifact: RecoverableArtifact): DetailSection[] => {
@@ -144,6 +165,26 @@ const buildRecoverableDetailSections = (artifact: RecoverableArtifact): DetailSe
}),
makeDetailRow('Prune protection', artifact.protected ? 'Kept when pruning' : ''),
]),
+ footerContent: (
+ <div
+ role="note"
+ aria-label="Recovery evidence limits"
+ class="space-y-1 whitespace-normal text-[11px] leading-snug text-muted wrap-anywhere"
+ >
+ <p>{artifactEvidenceLimit(artifact)}</p>
+ <Show when={artifact.protected}>
+ <p>
+ Kept when pruning is a retention setting, not verification or workload protection.
+ </p>
+ </Show>
+ <Show when={artifact.workload.type === 'vm' || artifact.workload.type === 'ct'}>
+ <p>
+ Backup and snapshot records do not establish that the guest has thawed or that its
+ filesystems accept writes.
+ </p>
+ </Show>
+ </div>
+ ),
},
{
label: 'Workload',
diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
index 7fef2facc3..5def674bcd 100644
--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
@@ -3086,3 +3086,151 @@ describe('By-date restore-point scope', () => {
vi.useRealTimers();
});
});
+
+describe('By date recovery evidence limits', () => {
+ beforeEach(() => {
+ vi.useFakeTimers({ now: BACKUP_IDENTITY_NOW, toFake: ['Date'] });
+ window.history.replaceState({}, '', '/proxmox/backups/date');
+ apiFetchJSONMock.mockResolvedValue({ data: [], policy: protectionPolicy });
+ });
+ afterEach(() => vi.useRealTimers());
+
+ it.each([
+ {
+ name: 'guest snapshot',
+ pve: { ...emptyPVE.data, guestSnapshots: [identitySnapshot()] },
+ pbs: [] as ReturnType<typeof identityPBS>[],
+ explanation: /shares the guest's storage.*not a separate backup/,
+ },
+ {
+ name: 'verified PBS snapshot',
+ pve: emptyPVE.data,
+ pbs: [identityPBS({ protected: true })],
+ explanation: /Verified is the provider's reported backup check, not a tested restore/,
+ },
+ {
+ name: 'unverified PBS snapshot',
+ pve: emptyPVE.data,
+ pbs: [identityPBS({ verified: false })],
+ explanation: /not reported as verified.*does not establish a successful restore/,
+ },
+ {
+ name: 'PVE file without verification',
+ pve: { ...emptyPVE.data, storageBackups: [identityArchive({ protected: true })] },
+ pbs: [],
+ explanation: /verification is not reported.*does not establish a successful restore/,
+ },
+ {
+ name: 'PBS-backed PVE file',
+ pve: {
+ ...emptyPVE.data,
+ storageBackups: [identityArchive({ isPBS: true, verified: true })],
+ },
+ pbs: [],
+ explanation: /Verified is the provider's reported backup check, not a tested restore/,
+ },
+ {
+ name: 'running PBS snapshot',
+ pve: emptyPVE.data,
+ pbs: [identityPBS({ inProgress: true, writeActivityObserved: true, writeActive: true })],
+ explanation: /still being written.*not a completed restore point/,
+ },
+ {
+ name: 'failed PBS snapshot',
+ pve: emptyPVE.data,
+ pbs: [identityPBS({ inProgress: true, writeActivityObserved: true, writeActive: false })],
+ explanation: /incomplete after a failed task.*not a completed restore point/,
+ },
+ {
+ name: 'running PVE file',
+ pve: { ...emptyPVE.data, storageBackups: [identityArchive({ inProgress: true })] },
+ pbs: [],
+ explanation: /still being written.*not a completed restore point/,
+ },
+ ])('explains $name without claiming a tested recovery', async ({ pve, pbs, explanation }) => {
+ apiFetchMock.mockImplementation((url: string) =>
+ Promise.resolve(jsonResponse({ data: url.endsWith('/pbs') ? { backups: pbs } : pve })),
+ );
+ renderInRouter(() => (
+ <ProxmoxBackupsTable
+ emptyIcon={<span />}
+ workloads={[identityGuest('guest-100', 'east', 'pve-1')]}
+ />
+ ));
+ const toggle = await screen.findByRole('button', { name: /Expand details/ });
+ fireEvent.click(toggle);
+ const detail = screen.getByTestId('proxmox-recoverable-detail');
+ const note = within(detail).getByRole('note', { name: 'Recovery evidence limits' });
+ expect(note).toBeVisible();
+ expect(note).toHaveTextContent(explanation);
+ expect(note).toHaveTextContent(/do not establish that the guest has thawed/);
+ expect(note).toHaveTextContent(/filesystems accept writes/);
+ expect(note).toHaveClass('whitespace-normal', 'wrap-anywhere');
+ const kept =
+ pbs.some((point) => point.protected) || pve.storageBackups.some((point) => point.protected);
+ expect(
+ note.textContent?.includes('retention setting, not verification or workload protection'),
+ ).toBe(kept);
+ expect(apiFetchMock).toHaveBeenCalledTimes(2);
+ });
+
+ it('does not describe a host backup as a thawed guest', async () => {
+ apiFetchMock.mockImplementation((url: string) =>
+ Promise.resolve(
+ jsonResponse(
+ url.endsWith('/pbs')
+ ? { data: { backups: [identityPBS({ backupType: 'host', vmid: 'host-proof' })] } }
+ : emptyPVE,
+ ),
+ ),
+ );
+ renderInRouter(() => <ProxmoxBackupsTable emptyIcon={<span />} />);
+ fireEvent.click(await screen.findByRole('button', { name: /Expand details/ }));
+ const note = screen.getByRole('note', { name: 'Recovery evidence limits' });
+ expect(note).toHaveTextContent(/not a tested restore/);
+ expect(note).not.toHaveTextContent(/guest|thawed|filesystems/);
+ });
+
+ it('updates the same open point from verified to incomplete and recovered without stale assurance', async () => {
+ vi.useFakeTimers({
+ now: BACKUP_IDENTITY_NOW,
+ toFake: ['Date', 'setInterval', 'clearInterval'],
+ });
+ let point = identityPBS({ protected: true });
+ apiFetchMock.mockImplementation((url: string) =>
+ Promise.resolve(
+ jsonResponse(url.endsWith('/pbs') ? { data: { backups: [point] } } : emptyPVE),
+ ),
+ );
+ renderInRouter(() => <ProxmoxBackupsTable emptyIcon={<span />} />);
+ const toggle = await screen.findByRole('button', { name: /Expand details/ });
+ fireEvent.click(toggle);
+ toggle.focus();
+ const detail = screen.getByTestId('proxmox-recoverable-detail');
+ expect(within(detail).getByRole('note')).toHaveTextContent(/not a tested restore/);
+ for (const [next, message] of [
+ [
+ identityPBS({ inProgress: true, writeActivityObserved: true, writeActive: true }),
+ 'still being written',
+ ],
+ [
+ identityPBS({ inProgress: true, writeActivityObserved: true, writeActive: false }),
+ 'incomplete after a failed task',
+ ],
+ [identityPBS({ verified: false }), 'not reported as verified'],
+ [identityPBS({ verified: true }), "provider's reported backup check"],
+ ] as const) {
+ point = next;
+ await vi.advanceTimersByTimeAsync(30_000);
+ await waitFor(() => expect(within(detail).getByRole('note')).toHaveTextContent(message));
+ expect(screen.getByTestId('proxmox-recoverable-detail')).toBe(detail);
+ expect(toggle).toHaveFocus();
+ expect(within(detail).getByRole('note')).not.toHaveTextContent('retention setting');
+ if (next.inProgress)
+ expect(within(detail).getByRole('note')).not.toHaveTextContent(
+ "provider's reported backup check",
+ );
+ }
+ expect(apiFetchMock).toHaveBeenCalledTimes(10);
+ });
+});