// Command release-channel-e2e drives the real v0.7.1 release channel end to end // against the endpoints in a release config file, so the retrieval lanes and the // knowledge base wiki snapshot can be exercised together: // // publish : Prepare → Activate → Verify (document + KB wiki into production) // withdraw : Prepare → Restore("absent") → VerifyRestored("absent") // (document disabled in retrieval AND its wiki contribution retracted) // rollback : Restore(revision) → VerifyRestored(revision) // // It reuses the same production code path as the release worker // (DocumentExporter → DocumentTarget → WeKnoraVerifier); only the orchestration // (platform queue rows) is skipped. Credentials are read from files and never // printed. package main import ( "context" "encoding/json" "errors" "flag" "fmt" "net/url" "os" "path/filepath" "strings" "time" "github.com/jackc/pgx/v5/pgxpool" "knowledge-governance/internal/governance" "knowledge-governance/internal/platform/weknora" v071 "knowledge-governance/internal/releaseadapter/v071" releaseworkflow "knowledge-governance/internal/workflows/release" ) 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"` TokenFile string `json:"token_file"` } `json:"elasticsearch"` Object objectCfg `json:"object"` WeKnora struct { BaseURL string `json:"base_url"` APIKeyFile string `json:"api_key_file"` } `json:"weknora"` } type config struct { ArchiveRoot string `json:"archive_root"` 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 { if path == "" { return "" } 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 release") mode := flag.String("mode", "publish", "publish | withdraw | rollback") revision := flag.String("revision", "wiki-e2e-v1", "release revision") previous := flag.String("previous", "", "previous production revision (rollback target)") archiveRoot := flag.String("archive", "", "override archive root") flag.Parse() if *configPath == "" || *knowledgeID == "" { fmt.Println("FATAL -config and -knowledge are required") os.Exit(2) } raw, err := os.ReadFile(*configPath) if err != nil { fmt.Println("FATAL read config:", err) os.Exit(1) } var cfg config if err := json.Unmarshal(raw, &cfg); err != nil || len(cfg.Routes) != 1 { fmt.Println("FATAL parse config:", err) os.Exit(1) } route := cfg.Routes[0] if *archiveRoot != "" { cfg.ArchiveRoot = *archiveRoot } fmt.Printf("route kb=%s tenant=%d mode=%s revision=%s previous=%q\n", route.KnowledgeBaseID, route.TenantID, *mode, *revision, *previous) ctx, cancel := context.WithTimeout(context.Background(), 300*time.Second) defer cancel() sourcePool, err := openPool(ctx, secret(route.Source.DatabaseURLFile)) if err != nil { fmt.Println("STEP source PG connect: FAIL", err) return } defer sourcePool.Close() targetPool, err := openPool(ctx, secret(route.Target.DatabaseURLFile)) if err != nil { fmt.Println("STEP target PG connect: FAIL", err) return } defer targetPool.Close() fmt.Println("STEP both PG connect: ok") sourceSearch, err := v071.NewSearchExporter(v071.SearchExporterConfig{BaseURL: route.Source.Elasticsearch.BaseURL, Index: route.Source.Elasticsearch.Index, AuthorizationToken: secret(route.Source.Elasticsearch.TokenFile), PageSize: 500}) if err != nil { fmt.Println("STEP source ES: FAIL", err) return } targetSearchConfig := v071.SearchExporterConfig{BaseURL: route.Target.Elasticsearch.BaseURL, Index: route.Target.Elasticsearch.Index, AuthorizationToken: secret(route.Target.Elasticsearch.TokenFile), PageSize: 500} targetSearchInspector, err := v071.NewSearchExporter(targetSearchConfig) if err != nil { fmt.Println("STEP target ES inspector: FAIL", err) return } targetSearch, err := v071.NewSearchImporter(targetSearchConfig) if err != nil { fmt.Println("STEP target ES importer: FAIL", err) return } sourceStore, err := newStore(route.Source.Object) if err != nil { fmt.Println("STEP source object store: FAIL", err) return } targetStore, err := newStore(route.Target.Object) if err != nil { fmt.Println("STEP target object store: FAIL", err) return } objectExporter, _ := v071.NewObjectExporter(sourceStore, v071.ObjectExporterLimits{}) objectImporter, _ := v071.NewObjectImporter(targetStore, v071.TargetObjectConfig{StorageBackendID: route.Target.Object.StorageBackendID, Provider: route.Target.Object.Provider}) postgresExporter, _ := v071.NewPostgresExporter(sourcePool) postgresImporter, 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("STEP target PG importer: FAIL", err) return } sourceContract, err := v071.NewTargetContractInspector(v071.TargetContractInspectorConfig{DB: sourcePool, Mapping: sourceSearch, KnowledgeBaseID: route.KnowledgeBaseID, TenantID: route.TenantID, IndexName: route.Source.Elasticsearch.Index, ReadTestedBase: true}) if err != nil { fmt.Println("STEP source contract: FAIL", err) return } targetContract, err := v071.NewTargetContractInspector(v071.TargetContractInspectorConfig{DB: targetPool, Mapping: targetSearchInspector, KnowledgeBaseID: route.KnowledgeBaseID, TenantID: route.TenantID, IndexName: route.Target.Elasticsearch.Index}) if err != nil { fmt.Println("STEP target contract: FAIL", err) return } documentExporter, err := v071.NewDocumentExporter(v071.DocumentExporterConfig{Contract: sourceContract, Postgres: postgresExporter, Search: sourceSearch, Objects: objectExporter, TenantID: route.TenantID, EmbeddingModel: route.EmbeddingModel, Now: time.Now}) if err != nil { fmt.Println("STEP document exporter: FAIL", err) return } archive, err := v071.NewBundleArchive(filepath.Join(cfg.ArchiveRoot, route.KnowledgeBaseID), 1024*1024*1024) if err != nil { fmt.Println("STEP archive: FAIL", err) return } weknoraClient, err := weknora.NewClient(weknora.ClientConfig{BaseURL: route.Target.WeKnora.BaseURL, APIKey: secret(route.Target.WeKnora.APIKeyFile), Timeout: 60 * time.Second, AllowDockerHTTP: true}) if err != nil { fmt.Println("STEP target WeKnora client: FAIL", err) return } verifier, _ := v071.NewWeKnoraVerifier(weknoraClient) target, err := v071.NewDocumentTarget(v071.DocumentTargetConfig{Archive: archive, Contract: targetContract, Postgres: postgresImporter, Search: targetSearch, Objects: objectImporter, Verifier: verifier}) if err != nil { fmt.Println("STEP document target: FAIL", err) return } action := "upsert" if *mode == "withdraw" { action = "delete" } item := releaseworkflow.PlanItem{ ReleaseExecutionID: "rx-wiki-e2e", PublicationID: "tp-wiki-e2e", Action: action, SourceItemVersionID: "sv-wiki-e2e", SourceRevision: "source-wiki-e2e", ParseRevision: "parser-wiki-e2e@index-wiki-e2e", ReleaseRevision: *revision, TestKnowledgeBaseID: route.KnowledgeBaseID, KnowledgeID: *knowledgeID, DecidedVisibility: governance.VisibilityInternal, PreviousProductionRevision: *previous, } printWiki("target wiki before", ctx, weknoraClient, route.KnowledgeBaseID) switch *mode { case "publish": change, err := target.Prepare(ctx, item, mustExport(ctx, documentExporter, item)) if err != nil { fmt.Println("STEP prepare: FAIL", err) return } fmt.Printf("STEP prepare: ok previous=%s production=%s\n", change.PreviousRevision, change.ProductionRevision) bundle, err := archive.Load(change.ProductionRevision) if err != nil { fmt.Println("STEP bundle reload: FAIL", err) return } printBundle(bundle) if err := target.Activate(ctx, item, change); err != nil { fmt.Println("STEP activate: FAIL", err) return } fmt.Println("STEP activate: ok") if err := target.Verify(ctx, item, change); err != nil { fmt.Println("STEP verify: FAIL", err) return } fmt.Println("STEP verify: ok (document + wiki)") case "withdraw": change, err := target.Prepare(ctx, item, mustExport(ctx, documentExporter, item)) if err != nil { fmt.Println("STEP prepare: FAIL", err) return } bundle, err := archive.Load(change.ProductionRevision) if err != nil { fmt.Println("STEP bundle reload: FAIL", err) return } printBundle(bundle) revision, err := target.Restore(ctx, item, "absent") if err != nil { fmt.Println("STEP restore absent: FAIL", err) return } fmt.Println("STEP restore absent: ok revision=", revision) if err := target.VerifyRestored(ctx, item, "absent"); err != nil { fmt.Println("STEP verify withdrawn: FAIL", err) return } fmt.Println("STEP verify withdrawn: ok (retrieval disabled + wiki retracted)") case "rollback": if *previous == "" { fmt.Println("FATAL rollback mode needs -previous") os.Exit(2) } revision, err := target.Restore(ctx, item, *previous) if err != nil { fmt.Println("STEP restore: FAIL", err) return } fmt.Println("STEP restore: ok revision=", revision) if err := target.VerifyRestored(ctx, item, *previous); err != nil { fmt.Println("STEP verify restored: FAIL", err) return } fmt.Println("STEP verify restored: ok") default: fmt.Println("FATAL unknown mode:", *mode) os.Exit(2) } printWiki("target wiki after", ctx, weknoraClient, route.KnowledgeBaseID) } func mustExport(ctx context.Context, exporter *v071.DocumentExporter, item releaseworkflow.PlanItem) releaseworkflow.ExportedBundle { value, err := exporter.Export(ctx, item) if err != nil { fmt.Println("STEP export: FAIL", err) os.Exit(1) } return value } func printBundle(bundle *v071.DocumentBundle) { parts := make([]string, 0, len(bundle.Postgres.Tables)) for _, table := range bundle.Postgres.Tables { parts = append(parts, fmt.Sprintf("%s=%d", table.Name, table.RowCount)) } fmt.Println("bundle tables:", strings.Join(parts, " ")) fmt.Printf("bundle search=%d objects=%d\n", bundle.Manifest.Search.DocumentCount, bundle.Manifest.Assets.ObjectCount) } func printWiki(label string, ctx context.Context, client *weknora.Client, knowledgeBaseID string) { pages, total, err := client.ListWikiPages(ctx, knowledgeBaseID, 1, 20) if err != nil { fmt.Printf("%s: FAIL %v\n", label, err) return } slugs := make([]string, 0, len(pages)) for _, page := range pages { slugs = append(slugs, page.Slug) } fmt.Printf("%s: total=%d first=%s\n", label, total, strings.Join(slugs, ",")) } func newStore(object objectCfg) (*v071.S3ObjectStore, error) { parsed, err := url.Parse(object.Endpoint) if err != nil { return nil, err } accessKey, secretKey := secret(object.AccessKeyFile), secret(object.SecretKeyFile) if accessKey == "" || secretKey == "" { return nil, errors.New("object credentials are required") } return v071.NewS3ObjectStore(v071.S3ObjectStoreConfig{Provider: object.Provider, Endpoint: object.Endpoint, Region: object.Region, AccessKeyID: accessKey, SecretAccessKey: secretKey, Bucket: object.Bucket, Secure: parsed.Scheme == "https"}) } func openPool(ctx context.Context, databaseURL string) (*pgxpool.Pool, error) { pool, err := pgxpool.New(ctx, databaseURL) if err != nil { return nil, err } if err := pool.Ping(ctx); err != nil { pool.Close() return nil, err } return pool, nil }