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 干净
244 lines
9.4 KiB
Go
244 lines
9.4 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
|
|
"knowledge-governance/internal/governance"
|
|
)
|
|
|
|
func (s *Store) RouteCatalogFiles(ctx context.Context, request governance.CatalogRouteRequest) (governance.CatalogRouteResult, error) {
|
|
if err := validateCatalogRouteRequest(request); err != nil {
|
|
return governance.CatalogRouteResult{}, err
|
|
}
|
|
beginner, ok := s.db.(interface {
|
|
Begin(context.Context) (pgx.Tx, error)
|
|
})
|
|
if !ok {
|
|
return governance.CatalogRouteResult{}, errors.New("catalog route transactions are unavailable")
|
|
}
|
|
tx, err := beginner.Begin(ctx)
|
|
if err != nil {
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("begin catalog route: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
result, err := routeCatalogFilesTx(ctx, tx, request)
|
|
if err != nil {
|
|
return governance.CatalogRouteResult{}, err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("commit catalog route: %w", err)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func validateCatalogRouteRequest(request governance.CatalogRouteRequest) error {
|
|
targetKnowledgeBaseIDs := request.TargetKnowledgeBaseIDs
|
|
if len(targetKnowledgeBaseIDs) == 0 && request.TargetKnowledgeBaseID != "" {
|
|
targetKnowledgeBaseIDs = []string{request.TargetKnowledgeBaseID}
|
|
}
|
|
if !validRouteID(request.ConnectionID) || len(request.NodeIDs) == 0 || len(request.NodeIDs) > 100 ||
|
|
!validCatalogPolicy(request.Visibility, targetKnowledgeBaseIDs) || strings.TrimSpace(request.OperatorRef) == "" || len(request.OperatorRef) > 128 ||
|
|
strings.TrimSpace(request.Reason) == "" || len(request.Reason) > 500 || request.Now.IsZero() {
|
|
return errors.New("invalid catalog route request")
|
|
}
|
|
seen := map[string]bool{}
|
|
for _, id := range request.NodeIDs {
|
|
if !validRouteID(id) || seen[id] {
|
|
return errors.New("invalid catalog route nodes")
|
|
}
|
|
seen[id] = true
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func routeCatalogFilesTx(ctx context.Context, tx pgx.Tx, request governance.CatalogRouteRequest) (governance.CatalogRouteResult, error) {
|
|
targetKnowledgeBaseIDs := request.TargetKnowledgeBaseIDs
|
|
if len(targetKnowledgeBaseIDs) == 0 && request.TargetKnowledgeBaseID != "" {
|
|
targetKnowledgeBaseIDs = []string{request.TargetKnowledgeBaseID}
|
|
}
|
|
nodeIDs := append([]string(nil), request.NodeIDs...)
|
|
selectedRows, err := tx.Query(ctx, `SELECT node.node_id,node.node_type,node.relative_path
|
|
FROM source_catalog_heads head
|
|
JOIN source_catalog_nodes node ON node.snapshot_id=head.snapshot_id
|
|
WHERE head.source_connection_id=$1 AND node.node_id=ANY($2::text[])
|
|
ORDER BY node.node_id
|
|
FOR UPDATE OF node`, request.ConnectionID, nodeIDs)
|
|
if err != nil {
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("select catalog route nodes: %w", err)
|
|
}
|
|
selectedCount := 0
|
|
directoryPaths := make([]string, 0)
|
|
for selectedRows.Next() {
|
|
var nodeID, nodeType, directoryPath string
|
|
if err := selectedRows.Scan(&nodeID, &nodeType, &directoryPath); err != nil {
|
|
selectedRows.Close()
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("scan catalog route node: %w", err)
|
|
}
|
|
selectedCount++
|
|
if nodeType == "folder" {
|
|
directoryPaths = append(directoryPaths, directoryPath)
|
|
}
|
|
}
|
|
if err := selectedRows.Err(); err != nil {
|
|
selectedRows.Close()
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("iterate catalog route nodes: %w", err)
|
|
}
|
|
selectedRows.Close()
|
|
if selectedCount != len(nodeIDs) {
|
|
return governance.CatalogRouteResult{}, errors.New("catalog route contains missing nodes")
|
|
}
|
|
for _, directoryPath := range directoryPaths {
|
|
if err := setCatalogDirectoryPolicy(ctx, tx, request, directoryPath); err != nil {
|
|
return governance.CatalogRouteResult{}, err
|
|
}
|
|
}
|
|
|
|
rows, err := tx.Query(ctx, `WITH RECURSIVE selected AS (
|
|
SELECT node.snapshot_id,node.node_id,node.node_type
|
|
FROM source_catalog_heads head
|
|
JOIN source_catalog_nodes node ON node.snapshot_id=head.snapshot_id
|
|
WHERE head.source_connection_id=$1 AND node.node_id=ANY($2::text[])
|
|
), descendants AS (
|
|
SELECT snapshot_id,node_id,node_type FROM selected
|
|
UNION
|
|
SELECT child.snapshot_id,child.node_id,child.node_type
|
|
FROM descendants parent
|
|
JOIN source_catalog_nodes child ON child.snapshot_id=parent.snapshot_id AND child.parent_node_id=parent.node_id
|
|
WHERE parent.node_type='folder'
|
|
)
|
|
SELECT DISTINCT node.node_id,node.source_item_id,(node.node_id=ANY($2::text[])) AS directly_selected
|
|
FROM descendants
|
|
JOIN source_catalog_nodes node ON node.snapshot_id=descendants.snapshot_id AND node.node_id=descendants.node_id
|
|
WHERE node.node_type='file'
|
|
ORDER BY node.node_id`, request.ConnectionID, nodeIDs)
|
|
if err != nil {
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("select catalog route files: %w", err)
|
|
}
|
|
type selectedFile struct {
|
|
nodeID string
|
|
sourceItemID *string
|
|
direct bool
|
|
}
|
|
files := make([]selectedFile, 0, len(nodeIDs))
|
|
for rows.Next() {
|
|
var file selectedFile
|
|
if err := rows.Scan(&file.nodeID, &file.sourceItemID, &file.direct); err != nil {
|
|
rows.Close()
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("scan catalog route file: %w", err)
|
|
}
|
|
files = append(files, file)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
rows.Close()
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("iterate catalog route files: %w", err)
|
|
}
|
|
rows.Close()
|
|
|
|
result := governance.CatalogRouteResult{SelectedFiles: len(files)}
|
|
routedItems := map[string]bool{}
|
|
for _, file := range files {
|
|
if file.sourceItemID == nil {
|
|
result.UnboundFiles++
|
|
continue
|
|
}
|
|
itemID := *file.sourceItemID
|
|
if routedItems[itemID] {
|
|
continue
|
|
}
|
|
routedItems[itemID] = true
|
|
if file.direct {
|
|
if _, err := tx.Exec(ctx, `INSERT INTO source_item_scope_overrides(source_item_id,visibility,updated_by,reason,created_at,updated_at)
|
|
VALUES($1,$2,$3,$4,$5,$5) ON CONFLICT(source_item_id) DO UPDATE SET visibility=EXCLUDED.visibility,updated_by=EXCLUDED.updated_by,reason=EXCLUDED.reason,updated_at=EXCLUDED.updated_at`, itemID, request.Visibility, request.OperatorRef, request.Reason, request.Now); err != nil {
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("set routed item scope: %w", err)
|
|
}
|
|
eventID, err := newOpaqueID("se-")
|
|
if err != nil {
|
|
return governance.CatalogRouteResult{}, err
|
|
}
|
|
if _, err := tx.Exec(ctx, `INSERT INTO scope_change_events(id,target_type,source_item_id,action,decided_visibility,operator_ref,reason,created_at)
|
|
VALUES($1,'item',$2,'set',$3,$4,$5,$6)`, eventID, itemID, request.Visibility, request.OperatorRef, request.Reason, request.Now); err != nil {
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("audit routed item scope: %w", err)
|
|
}
|
|
}
|
|
// S7: classify only. Annotations never create publications, retire targets, or enqueue jobs.
|
|
var currentVersionID *string
|
|
var contentState, spoolRef string
|
|
err = tx.QueryRow(ctx, `SELECT version.id,content.content_state,COALESCE(content.local_spool_ref,'') FROM source_items item
|
|
LEFT JOIN source_item_versions version ON version.source_item_id=item.id AND version.revision=item.revision
|
|
LEFT JOIN content_objects content ON content.id=version.content_object_id
|
|
WHERE item.id=$1`, itemID).Scan(¤tVersionID, &contentState, &spoolRef)
|
|
switch {
|
|
case errors.Is(err, pgx.ErrNoRows):
|
|
result.UnavailableFiles++
|
|
case err != nil:
|
|
return governance.CatalogRouteResult{}, fmt.Errorf("inspect routed artifact: %w", err)
|
|
case contentState == string(governance.ContentVerified) && spoolRef != "":
|
|
result.RoutableFiles++
|
|
default:
|
|
result.HashUnknownFiles++
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func setCatalogDirectoryPolicy(ctx context.Context, tx pgx.Tx, request governance.CatalogRouteRequest, directoryPath string) error {
|
|
if _, err := tx.Exec(ctx, `INSERT INTO directory_scope_rules(source_connection_id,directory_path,visibility,updated_by,reason,created_at,updated_at)
|
|
VALUES($1,$2,$3,$4,$5,$6,$6)
|
|
ON CONFLICT(source_connection_id,directory_path) DO UPDATE SET visibility=EXCLUDED.visibility,updated_by=EXCLUDED.updated_by,reason=EXCLUDED.reason,updated_at=EXCLUDED.updated_at`,
|
|
request.ConnectionID, directoryPath, request.Visibility, request.OperatorRef, request.Reason, request.Now); err != nil {
|
|
return fmt.Errorf("set routed directory scope: %w", err)
|
|
}
|
|
eventID, err := newOpaqueID("se-")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(ctx, `INSERT INTO scope_change_events(id,target_type,source_connection_id,directory_path,action,decided_visibility,operator_ref,reason,created_at)
|
|
VALUES($1,'directory',$2,$3,'set',$4,$5,$6,$7)`, eventID, request.ConnectionID, directoryPath, request.Visibility, request.OperatorRef, request.Reason, request.Now); err != nil {
|
|
return fmt.Errorf("audit routed directory scope: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validCatalogPolicy(policy governance.Visibility, targetKnowledgeBaseIDs []string) bool {
|
|
expectedTargets := 1
|
|
switch policy {
|
|
case governance.VisibilityInternal, governance.VisibilityExternal:
|
|
case governance.VisibilityBoth:
|
|
expectedTargets = 2
|
|
case governance.VisibilityBlocked:
|
|
expectedTargets = 0
|
|
default:
|
|
return false
|
|
}
|
|
if len(targetKnowledgeBaseIDs) != expectedTargets {
|
|
return false
|
|
}
|
|
seen := make(map[string]bool, len(targetKnowledgeBaseIDs))
|
|
for _, target := range targetKnowledgeBaseIDs {
|
|
if !validRouteID(target) || seen[target] {
|
|
return false
|
|
}
|
|
seen[target] = true
|
|
}
|
|
return true
|
|
}
|
|
|
|
func validRouteID(value string) bool {
|
|
if value == "" || len(value) > 128 {
|
|
return false
|
|
}
|
|
for _, character := range value {
|
|
if unicode.IsLetter(character) || unicode.IsDigit(character) || character == '-' || character == '_' {
|
|
continue
|
|
}
|
|
return false
|
|
}
|
|
return true
|
|
}
|