From ab6e610fb76e1e2b6857e454e8acf0c56001df1d Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Wed, 18 Nov 2026 01:00:16 +0000 Subject: [PATCH] Verify configured secrets startup handoff --- docs/roadmap/implementation.md | 2 + examples/consumers/secrets.go | 18 ++ examples/consumers/secrets_test.go | 41 +++++ facade_secrets_handoff_test.go | 180 ++++++++++++++++++++ internal/engine/secrets_from_config_test.go | 49 ++++++ 5 files changed, 290 insertions(+) create mode 100644 examples/consumers/secrets.go create mode 100644 examples/consumers/secrets_test.go create mode 100644 facade_secrets_handoff_test.go diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index 6c108ab..4bb1338 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -336,6 +336,8 @@ through ConfigKit's public package with the documented ownership and errors. ## Stage 8 — Verify the complete startup handoff +**Completed.** + Extend public integration coverage and add one maintained consumer startup example with ordinary and layered use explained from the same helper. diff --git a/examples/consumers/secrets.go b/examples/consumers/secrets.go new file mode 100644 index 0000000..5747bbf --- /dev/null +++ b/examples/consumers/secrets.go @@ -0,0 +1,18 @@ +package consumers + +import configkit "go.maximumdirect.net/configkit" + +// StartupConfig demonstrates an environment-backed credential and ordinary data. +type StartupConfig struct { + Name string `yaml:"name"` + Token configkit.Secret `yaml:"token"` +} + +// PrepareStartup performs the explicit bootstrap once and returns a captured +// main that can be passed to either Load or LoadLayered as its main source. +// The caller should handle a non-nil report even if preparation fails. +func PrepareStartup(main configkit.Source, root string) (*configkit.SecretsReport, configkit.Source, error) { + return configkit.LoadSecretsIntoEnvironmentFromConfig(main, configkit.SecretsFromConfigOptions{ + Filesystem: &configkit.FilesystemContext{Root: root}, + }) +} diff --git a/examples/consumers/secrets_test.go b/examples/consumers/secrets_test.go new file mode 100644 index 0000000..b607646 --- /dev/null +++ b/examples/consumers/secrets_test.go @@ -0,0 +1,41 @@ +package consumers_test + +import ( + "os" + "path/filepath" + "testing" + + configkit "go.maximumdirect.net/configkit" + "go.maximumdirect.net/configkit/examples/consumers" +) + +func TestConfiguredSecretsStartup(t *testing.T) { + root := t.TempDir() + if err := os.Mkdir(filepath.Join(root, "secrets"), 0o700); err != nil { + t.Fatal(err) + } + const name = "CONFIGKIT_EXAMPLE_STARTUP_SECRET" + t.Setenv(name, "") + if err := os.WriteFile(filepath.Join(root, "secrets", name), []byte("example-value\n"), 0o600); err != nil { + t.Fatal(err) + } + main := filepath.Join(root, "main.yml") + if err := os.WriteFile(main, []byte("config: {secrets_dir: secrets, secrets_overwrite: true}\nname: app\ntoken: "+name+"\n"), 0o600); err != nil { + t.Fatal(err) + } + search := configkit.SearchConfig("app", configkit.SearchPaths(main)) + report, prepared, err := consumers.PrepareStartup(search, root) + if err != nil || len(report.Entries()) != 1 || report.Entries()[0].Status != configkit.SecretFileLoaded { + t.Fatalf("prepare = %#v, %v", report, err) + } + ordinary, err := configkit.Load[consumers.StartupConfig](prepared) + if err != nil || ordinary.Config.Name != "app" || ordinary.Config.Token.Value() != "example-value" { + t.Fatalf("ordinary load = %#v, %v", ordinary, err) + } + layered, err := configkit.LoadLayered(configkit.Input{Source: prepared}, configkit.LayeredOptions[consumers.StartupConfig]{ + Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: configkit.Bytes("defaults", []byte("name: default\n"))}}}}, + }) + if err != nil || layered.Config.Name != "app" || layered.Config.Token.Value() != "example-value" { + t.Fatalf("layered load = %#v, %v", layered, err) + } +} diff --git a/facade_secrets_handoff_test.go b/facade_secrets_handoff_test.go new file mode 100644 index 0000000..dc25dea --- /dev/null +++ b/facade_secrets_handoff_test.go @@ -0,0 +1,180 @@ +package configkit_test + +import ( + "errors" + "io/fs" + "os" + "path/filepath" + "sync" + "testing" + + configkit "go.maximumdirect.net/configkit" +) + +type startupHandoffConfig struct { + Main string `yaml:"main"` + Imported string `yaml:"imported"` + Underlay string `yaml:"underlay"` + Overlay string `yaml:"overlay"` + Asset string `yaml:"asset"` + Token configkit.Secret `yaml:"token"` +} + +func TestConfiguredSecretsStartupHandoff(t *testing.T) { + root := t.TempDir() + other := t.TempDir() + t.Chdir(other) + write := func(name, contents string) string { + t.Helper() + file := filepath.Join(root, name) + if err := os.MkdirAll(filepath.Dir(file), 0o700); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(file, []byte(contents), 0o600); err != nil { + t.Fatal(err) + } + return file + } + const tokenName = "CONFIGKIT_HANDOFF_TOKEN" + const sdkName = "CONFIGKIT_HANDOFF_SDK_ONLY" + const emptyName = "CONFIGKIT_HANDOFF_EMPTY" + t.Setenv(tokenName, "previous") + t.Setenv(sdkName, "previous-sdk") + t.Setenv(emptyName, "") + write("app/secrets/"+tokenName, "bootstrap-token\n") + write("app/secrets/"+sdkName, "bootstrap-sdk\n") + write("app/secrets/"+emptyName, "bootstrap-empty\n") + write("app/fragment.yml", "imported: before\n") + write("app/lower.yml", "underlay: companion\n") + write("app/overlays/dev.yml", "overlay: selected\n") + write("app/asset.txt", "resource-data") + main := write("app/main.yml", "config: {secrets_dir: secrets, secrets_overwrite: true, imports: [{path: fragment.yml}]}\nmain: captured\nasset: asset.txt\ntoken: "+tokenName+"\n") + candidate := filepath.Join(root, "app", "earlier.yml") + search := configkit.SearchConfig("app", configkit.SearchPaths(candidate, main)) + report, prepared, err := configkit.LoadSecretsIntoEnvironmentFromConfig(search, configkit.SecretsFromConfigOptions{Filesystem: &configkit.FilesystemContext{Root: root}}) + if err != nil || report == nil || len(report.Entries()) != 3 || os.Getenv(tokenName) != "bootstrap-token" || os.Getenv(sdkName) != "bootstrap-sdk" || os.Getenv(emptyName) != "bootstrap-empty" { + t.Fatalf("prepare report = %#v, error = %v", report, err) + } + for _, entry := range report.Entries() { + if entry.Status != configkit.SecretFileLoaded { + t.Fatalf("bootstrap entry = %#v", entry) + } + } + options := configkit.Options[startupHandoffConfig]{Imports: true} + first, err := configkit.Load[startupHandoffConfig](prepared, options) + if err != nil || first.Config.Main != "captured" || first.Config.Imported != "before" || first.Config.Token.Value() != "bootstrap-token" { + t.Fatalf("first load = %#v, %v", first, err) + } + write("app/main.yml", "main: changed\n") + write("app/earlier.yml", "main: different-candidate\n") + write("app/fragment.yml", "imported: after\n") + if err := os.Setenv(tokenName, "later-token"); err != nil { + t.Fatal(err) + } + second, err := configkit.Load[startupHandoffConfig](prepared, options) + if err != nil || second.Config.Main != "captured" || second.Config.Imported != "after" || second.Config.Token.Value() != "later-token" || first.Config.Imported != "before" || first.Config.Token.Value() != "bootstrap-token" { + t.Fatalf("subsequent load = %#v, %v", second, err) + } + sources := second.Sources() + canonicalMain, err := filepath.EvalSymlinks(main) + if err != nil { + t.Fatal(err) + } + if len(sources) != 2 || sources[0].Kind != configkit.SourceKindFile || sources[0].Path != canonicalMain || sources[0].ID != "source-1" || sources[1].ID != "source-2" { + t.Fatalf("sources = %#v", sources) + } + sources[0].Label = "modified" + if second.Sources()[0].Label == "modified" || first.Sources()[0].Label == "modified" { + t.Fatal("source evidence is shared") + } + context, ok := second.SourceContext("source-1") + if !ok || context.BaseDir != "app" { + t.Fatalf("source context = %#v, %v", context, ok) + } + if data, err := fs.ReadFile(context.FS, "app/asset.txt"); err != nil || string(data) != "resource-data" { + t.Fatalf("resource = %q, %v", data, err) + } + underlay := configkit.Input{Source: configkit.Bytes("companion", []byte("config: {imports: [{path: lower.yml}]}\n")), Imports: true, MainRelative: configkit.MainRelative()} + layered, err := configkit.LoadLayered(configkit.Input{Source: prepared, Imports: true, Filesystem: &configkit.FilesystemContext{Root: root}}, configkit.LayeredOptions[startupHandoffConfig]{ + Underlays: []configkit.Underlay{{Inputs: []configkit.Input{underlay}}}, Overlay: "dev", + }) + if err != nil || layered.Config.Underlay != "companion" || layered.Config.Overlay != "selected" || layered.Config.Imported != "after" { + t.Fatalf("layered load = %#v, %v", layered, err) + } + _, err = configkit.LoadLayered(configkit.Input{Source: prepared, Filesystem: &configkit.FilesystemContext{Root: filepath.Join(root, "app")}}, configkit.LayeredOptions[startupHandoffConfig]{}) + var loadErr *configkit.LoadError + if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) == 0 || loadErr.Diagnostics()[0].Code != configkit.CodeOptionsInvalid || os.Getenv(tokenName) != "later-token" { + t.Fatalf("incompatible context error = %v", err) + } + _, err = configkit.Load[startupHandoffConfig](prepared, configkit.Options[startupHandoffConfig]{Imports: true, Definition: configkit.Definition[startupHandoffConfig]{Validate: func(_ *startupHandoffConfig, validation *configkit.Validation) { + validation.Error(configkit.Keys("main"), "invalid startup setting") + }}}) + if !errors.As(err, &loadErr) || os.Getenv(tokenName) != "later-token" || os.Getenv(sdkName) != "bootstrap-sdk" || len(report.Entries()) != 3 { + t.Fatalf("later validation error = %v, report = %#v", err, report) + } + var group sync.WaitGroup + errorsFound := make(chan error, 8) + for range 8 { + group.Go(func() { + loaded, err := configkit.Load[startupHandoffConfig](prepared, options) + if err != nil { + errorsFound <- err + } else if loaded.Config.Main != "captured" || loaded.Config.Token.Value() != "later-token" { + errorsFound <- errors.New("captured source produced unexpected values") + } + }) + } + group.Wait() + close(errorsFound) + for err := range errorsFound { + t.Error(err) + } +} + +func TestConfiguredSecretsPreservesExistingEmptyValue(t *testing.T) { + root := t.TempDir() + if err := os.Mkdir(filepath.Join(root, "secrets"), 0o700); err != nil { + t.Fatal(err) + } + const name = "CONFIGKIT_HANDOFF_PRESERVED_EMPTY" + t.Setenv(name, "") + if err := os.WriteFile(filepath.Join(root, "secrets", name), []byte("replacement"), 0o600); err != nil { + t.Fatal(err) + } + main := filepath.Join(root, "main.yml") + if err := os.WriteFile(main, []byte("config: {secrets_dir: secrets}\nmain: value\n"), 0o600); err != nil { + t.Fatal(err) + } + report, _, err := configkit.LoadSecretsIntoEnvironmentFromConfig(configkit.File(main)) + if err != nil || len(report.Entries()) != 1 || report.Entries()[0].Status != configkit.SecretFileSkippedExisting || !report.Entries()[0].ExistingEmpty || os.Getenv(name) != "" { + t.Fatalf("report = %#v, error = %v", report, err) + } +} + +func TestOrdinaryLoadingNeverBootstrapsSecrets(t *testing.T) { + root := t.TempDir() + if err := os.Mkdir(filepath.Join(root, "secrets"), 0o700); err != nil { + t.Fatal(err) + } + const name = "CONFIGKIT_NO_AUTOMATIC_BOOTSTRAP" + t.Setenv(name, "existing") + if err := os.WriteFile(filepath.Join(root, "secrets", name), []byte("replacement"), 0o600); err != nil { + t.Fatal(err) + } + main := filepath.Join(root, "main.yml") + if err := os.WriteFile(main, []byte("config: {secrets_dir: secrets, secrets_overwrite: true}\nmain: ordinary\n"), 0o600); err != nil { + t.Fatal(err) + } + type ordinaryConfig struct { + Main string `yaml:"main"` + } + if _, err := configkit.Load[ordinaryConfig](configkit.File(main)); err != nil { + t.Fatal(err) + } + if _, err := configkit.LoadLayered(configkit.Input{Source: configkit.File(main)}, configkit.LayeredOptions[ordinaryConfig]{}); err != nil { + t.Fatal(err) + } + if os.Getenv(name) != "existing" { + t.Fatal("ordinary loading changed the environment") + } +} diff --git a/internal/engine/secrets_from_config_test.go b/internal/engine/secrets_from_config_test.go index 2be383c..ad7a486 100644 --- a/internal/engine/secrets_from_config_test.go +++ b/internal/engine/secrets_from_config_test.go @@ -170,3 +170,52 @@ func TestSecretsFromConfigKeepsPartialReportSafe(t *testing.T) { t.Fatalf("report = %#v, source = %#v, error = %v", report, prepared, err) } } + +func TestSecretsFromConfigClosesOpenedFiles(t *testing.T) { + for _, test := range []struct { + name, contents string + fails bool + }{ + {"success", "value", false}, + {"read failure", "bad\x00value", true}, + } { + t.Run(test.name, func(t *testing.T) { + root := t.TempDir() + main := writeImportFile(t, root, "main.yml", "config: {secrets_dir: secrets}\n") + writeImportFile(t, root, "secrets/SECRET", test.contents) + var opened []*os.File + open := func(name string) (*os.File, error) { + file, err := os.Open(name) + if err == nil { + opened = append(opened, file) + } + return file, err + } + access := testSecretsAccess() + access.openDirectory, access.openFile = open, open + _, prepared, err := loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(map[string]string{}), access) + if (err != nil) != test.fails || (prepared.kind == sourceInvalid) != test.fails || len(opened) != 2 { + t.Fatalf("source = %#v, error = %v, opened = %d", prepared, err, len(opened)) + } + for _, file := range opened { + if _, err := file.Stat(); !errors.Is(err, os.ErrClosed) { + t.Fatalf("file %q remains open: %v", file.Name(), err) + } + } + // On systems exposing process descriptors, also check the main file, + // whose normal acquisition uses the shared regular-file reader. + entries, err := os.ReadDir("/proc/self/fd") + if err != nil { + return + } + canonical := canonicalTestPath(t, main) + canonicalRoot := canonicalTestPath(t, root) + for _, entry := range entries { + target, err := os.Readlink(filepath.Join("/proc/self/fd", entry.Name())) + if err == nil && (target == canonical || target == canonicalRoot) { + t.Fatalf("main or root remains open through descriptor %s", entry.Name()) + } + } + }) + } +}