@skyhook-io/radar-app 1.17.0 → 1.17.1

package/src/components/cnpg/protection/CNPGAttachArchiveDialog.tsx

@@ -0,0 +1,185 @@
+import { useState } from 'react'
+import {
+  ActionConfirmDialog,
+  FactGrid,
+  FactRow,
+  Input,
+  RadarUpgradeNote,
+  getRadarUpgradeRequirement,
+} from '@skyhook-io/k8s-ui'
+import { useCNPGArchivingPreview, useCNPGProtectionAction } from '../../../api/cnpg-protection'
+import { useConnection } from '../../../context/ConnectionContext'
+import { actionDialogResult } from '../../../api/actions'
+import { useCNPGWriteGuard } from '../actions/useCNPGWriteGuard'
+import { useToast } from '../../ui/Toast'
+import { CNPG_FORM_FIELD } from '../formFields'
+
+export function CNPGAttachArchiveDialog({
+  namespace,
+  name,
+  uid,
+  stores,
+  current,
+  onClose,
+}: {
+  namespace: string
+  name: string
+  uid: string
+  stores: any[]
+  current?: { objectStore: string; serverName: string }
+  onClose: () => void
+}) {
+  const { connection } = useConnection()
+  const [context] = useState(connection.context)
+  const [objectStore, setObjectStore] = useState(
+    current?.objectStore || (stores.length === 1 ? stores[0].metadata.name : ''),
+  )
+  const [serverName, setServerName] = useState(current?.serverName || `${name.slice(0, 54)}-${uid.slice(0, 8)}`)
+  const [acknowledged, setAcknowledged] = useState(false)
+  const preview = useCNPGArchivingPreview(namespace, name)
+  const write = useCNPGProtectionAction('clusters', namespace, name, preview.data?.context)
+  const guard = useCNPGWriteGuard({ namespace, name, scope: { kind: 'spec', paths: ['spec.plugins'] } })
+  const { showSuccess } = useToast()
+  const changed = connection.context !== context
+  const reviewed = preview.data
+  const upgrade = getRadarUpgradeRequirement(write.error || preview.error)
+  const result = actionDialogResult(write.outcomeError ?? write.error, { error: reviewed ? undefined : 'Attachment could not be reviewed', unknown: 'An earlier write to this Cluster may have taken effect' })
+    ?? (preview.error ? { state: 'error' as const, message: preview.error.message, title: reviewed ? undefined : 'Attachment could not be reviewed' } : undefined)
+  return (
+    <ActionConfirmDialog
+      open
+      onClose={onClose}
+      onBack={
+        reviewed
+          ? () => {
+              preview.reset()
+              write.reset()
+              setAcknowledged(false)
+            }
+          : undefined
+      }
+      backLabel="Back to storage"
+      onConfirm={() => {
+        if (!reviewed) {
+          preview.mutate({ reviewedContext: context, objectStore: objectStore.trim(), serverName: serverName.trim() })
+          return
+        }
+        write.mutate(
+          {
+            kind: 'clusters',
+            action: 'configureArchiving',
+            request: {
+              reviewedContext: reviewed.context,
+              uid: reviewed.uid,
+              facts: reviewed.facts,
+              params: {
+                objectStore: reviewed.facts.objectStore,
+                serverName: reviewed.facts.serverName,
+                acknowledgeArchive: acknowledged,
+              },
+            },
+          },
+          {
+            onSuccess: () => {
+              showSuccess('Archive configuration saved. Check WAL uploads and a successful base backup next.')
+              onClose()
+            },
+          },
+        )
+      }}
+      title={reviewed ? 'Review archive attachment' : 'Choose existing backup storage'}
+      subject={{ kind: 'Cluster', namespace, name }}
+      context={context}
+      effect="Enable the Barman plugin for WAL archiving and base backups. The ObjectStore itself is unchanged."
+      disabledReason={
+        changed ? 'The context changed. Close this guide and start again in the current context.' : undefined
+      }
+      incompleteReason={
+        !reviewed && (!objectStore.trim() || !serverName.trim())
+          ? 'Choose a store and archive server name'
+          : reviewed && !acknowledged
+            ? 'Confirm this archive identity is reserved for this Cluster'
+            : undefined
+      }
+      guard={reviewed ? guard.node : undefined}
+      guardSatisfied={!upgrade && (!reviewed || guard.satisfied)}
+      confirmLabel={reviewed ? (reviewed.unchanged ? 'Keep configuration' : 'Enable archiving') : 'Review attachment'}
+      isLoading={preview.isPending || write.isPending}
+      result={upgrade && result?.state === 'error' ? undefined : result}
+      warnings={reviewed?.warnings}
+      writes={
+        reviewed
+          ? [
+              {
+                summary: `patch Cluster ${namespace}/${name}`,
+                detail: `spec.plugins: enable ${String(reviewed.plugin.name)} with barmanObjectName=${reviewed.facts.objectStore}, serverName=${reviewed.facts.serverName}; preserve other plugins and parameters`,
+              },
+            ]
+          : undefined
+      }
+    >
+      {upgrade && <RadarUpgradeNote requirement={upgrade} />}
+      {reviewed ? (
+        <div className="space-y-3">
+          <FactGrid>
+            <FactRow label="ObjectStore">{reviewed.facts.objectStore}</FactRow>
+            <FactRow label="Archive identity">{reviewed.facts.serverName}</FactRow>
+            <FactRow label="Destination">
+              <span className="break-all font-mono">{reviewed.destination}</span>
+            </FactRow>
+            {reviewed.endpoint && (
+              <FactRow label="Endpoint">
+                <span className="break-all font-mono">{reviewed.endpoint}</span>
+              </FactRow>
+            )}
+          </FactGrid>
+          <p className="text-xs text-theme-text-secondary">
+            Kubernetes accepted the server dry-run. This does not verify uploads or archive isolation. The selected
+            ObjectStore is re-read on confirmation; it is not locked against a concurrent change.
+          </p>
+          <label className="flex items-start gap-2 text-sm">
+            <input type="checkbox" checked={acknowledged} onChange={(event) => setAcknowledged(event.target.checked)} />
+            <span>I confirm this archive identity is reserved for {name}.</span>
+          </label>
+        </div>
+      ) : (
+        <div className="space-y-3">
+          <label className="block">
+            <span className="text-xs font-medium text-theme-text-secondary">ObjectStore · namespace {namespace}</span>
+            <Input
+              aria-label="ObjectStore name"
+              list="cnpg-protection-stores"
+              value={objectStore}
+              disabled={!!current?.objectStore || preview.isPending}
+              onChange={(event) => setObjectStore(event.target.value)}
+              className={CNPG_FORM_FIELD}
+            />
+            <datalist id="cnpg-protection-stores">
+              {stores.map((store) => (
+                <option key={store.metadata.name} value={store.metadata.name} />
+              ))}
+            </datalist>
+          </label>
+          <label className="block">
+            <span className="text-xs font-medium text-theme-text-secondary">Archive server name</span>
+            <Input
+              aria-label="Archive server name"
+              value={serverName}
+              disabled={!!current?.objectStore || preview.isPending}
+              onChange={(event) => setServerName(event.target.value)}
+              className={CNPG_FORM_FIELD}
+            />
+          </label>
+          <p className="text-xs text-theme-text-secondary">
+            This name separates this Cluster’s archive inside the storage destination. A restored Cluster must use a
+            different archive identity from its recovery source. Store names alone do not establish isolation.
+          </p>
+          <p className="text-xs text-theme-text-tertiary">
+            Enter an existing store directly if suggestions are unavailable. Creating stores, configuring credentials
+            and installing the plugin are separate prerequisites.
+          </p>
+        </div>
+      )}
+    </ActionConfirmDialog>
+  )
+}

package/src/components/cnpg/protection/CNPGCreateScheduleDialog.tsx

@@ -0,0 +1,196 @@
+import { useState } from 'react'
+import yaml from 'yaml'
+import {
+  ActionConfirmDialog,
+  CNPGSchedulePreviewFacts,
+  ConfirmDialog,
+  FactGrid,
+  Input,
+  RadarUpgradeNote,
+  getRadarUpgradeRequirement,
+  useDebouncedValue,
+} from '@skyhook-io/k8s-ui'
+import { validateRFC1123Label } from '@skyhook-io/k8s-ui/utils/validators'
+import { useCNPGDraftSchedulePreview } from '../../../api/cnpg-protection'
+import { useConnection } from '../../../context/ConnectionContext'
+import { CreateResourceDialog } from '../../shared/CreateResourceDialog'
+import { CNPGScheduleInput } from './CNPGScheduleInput'
+import { useToast } from '../../ui/Toast'
+import { CNPG_FORM_FIELD } from '../formFields'
+
+export function CNPGCreateScheduleDialog({
+  namespace,
+  cluster,
+  onClose,
+  onCreated,
+}: {
+  namespace: string
+  cluster: string
+  onClose: () => void
+  onCreated: () => void
+}) {
+  const { connection } = useConnection()
+  const [context] = useState(connection.context)
+  const [name, setName] = useState(`${cluster.slice(0, 56)}-backup`)
+  const [schedule, setSchedule] = useState('0 0 2 * * *')
+  const [immediate, setImmediate] = useState(false)
+  const [draft, setDraft] = useState<string | null>(null)
+  const [editing, setEditing] = useState(false)
+  const [replace, setReplace] = useState(false)
+  const debounced = useDebouncedValue(schedule.trim(), 300)
+  const preview = useCNPGDraftSchedulePreview(namespace, cluster, debounced, !!debounced)
+  const { showSuccess } = useToast()
+  const current =
+    debounced === schedule.trim() && preview.data?.schedule === debounced && !preview.isFetching
+      ? preview.data
+      : undefined
+  const generated = () =>
+    yaml.stringify({
+      apiVersion: 'postgresql.cnpg.io/v1',
+      kind: 'ScheduledBackup',
+      metadata: { name: name.trim(), namespace },
+      spec: {
+        cluster: { name: cluster },
+        method: 'plugin',
+        pluginConfiguration: { name: 'barman-cloud.cloudnative-pg.io' },
+        schedule: schedule.trim(),
+        immediate,
+      },
+    })
+  const upgrade = getRadarUpgradeRequirement(preview.error)
+  const changed = context !== connection.context
+  if (changed)
+    return (
+      <ActionConfirmDialog
+        open
+        onClose={onClose}
+        onConfirm={() => {}}
+        title="Create backup schedule"
+        subject={{ kind: 'Cluster', namespace, name: cluster }}
+        context={context}
+        effect="The context changed."
+        confirmLabel="Review manifest"
+        disabledReason="Close this dialog and start again in the current context."
+      />
+    )
+  if (replace)
+    return (
+      <ConfirmDialog
+        open
+        onClose={() => setReplace(false)}
+        onConfirm={() => {
+          setDraft(generated())
+          setEditing(true)
+          setReplace(false)
+        }}
+        title="Replace the current schedule YAML?"
+        message="This uses the setup choices below and discards the YAML you edited."
+        variant="warning"
+        showWarning={false}
+        confirmLabel="Replace YAML"
+      />
+    )
+  if (editing && draft !== null)
+    return (
+      <CreateResourceDialog
+        open
+        onClose={onClose}
+        onBack={(value) => {
+          setDraft(value)
+          setEditing(false)
+        }}
+        backLabel="Back to schedule setup"
+        initialYaml={draft}
+        initialMode="create"
+        lockMode
+        title="Create backup schedule"
+        onCreated={(result) => {
+          onCreated()
+          showSuccess(
+            `${result.kind} ${result.name} created. Check its settings and the next backup; creation alone does not prove protection.`,
+          )
+        }}
+      />
+    )
+  return (
+    <ActionConfirmDialog
+      open
+      onClose={onClose}
+      onConfirm={() => {
+        if (draft !== null && draft !== generated()) {
+          setReplace(true)
+          return
+        }
+        setDraft(generated())
+        setEditing(true)
+      }}
+      title="Create matching backup schedule"
+      subject={{ kind: 'Cluster', namespace, name: cluster }}
+      context={context}
+      effect="Create a separate ScheduledBackup using this Cluster’s Barman plugin, then review its exact manifest."
+      size="wide"
+      confirmLabel="Review manifest"
+      guardSatisfied={!upgrade}
+      disabledReason={preview.error && !upgrade ? `Timing could not be checked: ${preview.error.message}` : undefined}
+      incompleteReason={
+        !name.trim()
+          ? 'Enter a schedule name'
+          : !validateRFC1123Label(name.trim()).valid
+            ? 'Use a valid schedule name'
+            : !current
+              ? 'Checking the schedule…'
+              : !current.valid
+                ? 'Choose a schedule the operator can run'
+                : undefined
+      }
+      notes={['Each scheduled run creates a Backup. This does not change the Cluster or validate credentials.']}
+    >
+      {upgrade && <RadarUpgradeNote requirement={upgrade} />}
+      {draft !== null && (
+        <div className="space-y-2 text-xs text-theme-text-secondary">
+          <p>
+            The current YAML is retained. Returning to review keeps it; rebuilding from these fields requires
+            confirmation.
+          </p>
+          <button type="button" className="btn-secondary px-3 py-1.5" onClick={() => setEditing(true)}>
+            Continue editing current YAML
+          </button>
+        </div>
+      )}
+      <label className="block">
+        <span className="text-xs font-medium text-theme-text-secondary">Schedule name · namespace {namespace}</span>
+        <Input
+          aria-label="Schedule name"
+          value={name}
+          onChange={(event) => setName(event.target.value)}
+          className={CNPG_FORM_FIELD}
+        />
+      </label>
+      <CNPGScheduleInput value={schedule} onChange={setSchedule} />
+      <label className="flex items-start gap-2 text-sm">
+        <input type="checkbox" checked={immediate} onChange={(event) => setImmediate(event.target.checked)} />
+        <span>
+          Also request a backup when the schedule is created.
+          <span className="mt-1 block text-xs text-theme-text-tertiary">
+            Off by default. Otherwise the first backup waits for its scheduled run.
+          </span>
+        </span>
+      </label>
+      {current && (
+        <FactGrid>
+          <CNPGSchedulePreviewFacts preview={current} />
+        </FactGrid>
+      )}
+      {preview.error && (
+        <button
+          type="button"
+          className="text-xs text-accent-text hover:underline"
+          onClick={() => void preview.refetch()}
+          disabled={preview.isFetching}
+        >
+          Retry timing check
+        </button>
+      )}
+    </ActionConfirmDialog>
+  )
+}

package/src/components/cnpg/protection/CNPGProtectionSetup.test.tsx

@@ -0,0 +1,121 @@
+// @vitest-environment jsdom
+import { renderToStaticMarkup } from 'react-dom/server'
+import { MemoryRouter } from 'react-router-dom'
+import { beforeEach, expect, it, vi } from 'vitest'
+import { CNPGProtectionSetup } from './CNPGProtectionSetup'
+
+const state = vi.hoisted(() => ({
+  support: 'supported',
+  context: 'ctx',
+  cluster: {} as any,
+  schedules: [] as any[],
+  coverage: 'full',
+  wal: 'Not reported',
+  walState: 'unknown',
+  backup: 'No successful backup yet',
+}))
+vi.mock('../../../api/client', () => ({ useRadarFeature: () => ({ support: state.support }) }))
+vi.mock('../../../context/ConnectionContext', () => ({
+  useConnection: () => ({ connection: { context: state.context } }),
+}))
+vi.mock('../useCNPGSidebarWorkspace', () => ({
+  useCNPGFleet: () => ({
+    query: {
+      data: {
+        objects: { objectStores: [], scheduledBackups: state.schedules },
+        coverage: { scheduledBackups: { state: state.coverage } },
+      },
+      refetch: vi.fn(),
+    },
+    fleet: {
+      rows: [
+        {
+          namespace: 'db',
+          name: 'pg',
+          cluster: state.cluster,
+          protection: { walArchiving: { text: state.wal, state: state.walState }, lastSuccessfulBackup: { text: state.backup } },
+        },
+      ],
+    },
+  }),
+}))
+vi.mock('../../../api/cnpg', () => ({
+  useCNPGOperator: () => ({
+    data: { components: [{ pluginName: 'barman-cloud.cloudnative-pg.io' }], coverage: { services: { state: 'full' } } },
+  }),
+  useCNPGClusterCapabilities: () => ({
+    data: { actions: { backup: { allowed: false, reason: 'You need create backups in namespace db' } } },
+  }),
+}))
+vi.mock('@skyhook-io/k8s-ui', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@skyhook-io/k8s-ui')>()),
+  DialogPortal: ({ children }: any) => children,
+}))
+
+beforeEach(() => {
+  state.support = 'supported'
+  state.cluster = { metadata: { name: 'pg', namespace: 'db', uid: 'uid' }, spec: {} }
+  state.schedules = []
+  state.coverage = 'full'
+  state.walState = 'unknown'
+  state.wal = 'Not reported'
+  state.backup = 'No successful backup yet'
+})
+const text = () =>
+  new DOMParser().parseFromString(renderToStaticMarkup(
+    <MemoryRouter initialEntries={['/?protectionSetup=1']}>
+      <CNPGProtectionSetup namespace="db" name="pg" onInspect={vi.fn()} />
+    </MemoryRouter>,
+  ), 'text/html').body.textContent!
+
+it('presents the whole task without treating a declaration or an unread fact as protection', () => {
+  const html = text()
+  expect(html).toContain('1. Archive storage')
+  expect(html).toContain('2. Backup schedule')
+  expect(html).toContain('3. Verify protection')
+  expect(html).toContain('Attach the Barman archive destination first')
+  expect(html).toContain('You need create backups in namespace db')
+  expect(html).toContain('Not reported')
+  expect(html).not.toContain('Protection complete')
+})
+
+it('makes a suspended matching schedule reachable rather than presenting active protection', () => {
+  state.cluster.spec.plugins = [
+    { name: 'barman-cloud.cloudnative-pg.io', isWALArchiver: true, parameters: { barmanObjectName: 'store' } },
+  ]
+  state.schedules = [
+    {
+      metadata: { name: 'nightly', namespace: 'db' },
+      spec: {
+        cluster: { name: 'pg' },
+        method: 'plugin',
+        pluginConfiguration: { name: 'barman-cloud.cloudnative-pg.io' },
+        schedule: '@daily',
+        suspend: true,
+      },
+    },
+  ]
+  expect(text()).toContain('suspended: open the schedule to resume it')
+  expect(text()).not.toContain('Create matching schedule…')
+})
+
+it('does not interpret denied schedule inventory as an absent schedule', () => {
+  state.coverage = 'denied'
+  expect(text()).toContain('Inventory incomplete')
+  expect(text()).toContain('Schedules may exist outside the readable inventory')
+})
+
+it('shows the upgrade path before offering setup writes against an older Radar', () => {
+  state.support = 'unsupported'
+  expect(text()).toContain('need a newer Radar')
+  expect(text()).not.toContain('Choose existing ObjectStore')
+})
+
+it('puts failed uploads ahead of the setup milestones and links to the existing repair flow', () => {
+ state.wal = 'Failing'
+ state.walState = 'failing'
+ const html = new DOMParser().parseFromString(renderToStaticMarkup(<MemoryRouter initialEntries={['/?protectionSetup=1']}><CNPGProtectionSetup namespace="db" name="pg" onInspect={vi.fn()} onOpenArchivingRepair={vi.fn()} /></MemoryRouter>), 'text/html').body.textContent!
+ expect(html.indexOf('Repair WAL archiving first')).toBeLessThan(html.indexOf('1. Archive storage'))
+ expect(html).toContain('Open archiving repair')
+ expect(html).toContain('Uploads failing')
+})