Files
knowledge-governance/internal/releaseadapter/v071/document_target.go
T
zheromiku dcdc8d1ddd feat: 知识治理平台(含已验证发布/回滚契约)
全栈知识治理平台首次入库(P1-P10 + 发布链路模拟验证闭环):

- 治理核心:源目录/变更集/人工审核/发布批次/发布执行(fail-closed 闸口)
- 测试通道:WeKnora 测试 KB 上传/轮询/验收;poll 完成时写入
  parser_generation/index_generation,修复 manual/seed 路径发布闸口永久拦截
- 发布适配器 v071(本地 source=测试角色 / 云端 target=生产角色 模拟验证通过):
  * ES 导出/导入 mapping 自适应(.keyword 子字段、可选 tenant_id)
  * OSS locator 支持嵌套 scheme;chunks.seq_id 由目标序列分配
  * bundle 归档同身份重试原子替换;verifier 按 bundle chunk_type 计数
  * 回滚 job payload 支持 prior_execution_id(strict 解码)
- 三通道发布+回滚演练实测:publish 4/4 verified,检索命中,
  rollback 4/4 rolled_back,目标端 PG is_enabled=false、ES is_enabled=false
- 前端 A·Data-console 风格全站统一,120 用例通过
- 门禁:go vet / go test 全包通过,gofmt 干净
2026-09-30 10:54:06 +08:00

210 lines
8.3 KiB
Go

package v071
import (
"context"
"errors"
"knowledge-governance/internal/releasebundle"
releaseworkflow "knowledge-governance/internal/workflows/release"
)
type documentArchive interface {
Save(bundle *DocumentBundle) error
Load(releaseRevision string) (*DocumentBundle, error)
}
type targetContractInspector interface {
Contract(ctx context.Context, item releaseworkflow.PlanItem) (releasebundle.TargetContract, error)
}
type postgresDocumentTarget interface {
Replace(ctx context.Context, identity PostgresIdentity, snapshot PostgresSnapshot) error
Disable(ctx context.Context, identity PostgresIdentity) error
}
type searchDocumentTarget interface {
Replace(ctx context.Context, identity SearchIdentity, snapshot SearchSnapshot) (SearchSnapshot, error)
Disable(ctx context.Context, identity SearchIdentity) error
}
type objectDocumentTarget interface {
Stage(ctx context.Context, releaseRevision string, snapshot ObjectSnapshot) (ObjectStage, error)
Promote(ctx context.Context, stage ObjectStage) error
}
type ProductionVerifier interface {
Verify(ctx context.Context, item releaseworkflow.PlanItem, bundle *DocumentBundle) error
VerifyDisabled(ctx context.Context, item releaseworkflow.PlanItem) error
}
type DocumentTargetConfig struct {
Archive documentArchive
Contract targetContractInspector
Postgres postgresDocumentTarget
Search searchDocumentTarget
Objects objectDocumentTarget
Verifier ProductionVerifier
}
type DocumentTarget struct {
config DocumentTargetConfig
}
func NewDocumentTarget(config DocumentTargetConfig) (*DocumentTarget, error) {
if config.Archive == nil || config.Contract == nil || config.Postgres == nil || config.Search == nil || config.Objects == nil || config.Verifier == nil {
return nil, errors.New("v0.7.1 document target dependencies are required")
}
return &DocumentTarget{config: config}, nil
}
func (target *DocumentTarget) Contract(ctx context.Context, item releaseworkflow.PlanItem) (releasebundle.TargetContract, error) {
contract, err := target.config.Contract.Contract(ctx, item)
if err != nil {
return releasebundle.TargetContract{}, errors.New("inspect target release contract")
}
return contract, nil
}
func (target *DocumentTarget) Prepare(ctx context.Context, item releaseworkflow.PlanItem, exported releaseworkflow.ExportedBundle) (releaseworkflow.PreparedChange, error) {
bundle, ok := exported.(*DocumentBundle)
if !ok || validateDocumentBundle(bundle) != nil || bundle.Manifest.ReleaseRevision != item.ReleaseRevision {
return releaseworkflow.PreparedChange{}, errors.New("invalid v0.7.1 target bundle")
}
if err := target.config.Archive.Save(bundle); err != nil {
return releaseworkflow.PreparedChange{}, errors.New("archive v0.7.1 target bundle")
}
previousRevision := item.PreviousProductionRevision
if previousRevision == "" {
previousRevision = "absent"
} else if previousRevision != "absent" {
if _, err := target.config.Archive.Load(previousRevision); err != nil {
return releaseworkflow.PreparedChange{}, errors.New("prior release bundle is unavailable")
}
}
if _, err := target.config.Objects.Stage(ctx, bundle.Manifest.ReleaseRevision, bundle.Objects); err != nil {
return releaseworkflow.PreparedChange{}, errors.New("stage v0.7.1 release assets")
}
return releaseworkflow.PreparedChange{PreviousRevision: previousRevision, ProductionRevision: bundle.Manifest.ReleaseRevision}, nil
}
func (target *DocumentTarget) Activate(ctx context.Context, item releaseworkflow.PlanItem, change releaseworkflow.PreparedChange) error {
bundle, err := target.config.Archive.Load(change.ProductionRevision)
if err != nil || bundle.Manifest.ReleaseRevision != item.ReleaseRevision {
return errors.New("load staged v0.7.1 release bundle")
}
stage, err := target.config.Objects.Stage(ctx, bundle.Manifest.ReleaseRevision, bundle.Objects)
if err != nil {
return errors.New("restage v0.7.1 release assets")
}
if err := target.config.Objects.Promote(ctx, stage); err != nil {
return errors.New("promote v0.7.1 release assets")
}
postgresIdentity, searchIdentity := targetIdentities(bundle.Manifest)
if err := target.config.Postgres.Replace(ctx, postgresIdentity, bundle.Postgres); err != nil {
return errors.New("activate v0.7.1 PostgreSQL release")
}
if _, err := target.config.Search.Replace(ctx, searchIdentity, bundle.Search); err != nil {
return errors.New("activate v0.7.1 Elasticsearch release")
}
return nil
}
func (target *DocumentTarget) Verify(ctx context.Context, item releaseworkflow.PlanItem, change releaseworkflow.PreparedChange) error {
bundle, err := target.config.Archive.Load(change.ProductionRevision)
if err != nil {
return errors.New("load v0.7.1 release for verification")
}
if err := target.config.Verifier.Verify(ctx, item, bundle); err != nil {
return errors.New("verify v0.7.1 production release")
}
return nil
}
func (target *DocumentTarget) Compensate(ctx context.Context, item releaseworkflow.PlanItem, change releaseworkflow.PreparedChange) error {
if change.PreviousRevision == "" || change.PreviousRevision == "absent" {
manifestBundle, err := target.config.Archive.Load(change.ProductionRevision)
if err != nil {
return errors.New("load failed first release bundle")
}
postgresIdentity, searchIdentity := targetIdentities(manifestBundle.Manifest)
if err := target.config.Postgres.Disable(ctx, postgresIdentity); err != nil {
return errors.New("disable failed first PostgreSQL release")
}
if err := target.config.Search.Disable(ctx, searchIdentity); err != nil {
return errors.New("disable failed first Elasticsearch release")
}
if err := target.config.Verifier.VerifyDisabled(ctx, item); err != nil {
return errors.New("verify disabled first release")
}
return nil
}
return target.restoreBundle(ctx, change.PreviousRevision)
}
func (target *DocumentTarget) Restore(ctx context.Context, item releaseworkflow.PlanItem, revision string) (string, error) {
if revision == "absent" {
current, err := target.config.Archive.Load(item.ReleaseRevision)
if err != nil {
return "", errors.New("load current release for disable")
}
postgresIdentity, searchIdentity := targetIdentities(current.Manifest)
if err := target.config.Postgres.Disable(ctx, postgresIdentity); err != nil {
return "", errors.New("disable current PostgreSQL release")
}
if err := target.config.Search.Disable(ctx, searchIdentity); err != nil {
return "", errors.New("disable current Elasticsearch release")
}
return "absent", nil
}
if err := target.restoreBundle(ctx, revision); err != nil {
return "", err
}
return revision, nil
}
func (target *DocumentTarget) VerifyRestored(ctx context.Context, item releaseworkflow.PlanItem, revision string) error {
if revision == "absent" {
if err := target.config.Verifier.VerifyDisabled(ctx, item); err != nil {
return errors.New("verify disabled production release")
}
return nil
}
bundle, err := target.config.Archive.Load(revision)
if err != nil {
return errors.New("load restored v0.7.1 release")
}
if err := target.config.Verifier.Verify(ctx, item, bundle); err != nil {
return errors.New("verify restored v0.7.1 release")
}
return nil
}
func (target *DocumentTarget) restoreBundle(ctx context.Context, revision string) error {
bundle, err := target.config.Archive.Load(revision)
if err != nil {
return errors.New("load prior v0.7.1 release bundle")
}
stage, err := target.config.Objects.Stage(ctx, revision, bundle.Objects)
if err != nil {
return errors.New("stage prior v0.7.1 release assets")
}
if err := target.config.Objects.Promote(ctx, stage); err != nil {
return errors.New("promote prior v0.7.1 release assets")
}
postgresIdentity, searchIdentity := targetIdentities(bundle.Manifest)
if err := target.config.Postgres.Replace(ctx, postgresIdentity, bundle.Postgres); err != nil {
return errors.New("restore prior v0.7.1 PostgreSQL release")
}
if _, err := target.config.Search.Replace(ctx, searchIdentity, bundle.Search); err != nil {
return errors.New("restore prior v0.7.1 Elasticsearch release")
}
return nil
}
func targetIdentities(manifest releasebundle.Manifest) (PostgresIdentity, SearchIdentity) {
postgresIdentity := PostgresIdentity{TenantID: manifest.Contract.TenantID, KnowledgeBaseID: manifest.Contract.KnowledgeBaseID, KnowledgeID: manifest.Contract.KnowledgeID}
return postgresIdentity, SearchIdentity(postgresIdentity)
}
var _ releaseworkflow.SidecarTarget = (*DocumentTarget)(nil)