e34306b2db
build / build (push) Failing after 18s
发布管理: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 档案)。
1894 lines
74 KiB
TypeScript
1894 lines
74 KiB
TypeScript
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()}
|
||
/>
|
||
</>
|
||
)
|
||
}
|