// Command release-diag replays the read-only steps of the release export path // (source PG snapshot, source ES snapshot, source object read) and additionally // lists candidate OSS key prefixes, to pinpoint a failing export step with its // real underlying error. Credentials are read from files only and never printed. package main import ( "bytes" "context" "encoding/json" "flag" "fmt" "io" "net/url" "os" "time" "unicode/utf8" "github.com/aws/aws-sdk-go-v2/aws" awsconfig "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/jackc/pgx/v5/pgxpool" "knowledge-governance/internal/platform/weknora" "knowledge-governance/internal/releaseadapter/v071" ) type objectCfg struct { Provider string `json:"provider"` StorageBackendID string `json:"storage_backend_id"` Endpoint string `json:"endpoint"` Region string `json:"region"` Bucket string `json:"bucket"` AccessKeyFile string `json:"access_key_file"` SecretKeyFile string `json:"secret_key_file"` } type endpointCfg struct { DatabaseURLFile string `json:"database_url_file"` Elasticsearch struct { BaseURL string `json:"base_url"` Index string `json:"index"` } `json:"elasticsearch"` Object objectCfg `json:"object"` WeKnora struct { BaseURL string `json:"base_url"` APIKeyFile string `json:"api_key_file"` } `json:"weknora"` } type config struct { Routes []struct { TenantID uint64 `json:"tenant_id"` KnowledgeBaseID string `json:"knowledge_base_id"` EmbeddingModel string `json:"embedding_model"` Source endpointCfg `json:"source"` Target endpointCfg `json:"target"` } `json:"routes"` } func secret(path string) string { data, err := os.ReadFile(path) if err != nil { fmt.Println("FATAL read secret:", err) os.Exit(1) } return string(data) } func main() { configPath := flag.String("config", "", "release config json") knowledgeID := flag.String("knowledge", "", "knowledge id to diagnose") flag.Parse() raw, err := os.ReadFile(*configPath) if err != nil { panic(err) } var cfg config if err := json.Unmarshal(raw, &cfg); err != nil || len(cfg.Routes) != 1 { panic(err) } route := cfg.Routes[0] fmt.Println("route:", route.KnowledgeBaseID, "tenant:", route.TenantID) ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) defer cancel() pool, err := pgxpool.New(ctx, secret(route.Source.DatabaseURLFile)) if err != nil { panic(err) } defer pool.Close() if err := pool.Ping(ctx); err != nil { fmt.Println("STEP source PG connect: FAIL", err) return } fmt.Println("STEP source PG connect: ok") postgres, err := v071.NewPostgresExporter(pool) if err != nil { panic(err) } snapshot, err := postgres.Export(ctx, v071.PostgresIdentity{TenantID: route.TenantID, KnowledgeBaseID: route.KnowledgeBaseID, KnowledgeID: *knowledgeID}) if err != nil { fmt.Println("STEP postgres export: FAIL", err) return } names := make([]string, 0, len(snapshot.Tables)) for _, table := range snapshot.Tables { names = append(names, fmt.Sprintf("%s:%d", table.Name, table.RowCount)) } fmt.Println("STEP postgres export: ok tables", names) search, err := v071.NewSearchExporter(v071.SearchExporterConfig{BaseURL: route.Source.Elasticsearch.BaseURL, Index: route.Source.Elasticsearch.Index, PageSize: 500}) if err != nil { panic(err) } searchSnapshot, err := search.Export(ctx, v071.SearchIdentity{TenantID: route.TenantID, KnowledgeBaseID: route.KnowledgeBaseID, KnowledgeID: *knowledgeID}) if err != nil { fmt.Println("STEP elasticsearch export: FAIL", err) return } fmt.Printf("STEP elasticsearch export: ok documents=%d\n", len(searchSnapshot.Documents)) store, err := newStore(ctx, route.Source.Object) if err != nil { fmt.Println("STEP object store build: FAIL", err) return } exporter, err := v071.NewObjectExporter(store, v071.ObjectExporterLimits{}) if err != nil { panic(err) } objectSnapshot, err := exporter.Export(ctx, snapshot) if err != nil { fmt.Println("STEP object export: FAIL", err) } else { fmt.Printf("STEP object export: ok objects=%d bytes=%d\n", len(objectSnapshot.Objects), objectSnapshot.TotalBytes) } client, err := newRawClient(ctx, route.Source.Object) if err != nil { panic(err) } for _, prefix := range []string{"weknora/", "oss://", ""} { listed, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(route.Source.Object.Bucket), Prefix: aws.String(prefix), MaxKeys: aws.Int32(3)}) if err != nil { fmt.Printf("STEP list prefix %q: FAIL %v\n", prefix, err) continue } fmt.Printf("STEP list prefix %q: %d objects\n", prefix, len(listed.Contents)) for _, object := range listed.Contents { fmt.Println(" ", aws.ToString(object.Key)) } } knowledge := snapshot.Table("knowledges") for _, row := range knowledge.Rows { var typed struct { Source string `json:"source"` } _ = json.Unmarshal(row, &typed) fmt.Println("knowledge.source:", typed.Source) } for _, raw := range snapshot.Table("resources").Rows { var typed struct { PhysicalPath string `json:"physical_path"` } _ = json.Unmarshal(raw, &typed) fmt.Println("resource physical_path:", typed.PhysicalPath) } fmt.Println("STEP target object stage probe:") targetStore, err := newStore(ctx, route.Target.Object) if err != nil { fmt.Println(" target store build FAIL", err) return } probePath := ".governance-release-diag/probe.txt" payload := []byte("release-sim-probe") if err := targetStore.Put(ctx, route.Target.Object.Provider, probePath, bytes.NewReader(payload), int64(len(payload))); err != nil { fmt.Println(" target Put FAIL:", err) } else { size, digest, err := targetStore.Stat(ctx, route.Target.Object.Provider, probePath) fmt.Println(" target Put ok; Stat:", size, digest[:8], "err:", err) } fmt.Println("STEP real ObjectImporter Stage/Promote with exported snapshot:") importer, err := v071.NewObjectImporter(targetStore, v071.TargetObjectConfig{StorageBackendID: route.Target.Object.StorageBackendID, Provider: route.Target.Object.Provider}) if err != nil { fmt.Println(" importer build FAIL", err) return } stage, err := importer.Stage(ctx, "diag-stage", objectSnapshot) if err != nil { fmt.Println(" Stage FAIL:", err) return } fmt.Println(" Stage ok objects:", len(stage.Objects)) if err := importer.Promote(ctx, stage); err != nil { fmt.Println(" Promote FAIL:", err) return } fmt.Println(" Promote ok") fmt.Println("STEP target Postgres replace:") targetPool, err := pgxpool.New(ctx, secret(route.Target.DatabaseURLFile)) if err != nil { fmt.Println(" target pool FAIL", err) return } defer targetPool.Close() if err := targetPool.Ping(ctx); err != nil { fmt.Println(" target PG connect FAIL", err) return } pgImporter, err := v071.NewPostgresImporter(targetPool, v071.PostgresImporterConfig{TargetStorageBackendID: route.Target.Object.StorageBackendID, TargetProvider: route.Target.Object.Provider, TargetBucket: route.Target.Object.Bucket}) if err != nil { fmt.Println(" importer config FAIL", err) return } identity := v071.PostgresIdentity{TenantID: route.TenantID, KnowledgeBaseID: route.KnowledgeBaseID, KnowledgeID: *knowledgeID} if err := pgImporter.Replace(ctx, identity, snapshot); err != nil { fmt.Println(" Replace FAIL:", err) return } fmt.Println(" Replace ok") fmt.Println("STEP target ES replace:") targetSearch, err := v071.NewSearchImporter(v071.SearchExporterConfig{BaseURL: route.Target.Elasticsearch.BaseURL, Index: route.Target.Elasticsearch.Index, PageSize: 500}) if err != nil { fmt.Println(" importer build FAIL", err) return } if _, err := targetSearch.Replace(ctx, v071.SearchIdentity{TenantID: route.TenantID, KnowledgeBaseID: route.KnowledgeBaseID, KnowledgeID: *knowledgeID}, searchSnapshot); err != nil { fmt.Println(" ES Replace FAIL:", err) return } fmt.Println(" ES Replace ok") fmt.Println("STEP target WeKnora verification replay:") wknoraClient, err := weknora.NewClient(weknora.ClientConfig{BaseURL: route.Target.WeKnora.BaseURL, APIKey: secret(route.Target.WeKnora.APIKeyFile), Timeout: 30 * time.Second, AllowDockerHTTP: true}) if err != nil { fmt.Println(" client build FAIL", err) return } knowledgeRemote, err := wknoraClient.GetKnowledge(ctx, *knowledgeID) fmt.Println(" GetKnowledge err:", err, "id:", knowledgeRemote.ID, "kb:", knowledgeRemote.KnowledgeBaseID, "parse:", knowledgeRemote.ParseStatus) chunksRemote, total, err := wknoraClient.ListChunks(ctx, *knowledgeID, 1, 5, nil) fmt.Println(" ListChunks err:", err, "total:", total, "page:", len(chunksRemote)) probe := "" for _, document := range searchSnapshot.Documents { var fields struct { Content string `json:"content"` } _ = json.Unmarshal(document.Source, &fields) if utf8.RuneCountInString(fields.Content) >= 12 { probe = string([]rune(fields.Content)[:min(48, utf8.RuneCountInString(fields.Content))]) break } } results, err := wknoraClient.SearchKnowledge(ctx, weknora.SearchRequest{Query: probe, KnowledgeIDs: []string{*knowledgeID}}) fmt.Println(" SearchKnowledge err:", err, "probe_len:", len(probe), "results:", len(results)) for index, result := range results { if index >= 3 { break } fmt.Printf(" hit knowledge=%s score=%.3f type=%s\n", result.KnowledgeID, result.Score, result.ChunkType) } if len(results) == 0 && probe != "" { results, err = wknoraClient.SearchKnowledge(ctx, weknora.SearchRequest{Query: "CRA 620mm", KnowledgeIDs: []string{*knowledgeID}}) fmt.Println(" short-probe SearchKnowledge err:", err, "results:", len(results)) } } func min(a, b int) int { if a < b { return a } return b } func newStore(ctx context.Context, object objectCfg) (*v071.S3ObjectStore, error) { parsed, err := url.Parse(object.Endpoint) if err != nil { return nil, err } return v071.NewS3ObjectStore(v071.S3ObjectStoreConfig{ Provider: object.Provider, Endpoint: object.Endpoint, Region: object.Region, AccessKeyID: secret(object.AccessKeyFile), SecretAccessKey: secret(object.SecretKeyFile), Bucket: object.Bucket, Secure: parsed.Scheme == "https", }) } func newRawClient(ctx context.Context, object objectCfg) (*s3.Client, error) { parsed, err := url.Parse(object.Endpoint) if err != nil { return nil, err } awsCfg, err := awsconfig.LoadDefaultConfig(ctx, awsconfig.WithRegion(object.Region), awsconfig.WithCredentialsProvider( credentials.NewStaticCredentialsProvider(secret(object.AccessKeyFile), secret(object.SecretKeyFile), ""))) if err != nil { return nil, err } return s3.NewFromConfig(awsCfg, func(options *s3.Options) { options.BaseEndpoint = aws.String(object.Endpoint) options.UsePathStyle = false _ = parsed }), nil } var _ = io.Discard