Verify configured secrets startup handoff

This commit is contained in:
2026-11-18 01:00:16 +00:00
parent 60bcb6ddac
commit ab6e610fb7
5 changed files with 290 additions and 0 deletions

View File

@@ -336,6 +336,8 @@ through ConfigKit's public package with the documented ownership and errors.
## Stage 8 — Verify the complete startup handoff ## Stage 8 — Verify the complete startup handoff
**Completed.**
Extend public integration coverage and add one maintained consumer startup Extend public integration coverage and add one maintained consumer startup
example with ordinary and layered use explained from the same helper. example with ordinary and layered use explained from the same helper.

View File

@@ -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},
})
}

View File

@@ -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)
}
}

View File

@@ -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")
}
}

View File

@@ -170,3 +170,52 @@ func TestSecretsFromConfigKeepsPartialReportSafe(t *testing.T) {
t.Fatalf("report = %#v, source = %#v, error = %v", report, prepared, err) 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())
}
}
})
}
}