dcdc8d1ddd
全栈知识治理平台首次入库(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 干净
131 lines
4.9 KiB
Go
131 lines
4.9 KiB
Go
package v071
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
type ObjectStore interface {
|
|
Put(ctx context.Context, provider, path string, reader io.Reader, size int64) error
|
|
Stat(ctx context.Context, provider, path string) (size int64, sha256 string, err error)
|
|
Copy(ctx context.Context, provider, sourcePath, targetPath string) error
|
|
}
|
|
|
|
type TargetObjectConfig struct {
|
|
StorageBackendID string
|
|
Provider string
|
|
}
|
|
|
|
type StagedObject struct {
|
|
Handle string
|
|
StagingPath string
|
|
FinalPath string
|
|
Size int64
|
|
SHA256 string
|
|
}
|
|
|
|
type ObjectStage struct {
|
|
ReleaseRevision string
|
|
Provider string
|
|
Objects []StagedObject
|
|
}
|
|
|
|
type ObjectImporter struct {
|
|
store ObjectStore
|
|
config TargetObjectConfig
|
|
}
|
|
|
|
func NewObjectImporter(store ObjectStore, config TargetObjectConfig) (*ObjectImporter, error) {
|
|
config.StorageBackendID = strings.TrimSpace(config.StorageBackendID)
|
|
config.Provider = strings.TrimSpace(config.Provider)
|
|
if store == nil || !validSearchIdentifier(config.StorageBackendID) || !validObjectProvider(config.Provider) {
|
|
return nil, errors.New("invalid target object importer configuration")
|
|
}
|
|
return &ObjectImporter{store: store, config: config}, nil
|
|
}
|
|
|
|
func (importer *ObjectImporter) Stage(ctx context.Context, releaseRevision string, snapshot ObjectSnapshot) (ObjectStage, error) {
|
|
if !validSearchIdentifier(releaseRevision) || !validLowerSHA256(snapshot.SHA256) || snapshot.SHA256 != objectSnapshotDigest(snapshot.Objects) {
|
|
return ObjectStage{}, errors.New("invalid object import snapshot")
|
|
}
|
|
var total int64
|
|
stage := ObjectStage{ReleaseRevision: releaseRevision, Provider: importer.config.Provider, Objects: make([]StagedObject, 0, len(snapshot.Objects))}
|
|
for _, object := range snapshot.Objects {
|
|
if !validSearchIdentifier(object.ResourceID) || len(object.Handle) != 22 || object.Size != int64(len(object.Data)) || object.SHA256 != shaBytes(object.Data) || !validObjectKey(object.PhysicalPath) {
|
|
return ObjectStage{}, errors.New("invalid object import entry")
|
|
}
|
|
providerPath, ok := providerPathFromLocator(object.PhysicalPath)
|
|
if !ok {
|
|
return ObjectStage{}, errors.New("invalid object import locator")
|
|
}
|
|
total += object.Size
|
|
stagingPath := ".governance-release-stage/" + releaseRevision + "/" + providerPath
|
|
if !validObjectLocator(stagingPath) {
|
|
return ObjectStage{}, errors.New("invalid object staging locator")
|
|
}
|
|
if err := importer.store.Put(ctx, importer.config.Provider, stagingPath, bytes.NewReader(object.Data), object.Size); err != nil {
|
|
return ObjectStage{}, errors.New("write staged release object")
|
|
}
|
|
size, digest, err := importer.store.Stat(ctx, importer.config.Provider, stagingPath)
|
|
if err != nil || size != object.Size || digest != object.SHA256 {
|
|
return ObjectStage{}, errors.New("verify staged release object")
|
|
}
|
|
stage.Objects = append(stage.Objects, StagedObject{Handle: object.Handle, StagingPath: stagingPath, FinalPath: providerPath, Size: object.Size, SHA256: object.SHA256})
|
|
}
|
|
if total != snapshot.TotalBytes {
|
|
return ObjectStage{}, errors.New("object import total mismatch")
|
|
}
|
|
return stage, nil
|
|
}
|
|
|
|
func (importer *ObjectImporter) Promote(ctx context.Context, stage ObjectStage) error {
|
|
if stage.Provider != importer.config.Provider || !validSearchIdentifier(stage.ReleaseRevision) {
|
|
return errors.New("invalid object promotion stage")
|
|
}
|
|
for _, object := range stage.Objects {
|
|
if !validObjectLocator(object.StagingPath) || !validObjectLocator(object.FinalPath) || !validLowerSHA256(object.SHA256) || object.Size < 0 {
|
|
return errors.New("invalid object promotion entry")
|
|
}
|
|
if err := importer.store.Copy(ctx, importer.config.Provider, object.StagingPath, object.FinalPath); err != nil {
|
|
return errors.New("promote release object")
|
|
}
|
|
size, digest, err := importer.store.Stat(ctx, importer.config.Provider, object.FinalPath)
|
|
if err != nil || size != object.Size || digest != object.SHA256 {
|
|
return errors.New("verify promoted release object")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func providerPathFromLocator(locator string) (string, bool) {
|
|
rest := locator
|
|
if strings.HasPrefix(locator, "storage://") {
|
|
rest = strings.TrimPrefix(locator, "storage://")
|
|
parts := strings.SplitN(rest, "/", 2)
|
|
if len(parts) != 2 || !validSearchIdentifier(parts[0]) || !validObjectLocator(parts[1]) {
|
|
return "", false
|
|
}
|
|
rest = parts[1]
|
|
} else if !validObjectLocator(locator) {
|
|
return "", false
|
|
}
|
|
// WeKnora nests the provider locator inside the storage locator:
|
|
// "storage://<backend-id>/oss://<bucket>/<key>". S3 keys address the
|
|
// bucket configured for the store, so strip the inner scheme and bucket.
|
|
if separator := strings.Index(rest, "://"); separator >= 0 {
|
|
if !validSearchIdentifier(rest[:separator]) {
|
|
return "", false
|
|
}
|
|
schemeless := rest[separator+3:]
|
|
boundary := strings.Index(schemeless, "/")
|
|
if boundary < 0 || boundary == len(schemeless)-1 {
|
|
return "", false
|
|
}
|
|
rest = schemeless[boundary+1:]
|
|
}
|
|
return rest, validObjectLocator(rest)
|
|
}
|