a0a7a26639
build / build (push) Successful in 1m21s
治理侧的摘要登记与取回原先只能连真实治理库验证,等于没有负例。这里把"列版本" 抽成一个最小接口(真实 store 原样满足),并为三个判据补单测:预备份原有证据必须 保留、摘要必须按"作业+目标+预备份"三者匹配才能取回、接管时没有写集合必须失败。 本地验证:go test ./cmd/worker/ -run 'WriteSet|LedgerBackup' 4 项通过; go vet ./cmd/worker/ 无输出。
152 lines
6.0 KiB
Go
152 lines
6.0 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"time"
|
|
|
|
"knowledge-governance/internal/governance"
|
|
"knowledge-governance/internal/libraryrelease"
|
|
v071 "knowledge-governance/internal/releaseadapter/v071"
|
|
)
|
|
|
|
// 写集合台账在治理侧的锚点:摘要登记在"这次作业的预备份版本"证据里。
|
|
// 为什么不用新表:版本记录本来就绑定 scope + snapshot + 作业,且 id 由这三者
|
|
// 决定;把摘要挂上去,重启后按同一身份就能取回,不需要改 schema。
|
|
|
|
// libraryVersionLister 只暴露"按 scope 列版本"这一件事:装配真实 store 用,
|
|
// 单元测试用假实现,不必为验证摘要锚点去连治理库。
|
|
type libraryVersionLister interface {
|
|
LibraryVersions(ctx context.Context, scope string, limit int) ([]governance.LibraryVersion, error)
|
|
}
|
|
|
|
// writeSetDigestOf 读某次作业/某份预备份登记的写集合摘要。
|
|
// 读不到就返回错误:缺失必须让调用方失败,不能降级成"没有记录就当没写过"。
|
|
func writeSetDigestOf(ctx context.Context, store libraryVersionLister, scope, jobID, snapshotID string) (string, error) {
|
|
versions, err := store.LibraryVersions(ctx, scope, 200)
|
|
if err != nil {
|
|
return "", fmt.Errorf("读不到版本记录:%w", err)
|
|
}
|
|
for _, version := range versions {
|
|
if version.Kind != governance.LibraryVersionProductionPrebackup || version.SnapshotID != snapshotID {
|
|
continue
|
|
}
|
|
if version.SourceJobID != jobID {
|
|
continue
|
|
}
|
|
raw, _ := version.Evidence["writeset_digest"].(string)
|
|
if raw == "" {
|
|
return "", fmt.Errorf("预备份 %s 没有登记写集合摘要(作业 %s)", snapshotID, jobID)
|
|
}
|
|
return raw, nil
|
|
}
|
|
return "", fmt.Errorf("找不到作业 %s 的预备份版本记录(快照 %s)", jobID, snapshotID)
|
|
}
|
|
|
|
// loadWriteSetForJob 按"作业 + 目标 + 预备份"取回写集合并逐项核对绑定。
|
|
// 任何一步不符都返回错误:恢复宁可保持维护,也不许用一份对不上的记录去删目标数据。
|
|
func loadWriteSetForJob(ctx context.Context, store libraryVersionLister, archiveRoot, scope, jobID, snapshotID string) (*libraryrelease.WriteSet, error) {
|
|
digest, err := writeSetDigestOf(ctx, store, scope, jobID, snapshotID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
set, err := v071.LoadWriteSet(archiveRoot, digest)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if set.JobID != jobID {
|
|
return nil, fmt.Errorf("写集合记录属于作业 %s,不是 %s", set.JobID, jobID)
|
|
}
|
|
if set.Target != scope {
|
|
return nil, fmt.Errorf("写集合记录属于目标 %s,不是 %s", set.Target, scope)
|
|
}
|
|
if set.BackupSnapshotID != snapshotID {
|
|
return nil, fmt.Errorf("写集合记录绑定预备份 %s,不是 %s", set.BackupSnapshotID, snapshotID)
|
|
}
|
|
return set, nil
|
|
}
|
|
|
|
// writeSetEvidence 在预备份原有证据上追加写集合锚点(纯函数,便于单独验证)。
|
|
// 不能整份替换:备份字节、索引映射这些字段是页面与恢复都在用的。
|
|
func writeSetEvidence(existing map[string]any, set libraryrelease.WriteSet, mappingDigest string) map[string]any {
|
|
evidence := map[string]any{}
|
|
for key, value := range existing {
|
|
evidence[key] = value
|
|
}
|
|
evidence["backup_snapshot"] = set.BackupSnapshotID
|
|
evidence["job"] = set.JobID
|
|
if mappingDigest != "" {
|
|
evidence["index_mapping_sha256"] = mappingDigest
|
|
}
|
|
evidence["writeset_digest"] = set.Digest
|
|
evidence["writeset_universe_digest"] = set.UniverseDigest()
|
|
evidence["writeset_target_snapshot"] = set.TargetSnapshotID
|
|
evidence["writeset_rows"] = len(set.Rows)
|
|
return evidence
|
|
}
|
|
|
|
// WriteSetPlanned 把写集合摘要登记进"这次作业的预备份版本"证据。
|
|
// 它在第一笔写入之前被调用;失败即中止(调用方据此不写目标)。
|
|
func (r libraryStageRecorder) WriteSetPlanned(ctx context.Context, set libraryrelease.WriteSet) error {
|
|
versions, err := r.store.LibraryVersions(ctx, r.scope, 200)
|
|
if err != nil {
|
|
return fmt.Errorf("读不到现有版本证据:%w", err)
|
|
}
|
|
var existing map[string]any
|
|
for _, version := range versions {
|
|
if version.Kind == governance.LibraryVersionProductionPrebackup && version.SnapshotID == set.BackupSnapshotID {
|
|
existing = version.Evidence
|
|
break
|
|
}
|
|
}
|
|
evidence := writeSetEvidence(existing, set, r.mappingDigest)
|
|
return r.store.RecordLibraryVersion(ctx, governance.LibraryVersion{
|
|
ID: governance.LibraryVersionID(governance.LibraryVersionProductionPrebackup, r.scope, set.BackupSnapshotID),
|
|
Scope: r.scope, Kind: governance.LibraryVersionProductionPrebackup, SnapshotID: set.BackupSnapshotID,
|
|
SourceJobID: r.jobID, CreatedBy: "worker", Evidence: evidence, CreatedAt: time.Now().UTC(),
|
|
})
|
|
}
|
|
|
|
// ledgerBackupStore 是"接管/恢复"用的预备份来源:只认已经持久化的那一份,
|
|
// 并把它绑定的写集合一起带出来。
|
|
//
|
|
// 为什么不能像以前那样只返回 snapshot id:那一刻目标已经被写过,恢复若拿不到
|
|
// 写集合就只能按目标现状推断残渣——那正是会误删历史资源的路径。所以这里取不到
|
|
// 记录就直接失败,而不是返回一个"没有 Universe 的引用"。
|
|
type ledgerBackupStore struct {
|
|
ref libraryrelease.BackupRef
|
|
write *libraryrelease.WriteSet
|
|
}
|
|
|
|
func (s ledgerBackupStore) Prepare(context.Context, string, libraryrelease.CurrentState) (libraryrelease.BackupRef, error) {
|
|
if s.write == nil {
|
|
return libraryrelease.BackupRef{}, errors.New("恢复缺少持久化的写集合记录:拒绝在没有可追溯写集合的情况下继续")
|
|
}
|
|
ref := s.ref
|
|
ref.WriteSet = s.write
|
|
return ref, nil
|
|
}
|
|
|
|
// sortedWriteSetSummary 只用于日志/证据:把本次写集合按表汇总成稳定的短摘要。
|
|
func sortedWriteSetSummary(set libraryrelease.WriteSet) string {
|
|
counts := map[string]int{}
|
|
for _, row := range set.Rows {
|
|
counts[row.Table]++
|
|
}
|
|
tables := make([]string, 0, len(counts))
|
|
for table := range counts {
|
|
tables = append(tables, table)
|
|
}
|
|
sort.Strings(tables)
|
|
summary := ""
|
|
for _, table := range tables {
|
|
if summary != "" {
|
|
summary += ","
|
|
}
|
|
summary += fmt.Sprintf("%s=%d", table, counts[table])
|
|
}
|
|
return summary
|
|
}
|