0cc3cac837
build / build (push) Successful in 1m47s
业务名「对内知识库」在 WeKnora 里叫 wiki-demo,两边对不上号。 页面从测试知识库绑定读取库名并拼在业务名后,读不到就只显示业务名, 不影响发布状态判定。
2567 lines
105 KiB
TypeScript
2567 lines
105 KiB
TypeScript
import { useCallback, useEffect, useRef, useState } from 'react'
|
||
import {
|
||
createLibraryRestoreAuthorization,
|
||
createLibrarySyncAuthorization,
|
||
enqueueLibraryBaseline,
|
||
enqueueLibraryCapture,
|
||
enqueueLibraryRecovery,
|
||
enqueueLibraryRestore,
|
||
enqueueLibrarySync,
|
||
fetchLibraryCaptures,
|
||
fetchLibraryJobDetail,
|
||
fetchLibraryMaintenance,
|
||
maintenanceOwnerJobID,
|
||
fetchLibraryOverview,
|
||
fetchLibraryRestoreAvailability,
|
||
fetchLibrarySnapshots,
|
||
reconcileLibraryCapture,
|
||
formatBytes,
|
||
scopeLabel,
|
||
type LibraryCaptureJob,
|
||
type LibraryJobLookup,
|
||
type LibraryJobRecord,
|
||
type LibraryMaintenanceView,
|
||
type LibraryOverview,
|
||
type LibraryRestoreAvailability,
|
||
type LibrarySnapshot,
|
||
type LibrarySnapshotList,
|
||
type LibraryStageRow,
|
||
type LibraryVersionRef,
|
||
} from './librarySnapshots'
|
||
import { useOptionalAuth } from './auth'
|
||
import './releaseTargets.css'
|
||
import { RestoreVerificationSection } from './RestoreVerificationSection'
|
||
import { fetchSnapshotVerification } from './restoreVerification'
|
||
import { fetchRoutingBindings } from './routingBindings'
|
||
|
||
// 一个知识库对应一个发布工作区。主操作随封存、授权、执行状态推进;
|
||
// 诊断按需展开,维护占用与失败恢复始终可见。
|
||
|
||
const stamp = (value: string) =>
|
||
value && Number.isFinite(new Date(value).getTime())
|
||
? new Date(value).toLocaleString('zh-CN', {
|
||
timeZone: 'Asia/Shanghai',
|
||
month: '2-digit',
|
||
day: '2-digit',
|
||
hour: '2-digit',
|
||
minute: '2-digit',
|
||
hour12: false,
|
||
})
|
||
: '—'
|
||
|
||
const elapsed = (from: string, to: number) => {
|
||
const start = new Date(from).getTime()
|
||
if (!Number.isFinite(start) || to <= start) return '—'
|
||
const total = Math.floor((to - start) / 1000)
|
||
const minutes = Math.floor(total / 60)
|
||
const seconds = total % 60
|
||
return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`
|
||
}
|
||
|
||
const ACTIVE_STATES = ['pending', 'running', 'retry']
|
||
const jobStateLabel: Record<string, string> = {
|
||
pending: '排队中',
|
||
running: '执行中',
|
||
retry: '重试中',
|
||
completed: '已完成',
|
||
failed: '失败',
|
||
}
|
||
|
||
type Scope = 'internal' | 'external'
|
||
|
||
// 签发授权与执行是两步:页面只提供入口,不会替人签发,也不会自动重试执行。
|
||
export interface ReleaseSyncActions {
|
||
// 管理员才能签发;工程师看得到条件但没有按钮。
|
||
canSign: boolean
|
||
pendingGrant: boolean
|
||
onGrant: () => void
|
||
// 闸口全部满足才能启动(接口用同一份判定,按钮只是提前说明)。
|
||
canStart: boolean
|
||
pending: boolean
|
||
onStart: () => void
|
||
}
|
||
|
||
export interface ReleaseBaselineActions {
|
||
canStart: boolean
|
||
pending: boolean
|
||
onStart: () => void
|
||
}
|
||
|
||
interface ScopeView {
|
||
scope: Scope
|
||
snapshot?: LibrarySnapshot
|
||
history: LibrarySnapshot[]
|
||
activeJob?: LibraryCaptureJob
|
||
lastJob?: LibraryCaptureJob
|
||
// 持久作业与三类版本:来自 /api/v1/library/overview,重启后仍可读。
|
||
overview?: LibraryOverview | null
|
||
job?: LibraryJobRecord
|
||
syncJob?: LibraryJobRecord
|
||
}
|
||
|
||
interface ViewProps {
|
||
page: LibrarySnapshotList | null
|
||
jobs: LibraryCaptureJob[]
|
||
loading: boolean
|
||
error: string | null
|
||
notice: string | null
|
||
scope: Scope
|
||
onScope: (scope: Scope) => void
|
||
// 真实库名(来自测试知识库绑定):scope 是业务名,光看"对内知识库"对不上 WeKnora 里的库。
|
||
kbNames?: Record<Scope, string>
|
||
drawerOpen: boolean
|
||
onDrawer: (open: boolean) => void
|
||
expandedSnapshot: string | null
|
||
onExpandSnapshot: (id: string | null) => void
|
||
pendingCapture: boolean
|
||
canCapture: boolean
|
||
canWrite: boolean
|
||
// 管理员核对已完成 queue/精确版本/归档后修复 pending 封存作业终态。
|
||
canReconcileCapture: boolean
|
||
pendingReconcileCapture: string
|
||
onReconcileCapture: (jobID: string) => void
|
||
// 发布动作:签发授权(管理员)与启动同步是两个独立步骤,页面绝不自动签发。
|
||
sync: ReleaseSyncActions
|
||
// 目标非空又没有生效版本时,唯一入口是"建立目标权威基线"(管理员)。
|
||
baseline: ReleaseBaselineActions
|
||
// 恢复验证(真实作业)的接受/终态要回到父页面:父级据此启动轮询并在终态读回
|
||
// overview/维护/闸口,不能只在子面板里刷新自己。
|
||
verification: {
|
||
onAccepted: (jobId: string) => void
|
||
onComplete: (jobId: string) => void
|
||
}
|
||
// 按版本恢复是管理员动作:工程师看得到条件,但拿不到恢复入口。
|
||
canRestore: boolean
|
||
restore: LibraryRestoreAvailability | null
|
||
restoreNotice: string | null
|
||
pendingRestore: boolean
|
||
pendingGrant: boolean
|
||
onGrantRestore: () => void
|
||
onRestore: () => void
|
||
overview: LibraryOverview | null
|
||
/** F09: 每个 scope 的独立观测;不能拿当前 scope 的 overview 重算另一个页签。 */
|
||
overviews?: Record<Scope, LibraryOverview | null>
|
||
maintenance: LibraryMaintenanceView | null
|
||
// 维护记录里 owner_job_id 对应的作业详情;缺失就是“未读取”,不能用 overview.job 顶替。
|
||
maintenanceOwnerJob?: LibraryJobLookup
|
||
now: number
|
||
onRefresh: () => void
|
||
onCapture: () => void
|
||
onRecover: (windowJobID: string) => void
|
||
}
|
||
|
||
function scopeView(
|
||
page: LibrarySnapshotList | null,
|
||
jobs: LibraryCaptureJob[],
|
||
scope: Scope,
|
||
overview: LibraryOverview | null
|
||
): ScopeView {
|
||
const history = (page?.snapshots ?? []).filter((item) => item.scope === scope)
|
||
const scoped = jobs.filter((job) => job.scope === scope)
|
||
const persisted = overview?.jobs ?? []
|
||
// F02/F06: 顶部阶段必须跟当前在飞作业;只有没有在飞作业时才显示最近终态。
|
||
// 同一个 overview 里可能有刚完成的封存和正在跑的同步,不能用"最近一条"覆盖当前阶段。
|
||
const job =
|
||
persisted.find((item) => item.state === 'pending' || item.state === 'running') ?? overview?.job ?? persisted[0]
|
||
return {
|
||
scope,
|
||
// 候选只认接口给的 test_sealed(来自版本登记):归档里还有生产预备份与
|
||
// 目标基线快照,按"最新一份"挑会把目标自己的内容显示成测试封存。
|
||
snapshot: overview?.test_sealed,
|
||
history,
|
||
activeJob: scoped.find((job) => ACTIVE_STATES.includes(job.state)),
|
||
lastJob: scoped[0],
|
||
overview,
|
||
job,
|
||
syncJob: persisted.find((item) => item.kind === 'sync'),
|
||
}
|
||
}
|
||
|
||
const scopeName = (scope: Scope) => (scope === 'internal' ? '对内知识库' : '对外知识库')
|
||
// 绑定里拿不到库名时只显示业务名,不编一个名字出来。
|
||
const scopeTitle = (scope: Scope, kbName?: string) => {
|
||
const kb = kbName?.trim()
|
||
return kb ? `${scopeName(scope)} · ${kb}` : scopeName(scope)
|
||
}
|
||
|
||
// 生产目标必须按接口的四类状态原样呈现:把"已读且为空"和"读不到"都写成"未知",
|
||
// 会让人去点一个必然被拒绝的"建立基线"(后端对空目标返回 409 library_baseline_target_empty,
|
||
// 对读不到的目标返回 503 library_baseline_unprobeable)。
|
||
type ProductionTargetClass = 'known' | 'empty' | 'nonempty' | 'unreachable' | 'no-observation'
|
||
|
||
// 只有真正读到的 overview 才能分类。页面自己补的 {state:'unknown'} 与后端
|
||
// "已探测且非空"在 JSON 上无法区分,所以缺观测必须单列一类(no-observation),
|
||
// 否则首次加载、整体读取失败、当前范围没数据都会被误报成"目标非空"(F1)。
|
||
function productionTargetClass(production: LibraryOverview['production'] | null | undefined): ProductionTargetClass {
|
||
if (!production) return 'no-observation'
|
||
if (production.state === 'known' && production.version) return 'known'
|
||
if (production.state === 'unreachable') return 'unreachable'
|
||
// unknown 有两种:可读且空(空基线,首次发布合法起点)与可读但非空(缺权威版本)。
|
||
return production.empty_baseline ? 'empty' : 'nonempty'
|
||
}
|
||
|
||
// 刷新失败时页面会保留上一次的 overview:那份观测仍是当时的真实结果,
|
||
// 但已经不是刚刚验证过的状态,必须标出来,不能混作当前结论。
|
||
const STALE_NOTE = '上次观测 · 刷新失败,可能已过期'
|
||
|
||
function noObservationText(loading: boolean, error: string | null): string {
|
||
if (loading) return '正在读取目标状态(尚未确认空或非空)'
|
||
if (error) return '读取失败,还没有读到目标状态(不能据此判定空或非空)'
|
||
return '还没有读到该范围的目标状态'
|
||
}
|
||
|
||
// 不可发起时必须说清是哪一条不满足:读的是接口给出的真实原因(执行器不可达、
|
||
// 指向别的实例、降级、观测过期),不是一句写死的"通道未接线"。
|
||
function captureHint(view: ScopeView, canWrite: boolean): string {
|
||
if (!canWrite) return '封存需要知识工程师及以上权限'
|
||
const executor = view.overview?.executor
|
||
const reason = view.overview?.capture_reason || executor?.reason
|
||
const observed = executor?.observed_at ? `(观测于 ${stamp(executor.observed_at)})` : ''
|
||
const identity = executor?.project
|
||
? `执行器 ${executor.project}${executor.source_app ? ` / ${executor.source_app}` : ''} · `
|
||
: ''
|
||
if (reason) return `${identity}封存通道不可用:${reason}${observed}`
|
||
return '封存通道状态未知:还没有读到执行器观测'
|
||
}
|
||
|
||
function statusOf(view: ScopeView) {
|
||
const job = view.job
|
||
if (job && (job.state === 'running' || job.state === 'pending')) {
|
||
// 页签徽标也要说清是哪一类作业在跑:把"建立基线"写成"同步中"会让人
|
||
// 以为生产正在被写入。
|
||
const text =
|
||
job.kind === 'seal'
|
||
? '封存中'
|
||
: job.kind === 'restore'
|
||
? '恢复中'
|
||
: job.kind === 'baseline'
|
||
? '建基线中'
|
||
: '同步中'
|
||
return { text, tone: 'blue' as const }
|
||
}
|
||
if (view.overview?.production.state === 'known') return { text: '生产已记录版本', tone: 'green' as const }
|
||
if (view.overview?.test_sealed || view.snapshot) return { text: '已有封存', tone: 'green' as const }
|
||
return { text: '尚无封存', tone: 'gray' as const }
|
||
}
|
||
|
||
const jstate = (state?: string) =>
|
||
state === 'failed' ? '封存失败,可在版本与快照里查看原因' : state ? '封存已完成,生产段未接入' : '尚无作业'
|
||
|
||
// 五个阶段对应原稿:固定测试版本 → 备份生产 → 同步数据与 Wiki → 生产验证 → 新版本生效。
|
||
// 勾选只能来自**当前这次作业**的阶段证据;历史封存记录不代表本次作业推进过,
|
||
// 所以没有作业时全部是"本次作业尚未开始",不再把旧快照打勾。
|
||
function stageOf(job: LibraryJobRecord | undefined, name: string): LibraryStageRow | undefined {
|
||
return job?.stages.find((item) => item.stage === name)
|
||
}
|
||
|
||
function worstState(rows: LibraryStageRow[]): 'succeeded' | 'running' | 'failed' | 'pending' {
|
||
if (rows.some((row) => row.state === 'failed')) return 'failed'
|
||
if (rows.some((row) => row.state === 'running')) return 'running'
|
||
if (rows.length > 0 && rows.every((row) => row.state === 'succeeded' || row.state === 'skipped')) return 'succeeded'
|
||
return 'pending'
|
||
}
|
||
|
||
type StepState = 'done' | 'live' | 'fail' | 'idle'
|
||
|
||
function toState(value: 'succeeded' | 'running' | 'failed' | 'pending'): StepState {
|
||
return value === 'succeeded' ? 'done' : value === 'running' ? 'live' : value === 'failed' ? 'fail' : 'idle'
|
||
}
|
||
|
||
function jobStateText(job: LibraryJobRecord): string {
|
||
const map: Record<string, string> = {
|
||
pending: '排队中',
|
||
running: '执行中',
|
||
succeeded: '已完成',
|
||
failed: '失败',
|
||
cancelled: '已取消',
|
||
}
|
||
return map[job.state] ?? job.state
|
||
}
|
||
|
||
// 作业类型必须逐类写清:基线不是同步,恢复也不是同步。混写会让人以为
|
||
// "建立基线"正在把测试内容写进生产,或者把恢复当成一次正式发布。
|
||
export function jobKindText(kind?: string): string {
|
||
if (kind === 'seal') return '测试封存'
|
||
if (kind === 'sync') return '生产同步'
|
||
if (kind === 'restore') return '按版本恢复'
|
||
if (kind === 'baseline') return '建立目标基线'
|
||
if (kind === 'verify') return '恢复验证'
|
||
return kind ? kind : '—'
|
||
}
|
||
|
||
// 归档里的每一份快照属于哪一类版本:只能来自版本登记,不能一律写"测试封存"。
|
||
export function snapshotVersionLabel(refs: LibraryVersionRef[] | undefined, snapshotID: string): string {
|
||
const kinds = new Set((refs ?? []).filter((item) => item.snapshot_id === snapshotID).map((item) => item.kind))
|
||
const labels: string[] = []
|
||
if (kinds.has('test_sealed')) labels.push('测试封存')
|
||
if (kinds.has('production_effective')) labels.push('生产生效')
|
||
if (kinds.has('production_prebackup')) labels.push('生产预备份')
|
||
return labels.length > 0 ? labels.join(' · ') : '未登记(归档文件,不作为发布候选)'
|
||
}
|
||
|
||
// 生产写入的当前状态:不能用一句写死的"尚未启动"顶替已经完成的作业。
|
||
export function publishStateText(job?: LibraryJobRecord): string {
|
||
if (!job) return '尚未启动,不修改生产'
|
||
if (job.state === 'pending' || job.state === 'running') {
|
||
return job.kind === 'seal'
|
||
? '封存进行中(只读导出测试版本,不修改目标生产)'
|
||
: job.kind === 'restore'
|
||
? '恢复进行中(目标在维护中)'
|
||
: job.kind === 'baseline'
|
||
? '建立基线进行中(只读捕获目标,不写内容)'
|
||
: job.kind === 'verify'
|
||
? '恢复验证进行中(目标在维护中)'
|
||
: '同步进行中(目标在维护中)'
|
||
}
|
||
if (job.state === 'succeeded') return `${jobKindText(job.kind)}已完成 · ${stamp(job.finished_at ?? job.updated_at)}`
|
||
if (job.state === 'failed') return `${jobKindText(job.kind)}失败 · ${stamp(job.finished_at ?? job.updated_at)}`
|
||
return `${jobKindText(job.kind)}已取消 · ${stamp(job.finished_at ?? job.updated_at)}`
|
||
}
|
||
|
||
// 轮询范围 = 投递中 + 有在飞作业(封存队列与持久作业都算)。
|
||
// 终态(成功/失败/取消)必须停下来:无限轮询一个失败作业既没意义,
|
||
// 也会把"作业已经结束"这个事实淹没在不停刷新的页面里。
|
||
export function libraryPollingActive(input: {
|
||
captures: LibraryCaptureJob[]
|
||
overviews: Record<Scope, LibraryOverview | null>
|
||
pending: boolean
|
||
/** 按预备份恢复是一次队列作业,不产生新的 library_jobs 行:必须单独记住"还在等它"。 */
|
||
recoveryPending?: boolean
|
||
/** 维护窗口仍被持有 ⇒ 恢复/收尾还没结束,页面必须继续读回。 */
|
||
maintenances?: Record<Scope, LibraryMaintenanceView | null>
|
||
}): boolean {
|
||
if (input.pending) return true
|
||
if (input.recoveryPending) return true
|
||
if (input.captures.some((job) => ACTIVE_STATES.includes(job.state))) return true
|
||
const maintenanceHeld = (['internal', 'external'] as Scope[]).some((scope) => {
|
||
const view = input.maintenances?.[scope]
|
||
return Boolean(view?.held)
|
||
})
|
||
if (maintenanceHeld) return true
|
||
return (['internal', 'external'] as Scope[]).some((scope) => {
|
||
const job = input.overviews[scope]?.job
|
||
return Boolean(job && ACTIVE_STATES.includes(job.state))
|
||
})
|
||
}
|
||
|
||
// ---- 目标维护窗口:级别 / 进度 / 恢复错误 ----
|
||
//
|
||
// 维护窗口有两种级别:实例级(跨 scope 共用一把锁,真正挡住写入者)和库级。
|
||
// 页面必须说清是哪一级、入口是开还是关、作业走到哪、恢复失败的具体错误——
|
||
// 这些都来自 /api/v1/library/maintenance 的真实记录,没有记录就说"未接入"。
|
||
export interface MaintenanceSummary {
|
||
level: string
|
||
held: boolean
|
||
owner: string
|
||
state: string
|
||
ingress: string
|
||
services: string
|
||
acquiredAt: string
|
||
releasedAt: string
|
||
progress: string
|
||
recoveryError: string
|
||
// 作业失败但维护窗口已释放:只保留失败记录,不能再说"目标保持维护"。
|
||
releasedFailure: string
|
||
recoveryNote: string
|
||
// 窗口未释放但持有作业已经是终态成功:对账缺口,页面不提供强制成功。
|
||
unreconciledNote: string
|
||
// 实例级窗口属于另一个 scope:不在此投递恢复,提示切回持有 scope。
|
||
scopeNote: string
|
||
canRecover: boolean
|
||
}
|
||
|
||
// 阶段名给操作员看的映射;没映射到的阶段原样显示,不猜。
|
||
const stageLabel: Record<string, string> = {
|
||
prebackup: '预备份',
|
||
database: '数据库',
|
||
resources: '资源',
|
||
index: '索引',
|
||
wiki: 'Wiki',
|
||
verify: '校验',
|
||
finalize: '登记版本',
|
||
rollback: '回滚',
|
||
export: '导出',
|
||
acquire: '开窗口',
|
||
drain: '排空',
|
||
stop: '停写入者',
|
||
}
|
||
|
||
const ingressText = (state?: string) =>
|
||
state === 'closed'
|
||
? '已关闭(排空后等待写入)'
|
||
: state === 'none'
|
||
? '无闸门(测试模式)'
|
||
: state === 'open'
|
||
? '打开'
|
||
: state
|
||
? state
|
||
: '未知'
|
||
|
||
// 持有作业详情没读到时只写未读取/未知,绝不拿同 scope 最新作业顶替。
|
||
const ownerJobText = (lookup: LibraryJobLookup | undefined, ownerJobID: string) => {
|
||
const id = ownerJobID || '—'
|
||
if (lookup?.state === 'error') return `持有作业状态读取失败:${lookup.reason}(不使用其他作业推断)`
|
||
if (lookup?.state === 'missing') return `持有作业 ${id} 不存在(维护记录引用了未登记的作业)`
|
||
if (lookup?.state === 'loaded')
|
||
return `持有作业状态未读取/未知(维护记录为 ${id},读取到的是 ${lookup.job.id},不采用)`
|
||
return `持有作业状态未读取/未知(owner_job_id=${id};不使用最新作业代替)`
|
||
}
|
||
|
||
// 维护卡只消费“维护记录里的持有作业”。同 scope 最新作业可能是一次无关封存:
|
||
// 拿它当窗口进度会把 needs_restore 显示成“导出 · 已完成”(真实事故 2026-11-03)。
|
||
export function maintenanceSummary(
|
||
maintenance: LibraryMaintenanceView | null | undefined,
|
||
ownerJob?: LibraryJobLookup,
|
||
scope?: string
|
||
): MaintenanceSummary {
|
||
const record = maintenance?.instance_maintenance ?? maintenance?.maintenance ?? null
|
||
const level = !record
|
||
? '未接入'
|
||
: record.level === 'instance'
|
||
? '实例级'
|
||
: record.level === 'library'
|
||
? '库级'
|
||
: record.level || '未知'
|
||
const held = Boolean(maintenance?.held)
|
||
const ownerScope = maintenance?.instance_maintenance?.owner_scope ?? record?.scope ?? ''
|
||
const ownerJobID = record?.owner_job_id ?? ''
|
||
// 只有 id 与维护记录一致的作业才是本窗口的进度;其余按“未读取”处理。
|
||
const owner = ownerJob?.state === 'loaded' && ownerJob.job.id === ownerJobID ? ownerJob.job : undefined
|
||
const failed = owner?.state === 'failed'
|
||
const progress = owner
|
||
? `${stageLabel[owner.stage] ?? owner.stage ?? '—'} · ${jobStateText(owner)}`
|
||
: record
|
||
? ownerJobText(ownerJob, ownerJobID)
|
||
: '尚无作业进度'
|
||
// 实例级窗口跨 scope 共用:只有持有 scope 才能投递恢复,否则后端必然 409。
|
||
const sameScope = !scope || !ownerScope || ownerScope === scope
|
||
const scopeNote =
|
||
held && !sameScope
|
||
? `维护窗口属于 ${ownerScope},当前查看 ${scope}:页面不向另一个 scope 投递恢复,请切回 ${ownerScope} 再处理`
|
||
: ''
|
||
// 恢复只由“维护仍持有 + 本窗口作业未收口”决定,与无关的最新作业无关。
|
||
const unsettled = owner
|
||
? owner.state === 'failed' || owner.state === 'cancelled'
|
||
: record?.state === 'needs_restore' || record?.state === 'failed' || record?.state === 'held'
|
||
return {
|
||
level,
|
||
held,
|
||
owner: record ? `${ownerScope || '—'} · ${record.owner_job_id || '—'}` : '—',
|
||
state: record?.state || '—',
|
||
ingress: record ? ingressText(record.ingress_state) : '—',
|
||
services: (record?.services ?? []).join('、') || '—',
|
||
acquiredAt: record?.acquired_at ? stamp(record.acquired_at) : '—',
|
||
releasedAt: record?.released_at ? stamp(record.released_at) : '',
|
||
progress,
|
||
// 只有仍然 held 的失败才配 held 处置说明;窗口已释放时那段文案是假的。
|
||
recoveryError: failed && held ? owner?.error || '作业失败但没有留下错误明细' : '',
|
||
releasedFailure: failed && !held ? owner?.error || '作业失败但没有留下错误明细' : '',
|
||
recoveryNote: owner?.recovery || '',
|
||
unreconciledNote:
|
||
held && owner && owner.state === 'succeeded'
|
||
? '持有作业已完成但维护窗口仍未释放:维护记录与作业终态未对账,页面不提供强制成功,需按窗口记录人工核验'
|
||
: '',
|
||
scopeNote,
|
||
canRecover: held && Boolean(record) && sameScope && Boolean(unsettled),
|
||
}
|
||
}
|
||
|
||
export function MaintenanceCard({
|
||
maintenance,
|
||
ownerJob,
|
||
scope,
|
||
canWrite,
|
||
onRecover,
|
||
}: {
|
||
maintenance: LibraryMaintenanceView | null | undefined
|
||
// 只收“按 owner_job_id 读到的持有作业”,不是 scope 的最新作业。
|
||
ownerJob?: LibraryJobLookup
|
||
scope?: string
|
||
canWrite: boolean
|
||
onRecover: (windowJobID: string) => void
|
||
}) {
|
||
const summary = maintenanceSummary(maintenance, ownerJob, scope)
|
||
const record = maintenance?.instance_maintenance ?? maintenance?.maintenance
|
||
// "没有窗口记录"不等于"没有维护能力":能力是配置事实,接口单独返回。
|
||
// 接口没给能力信息时也不能猜,明确写"未知"。
|
||
const capability = maintenance?.capability
|
||
const capabilityText = !capability
|
||
? '维护能力状态未知:接口没有返回能力信息,无法区分"未运行维护"与"能力未接线"'
|
||
: capability.configured
|
||
? `维护能力已接线:实例 ${capability.instance || '—'} · 写入者 ${(capability.writers ?? []).join('、') || '—'}`
|
||
: `维护能力未接线:缺少 ${(capability.missing ?? []).join('、') || '必要配置'}`
|
||
return (
|
||
<div className="rel-panel rel-maintenance">
|
||
<header className="rel-panel-head">
|
||
<div>
|
||
<h2>目标维护</h2>
|
||
<p>同步/恢复期间目标写入者被停住;级别与入口状态来自维护记录本身</p>
|
||
</div>
|
||
<span
|
||
className={`rel-pill ${summary.held ? 'blue' : record ? 'green' : capability?.configured ? 'gray' : 'red'}`}
|
||
>
|
||
{summary.held
|
||
? `${summary.level} · 占用中`
|
||
: record
|
||
? '未占用'
|
||
: capability?.configured
|
||
? '未运行维护'
|
||
: capability
|
||
? '能力未接线'
|
||
: '能力未知'}
|
||
</span>
|
||
</header>
|
||
{!record ? (
|
||
<p className="rel-scope-note">
|
||
暂无维护窗口记录。{capabilityText}
|
||
{capability?.configured
|
||
? ';窗口只在同步或建立基线时开启,页面不会单独开窗口。'
|
||
: ';维护类操作保持 fail closed,不会在此状态下写目标。'}
|
||
</p>
|
||
) : (
|
||
<>
|
||
<ul className="rel-maintenance-rows">
|
||
<li>
|
||
<span>级别</span>
|
||
<b>{summary.level}</b>
|
||
</li>
|
||
<li>
|
||
<span>持有</span>
|
||
<b>{summary.owner}</b>
|
||
</li>
|
||
<li>
|
||
<span>阶段</span>
|
||
<b>{summary.state}</b>
|
||
</li>
|
||
<li>
|
||
<span>入口(维护记录,未实时探测)</span>
|
||
<b>{summary.ingress}</b>
|
||
</li>
|
||
<li>
|
||
<span>服务</span>
|
||
<b>{summary.services}</b>
|
||
</li>
|
||
<li>
|
||
<span>开始</span>
|
||
<b>{summary.acquiredAt}</b>
|
||
</li>
|
||
<li>
|
||
<span>释放</span>
|
||
<b>{summary.releasedAt || '未释放'}</b>
|
||
</li>
|
||
</ul>
|
||
<p className="rel-scope-note">
|
||
进度:{summary.progress}
|
||
{summary.releasedAt ? ` · 窗口已于 ${summary.releasedAt} 释放` : ''}
|
||
</p>
|
||
{summary.scopeNote ? <p className="rel-scope-note">{summary.scopeNote}</p> : null}
|
||
{summary.held ? (
|
||
<p className="rel-scope-note">
|
||
窗口仍被持有:只有维护记录本身释放才算结束,其他作业的完成或失败不改变本窗口。
|
||
</p>
|
||
) : null}
|
||
{summary.unreconciledNote ? (
|
||
<div className="rel-scope-note">
|
||
<strong>维护记录未对账</strong>
|
||
<p>{summary.unreconciledNote}</p>
|
||
</div>
|
||
) : null}
|
||
{summary.releasedFailure ? (
|
||
<div className="rel-scope-note">
|
||
<strong>作业失败(维护窗口已释放)</strong>
|
||
<p>{summary.releasedFailure}</p>
|
||
{summary.recoveryNote ? <p>处理记录:{summary.recoveryNote}</p> : null}
|
||
<p>
|
||
窗口已释放,维护记录中的入口状态:{summary.ingress}(未实时探测):这里是历史失败记录,不再按 held
|
||
处置,也不提供强制成功。
|
||
</p>
|
||
</div>
|
||
) : null}
|
||
{summary.recoveryError ? (
|
||
<div className="rel-blocked">
|
||
<strong>恢复错误</strong>
|
||
<p>{summary.recoveryError}</p>
|
||
{summary.recoveryNote ? <p>处理记录:{summary.recoveryNote}</p> : null}
|
||
<p>
|
||
内容可能已写入并通过校验,但收尾没有完成:目标保持维护、入口未开。请按本作业的预备份与校验证据人工核验后再放行;
|
||
页面不提供“强制成功”,也不会因为“看起来已经写进去了”就开门。
|
||
</p>
|
||
</div>
|
||
) : null}
|
||
<p className="rel-scope-note">
|
||
发布或恢复完成后,Wiki 与日志页面需要刷新再翻页:发布前的分页游标在发布后失效(本地编号会被重新编排),
|
||
用旧标签页继续翻页会得到错位的结果,这不是数据损坏。
|
||
</p>
|
||
{canWrite && summary.canRecover && record ? (
|
||
<button type="button" className="rel-secondary" onClick={() => onRecover(record.owner_job_id)}>
|
||
按预备份恢复
|
||
</button>
|
||
) : null}
|
||
</>
|
||
)}
|
||
</div>
|
||
)
|
||
}
|
||
|
||
// 逐页贡献级差异:一条页面一行,直接写清来源少了几份、引用从几变几。
|
||
export function wikiContributionLines(diff: LibraryOverview['diff'] | undefined): string[] {
|
||
const wiki = diff?.wiki
|
||
if (!wiki || wiki.state !== 'computed' || !wiki.pages || wiki.pages.length === 0) return []
|
||
const label: Record<string, string> = { added: '新增', updated: '更新', removed: '整页撤销' }
|
||
return wiki.pages.map((page) => {
|
||
const parts = [`${label[page.status] ?? page.status} ${page.title || page.slug}`]
|
||
if (page.changed.length > 0) parts.push(page.changed.join('、'))
|
||
if ((page.sources_removed ?? []).length > 0) parts.push(`来源 -${page.sources_removed!.length}`)
|
||
if ((page.sources_added ?? []).length > 0) parts.push(`来源 +${page.sources_added!.length}`)
|
||
if (page.citations_before !== page.citations_after)
|
||
parts.push(`引用 ${page.citations_before}→${page.citations_after}`)
|
||
return parts.join(' · ')
|
||
})
|
||
}
|
||
|
||
function StageBar({ view }: { view: ScopeView }) {
|
||
const job = view.job
|
||
if (job?.kind === 'verify') {
|
||
const labels: Record<string, string> = {
|
||
capture: '捕获目标',
|
||
verify: '基线校验',
|
||
canary: '写入并核对 canary',
|
||
restore: '按预备份恢复',
|
||
finalize: '登记验证证据',
|
||
}
|
||
return (
|
||
<>
|
||
<ol className="rel-steps" aria-label="恢复验证阶段">
|
||
{Object.entries(labels).map(([name, label], index) => {
|
||
const row = job.stages.find((item) => item.stage === name)
|
||
const state = row ? toState(row.state as 'succeeded' | 'running' | 'failed' | 'pending') : 'idle'
|
||
return (
|
||
<li key={name} className={`rel-step ${state}`}>
|
||
<span className="rel-step-mark">
|
||
{state === 'done' ? '✓' : state === 'live' ? '●' : state === 'fail' ? '!' : '○'}
|
||
</span>
|
||
<strong>{label}</strong>
|
||
<small>{row?.detail || (state === 'idle' ? '未开始' : '')}</small>
|
||
{index < 4 ? <span className="rel-step-arrow">→</span> : null}
|
||
</li>
|
||
)
|
||
})}
|
||
</ol>
|
||
<p className="rel-steps-note">
|
||
作业 {job.id} · 恢复验证 · {jobStateText(job)}
|
||
{job.error ? ` · ${job.error}` : ''};完成只表示本次恢复验证证据已登记,不会登记新版本。
|
||
</p>
|
||
</>
|
||
)
|
||
}
|
||
if (job?.kind === 'seal') {
|
||
const exportRow = job.stages.find((item) => item.stage === 'export')
|
||
const state =
|
||
job.state === 'succeeded'
|
||
? 'done'
|
||
: job.state === 'failed'
|
||
? 'fail'
|
||
: job.state === 'running' || job.state === 'pending'
|
||
? 'live'
|
||
: 'idle'
|
||
return (
|
||
<>
|
||
<ol className="rel-steps" aria-label="测试库封存阶段">
|
||
<li className={`rel-step ${state}`}>
|
||
<span className="rel-step-mark">
|
||
{state === 'done' ? '✓' : state === 'live' ? '●' : state === 'fail' ? '!' : '○'}
|
||
</span>
|
||
<strong>只读导出测试版本</strong>
|
||
<small>
|
||
{exportRow?.detail ||
|
||
(state === 'done'
|
||
? '测试库快照已导出并登记'
|
||
: state === 'fail'
|
||
? '封存未完成'
|
||
: state === 'live'
|
||
? '正在读取测试库并导出快照'
|
||
: '未开始')}
|
||
</small>
|
||
</li>
|
||
</ol>
|
||
<p className="rel-steps-note">
|
||
作业 {job.id} · 测试封存 · {jobStateText(job)}
|
||
{job.error ? ` · ${job.error}` : ''};封存只读测试库,不备份、不写入、不切换目标生产。
|
||
</p>
|
||
</>
|
||
)
|
||
}
|
||
// 同步、恢复、建立基线共用同一串阶段(预备份 → 数据四类 → 校验 → 登记版本)。
|
||
// 只按"sync"找阶段会让刚跑完的恢复/基线在页面上显示成"本次作业尚未开始"。
|
||
const writeJob = job
|
||
|
||
let first: { state: StepState; hint: string }
|
||
if (writeJob) {
|
||
first =
|
||
writeJob.kind === 'restore'
|
||
? { state: 'done', hint: '恢复到选定快照(不经过测试封存)' }
|
||
: writeJob.kind === 'baseline'
|
||
? { state: 'done', hint: '目标自身内容,非测试封存' }
|
||
: { state: 'done', hint: '已绑定的测试版本' }
|
||
} else {
|
||
first = { state: 'idle', hint: '本次作业尚未开始' }
|
||
}
|
||
|
||
const prebackup = writeJob ? stageOf(writeJob, 'prebackup') : undefined
|
||
const dataStages = writeJob
|
||
? ['database', 'resources', 'index', 'wiki']
|
||
.map((name) => stageOf(writeJob, name))
|
||
.filter((row): row is LibraryStageRow => Boolean(row))
|
||
: []
|
||
const verifyStage = writeJob ? stageOf(writeJob, 'verify') : undefined
|
||
|
||
const stages: { label: string; state: StepState; hint: string }[] = [
|
||
{ label: '固定测试版本', ...first },
|
||
{
|
||
label: '备份生产',
|
||
state: prebackup ? toState(worstState([prebackup])) : 'idle',
|
||
hint: prebackup
|
||
? prebackup.state === 'succeeded'
|
||
? '已完成生产预备份'
|
||
: prebackup.state === 'running'
|
||
? '正在备份生产'
|
||
: prebackup.state === 'failed'
|
||
? '预备份失败'
|
||
: '未开始'
|
||
: '未接入',
|
||
},
|
||
{
|
||
label: '同步数据与 Wiki',
|
||
state: dataStages.length > 0 ? toState(worstState(dataStages)) : 'idle',
|
||
hint: dataStages.length > 0 ? '按数据库 / 资源 / 索引 / Wiki 分项上报' : '未接入',
|
||
},
|
||
{
|
||
label: '生产验证',
|
||
state: verifyStage ? toState(worstState([verifyStage])) : 'idle',
|
||
hint: verifyStage ? (verifyStage.state === 'succeeded' ? '校验通过' : '未完成') : '未接入',
|
||
},
|
||
{
|
||
label: writeJob?.kind === 'restore' ? '目标恢复生效' : '生产生效',
|
||
state: writeJob && writeJob.state === 'succeeded' ? 'done' : 'idle',
|
||
hint:
|
||
writeJob && writeJob.state === 'succeeded'
|
||
? writeJob.kind === 'restore'
|
||
? '目标已回到该快照,恢复后复核通过'
|
||
: writeJob.kind === 'baseline'
|
||
? '目标基线已登记(目标内容未改)'
|
||
: '生产已生效'
|
||
: '未开始',
|
||
},
|
||
]
|
||
return (
|
||
<>
|
||
<ol className="rel-steps" aria-label="作业阶段">
|
||
{stages.map((stage, index) => (
|
||
<li key={stage.label} className={`rel-step ${stage.state}`}>
|
||
<span className="rel-step-mark">
|
||
{stage.state === 'done' ? '✓' : stage.state === 'live' ? '●' : stage.state === 'fail' ? '!' : '○'}
|
||
</span>
|
||
<strong>{stage.label}</strong>
|
||
<small>{stage.hint}</small>
|
||
{index < stages.length - 1 ? <span className="rel-step-arrow">→</span> : null}
|
||
</li>
|
||
))}
|
||
</ol>
|
||
<p className="rel-steps-note">
|
||
{job
|
||
? `作业 ${job.id} · ${jobKindText(job.kind)} · ${jobStateText(job)}${job.error ? ` · ${job.error}` : ''}`
|
||
: view.snapshot
|
||
? `已有测试封存 ${stamp(view.snapshot.created_at)}(历史记录),但本次作业尚未开始;没有当前作业证据时不会把历史封存当作阶段完成。`
|
||
: '本次作业尚未开始。'}
|
||
</p>
|
||
</>
|
||
)
|
||
}
|
||
|
||
// 差异行是 {id,title,digest} 对象;只展示人能核对的身份,不摊开内部摘要。
|
||
function diffLabel(item: unknown): string {
|
||
if (typeof item === 'string') return item
|
||
if (item && typeof item === 'object') {
|
||
const record = item as Record<string, unknown>
|
||
const title = typeof record.title === 'string' ? record.title : ''
|
||
const id = typeof record.id === 'string' ? record.id : ''
|
||
if (title && id) return `${title} · ${id.slice(0, 8)}`
|
||
if (title) return title
|
||
if (id) return id
|
||
}
|
||
return JSON.stringify(item)
|
||
}
|
||
|
||
function ChangeTable({ diff }: { diff: LibraryOverview['diff'] }) {
|
||
const computed = diff.state === 'computed'
|
||
const rows = computed
|
||
? [
|
||
...diff.added.map((item) => ({ action: '新增', item })),
|
||
...diff.updated.map((item) => ({ action: '更新', item })),
|
||
...diff.removed.map((item) => ({ action: '删除', item })),
|
||
]
|
||
: []
|
||
return (
|
||
<div className="rel-panel rel-changes">
|
||
<header className="rel-panel-head">
|
||
<div>
|
||
<h2>本次变更</h2>
|
||
<p>整库版本同步,不单独勾选文件</p>
|
||
</div>
|
||
<span className={`rel-pill ${computed ? 'green' : 'gray'}`}>{computed ? `${rows.length} 条` : '未接入'}</span>
|
||
</header>
|
||
{computed && diff.base_snapshot && diff.target_snapshot ? (
|
||
<p className="rel-scope-note">
|
||
生产 {diff.base_snapshot.slice(0, 12)} → 测试 {diff.target_snapshot.slice(0, 12)}
|
||
</p>
|
||
) : null}
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>动作</th>
|
||
<th>文档</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{rows.length === 0 ? (
|
||
<tr>
|
||
<td colSpan={2} className="rel-table-empty">
|
||
{computed
|
||
? '生产与测试版本没有文档差异'
|
||
: `尚无记录 · ${diff.reason || '变更清单来自生产与测试版本对比,这项数据还没有接入'}`}
|
||
</td>
|
||
</tr>
|
||
) : (
|
||
rows.map((row, index) => (
|
||
<tr key={`${row.action}-${index}`}>
|
||
<td>{row.action}</td>
|
||
<td>{diffLabel(row.item)}</td>
|
||
</tr>
|
||
))
|
||
)}
|
||
</tbody>
|
||
</table>
|
||
{diff.wiki && diff.wiki.state === 'computed' ? (
|
||
<div className="rel-wiki-diff">
|
||
<p className="rel-scope-note">
|
||
Wiki 页面:新增 {diff.wiki.added} · 更新 {diff.wiki.updated} · 撤销 {diff.wiki.removed}
|
||
{typeof diff.wiki.sources_removed === 'number'
|
||
? ` · 来源文档变化 −${diff.wiki.sources_removed} / +${diff.wiki.sources_added ?? 0}`
|
||
: ''}
|
||
(逐页比对来源、引用、出入边与目录;重算发生在源侧)
|
||
</p>
|
||
{wikiContributionLines(diff).length > 0 ? (
|
||
<ul className="rel-wiki-pages">
|
||
{wikiContributionLines(diff).map((line) => (
|
||
<li key={line}>{line}</li>
|
||
))}
|
||
</ul>
|
||
) : null}
|
||
{diff.wiki.pages_truncated ? <p className="rel-scope-note">逐页明细超过 50 条,只列出前 50 条。</p> : null}
|
||
</div>
|
||
) : null}
|
||
</div>
|
||
)
|
||
}
|
||
|
||
function ProtectionCard({
|
||
production,
|
||
productionNote,
|
||
stale,
|
||
prebackup,
|
||
gate,
|
||
authorization,
|
||
targetSealed,
|
||
sync,
|
||
baseline,
|
||
scope,
|
||
verification,
|
||
}: {
|
||
production: LibraryOverview['production'] | null
|
||
// 没有目标观测时显示的原因(加载中 / 整体读取失败 / 当前范围没数据)。
|
||
productionNote: string
|
||
stale: boolean
|
||
prebackup: LibraryOverview['prebackup']
|
||
gate: LibraryOverview['gate']
|
||
authorization: LibraryOverview['authorization']
|
||
targetSealed: boolean
|
||
sync: ReleaseSyncActions
|
||
baseline: ReleaseBaselineActions
|
||
scope: Scope
|
||
verification: {
|
||
onAccepted: (jobId: string) => void
|
||
onComplete: (jobId: string) => void
|
||
}
|
||
}) {
|
||
const backupKnown = prebackup.state === 'known' && prebackup.version
|
||
// 基线入口只在"目标非空、却没有生效版本"时才是答案;空库走首次同步(预备份+登记),
|
||
// 读不到或还没读到观测时必须先修连接/等读取,两者都不能被引导到会 409/503 的基线入口。
|
||
const productionTarget = productionTargetClass(production)
|
||
const baselineNeeded = productionTarget === 'nonempty' && targetSealed
|
||
const staleNote = stale ? `(${STALE_NOTE})` : ''
|
||
return (
|
||
<aside className="rel-panel rel-protection">
|
||
<header className="rel-panel-head">
|
||
<h2>生产保护与恢复</h2>
|
||
<span className={`rel-pill ${backupKnown ? 'green' : 'gray'}`}>
|
||
{backupKnown ? '已登记预备份' : '尚未创建'}
|
||
</span>
|
||
</header>
|
||
<dl>
|
||
<dt>最近一次生产写入前备份</dt>
|
||
<dd>
|
||
{backupKnown ? (
|
||
<>
|
||
{stamp(prebackup.version!.created_at)} ·{' '}
|
||
{prebackup.version!.version_label || prebackup.version!.snapshot_id.slice(0, 12)}
|
||
{prebackup.version!.source_job_id ? ` · 作业 ${prebackup.version!.source_job_id}` : ''}
|
||
<br />
|
||
<small>
|
||
{prebackup.bound_to_target
|
||
? '与当前拟发布目标是同一份快照'
|
||
: targetSealed
|
||
? '不是当前拟发布目标的快照(是那次生产写入前的状态)'
|
||
: '归档里没有拟发布目标,无法比对'}
|
||
</small>
|
||
</>
|
||
) : (
|
||
'未登记(这个范围还没有任何生产预备份)'
|
||
)}
|
||
</dd>
|
||
<dt>生产当前版本</dt>
|
||
<dd>
|
||
{productionTarget === 'known' && production?.version ? (
|
||
<>
|
||
{production.version.version_label || production.version.snapshot_id.slice(0, 12)}
|
||
<br />
|
||
<small>
|
||
快照 {production.version.snapshot_id.slice(0, 12)} · 登记于 {stamp(production.version.created_at)}
|
||
</small>
|
||
</>
|
||
) : productionTarget === 'empty' ? (
|
||
`目标已读且为空:首次发布还没有生效版本(写前仍会生成完整预备份)${staleNote}`
|
||
) : productionTarget === 'unreachable' ? (
|
||
`${production?.reason || '读取失败:无法确认目标是否为空'}${staleNote}`
|
||
) : productionTarget === 'nonempty' ? (
|
||
`未知(目标非空且还没有权威版本)${staleNote}`
|
||
) : (
|
||
productionNote
|
||
)}
|
||
</dd>
|
||
<dt>备份范围</dt>
|
||
<dd>数据库 / 资源 / 索引 / Wiki</dd>
|
||
<dt>发布授权</dt>
|
||
<dd>
|
||
{authorization.state === 'active'
|
||
? `${authorization.authorized_by || '管理员'} 签发 · 有效至 ${stamp(authorization.expires_at ?? '')}`
|
||
: '无有效授权(需管理员按目标+快照签发)'}
|
||
</dd>
|
||
<dt>恢复条件</dt>
|
||
<dd>{gate.reasons.length === 0 ? '已满足' : `缺 ${gate.reasons.length} 项`}</dd>
|
||
</dl>
|
||
<RestoreVerificationSection
|
||
scope={scope}
|
||
isAdmin={sync.canSign}
|
||
onAccepted={verification.onAccepted}
|
||
onComplete={verification.onComplete}
|
||
/>
|
||
|
||
<div className="rel-drawer-actions">
|
||
{baseline.canStart && baselineNeeded ? (
|
||
<button type="button" className="rel-secondary" onClick={baseline.onStart} disabled={baseline.pending}>
|
||
{baseline.pending ? '投递中…' : '建立目标权威基线(维护隔离)'}
|
||
</button>
|
||
) : null}
|
||
</div>
|
||
{authorization.state !== 'active' && !sync.canSign ? (
|
||
<p className="rel-hint">同步授权只能由管理员按目标+快照签发;工程师看不到签发入口。</p>
|
||
) : null}
|
||
<p className="rel-hint">需要恢复旧版本时,从页面右上角「版本与快照」选择恢复点。</p>
|
||
</aside>
|
||
)
|
||
}
|
||
|
||
interface ReadyProps {
|
||
view: ScopeView
|
||
diff: LibraryOverview['diff']
|
||
production: LibraryOverview['production'] | null
|
||
// 缺观测时的说明与"旧观测"标记都由上层按 loading/error 判定,子组件只负责显示。
|
||
productionNote: string
|
||
stale: boolean
|
||
prebackup: LibraryOverview['prebackup']
|
||
gate: LibraryOverview['gate']
|
||
authorization: LibraryOverview['authorization']
|
||
sync: ReleaseSyncActions
|
||
baseline: ReleaseBaselineActions
|
||
verification: {
|
||
onAccepted: (jobId: string) => void
|
||
onComplete: (jobId: string) => void
|
||
}
|
||
}
|
||
|
||
function ReadyBody({
|
||
view,
|
||
diff,
|
||
production,
|
||
productionNote,
|
||
stale,
|
||
prebackup,
|
||
gate,
|
||
authorization,
|
||
sync,
|
||
baseline,
|
||
verification,
|
||
}: ReadyProps) {
|
||
return (
|
||
<>
|
||
<details className="rel-disclosure" key={`changes-${view.scope}`}>
|
||
<summary>
|
||
查看变更明细{' '}
|
||
<span>
|
||
{diff.state === 'computed'
|
||
? `${diff.added.length + diff.updated.length + diff.removed.length} 篇文档`
|
||
: '尚未取得对比结果'}
|
||
</span>
|
||
</summary>
|
||
<ChangeTable diff={diff} />
|
||
</details>
|
||
<details className="rel-disclosure" key={`protection-${view.scope}`}>
|
||
<summary>
|
||
发布准备与恢复验证{' '}
|
||
<span>{gate.reasons.length ? `待满足 ${gate.reasons.length} 项发布条件` : '查看备份与验证记录'}</span>
|
||
</summary>
|
||
<ProtectionCard
|
||
production={production}
|
||
productionNote={productionNote}
|
||
stale={stale}
|
||
prebackup={prebackup}
|
||
gate={gate}
|
||
authorization={authorization}
|
||
targetSealed={Boolean(view.snapshot)}
|
||
sync={sync}
|
||
baseline={baseline}
|
||
scope={view.scope}
|
||
verification={verification}
|
||
/>
|
||
</details>
|
||
{view.job ? (
|
||
<details className="rel-disclosure" key={`job-${view.scope}-${view.job.id}`} open={view.job.state === 'failed'}>
|
||
<summary>
|
||
最近作业{' '}
|
||
<span>
|
||
{jobKindText(view.job.kind)} · {jobStateText(view.job)}
|
||
</span>
|
||
</summary>
|
||
<div className="rel-panel rel-jobbar">
|
||
<header className="rel-panel-head">
|
||
<h2>启动后的作业进度</h2>
|
||
{/* 作业跑完/失败后不能还说"此时尚未运行":这个徽标说的是**最近一次作业**的终态。 */}
|
||
<span className={`rel-pill ${view.job ? (view.job.state === 'failed' ? 'red' : 'green') : 'gray'}`}>
|
||
{view.job
|
||
? `${jobKindText(view.job.kind)} · ${jobStateText(view.job)} · ${stamp(view.job.finished_at ?? view.job.updated_at)}`
|
||
: '此时尚未运行'}
|
||
</span>
|
||
</header>
|
||
<StageBar view={view} />
|
||
{view.job.error ? <p className="rel-warn">{view.job.error}</p> : null}
|
||
</div>
|
||
</details>
|
||
) : null}
|
||
</>
|
||
)
|
||
}
|
||
|
||
function ProgressBody({
|
||
view,
|
||
now,
|
||
canReconcileCapture,
|
||
pendingReconcileCapture,
|
||
onReconcileCapture,
|
||
}: {
|
||
view: ScopeView
|
||
now: number
|
||
canReconcileCapture: boolean
|
||
pendingReconcileCapture: string
|
||
onReconcileCapture: (jobID: string) => void
|
||
}) {
|
||
const job = view.job
|
||
const sealJob = job?.kind === 'seal' ? job : undefined
|
||
// 四类数据阶段对同步/恢复/基线都成立:分项读的是这份作业自己的阶段,
|
||
// 不是"只有 sync 才有"。写死 sync 会让恢复作业的分项全显示"未接入"。
|
||
const dataJob = job && job.kind !== 'seal' ? job : undefined
|
||
const running = job?.state === 'running' || job?.state === 'pending'
|
||
// Startup reconciliation used to rewrite a completed capture as "队列不存在".
|
||
// Only that exact legacy shape gets an admin reconcile action; real failures do not.
|
||
const legacyOrphan =
|
||
sealJob?.state === 'failed' &&
|
||
sealJob.stage === '' &&
|
||
sealJob.snapshot_id === '' &&
|
||
sealJob.error === '队列中已无对应作业,业务作业未收到结果' &&
|
||
sealJob.recovery === '封存作业由 agent 恢复来源;确认来源 healthy 后可重发'
|
||
const stage = (name: string) => (dataJob ?? sealJob)?.stages.find((item) => item.stage === name)
|
||
|
||
// F11: counts must belong to the snapshot this job actually used. A newly
|
||
// sealed test version must not decorate an older sync/restore/verify job.
|
||
const jobSnapshotID = job?.target_snapshot_id || job?.snapshot_id || ''
|
||
const sealed = jobSnapshotID
|
||
? view.history.find((item) => item.snapshot_id === jobSnapshotID)
|
||
: job
|
||
? undefined
|
||
: view.overview?.test_sealed
|
||
const breakdown = (keys: [string, string][]) =>
|
||
sealed
|
||
? keys
|
||
.map(([key, label]) => `${label} ${typeof sealed.totals[key] === 'number' ? sealed.totals[key] : '未知'}`)
|
||
.join(' · ')
|
||
: ''
|
||
const cards = [
|
||
// F11: these totals are storage rows, not business document/page counts.
|
||
{
|
||
title: '数据库 · 存储行',
|
||
row: stage('database'),
|
||
axis: '行(文档/分块/标签/关系)',
|
||
counts: breakdown([
|
||
['documents', '文档'],
|
||
['chunks', '分块'],
|
||
['resources', '资源'],
|
||
['bindings', '绑定'],
|
||
]),
|
||
},
|
||
{ title: '原文件 · 图片 · 附件', row: stage('resources'), axis: '对象 / 字节', counts: '' },
|
||
{ title: '检索索引 · 向量', row: stage('index'), axis: '索引文档', counts: '' },
|
||
{
|
||
title: 'Wiki · 存储行',
|
||
row: stage('wiki'),
|
||
axis: '页面 / 目录 / 日志',
|
||
counts: breakdown([
|
||
['wiki_pages', '页面'],
|
||
['wiki_folders', '目录'],
|
||
['wiki_log_entries', '日志'],
|
||
]),
|
||
},
|
||
].map((card) => ({
|
||
...card,
|
||
// 只有真实的 total 才画进度;没有 total 就是"未知总量",绝不按 0 或 100% 画。
|
||
percent:
|
||
card.row && card.row.total && card.row.total > 0
|
||
? Math.min(100, Math.round(((card.row.completed ?? 0) / card.row.total) * 100))
|
||
: null,
|
||
count: card.row && card.row.total != null ? `${card.row.completed ?? '—'} / ${card.row.total}` : '— / 未知总量',
|
||
}))
|
||
|
||
return (
|
||
<>
|
||
<div className="rel-panel rel-progress-head" id="rel-progress">
|
||
<div className="rel-between">
|
||
<h2>
|
||
{sealJob ? '测试库封存作业' : dataJob ? `${jobKindText(dataJob.kind)}作业` : '本次作业'}
|
||
<span className="rel-version">
|
||
{sealJob ? (
|
||
<>只读导出测试库快照 → 不修改目标生产</>
|
||
) : (
|
||
<>
|
||
{dataJob?.kind === 'restore'
|
||
? `恢复到 ${dataJob.target_snapshot_id.slice(0, 12) || '—'}`
|
||
: dataJob?.kind === 'baseline'
|
||
? `目标基线 ${dataJob.target_snapshot_id.slice(0, 12) || '(本次捕获后登记)'}`
|
||
: `测试封存 ${view.overview?.test_sealed?.snapshot_id.slice(0, 12) ?? '未接入'}`}{' '}
|
||
→ 目标当前{' '}
|
||
<b>
|
||
{view.overview?.production.state === 'known' && view.overview.production.version
|
||
? view.overview.production.version.version_label ||
|
||
view.overview.production.version.snapshot_id.slice(0, 12)
|
||
: '未知'}
|
||
</b>
|
||
</>
|
||
)}
|
||
</span>
|
||
</h2>
|
||
<span className={`rel-pill ${running ? 'blue' : job?.state === 'failed' ? 'red' : job ? 'green' : 'gray'}`}>
|
||
{job ? `${jobStateText(job)} · 已用时 ${elapsed(job.created_at, now)}` : '无作业'}
|
||
</span>
|
||
</div>
|
||
<p className="rel-jobmeta">
|
||
作业 <code>{job?.id ?? '未接入'}</code> · 类型 {job ? jobKindText(job.kind) : '—'} · 操作人{' '}
|
||
{job?.actor || '—'} · 最近进展 {job ? stamp(job.updated_at) : '—'}
|
||
{job?.recovery ? ` · 恢复:${job.recovery}` : ''}
|
||
</p>
|
||
<StageBar view={view} />
|
||
{sealJob &&
|
||
canReconcileCapture &&
|
||
(sealJob.state === 'pending' || sealJob.state === 'running' || legacyOrphan) &&
|
||
stage('export')?.state === 'succeeded' ? (
|
||
<div className="rel-between rel-progress-foot" aria-label="核对封存结果">
|
||
<span>队列已完成、导出阶段已成功,但作业终态尚未回写。</span>
|
||
<button
|
||
type="button"
|
||
className="rel-secondary"
|
||
onClick={() => onReconcileCapture(sealJob.id)}
|
||
disabled={pendingReconcileCapture === sealJob.id}
|
||
>
|
||
{pendingReconcileCapture === sealJob.id ? '核对中…' : '核对封存结果'}
|
||
</button>
|
||
</div>
|
||
) : null}
|
||
<div className="rel-between rel-progress-foot">
|
||
<span>
|
||
当前:
|
||
{job?.state === 'running'
|
||
? job.stage || '执行中'
|
||
: job?.state === 'failed'
|
||
? job.error || '失败'
|
||
: job
|
||
? jobStateText(job)
|
||
: '本次作业尚未开始'}
|
||
</span>
|
||
</div>
|
||
</div>
|
||
|
||
<details className="rel-disclosure" key={`progress-detail-${view.scope}`}>
|
||
<summary>
|
||
查看执行明细 <span>各类数据进度与阶段记录</span>
|
||
</summary>
|
||
{sealJob ? (
|
||
<div className="rel-panel">
|
||
<header className="rel-panel-head">
|
||
<h2>封存范围</h2>
|
||
<span className="rel-pill gray">只读</span>
|
||
</header>
|
||
<p className="rel-scope-note">
|
||
本作业只读取测试库并导出快照,不备份生产、不写目标、不做生产验证,也不持有目标维护窗口。
|
||
快照完成后在“版本与快照”查看;没有真实导出总量时显示未知,不补零或 100%。
|
||
</p>
|
||
</div>
|
||
) : (
|
||
<>
|
||
<div className="rel-panel rel-datatypes">
|
||
<header className="rel-panel-head">
|
||
<h2>各类数据同步情况</h2>
|
||
<span className="rel-hint">没有真实总量与完成量的项目只显示状态,不编造百分比</span>
|
||
</header>
|
||
<div className="rel-grid rel-grid-4">
|
||
{cards.map((card) => (
|
||
<article key={card.title} className="rel-datacard">
|
||
<header>
|
||
<h3>{card.title}</h3>
|
||
<span
|
||
className={`rel-pill ${card.row?.state === 'succeeded' ? 'green' : card.row?.state === 'failed' ? 'red' : card.row?.state === 'running' ? 'blue' : 'gray'}`}
|
||
>
|
||
{card.row
|
||
? card.row.state === 'succeeded'
|
||
? '已完成'
|
||
: card.row.state === 'running'
|
||
? '执行中'
|
||
: card.row.state === 'failed'
|
||
? '失败'
|
||
: '等待'
|
||
: '未接入'}
|
||
</span>
|
||
</header>
|
||
<p className="rel-datacount">
|
||
<strong>{card.count}</strong> · {card.axis}
|
||
</p>
|
||
{card.counts ? <p className="rel-datadetail">封存快照分项:{card.counts}</p> : null}
|
||
<div className="rel-progress" aria-hidden={card.percent === null ? 'true' : undefined}>
|
||
<span style={{ width: `${card.percent ?? 0}%` }} />
|
||
</div>
|
||
<p className="rel-datadetail">
|
||
{card.row?.detail
|
||
? card.row.detail
|
||
: card.row
|
||
? card.row.state === 'running'
|
||
? '执行中;执行器尚未提供该分项明细'
|
||
: card.row.state === 'pending'
|
||
? '等待执行;不能按完成展示'
|
||
: card.row.state === 'failed'
|
||
? '失败;没有可核对完成量'
|
||
: card.row.state === 'succeeded'
|
||
? card.row.total != null
|
||
? `已完成 ${card.row.completed ?? card.row.total} / ${card.row.total} 条存储行`
|
||
: '该分项已完成,执行器未提供可核对总量'
|
||
: '状态未知;不按完成展示'
|
||
: dataJob
|
||
? '本次作业没有产生该分项阶段记录'
|
||
: '目标同步执行链未接通,分项不会产生数据'}
|
||
</p>
|
||
</article>
|
||
))}
|
||
</div>
|
||
</div>
|
||
|
||
<div className="rel-panel rel-details">
|
||
<header className="rel-panel-head">
|
||
<h2>同步明细</h2>
|
||
<span className="rel-hint">行来自持久作业阶段,worker 重启后仍可读</span>
|
||
</header>
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>任务 / 对象</th>
|
||
<th>阶段</th>
|
||
<th>进度</th>
|
||
<th>状态</th>
|
||
<th>说明</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{(job?.stages ?? []).length === 0 ? (
|
||
<tr>
|
||
<td colSpan={5} className="rel-table-empty">
|
||
尚无阶段记录
|
||
</td>
|
||
</tr>
|
||
) : (
|
||
job!.stages.map((row) => (
|
||
<tr key={row.stage}>
|
||
<td>{row.stage}</td>
|
||
<td>{row.stage === 'export' ? '测试封存' : row.stage}</td>
|
||
<td>
|
||
{row.total != null ? `${row.completed ?? '—'} / ${row.total}` : '未知总量'}
|
||
{row.bytes_total != null
|
||
? ` · ${formatBytes(row.bytes_done ?? 0)} / ${formatBytes(row.bytes_total)}`
|
||
: ''}
|
||
</td>
|
||
<td>
|
||
{row.state === 'succeeded'
|
||
? '已完成'
|
||
: row.state === 'running'
|
||
? '执行中'
|
||
: row.state === 'failed'
|
||
? '失败'
|
||
: row.state === 'skipped'
|
||
? '已跳过'
|
||
: '等待'}
|
||
</td>
|
||
<td>{row.detail || '—'}</td>
|
||
</tr>
|
||
))
|
||
)}
|
||
</tbody>
|
||
</table>
|
||
<footer className="rel-log">
|
||
<span>
|
||
最近事件:
|
||
{job?.error
|
||
? job.error.slice(0, 120)
|
||
: running
|
||
? '作业执行中;无错误。'
|
||
: job
|
||
? `作业${jobStateText(job)};无错误。`
|
||
: sealJob
|
||
? '封存作业已结束。'
|
||
: '尚无作业记录。'}
|
||
</span>
|
||
<span>文件传输 100% ≠ 作业完成;生产验证通过前不显示“完成”。</span>
|
||
</footer>
|
||
</div>
|
||
</>
|
||
)}
|
||
</details>
|
||
</>
|
||
)
|
||
}
|
||
|
||
// F03: list rows must use the same exact snapshot query as the detail. The
|
||
// scope-wide latest passed record is never allowed to color another snapshot.
|
||
function SnapshotVerificationBadge({ scope, snapshotID }: { scope: Scope; snapshotID: string }) {
|
||
const [state, setState] = useState<'loading' | 'loaded' | 'error'>('loading')
|
||
const [record, setRecord] = useState<Awaited<ReturnType<typeof fetchSnapshotVerification>>['snapshot_latest']>(null)
|
||
const [error, setError] = useState('')
|
||
useEffect(() => {
|
||
const controller = new AbortController()
|
||
setState('loading')
|
||
setRecord(null)
|
||
setError('')
|
||
fetchSnapshotVerification(scope, snapshotID, controller.signal)
|
||
.then((value) => {
|
||
setRecord(value.snapshot_latest ?? null)
|
||
setState('loaded')
|
||
})
|
||
.catch((reason: unknown) => {
|
||
if ((reason as Error)?.name === 'AbortError') return
|
||
setError(reason instanceof Error ? reason.message : '读取该快照的恢复验证记录失败')
|
||
setState('error')
|
||
})
|
||
return () => controller.abort()
|
||
}, [scope, snapshotID])
|
||
if (state === 'loading') return <span className="rel-pill gray">读取验证记录…</span>
|
||
if (state === 'error')
|
||
return (
|
||
<span className="rel-pill red" title={error}>
|
||
验证状态读取失败
|
||
</span>
|
||
)
|
||
if (!record) return <span className="rel-pill gray">未做生产恢复验证</span>
|
||
return record.status === 'passed' ? (
|
||
<span className="rel-pill green">恢复验证通过 · {record.job_id}</span>
|
||
) : (
|
||
<span className="rel-pill red">恢复验证未通过 · {record.job_id}</span>
|
||
)
|
||
}
|
||
|
||
// F03: exact snapshot evidence. This component deliberately reads
|
||
// snapshot_latest, not latest: a passed record for another snapshot must not
|
||
// make this one look verified.
|
||
function SnapshotVerification({ scope, snapshotID }: { scope: Scope; snapshotID: string }) {
|
||
const [state, setState] = useState<'loading' | 'loaded' | 'error'>('loading')
|
||
const [record, setRecord] = useState<Awaited<ReturnType<typeof fetchSnapshotVerification>>['snapshot_latest']>(null)
|
||
const [error, setError] = useState('')
|
||
useEffect(() => {
|
||
const controller = new AbortController()
|
||
setState('loading')
|
||
setRecord(null)
|
||
setError('')
|
||
fetchSnapshotVerification(scope, snapshotID, controller.signal)
|
||
.then((value) => {
|
||
setRecord(value.snapshot_latest ?? null)
|
||
setState('loaded')
|
||
})
|
||
.catch((reason: unknown) => {
|
||
if ((reason as Error)?.name === 'AbortError') return
|
||
setError(reason instanceof Error ? reason.message : '读取该快照的恢复验证记录失败')
|
||
setState('error')
|
||
})
|
||
return () => controller.abort()
|
||
}, [scope, snapshotID])
|
||
return (
|
||
<details className="rel-snapshot-verification">
|
||
<summary>查看校验记录</summary>
|
||
{state === 'loading' ? <p className="rel-hint">正在读取该快照的恢复验证记录…</p> : null}
|
||
{state === 'error' ? <p className="rel-warn">{error}</p> : null}
|
||
{state === 'loaded' && !record ? (
|
||
<p className="rel-hint">该快照没有真实恢复验证记录;未验证,原因不是加载失败。</p>
|
||
) : null}
|
||
{record ? (
|
||
<div>
|
||
<p className="rel-hint">
|
||
该快照最近一次:{record.status === 'passed' ? '通过' : '未通过'} · {record.finished_at} · 作业{' '}
|
||
{record.job_id}
|
||
</p>
|
||
{record.failure ? <p className="rel-warn">原因:{record.failure}</p> : null}
|
||
{record.report ? (
|
||
<details>
|
||
<summary>本次恢复验证报告</summary>
|
||
<pre>{JSON.stringify(record.report, null, 2)}</pre>
|
||
</details>
|
||
) : null}
|
||
</div>
|
||
) : null}
|
||
</details>
|
||
)
|
||
}
|
||
|
||
interface DrawerProps {
|
||
view: ScopeView
|
||
page: LibrarySnapshotList | null
|
||
now: number
|
||
open: boolean
|
||
expanded: string | null
|
||
onExpand: (id: string | null) => void
|
||
onClose: () => void
|
||
canRestore: boolean
|
||
// 恢复条件来自容器(真实接口判定):双闸 / 该快照的授权 / 目标是否在维护。
|
||
restore: LibraryRestoreAvailability | null
|
||
restoreNotice: string | null
|
||
pendingRestore: boolean
|
||
pendingGrant: boolean
|
||
onGrantRestore: () => void
|
||
onRestore: () => void
|
||
}
|
||
|
||
function Drawer({
|
||
view,
|
||
page,
|
||
now,
|
||
open,
|
||
expanded,
|
||
onExpand,
|
||
onClose,
|
||
canRestore,
|
||
restore,
|
||
restoreNotice,
|
||
pendingRestore,
|
||
pendingGrant,
|
||
onGrantRestore,
|
||
onRestore,
|
||
}: DrawerProps) {
|
||
const listing = view.history
|
||
const [kindFilter, setKindFilter] = useState<'registered' | 'all' | 'test' | 'production'>('registered')
|
||
const [historyPage, setHistoryPage] = useState(0)
|
||
const [confirmRestore, setConfirmRestore] = useState(false)
|
||
const selectedRef = useRef<HTMLElement | null>(null)
|
||
useEffect(() => {
|
||
setKindFilter('registered')
|
||
setHistoryPage(0)
|
||
setConfirmRestore(false)
|
||
}, [view.scope, open])
|
||
useEffect(() => {
|
||
if (expanded) selectedRef.current?.scrollIntoView?.({ block: 'nearest' })
|
||
}, [expanded])
|
||
const versionLabelOf = (snapshot: LibrarySnapshot) =>
|
||
snapshotVersionLabel(view.overview?.versions, snapshot.snapshot_id)
|
||
const filtered = listing.filter((snapshot) => {
|
||
const label = versionLabelOf(snapshot)
|
||
if (kindFilter === 'all') return true
|
||
if (kindFilter === 'test') return label.includes('测试封存')
|
||
if (kindFilter === 'production') return label.includes('生产生效')
|
||
return !label.startsWith('未登记')
|
||
})
|
||
const pageSize = 8
|
||
const pageCount = Math.max(1, Math.ceil(filtered.length / pageSize))
|
||
const currentPage = Math.min(historyPage, pageCount - 1)
|
||
const pageItems = filtered.slice(currentPage * pageSize, currentPage * pageSize + pageSize)
|
||
const selected = listing.find((item) => item.snapshot_id === expanded)
|
||
if (!open) return null
|
||
return (
|
||
<div className="rel-drawer-backdrop" role="presentation" onClick={onClose}>
|
||
<aside className="rel-drawer" role="dialog" aria-label="版本与快照" onClick={(event) => event.stopPropagation()}>
|
||
<header className="rel-drawer-head">
|
||
<div>
|
||
<h2>版本与快照</h2>
|
||
<p>{scopeName(view.scope)} · 归档里的全部快照,类型按版本登记标注</p>
|
||
</div>
|
||
<button type="button" className="rel-close" onClick={onClose}>
|
||
关闭 ✕
|
||
</button>
|
||
</header>
|
||
<dl className="rel-drawer-kinds">
|
||
<div>
|
||
<dt>目标当前生效</dt>
|
||
<dd>
|
||
{view.overview?.production.state === 'known' && view.overview.production.version
|
||
? `${view.overview.production.version.version_label || view.overview.production.version.snapshot_id.slice(0, 12)} · ${stamp(view.overview.production.version.created_at)}`
|
||
: '无记录(未知)'}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>最近一次生产预备份</dt>
|
||
<dd>
|
||
{view.overview?.prebackup.state === 'known' && view.overview.prebackup.version
|
||
? `${view.overview.prebackup.version.version_label || view.overview.prebackup.version.snapshot_id.slice(0, 12)} · ${stamp(view.overview.prebackup.version.created_at)}${
|
||
view.overview.prebackup.version.source_job_id
|
||
? ` · 作业 ${view.overview.prebackup.version.source_job_id}`
|
||
: ''
|
||
}${view.overview.prebackup.bound_to_target ? ' · 与拟发布目标同快照' : ''}`
|
||
: '无记录(这个范围还没有任何生产预备份)'}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>测试封存</dt>
|
||
<dd>
|
||
{view.overview?.test_sealed
|
||
? `封存 ${view.overview.test_sealed.snapshot_id.slice(0, 12)} · ${stamp(view.overview.test_sealed.created_at)}`
|
||
: '无记录'}
|
||
</dd>
|
||
</div>
|
||
</dl>
|
||
<p className="rel-notice">三类版本分别记录,不能互相顶替:测试封存不等于生产生效,预备份不等于已验证恢复。</p>
|
||
<nav className="rel-history-filters" aria-label="快照类型筛选">
|
||
{(
|
||
[
|
||
['registered', '已登记版本'],
|
||
['test', '测试封存'],
|
||
['production', '生产生效'],
|
||
['all', '全部归档(含未登记)'],
|
||
] as const
|
||
).map(([value, label]) => (
|
||
<button
|
||
key={value}
|
||
type="button"
|
||
className={kindFilter === value ? 'active' : ''}
|
||
aria-pressed={kindFilter === value}
|
||
onClick={() => {
|
||
setKindFilter(value)
|
||
setHistoryPage(0)
|
||
}}
|
||
>
|
||
{label}
|
||
</button>
|
||
))}
|
||
</nav>
|
||
<table className="rel-drawer-table">
|
||
<thead>
|
||
<tr>
|
||
<th>版本 / 发布记录</th>
|
||
<th>状态</th>
|
||
<th>恢复资料</th>
|
||
<th>操作</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{filtered.length === 0 ? (
|
||
<tr>
|
||
<td colSpan={4} className="rel-table-empty">
|
||
{kindFilter === 'all'
|
||
? '尚无封存记录。封存测试版本后,这里会按时间列出每一份完整版本。'
|
||
: '当前筛选下没有已登记版本;切到「全部归档」可查看未登记文件。'}
|
||
</td>
|
||
</tr>
|
||
) : (
|
||
pageItems.map((snapshot) => {
|
||
const isSelected = expanded === snapshot.snapshot_id
|
||
// 类型只能来自版本登记:归档里的目标基线与预备份也在同一个根下。
|
||
const versionLabel = snapshotVersionLabel(view.overview?.versions, snapshot.snapshot_id)
|
||
const sealed = versionLabel.includes('测试封存')
|
||
return (
|
||
<tr key={snapshot.snapshot_id} className={isSelected ? 'selected' : ''}>
|
||
<td>
|
||
<strong>快照 {snapshot.snapshot_id.slice(0, 12)}</strong>
|
||
<small>{stamp(snapshot.created_at)}</small>
|
||
</td>
|
||
<td>
|
||
<span className={`rel-pill ${sealed ? 'green' : 'gray'}`}>{versionLabel}</span>
|
||
</td>
|
||
<td>
|
||
<SnapshotVerificationBadge scope={view.scope} snapshotID={snapshot.snapshot_id} />
|
||
</td>
|
||
<td>
|
||
<button
|
||
type="button"
|
||
className="rel-link"
|
||
onClick={() => onExpand(isSelected ? null : snapshot.snapshot_id)}
|
||
>
|
||
{isSelected ? '收起快照' : '查看快照'}
|
||
</button>
|
||
<button
|
||
type="button"
|
||
className="rel-link"
|
||
onClick={() => onExpand(isSelected ? null : snapshot.snapshot_id)}
|
||
>
|
||
{isSelected ? '恢复条件见下方' : '查看恢复条件'}
|
||
</button>
|
||
</td>
|
||
</tr>
|
||
)
|
||
})
|
||
)}
|
||
</tbody>
|
||
</table>
|
||
<div className="rel-history-pager" aria-label="快照分页">
|
||
<button type="button" disabled={currentPage <= 0} onClick={() => setHistoryPage(currentPage - 1)}>
|
||
上一页
|
||
</button>
|
||
<span>
|
||
第 {currentPage + 1} / {pageCount} 页 · 共 {filtered.length} 份
|
||
</span>
|
||
<button type="button" disabled={currentPage >= pageCount - 1} onClick={() => setHistoryPage(currentPage + 1)}>
|
||
下一页
|
||
</button>
|
||
</div>
|
||
|
||
{selected ? (
|
||
<section className="rel-snapshot" ref={selectedRef}>
|
||
<header>
|
||
<h3>封存 {selected.snapshot_id.slice(0, 12)} · 恢复资料</h3>
|
||
<span className="rel-pill green">
|
||
{snapshotVersionLabel(view.overview?.versions, selected.snapshot_id)}
|
||
</span>
|
||
</header>
|
||
<p className="rel-hint">
|
||
完整快照 <code>{selected.snapshot_id}</code> · 封存于 {stamp(selected.created_at)} · 模型{' '}
|
||
{selected.compatibility.embedding_model || '未记录'}
|
||
</p>
|
||
<dl className="rel-snapshot-grid">
|
||
<div>
|
||
<dt>文档 / 分块</dt>
|
||
<dd>
|
||
{selected.totals.documents ?? 0} 份 · {selected.totals.chunks ?? 0} 分块 ✓
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>检索索引 / 向量</dt>
|
||
<dd>{selected.totals.index_documents ?? 0} 条 ✓</dd>
|
||
</div>
|
||
<div>
|
||
<dt>原文件 / 图片 / 附件</dt>
|
||
<dd>{selected.totals.resources ?? 0} 个 ✓</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Wiki 完整快照</dt>
|
||
<dd>{selected.totals.wiki_pages ?? 0} 页 ✓</dd>
|
||
</div>
|
||
</dl>
|
||
<details className="rel-parts">
|
||
<summary>分项数量 / 字节 / 摘要({selected.parts.length} 项)</summary>
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>类别</th>
|
||
<th>分项</th>
|
||
<th>数量</th>
|
||
<th>字节</th>
|
||
<th>摘要</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{selected.parts.map((part) => (
|
||
<tr key={`${part.kind}-${part.name}`}>
|
||
<td>{part.kind}</td>
|
||
<td>{part.name}</td>
|
||
<td>{part.count}</td>
|
||
<td>{part.bytes.toLocaleString('zh-CN')}</td>
|
||
<td>
|
||
<code>{part.sha256.slice(0, 10)}</code>
|
||
</td>
|
||
</tr>
|
||
))}
|
||
</tbody>
|
||
</table>
|
||
</details>
|
||
<p className="rel-hint">
|
||
以上是同一恢复点的配套内容,不支持只选择 Wiki 或某张数据表恢复。恢复速度需实测;“有备份文件”不等于可恢复。
|
||
</p>
|
||
<div className="rel-drawer-actions">
|
||
<SnapshotVerification scope={view.scope} snapshotID={selected.snapshot_id} />
|
||
{canRestore && restore && restore.authorization.state !== 'active' ? (
|
||
<button type="button" className="rel-secondary" onClick={onGrantRestore} disabled={pendingGrant}>
|
||
{pendingGrant ? '签发中…' : '签发恢复授权(30 分钟)'}
|
||
</button>
|
||
) : null}
|
||
{canRestore ? (
|
||
<button
|
||
type="button"
|
||
className="rel-danger"
|
||
onClick={() => setConfirmRestore(true)}
|
||
disabled={pendingRestore || restore?.allowed !== true}
|
||
title={
|
||
restore?.allowed
|
||
? '把整套生产知识状态恢复到这个快照'
|
||
: (restore?.reasons ?? []).join(';') || '恢复条件尚未读取到'
|
||
}
|
||
>
|
||
{pendingRestore ? '投递中…' : '恢复至该版本'}
|
||
</button>
|
||
) : (
|
||
<span className="rel-hint">按版本恢复仅管理员可发起</span>
|
||
)}
|
||
</div>
|
||
{restore && !restore.allowed ? (
|
||
<ul className="rel-gate" aria-label="恢复条件">
|
||
{restore.reasons.map((reason) => (
|
||
<li key={reason}>{reason}</li>
|
||
))}
|
||
</ul>
|
||
) : null}
|
||
{confirmRestore && selected ? (
|
||
<div className="rel-blocked" aria-label="按版本恢复影响确认">
|
||
<strong>确认按该快照恢复目标?</strong>
|
||
<p>
|
||
目标:{view.overview?.target_instance || '目标实例未读取'} · 知识库{' '}
|
||
{view.overview?.target_knowledge_base_id || '未读取'} · 快照 {selected.snapshot_id.slice(0, 12)}
|
||
</p>
|
||
<p>影响:停止目标写入者并关闭入口,按该快照回放数据库、索引、对象与 Wiki;恢复后复核通过才开入口。</p>
|
||
<p>恢复方式:本快照的完整写前镜像与预备份;不是同步,也不会登记新版本。</p>
|
||
<div className="rel-drawer-actions">
|
||
<button
|
||
type="button"
|
||
className="rel-danger"
|
||
onClick={() => {
|
||
setConfirmRestore(false)
|
||
onRestore()
|
||
}}
|
||
disabled={pendingRestore}
|
||
>
|
||
确认并恢复
|
||
</button>
|
||
<button type="button" className="rel-secondary" onClick={() => setConfirmRestore(false)}>
|
||
取消
|
||
</button>
|
||
</div>
|
||
</div>
|
||
) : null}
|
||
{restore?.allowed ? (
|
||
<p className="rel-hint">
|
||
条件已满足:生产写入闸口打开、这份快照有恢复授权
|
||
{restore.authorization.expires_at ? `(有效至 ${stamp(restore.authorization.expires_at)})` : ''}
|
||
、目标实例未在维护。
|
||
</p>
|
||
) : null}
|
||
{restore === null ? <p className="rel-hint">正在读取恢复条件…</p> : null}
|
||
{restoreNotice ? <p className="rel-notice">{restoreNotice}</p> : null}
|
||
</section>
|
||
) : null}
|
||
|
||
<footer className="rel-drawer-foot">
|
||
<div>
|
||
<strong>封存测试版本</strong>
|
||
<p>
|
||
封存只读测试库、短暂停住测试写入者并恢复;不会写入生产。当前作业:
|
||
{view.activeJob
|
||
? ` ${jobStateLabel[view.activeJob.state] ?? view.activeJob.state}(${elapsed(view.activeJob.created_at, now)})`
|
||
: ' 无'}
|
||
</p>
|
||
</div>
|
||
</footer>
|
||
<p className="rel-hint">
|
||
归档占用(只读):被版本引用的去重内容 {formatBytes(page?.content_bytes ?? 0)} · 磁盘分配{' '}
|
||
{formatBytes(page?.blob_allocated_bytes ?? 0)} · 未被引用 {page?.unreferenced_blobs ?? 0}{' '}
|
||
个。清理与保留策略在系统设置 → 存储管理:当前可查看去重与保护范围,删除与保留策略尚未开放。
|
||
</p>
|
||
</aside>
|
||
</div>
|
||
)
|
||
}
|
||
|
||
const viewScopeLabel = (scope: Scope, kbNames?: Record<Scope, string>) => scopeTitle(scope, kbNames?.[scope])
|
||
|
||
export function ReleaseTargetsView(props: ViewProps) {
|
||
const {
|
||
page,
|
||
jobs,
|
||
overview,
|
||
overviews,
|
||
loading,
|
||
error,
|
||
notice,
|
||
scope,
|
||
onScope,
|
||
kbNames,
|
||
drawerOpen,
|
||
onDrawer,
|
||
expandedSnapshot,
|
||
onExpandSnapshot,
|
||
pendingCapture,
|
||
canCapture,
|
||
canWrite,
|
||
canReconcileCapture,
|
||
pendingReconcileCapture,
|
||
onReconcileCapture,
|
||
sync,
|
||
baseline,
|
||
verification,
|
||
canRestore,
|
||
restore,
|
||
restoreNotice,
|
||
pendingRestore,
|
||
pendingGrant,
|
||
onGrantRestore,
|
||
onRestore,
|
||
now,
|
||
maintenance,
|
||
maintenanceOwnerJob,
|
||
onRefresh,
|
||
onCapture,
|
||
onRecover,
|
||
} = props
|
||
// A response with a different scope is not an observation for this tab.
|
||
const scopedOverview = (target: Scope): LibraryOverview | null => {
|
||
const candidate = overviews?.[target] ?? overview
|
||
return candidate?.scope === target ? candidate : null
|
||
}
|
||
const internal = scopeView(page, jobs, 'internal', scopedOverview('internal'))
|
||
const external = scopeView(page, jobs, 'external', scopedOverview('external'))
|
||
const view = scope === 'internal' ? internal : external
|
||
const legacyOrphanJob = Boolean(
|
||
view.job &&
|
||
view.job.kind === 'seal' &&
|
||
view.job.state === 'failed' &&
|
||
view.job.stage === '' &&
|
||
view.job.snapshot_id === '' &&
|
||
view.job.error === '队列中已无对应作业,业务作业未收到结果' &&
|
||
view.job.recovery === '封存作业由 agent 恢复来源;确认来源 healthy 后可重发'
|
||
)
|
||
const active =
|
||
Boolean(view.activeJob) || view.job?.state === 'running' || view.job?.state === 'pending' || legacyOrphanJob
|
||
// F06: 运行中禁止再次启动,也禁止把主按钮继续显示成可启动的绿色动作。
|
||
// 三类版本严格分开:target 是测试封存,production 是生产权威版本,prebackup 是本次预备份。
|
||
const target = view.overview?.test_sealed
|
||
// 没有 overview 时不能补一个 {state:'unknown'} 再当成"已探测且非空":
|
||
// production 保持 null,分类走 no-observation。
|
||
const production = view.overview?.production ?? null
|
||
const productionClass = productionTargetClass(production)
|
||
// 刷新失败但仍保留上一份 overview:显示可以继续,但必须标成上次观测。
|
||
const productionStale = Boolean(error) && production !== null
|
||
const productionNote = noObservationText(loading, error)
|
||
const prebackup = view.overview?.prebackup ?? { state: 'unknown' as const }
|
||
const diff = view.overview?.diff ?? {
|
||
state: 'unknown' as const,
|
||
reason: '生产与测试的文档级差异读取未接线',
|
||
added: [],
|
||
updated: [],
|
||
removed: [],
|
||
}
|
||
const gate = view.overview?.gate ?? { sync_allowed: false, reasons: ['整库状态接口不可用'] }
|
||
const authorization = view.overview?.authorization ?? { state: 'none' as const, reason: '整库状态接口不可用' }
|
||
const primaryAction = active
|
||
? {
|
||
label: '查看当前任务',
|
||
disabled: false,
|
||
hint: '作业正在处理,请勿重复启动',
|
||
onClick: () =>
|
||
document.getElementById('rel-progress')?.scrollIntoView?.({ behavior: 'smooth', block: 'start' }),
|
||
}
|
||
: !target
|
||
? {
|
||
label: pendingCapture ? '投递中…' : '封存测试版本',
|
||
disabled: !canCapture || pendingCapture || loading || Boolean(error),
|
||
hint: canCapture ? '短暂停止测试写入,保存完整版本后恢复' : captureHint(view, canWrite),
|
||
onClick: onCapture,
|
||
}
|
||
: authorization.state !== 'active'
|
||
? {
|
||
label: !sync.canSign ? '等待管理员授权' : sync.pendingGrant ? '签发中…' : '签发同步授权(30 分钟)',
|
||
disabled: !sync.canSign || sync.pendingGrant || pendingCapture || loading || Boolean(error),
|
||
hint: sync.canSign ? '授权绑定当前目标与快照;签发后仍需单独启动同步' : '请管理员完成本次授权',
|
||
onClick: sync.onGrant,
|
||
}
|
||
: {
|
||
label: sync.pending ? '投递中…' : '▶ 启动同步',
|
||
disabled: !sync.canStart || sync.pending || pendingCapture || loading || Boolean(error),
|
||
hint: sync.canStart
|
||
? '按已签发的同步授权启动:先固定测试版本,再备份目标并写入'
|
||
: `暂不能启动同步:${gate.reasons.join(';')}`,
|
||
onClick: sync.onStart,
|
||
}
|
||
|
||
return (
|
||
<section className="release-targets" aria-label="发布管理">
|
||
<header className="rel-head page-header">
|
||
<div>
|
||
<h1 className="page-title">发布管理</h1>
|
||
<p className="page-subtitle">封存测试版本 → 检查并授权 → 同步到生产</p>
|
||
</div>
|
||
<div className="rel-head-actions page-header-actions">
|
||
<button type="button" className="rel-secondary" onClick={() => onDrawer(true)}>
|
||
▣ 版本与快照
|
||
</button>
|
||
<button type="button" className="rel-secondary" onClick={onRefresh} disabled={loading}>
|
||
{loading ? '刷新中…' : '刷新'}
|
||
</button>
|
||
</div>
|
||
</header>
|
||
|
||
<div className="rel-tabs" role="tablist" aria-label="知识库">
|
||
{[internal, external].map((item) => {
|
||
const status = statusOf(item)
|
||
const isSelected = item.scope === scope
|
||
return (
|
||
<button
|
||
key={item.scope}
|
||
type="button"
|
||
role="tab"
|
||
aria-selected={isSelected}
|
||
className={isSelected ? 'rel-tab selected' : 'rel-tab'}
|
||
onClick={() => onScope(item.scope)}
|
||
>
|
||
<strong>{viewScopeLabel(item.scope, kbNames)}</strong>
|
||
<span className={`rel-pill ${status.tone}`}>{status.text}</span>
|
||
</button>
|
||
)
|
||
})}
|
||
</div>
|
||
|
||
{error ? (
|
||
<div className="rel-blocked">
|
||
<strong>读取失败</strong>
|
||
<p>{error}</p>
|
||
</div>
|
||
) : null}
|
||
{page && !page.available ? (
|
||
<div className="rel-blocked">
|
||
<strong>归档未接线</strong>
|
||
<p>{page.reason || '整库归档根未配置'}</p>
|
||
</div>
|
||
) : null}
|
||
{notice ? <p className="rel-notice">{notice}</p> : null}
|
||
|
||
<div className="rel-panel rel-jobhead">
|
||
<div className="rel-between">
|
||
<h2>
|
||
{viewScopeLabel(scope, kbNames)} ·{' '}
|
||
{active
|
||
? `${jobKindText(view.job?.kind)}进行中`
|
||
: view.snapshot
|
||
? '已封存,同步按条件放行'
|
||
: '尚无测试封存'}
|
||
</h2>
|
||
<div className="rel-head-actions">
|
||
{target && !active && canCapture ? (
|
||
<button
|
||
type="button"
|
||
className="rel-secondary"
|
||
onClick={onCapture}
|
||
disabled={pendingCapture || sync.pending || sync.pendingGrant || loading || Boolean(error)}
|
||
>
|
||
{pendingCapture ? '投递中…' : '重新封存'}
|
||
</button>
|
||
) : null}
|
||
<button
|
||
type="button"
|
||
className="rel-primary"
|
||
onClick={primaryAction.onClick}
|
||
disabled={primaryAction.disabled}
|
||
title={primaryAction.hint}
|
||
>
|
||
{primaryAction.label}
|
||
</button>
|
||
</div>
|
||
</div>
|
||
<p className="rel-target-identity" aria-label="实际目标实例">
|
||
目标实例 {view.overview?.target_instance || view.overview?.executor?.instance || '未读取'} · 项目{' '}
|
||
{view.overview?.target_project || view.overview?.executor?.project || '未读取'} · 知识库{' '}
|
||
{view.overview?.target_knowledge_base_id || target?.knowledge_base_id || '未读取'}({scopeName(scope)})
|
||
</p>
|
||
<p className="rel-versionline">
|
||
目标当前{' '}
|
||
{productionClass === 'known' && production?.version ? (
|
||
<b>
|
||
{production.version.version_label || `生效 ${production.version.snapshot_id.slice(0, 12)}`}
|
||
{' · '}
|
||
快照 {production.version.snapshot_id.slice(0, 12)}
|
||
</b>
|
||
) : productionClass === 'empty' ? (
|
||
<b>目标已读且为空(首次发布)</b>
|
||
) : productionClass === 'unreachable' ? (
|
||
<b className="rel-unknown">读取失败:{production?.reason || '无法读取目标整库状态'}</b>
|
||
) : productionClass === 'nonempty' ? (
|
||
<b className="rel-unknown">目标非空,尚无权威版本</b>
|
||
) : (
|
||
<b className="rel-unknown">{productionNote}</b>
|
||
)}
|
||
{productionStale ? <em className="rel-scope">({STALE_NOTE})</em> : null} → 拟发布{' '}
|
||
<b>{target ? `封存 ${target.snapshot_id.slice(0, 12)} · ${stamp(target.created_at)}` : '还没有测试封存'}</b> ·{' '}
|
||
{publishStateText(view.job)}
|
||
</p>
|
||
<dl className="rel-metrics">
|
||
<div>
|
||
<dt>新增文档</dt>
|
||
<dd className={diff.state === 'computed' ? '' : 'rel-unknown'}>
|
||
{diff.state === 'computed' ? diff.added.length : '未接入'}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>更新文档</dt>
|
||
<dd className={diff.state === 'computed' ? '' : 'rel-unknown'}>
|
||
{diff.state === 'computed' ? diff.updated.length : '未接入'}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>删除文档</dt>
|
||
<dd className={diff.state === 'computed' ? '' : 'rel-unknown'}>
|
||
{diff.state === 'computed' ? diff.removed.length : '未接入'}
|
||
</dd>
|
||
</div>
|
||
<div>
|
||
<dt>Wiki 发布方式</dt>
|
||
<dd>{target ? '完整快照' : '未接入'}</dd>
|
||
</div>
|
||
</dl>
|
||
{target?.source_identity ? (
|
||
<details className="rel-source-identity">
|
||
<summary>来源身份与完整摘要</summary>
|
||
<p>
|
||
来源实例:{target.source_identity.project} / {target.source_identity.app}
|
||
</p>
|
||
<p>
|
||
来源租户 / 知识库:{target.source_identity.tenant_id} / {target.source_identity.knowledge_base_id}
|
||
</p>
|
||
<p>来源身份:{target.source_id}</p>
|
||
<p>快照摘要:{target.snapshot_id}</p>
|
||
</details>
|
||
) : null}
|
||
<details className="rel-disclosure rel-integrity" key={`integrity-${scope}`}>
|
||
<summary>
|
||
封存完整性 <span>{target ? '查看分块、索引与 Wiki 清单' : '尚无封存'}</span>
|
||
</summary>
|
||
<ul className="rel-checklist">
|
||
<li className={target ? 'ok' : 'unknown'}>
|
||
{target
|
||
? `✓ 文档解析与索引完整(${target.totals.chunks ?? 0} 分块 / ${target.totals.index_documents ?? 0} 索引)`
|
||
: '○ 文档解析与索引:未接入'}
|
||
{target ? (
|
||
<em className="rel-scope">
|
||
依据 {stamp(target.created_at)} 封存的测试库全库快照,不代表实时测试库已就绪
|
||
</em>
|
||
) : null}
|
||
</li>
|
||
<li className={target ? 'ok' : 'unknown'}>
|
||
{target ? `✓ Wiki 快照完整(${target.totals.wiki_pages ?? 0} 页)` : '○ Wiki 快照:未接入'}
|
||
{target ? <em className="rel-scope">同一份封存快照,不是实时 Wiki 队列状态</em> : null}
|
||
</li>
|
||
<li className={target ? 'ok' : 'unknown'}>
|
||
{target ? `✓ 清单与摘要登记:${target.parts.length} 项部件摘要已记录` : '○ 数据完整性:尚无封存可核验'}
|
||
{target ? (
|
||
<em className="rel-scope">封存时逐项哈希登记;列表只校验清单自身,字节级复核在同步/恢复执行前进行</em>
|
||
) : null}
|
||
</li>
|
||
</ul>
|
||
{!canCapture ? <p className="rel-hint">{captureHint(view, canWrite)}</p> : null}
|
||
</details>
|
||
<p className="rel-next-step">
|
||
{active
|
||
? '正在处理,页面会自动更新进度。'
|
||
: !target
|
||
? canCapture
|
||
? '还没有测试库封存。下一步:封存测试版本。'
|
||
: captureHint(view, canWrite)
|
||
: authorization.state !== 'active'
|
||
? sync.canSign
|
||
? '下一步:检查下方发布条件,再签发本次同步授权。'
|
||
: '下一步:请管理员签发本次同步授权。'
|
||
: sync.canStart
|
||
? '条件已满足,可启动同步。'
|
||
: '请先处理以下阻塞项;备份与恢复验证入口在下方「发布准备与恢复验证」。'}
|
||
</p>
|
||
{!active && gate.reasons.length > 0 ? (
|
||
<ul className="rel-gate" aria-label="启动同步的缺项">
|
||
{gate.reasons.map((reason) => (
|
||
<li key={reason}>{reason}</li>
|
||
))}
|
||
</ul>
|
||
) : null}
|
||
<p className="rel-footnote">启动后先固定测试版本,再备份生产。备份失败或恢复条件不满足,不进入生产写入。</p>
|
||
</div>
|
||
|
||
<details
|
||
className="rel-disclosure"
|
||
key={`maintenance-${scope}-${Boolean(maintenance?.held)}`}
|
||
open={Boolean(maintenance?.held)}
|
||
>
|
||
<summary>
|
||
目标维护{' '}
|
||
<span>
|
||
{maintenance?.held ? '维护占用中,请关注当前作业' : maintenance ? '查看维护记录与诊断' : '维护状态尚未读取'}
|
||
</span>
|
||
</summary>
|
||
<MaintenanceCard
|
||
maintenance={maintenance}
|
||
ownerJob={maintenanceOwnerJob}
|
||
scope={scope}
|
||
canWrite={canWrite}
|
||
onRecover={onRecover}
|
||
/>
|
||
</details>
|
||
|
||
{active ? (
|
||
<ProgressBody
|
||
view={view}
|
||
now={now}
|
||
canReconcileCapture={canReconcileCapture}
|
||
pendingReconcileCapture={pendingReconcileCapture}
|
||
onReconcileCapture={onReconcileCapture}
|
||
/>
|
||
) : (
|
||
<ReadyBody
|
||
view={view}
|
||
diff={diff}
|
||
production={production}
|
||
productionNote={productionNote}
|
||
stale={productionStale}
|
||
prebackup={prebackup}
|
||
gate={gate}
|
||
authorization={authorization}
|
||
sync={sync}
|
||
baseline={baseline}
|
||
verification={verification}
|
||
/>
|
||
)}
|
||
|
||
<Drawer
|
||
view={view}
|
||
page={page}
|
||
now={now}
|
||
open={drawerOpen}
|
||
expanded={expandedSnapshot}
|
||
onExpand={onExpandSnapshot}
|
||
onClose={() => onDrawer(false)}
|
||
canRestore={canRestore}
|
||
restore={restore}
|
||
restoreNotice={restoreNotice}
|
||
pendingRestore={pendingRestore}
|
||
pendingGrant={pendingGrant}
|
||
onGrantRestore={onGrantRestore}
|
||
onRestore={onRestore}
|
||
/>
|
||
</section>
|
||
)
|
||
}
|
||
|
||
export function ReleaseTargets() {
|
||
const auth = useOptionalAuth()
|
||
const [page, setPage] = useState<LibrarySnapshotList | null>(null)
|
||
const [jobs, setJobs] = useState<LibraryCaptureJob[]>([])
|
||
const [overviews, setOverviews] = useState<Record<Scope, LibraryOverview | null>>({
|
||
internal: null,
|
||
external: null,
|
||
})
|
||
const [loading, setLoading] = useState(true)
|
||
const [error, setError] = useState<string | null>(null)
|
||
const [notice, setNotice] = useState<string | null>(null)
|
||
const [maintenances, setMaintenances] = useState<Record<Scope, LibraryMaintenanceView | null>>({
|
||
internal: null,
|
||
external: null,
|
||
})
|
||
// 维护窗口持有作业的详情:按 owner_job_id 单独读,和 scope 最新作业无关。
|
||
const [maintenanceJobs, setMaintenanceJobs] = useState<Record<Scope, LibraryJobLookup>>({
|
||
internal: { state: 'unread' },
|
||
external: { state: 'unread' },
|
||
})
|
||
// 轮询会并发多次 load:晚到的旧响应不许覆盖更新的维护窗口/作业。
|
||
const loadSeq = useRef(0)
|
||
const [scope, setScope] = useState<Scope>('internal')
|
||
const [drawerOpen, setDrawerOpen] = useState(false)
|
||
const [expandedSnapshot, setExpandedSnapshot] = useState<string | null>(null)
|
||
const [pendingCapture, setPendingCapture] = useState(false)
|
||
// 真实库名只用于显示:读不到就退回业务名,不让它影响发布状态。
|
||
const [kbNames, setKbNames] = useState<Record<Scope, string>>({ internal: '', external: '' })
|
||
const [pendingReconcileCapture, setPendingReconcileCapture] = useState('')
|
||
const [now, setNow] = useState(() => Date.now())
|
||
|
||
const load = useCallback(async (signal?: AbortSignal) => {
|
||
const seq = ++loadSeq.current
|
||
setLoading(true)
|
||
try {
|
||
const [
|
||
snapshots,
|
||
captures,
|
||
internalOverview,
|
||
externalOverview,
|
||
internalMaintenance,
|
||
externalMaintenance,
|
||
bindings,
|
||
] = await Promise.all([
|
||
fetchLibrarySnapshots(signal),
|
||
fetchLibraryCaptures(signal),
|
||
fetchLibraryOverview('internal', signal),
|
||
fetchLibraryOverview('external', signal),
|
||
fetchLibraryMaintenance('internal', signal),
|
||
fetchLibraryMaintenance('external', signal),
|
||
// 库名只是展示用:读不到(未登录/WeKnora 未连接)不能让整页报错。
|
||
fetchRoutingBindings(signal).catch(() => null),
|
||
])
|
||
// 只读既有作业详情接口,按维护记录的 owner_job_id 精确取;读不到就记下来,
|
||
// 不用 overview 的最新作业兜底(那是另一件事,会把失败窗口显示成已完成)。
|
||
const ownerIDs = {
|
||
internal: maintenanceOwnerJobID(internalMaintenance),
|
||
external: maintenanceOwnerJobID(externalMaintenance),
|
||
}
|
||
const [internalOwnerJob, externalOwnerJob] = await Promise.all([
|
||
ownerIDs.internal
|
||
? fetchLibraryJobDetail(ownerIDs.internal, signal)
|
||
: Promise.resolve<LibraryJobLookup>({ state: 'unread' }),
|
||
ownerIDs.external
|
||
? fetchLibraryJobDetail(ownerIDs.external, signal)
|
||
: Promise.resolve<LibraryJobLookup>({ state: 'unread' }),
|
||
])
|
||
// 晚回包直接丢掉:不覆盖更新的窗口,也不把旧窗口的作业挂到新窗口上。
|
||
if (seq !== loadSeq.current) return
|
||
setPage(snapshots)
|
||
setJobs(captures)
|
||
setOverviews({ internal: internalOverview, external: externalOverview })
|
||
setMaintenances({ internal: internalMaintenance, external: externalMaintenance })
|
||
setMaintenanceJobs({ internal: internalOwnerJob, external: externalOwnerJob })
|
||
if (bindings) {
|
||
setKbNames({ internal: bindings.internal_kb_name, external: bindings.external_kb_name })
|
||
}
|
||
setNow(Date.now())
|
||
setError(null)
|
||
} catch (loadError) {
|
||
if ((loadError as Error).name === 'AbortError') return
|
||
if (seq !== loadSeq.current) return
|
||
setError(loadError instanceof Error ? loadError.message : '加载发布状态失败')
|
||
} finally {
|
||
if (seq === loadSeq.current) setLoading(false)
|
||
}
|
||
}, [])
|
||
|
||
useEffect(() => {
|
||
const controller = new AbortController()
|
||
void load(controller.signal)
|
||
return () => controller.abort()
|
||
}, [load])
|
||
|
||
const role = auth?.identity?.role
|
||
const canWrite = role === 'engineer' || role === 'admin'
|
||
// 恢复写的是整套生产知识状态,接口只认管理员;页面必须与它一致。
|
||
const canRestore = role === 'admin'
|
||
// 签发同步授权同样是管理员动作:授权=钉死目标+快照+参数,不等于执行。
|
||
const canSignSync = role === 'admin'
|
||
const canCapture = canWrite && page?.capture_available === true
|
||
const [pendingSyncGrant, setPendingSyncGrant] = useState(false)
|
||
const [pendingSync, setPendingSync] = useState(false)
|
||
const [pendingBaseline, setPendingBaseline] = useState(false)
|
||
const current = overviews[scope]
|
||
const targetSnapshot = current?.test_sealed?.snapshot_id ?? ''
|
||
|
||
const grantSync = async () => {
|
||
if (!targetSnapshot) {
|
||
setNotice('还没有可发布的测试封存:先封存测试版本,再签发同步授权')
|
||
return
|
||
}
|
||
setPendingSyncGrant(true)
|
||
setNotice(null)
|
||
try {
|
||
const grant = await createLibrarySyncAuthorization(scope, targetSnapshot)
|
||
setNotice(
|
||
`已签发同步授权${grant.authorized_by ? `(${grant.authorized_by})` : ''},有效至 ${stamp(grant.expires_at)};` +
|
||
'执行仍需在下一次操作里点"启动同步"'
|
||
)
|
||
await load()
|
||
} catch (grantError) {
|
||
setNotice(grantError instanceof Error ? grantError.message : '签发同步授权失败')
|
||
} finally {
|
||
setPendingSyncGrant(false)
|
||
}
|
||
}
|
||
|
||
const startSync = async () => {
|
||
if (!targetSnapshot || !current?.test_sealed?.source_id) {
|
||
setNotice('还没有与当前来源绑定的可发布封存,请刷新状态')
|
||
return
|
||
}
|
||
setPendingSync(true)
|
||
setNotice(null)
|
||
try {
|
||
const accepted = await enqueueLibrarySync(scope, targetSnapshot, current?.test_sealed?.source_id ?? '')
|
||
setNotice(`已投递同步:${accepted.job_id}(先固定测试版本并生成预备份,再写目标)`)
|
||
await load()
|
||
} catch (syncError) {
|
||
setNotice(syncError instanceof Error ? syncError.message : '启动同步失败')
|
||
} finally {
|
||
setPendingSync(false)
|
||
}
|
||
}
|
||
|
||
const startBaseline = async () => {
|
||
setPendingBaseline(true)
|
||
setNotice(null)
|
||
try {
|
||
const accepted = await enqueueLibraryBaseline(scope)
|
||
setNotice(`已投递建立基线:${accepted.job_id}(维护隔离下捕获目标整库,逐类校验后登记为权威基线)`)
|
||
await load()
|
||
} catch (baselineError) {
|
||
setNotice(baselineError instanceof Error ? baselineError.message : '建立目标权威基线失败')
|
||
} finally {
|
||
setPendingBaseline(false)
|
||
}
|
||
}
|
||
|
||
// 恢复条件随"展开的那份快照"变化:闸口、该快照的授权、实例是否在维护都由接口判定。
|
||
const [restore, setRestore] = useState<LibraryRestoreAvailability | null>(null)
|
||
const [restoreNotice, setRestoreNotice] = useState<string | null>(null)
|
||
const [pendingRestore, setPendingRestore] = useState(false)
|
||
// 按预备份恢复(library.recover)是独立的队列作业,不会产生新的 library_jobs 行:
|
||
// 只靠 jobs/overview 判断会让页面在投递后立刻停止轮询,恢复完成也停在旧状态(F12)。
|
||
const [pendingRecovery, setPendingRecovery] = useState(false)
|
||
const recoveryStartedAt = useRef(0)
|
||
// 恢复验证是独立业务作业:投递后父页面必须自己轮询 overview/维护/闸口,
|
||
// 只在子面板刷新证据会让页面停在点击前的状态(审核 B4)。
|
||
const [activeVerifyJob, setActiveVerifyJob] = useState('')
|
||
const [pendingGrant, setPendingGrant] = useState(false)
|
||
// 轮询覆盖"投递 → 终态读回":投递中的动作也算在跑(点完到 worker 落库之间
|
||
// 有一次空窗,只看已有作业会让页面停在"尚未启动")。终态(成功/失败/取消)
|
||
// 再做一次读回就停,不会无限轮询失败作业。
|
||
const polling = libraryPollingActive({
|
||
captures: jobs,
|
||
overviews,
|
||
pending:
|
||
pendingCapture ||
|
||
pendingSync ||
|
||
pendingBaseline ||
|
||
pendingRestore ||
|
||
pendingSyncGrant ||
|
||
pendingGrant ||
|
||
activeVerifyJob !== '',
|
||
recoveryPending: pendingRecovery,
|
||
maintenances,
|
||
})
|
||
const wasPolling = useRef(false)
|
||
useEffect(() => {
|
||
if (polling) {
|
||
wasPolling.current = true
|
||
const timer = window.setInterval(() => {
|
||
setNow(Date.now())
|
||
void load().catch(() => undefined)
|
||
}, 3000)
|
||
return () => window.clearInterval(timer)
|
||
}
|
||
if (wasPolling.current) {
|
||
wasPolling.current = false
|
||
// 终态读回:拿最后一次的 finished_at / 阶段终值,然后停下。
|
||
void load().catch(() => undefined)
|
||
}
|
||
return undefined
|
||
}, [polling, load])
|
||
const [restoreRound, setRestoreRound] = useState(0)
|
||
const restoreSnapshot = expandedSnapshot ?? ''
|
||
useEffect(() => {
|
||
if (!drawerOpen || !restoreSnapshot) {
|
||
setRestore(null)
|
||
return
|
||
}
|
||
const controller = new AbortController()
|
||
void fetchLibraryRestoreAvailability(scope, restoreSnapshot, controller.signal)
|
||
.then((value) => setRestore(value))
|
||
.catch(() => setRestore(null))
|
||
return () => controller.abort()
|
||
}, [drawerOpen, restoreSnapshot, scope, restoreRound])
|
||
|
||
const grantRestore = async () => {
|
||
if (!restoreSnapshot) return
|
||
setPendingGrant(true)
|
||
setRestoreNotice(null)
|
||
try {
|
||
const grant = await createLibraryRestoreAuthorization(scope, restoreSnapshot)
|
||
setRestoreNotice(
|
||
`已签发恢复授权${grant.authorized_by ? `(${grant.authorized_by})` : ''},有效至 ${stamp(grant.expires_at)}`
|
||
)
|
||
setRestoreRound((round) => round + 1)
|
||
await load()
|
||
} catch (grantError) {
|
||
setRestoreNotice(grantError instanceof Error ? grantError.message : '签发恢复授权失败')
|
||
} finally {
|
||
setPendingGrant(false)
|
||
}
|
||
}
|
||
|
||
const startRestore = async () => {
|
||
if (!restoreSnapshot) return
|
||
setPendingRestore(true)
|
||
setRestoreNotice(null)
|
||
try {
|
||
const accepted = await enqueueLibraryRestore(scope, restoreSnapshot)
|
||
setRestoreNotice(`已投递恢复:${accepted.job_id}(整套生产知识状态回到该快照)`)
|
||
setRestoreRound((round) => round + 1)
|
||
await load()
|
||
} catch (restoreError) {
|
||
setRestoreNotice(restoreError instanceof Error ? restoreError.message : '发起恢复失败')
|
||
} finally {
|
||
setPendingRestore(false)
|
||
}
|
||
}
|
||
|
||
const startCapture = async () => {
|
||
setPendingCapture(true)
|
||
setNotice(null)
|
||
try {
|
||
const accepted = await enqueueLibraryCapture(scope)
|
||
setNotice(
|
||
accepted.reused
|
||
? `该封存作业已存在:${scopeLabel(scope)} · ${accepted.capture_job}(${jobStateLabel[accepted.state] ?? accepted.state})`
|
||
: `已投递封存:${scopeLabel(scope)} · ${accepted.capture_job}`
|
||
)
|
||
await load()
|
||
} catch (captureError) {
|
||
setNotice(captureError instanceof Error ? captureError.message : '发起封存失败')
|
||
} finally {
|
||
setPendingCapture(false)
|
||
}
|
||
}
|
||
|
||
const reconcileCapture = async (jobID: string) => {
|
||
setPendingReconcileCapture(jobID)
|
||
setNotice(null)
|
||
try {
|
||
const result = await reconcileLibraryCapture(jobID)
|
||
setNotice(
|
||
result.already_succeeded
|
||
? `封存作业 ${jobID} 已是成功终态,未重复写入`
|
||
: `已核对封存结果:${jobID} → ${result.snapshot_id.slice(0, 12)}(审计 ${result.audit_operation_id ?? '已记录'})`
|
||
)
|
||
await load()
|
||
} catch (reconcileError) {
|
||
setNotice(reconcileError instanceof Error ? reconcileError.message : '核对封存结果失败')
|
||
} finally {
|
||
setPendingReconcileCapture('')
|
||
}
|
||
}
|
||
|
||
const recover = async (windowJobID: string) => {
|
||
setNotice(null)
|
||
try {
|
||
const accepted = await enqueueLibraryRecovery(scope, windowJobID)
|
||
// 从这里开始页面必须持续读回,直到维护窗口真的关闭(成功)或恢复失败被记下来。
|
||
recoveryStartedAt.current = Date.now()
|
||
setPendingRecovery(true)
|
||
setNotice(`已投递按预备份恢复:${accepted.recovery_job || '(未返回作业号)'};正在等待恢复与校验完成`)
|
||
await load()
|
||
} catch (recoveryError) {
|
||
setPendingRecovery(false)
|
||
setNotice(recoveryError instanceof Error ? recoveryError.message : '恢复请求失败')
|
||
}
|
||
}
|
||
|
||
// 恢复轮询的收尾:维护窗口不再被持有 ⇒ 读到终态,停止等待并给出结论。
|
||
// 超时不是"成功":只停止轮询并把状态留给页面显示(恢复失败会继续 held + needs_restore)。
|
||
useEffect(() => {
|
||
if (!pendingRecovery) return
|
||
const held = Boolean(maintenances[scope]?.held)
|
||
const timedOut = Date.now() - recoveryStartedAt.current > 15 * 60 * 1000
|
||
if (!held || timedOut) {
|
||
setPendingRecovery(false)
|
||
if (timedOut) setNotice('恢复轮询超时:请查看维护窗口状态(仍在维护说明恢复/校验未通过)')
|
||
void load().catch(() => undefined)
|
||
}
|
||
}, [pendingRecovery, maintenances, scope, load])
|
||
|
||
return (
|
||
<>
|
||
<ReleaseTargetsView
|
||
page={page}
|
||
jobs={jobs}
|
||
overview={overviews[scope]}
|
||
overviews={overviews}
|
||
loading={loading}
|
||
error={error}
|
||
notice={notice}
|
||
scope={scope}
|
||
onScope={(next) => {
|
||
setScope(next)
|
||
setExpandedSnapshot(null)
|
||
// F10: 旧操作通知属于旧作业/旧对象,切范围后不得继续挂在页顶。
|
||
setNotice(null)
|
||
}}
|
||
kbNames={kbNames}
|
||
drawerOpen={drawerOpen}
|
||
onDrawer={setDrawerOpen}
|
||
expandedSnapshot={expandedSnapshot}
|
||
onExpandSnapshot={setExpandedSnapshot}
|
||
pendingCapture={pendingCapture}
|
||
canCapture={canCapture}
|
||
canWrite={canWrite}
|
||
canReconcileCapture={role === 'admin'}
|
||
pendingReconcileCapture={pendingReconcileCapture}
|
||
onReconcileCapture={(jobID) => void reconcileCapture(jobID)}
|
||
sync={{
|
||
canSign: canSignSync,
|
||
pendingGrant: pendingSyncGrant,
|
||
onGrant: () => void grantSync(),
|
||
canStart: current?.gate.sync_allowed === true && Boolean(current?.test_sealed?.source_id),
|
||
pending: pendingSync,
|
||
onStart: () => void startSync(),
|
||
}}
|
||
baseline={{
|
||
canStart: canSignSync,
|
||
pending: pendingBaseline,
|
||
onStart: () => void startBaseline(),
|
||
}}
|
||
verification={{
|
||
onAccepted: (jobId) => {
|
||
// F10: 新验证作业开始时清掉上一次封存/同步的旧通知。
|
||
setNotice(null)
|
||
setActiveVerifyJob(jobId)
|
||
void load()
|
||
},
|
||
onComplete: () => {
|
||
setActiveVerifyJob('')
|
||
void load()
|
||
},
|
||
}}
|
||
canRestore={canRestore}
|
||
restore={restore}
|
||
restoreNotice={restoreNotice}
|
||
pendingRestore={pendingRestore}
|
||
pendingGrant={pendingGrant}
|
||
onGrantRestore={() => void grantRestore()}
|
||
onRestore={() => void startRestore()}
|
||
maintenance={maintenances[scope]}
|
||
maintenanceOwnerJob={maintenanceJobs[scope]}
|
||
now={now}
|
||
onRefresh={() => void load()}
|
||
onCapture={() => void startCapture()}
|
||
onRecover={(windowJobID) => void recover(windowJobID)}
|
||
/>
|
||
</>
|
||
)
|
||
}
|