Files
knowledge-governance/web/src/ReleaseTargets.tsx
T
姚章浩 e34306b2db
build / build (push) Failing after 18s
fix(ui): 已释放窗口不再渲染 held 文案,版本页不再把 500 说成未接线
发布管理:maintenanceSummary 只看 job.state === 'failed' 就给 held 处置文案;
窗口已 released 的旧作业(libsync-internal-1793399248431728863)因此自相矛盾。
改为仅 held 时给 recoveryError,已释放时给 releasedFailure(如实记录失败,不提供强制成功)。

版本记录:LoadVersionHistorySyncState 把可空的 finished_at 扫进 time.Time;
部署重启触发的同步在"进行中"时该列为 NULL,扫描失败使整页 500
(nginx access log:GET /api/v1/version-history?limit=30 → 500,74 字节错误体)。
改为指针接值再判空。前端同时区分"未配置/加载失败"并显示服务端 code。

RED/GREEN:新增 Go 集成用例(NULL finished_at)、两条前端用例;
make verify 16/16 通过(local 档案)。
2026-11-01 19:34:31 +08:00

1894 lines
74 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { LegacySourceAssociation } from './LegacySourceAssociation'
import { useCallback, useEffect, useRef, useState } from 'react'
import {
createLibraryRestoreAuthorization,
createLibrarySyncAuthorization,
enqueueLibraryBaseline,
enqueueLibraryCapture,
enqueueLibraryRecovery,
enqueueLibraryRestore,
enqueueLibrarySync,
fetchLibraryCaptures,
fetchLibraryMaintenance,
fetchLibraryOverview,
fetchLibraryRestoreAvailability,
fetchLibrarySnapshots,
formatBytes,
scopeLabel,
type LibraryCaptureJob,
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'
// 发布管理:按已确认稿实现——顶部两个知识库页签,下面是**一个**作业区。
//
// 真实能力只有「测试库封存」这一段;生产当前版本、变更差异、生产预备份、
// 同步与生产验证都还没有接线。页面照原稿结构全部画出来,但未接线的位置一律
// 写「未接入 / 尚无记录」,不用 0、无变化或已同步冒充。队列状态、封存、传输、
// 生产验证是四个不同阶段,不能互相顶替。
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
drawerOpen: boolean
onDrawer: (open: boolean) => void
expandedSnapshot: string | null
onExpandSnapshot: (id: string | null) => void
pendingCapture: boolean
canCapture: boolean
canWrite: boolean
// 发布动作:签发授权(管理员)与启动同步是两个独立步骤,页面绝不自动签发。
sync: ReleaseSyncActions
// 目标非空又没有生效版本时,唯一入口是"建立目标权威基线"(管理员)。
baseline: ReleaseBaselineActions
// 按版本恢复是管理员动作:工程师看得到条件,但拿不到恢复入口。
canRestore: boolean
restore: LibraryRestoreAvailability | null
restoreNotice: string | null
pendingRestore: boolean
pendingGrant: boolean
onGrantRestore: () => void
onRestore: () => void
overview: LibraryOverview | null
maintenance: LibraryMaintenanceView | null
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 ?? []
const job =
overview?.job ?? persisted.find((item) => item.state === 'pending' || item.state === 'running') ?? 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' ? '对内知识库' : '对外知识库')
// 不可发起时必须说清是哪一条不满足:读的是接口给出的真实原因(执行器不可达、
// 指向别的实例、降级、观测过期),不是一句写死的"通道未接线"。
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 '建立目标基线'
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 === 'restore'
? '恢复进行中(目标在维护中)'
: job.kind === 'baseline'
? '建立基线进行中(只读捕获目标,不写内容)'
: '同步进行中(目标在维护中)'
}
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
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 === 'open' ? '打开' : state ? state : '未知'
export function maintenanceSummary(
maintenance: LibraryMaintenanceView | null | undefined,
job: LibraryJobRecord | undefined
): 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 failed = job?.state === 'failed'
const ownerScope = maintenance?.instance_maintenance?.owner_scope ?? record?.scope ?? '—'
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: job ? `${stageLabel[job.stage] ?? job.stage ?? '—'} · ${jobStateText(job)}` : '尚无作业进度',
// 只有仍然 held 的失败才配 held 处置说明;窗口已释放时那段文案是假的。
recoveryError: failed && held ? job?.error || '作业失败但没有留下错误明细' : '',
releasedFailure: failed && !held ? job?.error || '作业失败但没有留下错误明细' : '',
recoveryNote: job?.recovery || '',
canRecover: held && (failed || !job || job.state === 'cancelled'),
}
}
export function MaintenanceCard({
maintenance,
job,
canWrite,
onRecover,
}: {
maintenance: LibraryMaintenanceView | null | undefined
job: LibraryJobRecord | undefined
canWrite: boolean
onRecover: (windowJobID: string) => void
}) {
const summary = maintenanceSummary(maintenance, job)
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>入口 {summary.ingress}</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.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
const sealJob = job?.kind === 'seal' ? job : undefined
// 同步、恢复、建立基线共用同一串阶段(预备份 → 数据四类 → 校验 → 登记版本)。
// 只按"sync"找阶段会让刚跑完的恢复/基线在页面上显示成"本次作业尚未开始"。
const writeJob = job && job.kind !== 'seal' ? job : undefined
let first: { state: StepState; hint: string }
if (sealJob) {
const exportStage = stageOf(sealJob, 'export')
first = {
state: toState(sealJob.state === 'succeeded' ? 'succeeded' : sealJob.state === 'failed' ? 'failed' : 'running'),
hint:
sealJob.state === 'succeeded'
? `本次作业已封存 ${stamp(sealJob.finished_at ?? exportStage?.updated_at ?? sealJob.updated_at)}`
: sealJob.state === 'running'
? '本次封存执行中'
: sealJob.state === 'pending'
? '已排队,等待 worker'
: '本次封存未完成',
}
} else 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: '新版本生效',
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,
prebackup,
gate,
authorization,
targetSealed,
sync,
baseline,
onOpen,
}: {
production: LibraryOverview['production']
prebackup: LibraryOverview['prebackup']
gate: LibraryOverview['gate']
authorization: LibraryOverview['authorization']
targetSealed: boolean
sync: ReleaseSyncActions
baseline: ReleaseBaselineActions
onOpen: () => void
}) {
const backupKnown = prebackup.state === 'known' && prebackup.version
// 基线入口只在"目标非空、却没有生效版本"时才是答案;空库走首次同步(预备份+登记)。
const baselineNeeded = production.state !== 'known' && targetSealed
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>
{production.state === 'known' && production.version
? production.version.version_label || production.version.snapshot_id.slice(0, 12)
: '未知(生产还没有权威版本记录)'}
</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>
{gate.reasons.length > 0 ? (
<ul className="rel-gate" aria-label="恢复与启动条件">
{gate.reasons.map((reason) => (
<li key={reason}>{reason}</li>
))}
</ul>
) : null}
<div className="rel-drawer-actions">
{sync.canSign && authorization.state !== 'active' && targetSealed ? (
<button type="button" className="rel-secondary" onClick={sync.onGrant} disabled={sync.pendingGrant}>
{sync.pendingGrant ? '签发中…' : '签发同步授权(30 分钟)'}
</button>
) : null}
{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>
<button type="button" className="rel-secondary" onClick={onOpen}>
查看已有版本与快照 ›
</button>
<p className="rel-warn">恢复版本会恢复一整套生产知识状态,不回退测试知识库。</p>
</aside>
)
}
interface ReadyProps {
view: ScopeView
diff: LibraryOverview['diff']
production: LibraryOverview['production']
prebackup: LibraryOverview['prebackup']
gate: LibraryOverview['gate']
authorization: LibraryOverview['authorization']
canCapture: boolean
canWrite: boolean
pendingCapture: boolean
onCapture: () => void
onOpen: () => void
sync: ReleaseSyncActions
baseline: ReleaseBaselineActions
}
function ReadyBody({
view,
diff,
production,
prebackup,
gate,
authorization,
sync,
baseline,
canCapture,
canWrite,
pendingCapture,
onCapture,
onOpen,
}: ReadyProps) {
const snapshot = view.snapshot
return (
<>
<div className="rel-grid">
<ChangeTable diff={diff} />
<ProtectionCard
production={production}
prebackup={prebackup}
gate={gate}
authorization={authorization}
targetSealed={Boolean(snapshot)}
sync={sync}
baseline={baseline}
onOpen={onOpen}
/>
</div>
<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} />
</div>
<div className="rel-panel rel-seal">
<div>
<h2>测试库封存</h2>
<p>
{snapshot
? `最近一次封存 ${stamp(snapshot.created_at)},快照 ${snapshot.snapshot_id.slice(0, 12)}。封存只读测试库,不影响生产。`
: '还没有测试库封存。封存会短暂停住测试写入者,导出完整版本后恢复。'}
</p>
</div>
{canCapture ? (
<button
type="button"
className="rel-secondary"
onClick={onCapture}
disabled={pendingCapture || Boolean(view.activeJob)}
>
{pendingCapture ? '投递中…' : '封存测试版本'}
</button>
) : (
<span className="rel-hint">{captureHint(view, canWrite)}</span>
)}
</div>
</>
)
}
function ProgressBody({ view, now, onOpen }: { view: ScopeView; now: number; onOpen: () => 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'
const stage = (name: string) => dataJob?.stages.find((item) => item.stage === name)
const cards = [
{ title: '数据库 · 文档与分块', row: stage('database'), axis: '文档 / 分块' },
{ title: '原文件 · 图片 · 附件', row: stage('resources'), axis: '对象 / 字节' },
{ title: '检索索引 · 向量', row: stage('index'), axis: '索引文档' },
{ title: 'Wiki · 完整快照', row: stage('wiki'), axis: 'Wiki 页' },
].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">
<div className="rel-between">
<h2>
{sealJob ? '测试库封存作业' : dataJob ? `${jobKindText(dataJob.kind)}作业` : '本次作业'}
<span className="rel-version">
{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} />
<div className="rel-between rel-progress-foot">
<span>
当前:
{job?.state === 'running'
? job.stage || '执行中'
: job?.state === 'failed'
? job.error || '失败'
: job
? jobStateText(job)
: '本次作业尚未开始'}
</span>
<button type="button" className="rel-link" onClick={onOpen}>
查看版本与快照 ↗
</button>
</div>
</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>
<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
: 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>
</>
)
}
interface DrawerProps {
view: ScopeView
page: LibrarySnapshotList | null
now: number
open: boolean
expanded: string | null
onExpand: (id: string | null) => void
onClose: () => void
canCapture: boolean
canRestore: boolean
pendingCapture: boolean
onCapture: () => void
// 恢复条件来自容器(真实接口判定):双闸 / 该快照的授权 / 目标是否在维护。
restore: LibraryRestoreAvailability | null
restoreNotice: string | null
pendingRestore: boolean
pendingGrant: boolean
onGrantRestore: () => void
onRestore: () => void
}
function Drawer({
view,
page,
now,
open,
expanded,
onExpand,
onClose,
canCapture,
canRestore,
pendingCapture,
onCapture,
restore,
restoreNotice,
pendingRestore,
pendingGrant,
onGrantRestore,
onRestore,
}: DrawerProps) {
if (!open) return null
const listing = view.history
const selected = listing.find((item) => item.snapshot_id === expanded)
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>
<table className="rel-drawer-table">
<thead>
<tr>
<th>版本 / 发布记录</th>
<th>状态</th>
<th>恢复资料</th>
<th>操作</th>
</tr>
</thead>
<tbody>
{listing.length === 0 ? (
<tr>
<td colSpan={4} className="rel-table-empty">
尚无封存记录。封存测试版本后,这里会按时间列出每一份完整版本。
</td>
</tr>
) : (
listing.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>
<span className="rel-pill gray">分项完整 · 未做生产恢复验证</span>
</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>
{selected ? (
<section className="rel-snapshot">
<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">
<button type="button" disabled title="逐项校验证据在同步/恢复执行时产生,作业详情里可见">
查看校验记录
</button>
{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={onRestore}
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}
{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>
<button
type="button"
className="rel-secondary"
disabled={!canCapture || pendingCapture || Boolean(view.activeJob)}
onClick={onCapture}
>
{pendingCapture ? '投递中…' : '封存测试版本'}
</button>
</footer>
<p className="rel-hint">
归档占用(只读):被版本引用的去重内容 {formatBytes(page?.content_bytes ?? 0)} · 磁盘分配{' '}
{formatBytes(page?.blob_allocated_bytes ?? 0)} · 未被引用 {page?.unreferenced_blobs ?? 0}{' '}
个。清理与保留策略在系统设置 → 存储管理:当前可查看去重与保护范围,删除与保留策略尚未开放。
</p>
</aside>
</div>
)
}
export function ReleaseTargetsView(props: ViewProps) {
const {
page,
jobs,
overview,
loading,
error,
notice,
scope,
onScope,
drawerOpen,
onDrawer,
expandedSnapshot,
onExpandSnapshot,
pendingCapture,
canCapture,
canWrite,
sync,
baseline,
canRestore,
restore,
restoreNotice,
pendingRestore,
pendingGrant,
onGrantRestore,
onRestore,
now,
maintenance,
onRefresh,
onCapture,
onRecover,
} = props
const internal = scopeView(page, jobs, 'internal', overview?.scope === 'internal' ? overview : null)
const external = scopeView(page, jobs, 'external', overview?.scope === 'external' ? overview : null)
const view = scope === 'internal' ? internal : external
const active = Boolean(view.activeJob) || view.job?.state === 'running' || view.job?.state === 'pending'
// 三类版本严格分开:target 是测试封存,production 是生产权威版本,prebackup 是本次预备份。
const target = view.overview?.test_sealed
const production = view.overview?.production ?? { state: 'unknown' as const }
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: '整库状态接口不可用' }
return (
<section className="release-targets" aria-label="发布管理">
<header className="rel-head">
<div>
<h1>发布管理</h1>
<p>测试维护与验证,生产按知识库版本同步。</p>
</div>
<div className="rel-head-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>{scopeName(item.scope)}</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>
{scopeName(scope)} ·{' '}
{active
? `${jobKindText(view.job?.kind)}进行中`
: view.snapshot
? '已封存,同步按条件放行'
: '尚无测试封存'}
</h2>
<div className="rel-head-actions">
<button type="button" className="rel-secondary" onClick={() => onDrawer(true)}>
版本与快照
</button>
<button
type="button"
className="rel-primary"
onClick={sync.onStart}
disabled={!sync.canStart || sync.pending}
title={
sync.canStart
? '按已签发的同步授权启动:先固定测试版本,再备份目标并写入'
: `暂不能启动同步:${gate.reasons.join(';')}`
}
>
{sync.pending ? '投递中…' : '▶ 启动同步'}
</button>
</div>
</div>
<p className="rel-versionline">
生产当前{' '}
{production.state === 'known' && production.version ? (
<b>{production.version.version_label || `生效 ${production.version.snapshot_id.slice(0, 12)}`}</b>
) : (
<b className="rel-unknown">未知(尚未建立权威版本)</b>
)}{' '}
→ 拟发布{' '}
<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}
<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>
{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>
<MaintenanceCard maintenance={maintenance} job={view.job} canWrite={canWrite} onRecover={onRecover} />
{active ? (
<ProgressBody view={view} now={now} onOpen={() => onDrawer(true)} />
) : (
<ReadyBody
view={view}
diff={diff}
production={production}
prebackup={prebackup}
gate={gate}
authorization={authorization}
sync={sync}
baseline={baseline}
canCapture={canCapture}
canWrite={canWrite}
pendingCapture={pendingCapture}
onCapture={onCapture}
onOpen={() => onDrawer(true)}
/>
)}
<Drawer
view={view}
page={page}
now={now}
open={drawerOpen}
expanded={expandedSnapshot}
onExpand={onExpandSnapshot}
onClose={() => onDrawer(false)}
canCapture={canCapture}
canRestore={canRestore}
pendingCapture={pendingCapture}
onCapture={onCapture}
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,
})
const [scope, setScope] = useState<Scope>('internal')
const [drawerOpen, setDrawerOpen] = useState(false)
const [expandedSnapshot, setExpandedSnapshot] = useState<string | null>(null)
const [pendingCapture, setPendingCapture] = useState(false)
const [now, setNow] = useState(() => Date.now())
const load = useCallback(async (signal?: AbortSignal) => {
setLoading(true)
try {
const [snapshots, captures, internalOverview, externalOverview, internalMaintenance, externalMaintenance] =
await Promise.all([
fetchLibrarySnapshots(signal),
fetchLibraryCaptures(signal),
fetchLibraryOverview('internal', signal),
fetchLibraryOverview('external', signal),
fetchLibraryMaintenance('internal', signal),
fetchLibraryMaintenance('external', signal),
])
setPage(snapshots)
setJobs(captures)
setOverviews({ internal: internalOverview, external: externalOverview })
setMaintenances({ internal: internalMaintenance, external: externalMaintenance })
setNow(Date.now())
setError(null)
} catch (loadError) {
if ((loadError as Error).name === 'AbortError') return
setError(loadError instanceof Error ? loadError.message : '加载发布状态失败')
} finally {
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)
const [pendingGrant, setPendingGrant] = useState(false)
// 轮询覆盖"投递 → 终态读回":投递中的动作也算在跑(点完到 worker 落库之间
// 有一次空窗,只看已有作业会让页面停在"尚未启动")。终态(成功/失败/取消)
// 再做一次读回就停,不会无限轮询失败作业。
const polling = libraryPollingActive({
captures: jobs,
overviews,
pending: pendingCapture || pendingSync || pendingBaseline || pendingRestore || pendingSyncGrant || pendingGrant,
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 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]}
loading={loading}
error={error}
notice={notice}
scope={scope}
onScope={(next) => {
setScope(next)
setExpandedSnapshot(null)
}}
drawerOpen={drawerOpen}
onDrawer={setDrawerOpen}
expandedSnapshot={expandedSnapshot}
onExpandSnapshot={setExpandedSnapshot}
pendingCapture={pendingCapture}
canCapture={canCapture}
canWrite={canWrite}
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(),
}}
canRestore={canRestore}
restore={restore}
restoreNotice={restoreNotice}
pendingRestore={pendingRestore}
pendingGrant={pendingGrant}
onGrantRestore={() => void grantRestore()}
onRestore={() => void startRestore()}
maintenance={maintenances[scope]}
now={now}
onRefresh={() => void load()}
onCapture={() => void startCapture()}
onRecover={(windowJobID) => void recover(windowJobID)}
/>
<LegacySourceAssociation
key={scope}
scope={scope}
snapshots={page?.snapshots ?? []}
admin={role === 'admin'}
onBound={() => load()}
/>
</>
)
}