From c5802cf86dea1fa58bdb541ea7610a914038e14f Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sat, 31 Oct 2026 14:39:14 +1100 Subject: [PATCH] fix(releaseupdate): load the env file beside the config so update install gets the database password from a shell (#1431) --- internal/config/envfile.go | 91 ++++++++++++++ internal/config/envfile_test.go | 89 +++++++++++++ internal/releaseupdate/credentials.go | 115 +++++++++++++++++ internal/releaseupdate/credentials_test.go | 137 +++++++++++++++++++++ internal/releaseupdate/prepare.go | 3 + internal/releaseupdate/transaction.go | 20 ++- internal/releaseupdate/transaction_test.go | 10 +- 7 files changed, 458 insertions(+), 7 deletions(-) create mode 100644 internal/config/envfile.go create mode 100644 internal/config/envfile_test.go create mode 100644 internal/releaseupdate/credentials.go create mode 100644 internal/releaseupdate/credentials_test.go diff --git a/internal/config/envfile.go b/internal/config/envfile.go new file mode 100644 index 000000000..2ea028719 --- /dev/null +++ b/internal/config/envfile.go @@ -0,0 +1,91 @@ +package config + +import ( + "errors" + "os" + "path/filepath" + "strings" +) + +// EnvFileName is the env file beside config.toml that setup writes secrets +// to and the systemd units load with EnvironmentFile=-.../env. A process +// started outside systemd -- a login shell running `archied update install` +// -- does not have those variables, so anything that needs one loads the +// file itself. +const EnvFileName = "env" + +// EnvFilePath returns the env file beside the given config file, the same +// path the systemd units' EnvironmentFile names. +func EnvFilePath(configPath string) string { + return filepath.Join(filepath.Dir(configPath), EnvFileName) +} + +// defaultInstance mirrors configuration.DefaultInstance: the instance name +// when ARCHIE_INSTANCE is unset. +const defaultInstance = "archie" + +// DefaultConfigPath returns the config file archie binaries read when +// -config is not given: $XDG_CONFIG_HOME//config.toml, or +// ~/.config//config.toml. It mirrors configuration.DefaultConfigPath +// so a process outside the configuration loader can still find the env file +// beside that config. +func DefaultConfigPath() string { + dir := os.Getenv("XDG_CONFIG_HOME") + if dir == "" { + if home, err := os.UserHomeDir(); err == nil { + dir = filepath.Join(home, ".config") + } + } + instance := os.Getenv("ARCHIE_INSTANCE") + if instance == "" { + instance = defaultInstance + } + return filepath.Join(dir, instance, "config.toml") +} + +// LoadEnvFile reads the env file at path. A missing file yields no entries +// and no error: an install whose database_url carries its own password has +// no env file to read. +func LoadEnvFile(path string) (map[string]string, error) { + data, err := os.ReadFile(path) + if errors.Is(err, os.ErrNotExist) { + return nil, nil + } + if err != nil { + return nil, err + } + return ParseEnvFile(data), nil +} + +// ParseEnvFile parses the env file format setup writes and systemd loads: +// KEY='value' lines where a literal quote is escaped as '\” , plus unquoted +// KEY=value and double-quoted KEY="value" lines. Blank lines and #-comments +// are skipped, as are lines without a key. +func ParseEnvFile(data []byte) map[string]string { + entries := map[string]string{} + for line := range strings.Lines(string(data)) { + line = strings.TrimRight(line, "\r\n") + trimmed := strings.TrimSpace(line) + if trimmed == "" || strings.HasPrefix(trimmed, "#") { + continue + } + key, value, ok := strings.Cut(trimmed, "=") + if !ok || key == "" { + continue + } + entries[key] = parseEnvValue(value) + } + return entries +} + +// parseEnvValue strips the quoting one env-file value carries. The +// single-quoted form is the one setup writes, so its '\” escape is undone. +func parseEnvValue(value string) string { + if len(value) >= 2 && value[0] == '\'' && value[len(value)-1] == '\'' { + return strings.ReplaceAll(value[1:len(value)-1], `'\''`, "'") + } + if len(value) >= 2 && value[0] == '"' && value[len(value)-1] == '"' { + return value[1 : len(value)-1] + } + return value +} diff --git a/internal/config/envfile_test.go b/internal/config/envfile_test.go new file mode 100644 index 000000000..88f0d08f9 --- /dev/null +++ b/internal/config/envfile_test.go @@ -0,0 +1,89 @@ +package config + +import ( + "maps" + "os" + "path/filepath" + "testing" +) + +func TestEnvFilePath(t *testing.T) { + if got := EnvFilePath("/home/sam/.config/archie/config.toml"); got != "/home/sam/.config/archie/env" { + t.Errorf("EnvFilePath = %q", got) + } +} + +func TestDefaultConfigPath(t *testing.T) { + tests := []struct { + name string + xdgConfigHome string + instance string + want string + }{ + {name: "defaults", want: filepath.Join(homeConfigDir(t), "archie", "config.toml")}, + {name: "xdg config home", xdgConfigHome: "/xdg", want: filepath.Join("/xdg", "archie", "config.toml")}, + {name: "named instance", xdgConfigHome: "/xdg", instance: "archie-dev", want: filepath.Join("/xdg", "archie-dev", "config.toml")}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", tt.xdgConfigHome) + t.Setenv("ARCHIE_INSTANCE", tt.instance) + if got := DefaultConfigPath(); got != tt.want { + t.Errorf("DefaultConfigPath = %q, want %q", got, tt.want) + } + }) + } +} + +func homeConfigDir(t *testing.T) string { + t.Helper() + home, err := os.UserHomeDir() + if err != nil { + t.Fatal(err) + } + return filepath.Join(home, ".config") +} + +func TestParseEnvFile(t *testing.T) { + data := `# archie secrets +PGPASSWORD='s3cret' +GITEA_TOKEN='a'\''b' +PLAIN=unquoted +DOUBLE="double-quoted" + +no-equals-sign-line +=orphan +` + got := ParseEnvFile([]byte(data)) + want := map[string]string{ + "PGPASSWORD": "s3cret", + "GITEA_TOKEN": "a'b", + "PLAIN": "unquoted", + "DOUBLE": "double-quoted", + } + if !maps.Equal(got, want) { + t.Errorf("ParseEnvFile = %v, want %v", got, want) + } +} + +func TestLoadEnvFile(t *testing.T) { + t.Run("missing file is no entries and no error", func(t *testing.T) { + entries, err := LoadEnvFile(filepath.Join(t.TempDir(), "env")) + if err != nil || entries != nil { + t.Errorf("LoadEnvFile = %v, %v, want nil, nil", entries, err) + } + }) + t.Run("existing file parses", func(t *testing.T) { + path := filepath.Join(t.TempDir(), "env") + if err := os.WriteFile(path, []byte("PGPASSWORD='pw'\n"), 0o600); err != nil { + t.Fatal(err) + } + entries, err := LoadEnvFile(path) + if err != nil { + t.Fatal(err) + } + if entries["PGPASSWORD"] != "pw" { + t.Errorf("entries = %v", entries) + } + }) +} diff --git a/internal/releaseupdate/credentials.go b/internal/releaseupdate/credentials.go new file mode 100644 index 000000000..b8a62c679 --- /dev/null +++ b/internal/releaseupdate/credentials.go @@ -0,0 +1,115 @@ +package releaseupdate + +import ( + "fmt" + "net/url" + "os" + "strings" + + "github.com/BurntSushi/toml" + + "github.com/samcharles93/archie-core/internal/config" +) + +// DatabasePasswordEnv is the variable the PostgreSQL clients (pgx and the +// pg_dump/pg_restore tools) read the database password from. Setup stores it +// in the env file beside the config, which only the systemd units load. +const DatabasePasswordEnv = "PGPASSWORD" + +// configPath returns the config file this transaction runs against: the +// installer's ConfigPath, or the default one when it was not given. +func (t *Transaction) configPath() string { + if t.ConfigPath != "" { + return t.ConfigPath + } + return config.DefaultConfigPath() +} + +// loadEnvCredentials makes the env file beside the config visible to this +// process and refuses to run without the database password. The units load +// that file with EnvironmentFile; run from a login shell, the installer has +// to load it itself, so the documented `archied update install` works there. +// The process environment wins over the file, so an explicit export always +// overrides it. +func (t *Transaction) loadEnvCredentials() error { + configPath := t.configPath() + if urlCarriesPassword(readDatabaseURL(configPath)) { + return nil + } + envPath := config.EnvFilePath(configPath) + entries, err := config.LoadEnvFile(envPath) + if err != nil { + return fmt.Errorf("read the env file beside the config: %w", err) + } + password, err := resolveDatabasePassword(os.Getenv, entries) + if err != nil { + return fmt.Errorf("the update needs the database password but cannot find one: %w; %s is loaded by the systemd units, not by a shell -- export %s or add it to %s", + err, envPath, DatabasePasswordEnv, envPath) + } + if os.Getenv(DatabasePasswordEnv) == "" { + if err := os.Setenv(DatabasePasswordEnv, password); err != nil { + return err + } + } + // The rest of the file (forge and chat tokens, provider keys) backs the + // "env" secret engine, which reads the process environment: export every + // entry the process does not already have, never overriding one. + for key, value := range entries { + if os.Getenv(key) == "" { + if err := os.Setenv(key, value); err != nil { + return err + } + } + } + return nil +} + +// resolveDatabasePassword returns the database password in resolution order: +// the process environment first (an explicit export, or the systemd unit's +// EnvironmentFile), then the env file beside the config. It errors when +// neither holds one, so a missing password is never silent. +func resolveDatabasePassword(getenv func(string) string, envFile map[string]string) (string, error) { + if password := getenv(DatabasePasswordEnv); password != "" { + return password, nil + } + if password := envFile[DatabasePasswordEnv]; password != "" { + return password, nil + } + return "", fmt.Errorf("%s is not set and the env file has no %s entry", DatabasePasswordEnv, DatabasePasswordEnv) +} + +// readDatabaseURL reads database_url from the config file at path. It is +// best-effort: a config directory, a YAML config or a missing file yields +// "", and the caller then falls back to the environment password. +func readDatabaseURL(path string) string { + info, err := os.Stat(path) + if err != nil || !info.Mode().IsRegular() { + return "" + } + data, err := os.ReadFile(path) + if err != nil { + return "" + } + var file struct { + DatabaseURL string `toml:"database_url"` + } + if toml.Unmarshal(data, &file) != nil { + return "" + } + return file.DatabaseURL +} + +// urlCarriesPassword reports whether a PostgreSQL connection string already +// holds its password -- in a URL's userinfo or as a password= keyword -- in +// which case no environment password is needed. +func urlCarriesPassword(databaseURL string) bool { + if strings.Contains(databaseURL, "password=") { + return true + } + u, err := url.Parse(databaseURL) + if err != nil || u.User == nil { + return false + } + _, ok := u.User.Password() + return ok +} diff --git a/internal/releaseupdate/credentials_test.go b/internal/releaseupdate/credentials_test.go new file mode 100644 index 000000000..90357b6aa --- /dev/null +++ b/internal/releaseupdate/credentials_test.go @@ -0,0 +1,137 @@ +package releaseupdate + +import ( + "os" + "path/filepath" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/config" +) + +func TestResolveDatabasePassword(t *testing.T) { + tests := []struct { + name string + env map[string]string + envFile map[string]string + want string + wantErr bool + }{ + {name: "environment wins over the env file", env: map[string]string{"PGPASSWORD": "from-env"}, envFile: map[string]string{"PGPASSWORD": "from-file"}, want: "from-env"}, + {name: "env file supplies it when the environment does not", envFile: map[string]string{"PGPASSWORD": "from-file"}, want: "from-file"}, + {name: "neither holds one", wantErr: true}, + {name: "empty entries do not count", env: map[string]string{"PGPASSWORD": ""}, envFile: map[string]string{"PGPASSWORD": ""}, wantErr: true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + getenv := func(key string) string { return tt.env[key] } + got, err := resolveDatabasePassword(getenv, tt.envFile) + if tt.wantErr { + if err == nil || !strings.Contains(err.Error(), DatabasePasswordEnv) { + t.Fatalf("resolveDatabasePassword error = %v, want one naming %s", err, DatabasePasswordEnv) + } + return + } + if err != nil { + t.Fatalf("resolveDatabasePassword: %v", err) + } + if got != tt.want { + t.Errorf("resolveDatabasePassword = %q, want %q", got, tt.want) + } + }) + } +} + +func TestURLCarriesPassword(t *testing.T) { + tests := []struct { + url string + want bool + }{ + {"postgres://archie:secret@localhost/archie", true}, + {"postgres://archie@/archie?host=/run/archie/postgres", false}, + {"postgres://archie@localhost/archie", false}, + {"host=localhost user=archie password=secret", true}, + {"host=localhost user=archie", false}, + {"", false}, + } + for _, tt := range tests { + if got := urlCarriesPassword(tt.url); got != tt.want { + t.Errorf("urlCarriesPassword(%q) = %v, want %v", tt.url, got, tt.want) + } + } +} + +func TestLoadEnvCredentials(t *testing.T) { + writeConfig := func(t *testing.T, databaseURL string) (configPath string) { + t.Helper() + configPath = filepath.Join(t.TempDir(), "config.toml") + if err := os.WriteFile(configPath, []byte("database_url = \""+databaseURL+"\"\n"), 0o600); err != nil { + t.Fatal(err) + } + return configPath + } + + t.Run("env file beside the config supplies the password", func(t *testing.T) { + t.Setenv(DatabasePasswordEnv, "") + configPath := writeConfig(t, "postgres://archie@/archie?host=/run/archie/postgres") + envPath := config.EnvFilePath(configPath) + body := "# secrets\nPGPASSWORD='from-file'\nARCHIE_TEST_TOKEN='file-token'\n" + if err := os.WriteFile(envPath, []byte(body), 0o600); err != nil { + t.Fatal(err) + } + tx := &Transaction{ConfigPath: configPath} + if err := tx.loadEnvCredentials(); err != nil { + t.Fatalf("loadEnvCredentials: %v", err) + } + if got := os.Getenv(DatabasePasswordEnv); got != "from-file" { + t.Errorf("%s = %q, want %q", DatabasePasswordEnv, got, "from-file") + } + if got := os.Getenv("ARCHIE_TEST_TOKEN"); got != "file-token" { + t.Errorf("ARCHIE_TEST_TOKEN = %q, want %q", got, "file-token") + } + }) + + t.Run("the environment wins over the env file", func(t *testing.T) { + t.Setenv(DatabasePasswordEnv, "from-env") + t.Setenv("ARCHIE_TEST_TOKEN", "env-token") + configPath := writeConfig(t, "postgres://archie@/archie?host=/run/archie/postgres") + if err := os.WriteFile(config.EnvFilePath(configPath), []byte("PGPASSWORD='from-file'\nARCHIE_TEST_TOKEN='file-token'\n"), 0o600); err != nil { + t.Fatal(err) + } + tx := &Transaction{ConfigPath: configPath} + if err := tx.loadEnvCredentials(); err != nil { + t.Fatalf("loadEnvCredentials: %v", err) + } + if got := os.Getenv(DatabasePasswordEnv); got != "from-env" { + t.Errorf("%s = %q, want %q", DatabasePasswordEnv, got, "from-env") + } + if got := os.Getenv("ARCHIE_TEST_TOKEN"); got != "env-token" { + t.Errorf("ARCHIE_TEST_TOKEN = %q, want %q", got, "env-token") + } + }) + + t.Run("a database_url with its own password needs no env entry", func(t *testing.T) { + t.Setenv(DatabasePasswordEnv, "") + configPath := writeConfig(t, "postgres://archie:secret@localhost/archie") + tx := &Transaction{ConfigPath: configPath} + if err := tx.loadEnvCredentials(); err != nil { + t.Fatalf("loadEnvCredentials: %v", err) + } + if got := os.Getenv(DatabasePasswordEnv); got != "" { + t.Errorf("%s = %q, want unset", DatabasePasswordEnv, got) + } + }) + + t.Run("no password anywhere is a clear error", func(t *testing.T) { + t.Setenv(DatabasePasswordEnv, "") + configPath := writeConfig(t, "postgres://archie@/archie?host=/run/archie/postgres") + tx := &Transaction{ConfigPath: configPath} + err := tx.loadEnvCredentials() + if err == nil { + t.Fatal("loadEnvCredentials succeeded without any password") + } + if !strings.Contains(err.Error(), DatabasePasswordEnv) || !strings.Contains(err.Error(), config.EnvFilePath(configPath)) { + t.Errorf("error = %v, want it to name %s and the env file path", err, DatabasePasswordEnv) + } + }) +} diff --git a/internal/releaseupdate/prepare.go b/internal/releaseupdate/prepare.go index f3abfe91d..3cfa26a2c 100644 --- a/internal/releaseupdate/prepare.go +++ b/internal/releaseupdate/prepare.go @@ -59,6 +59,9 @@ func (t *Transaction) Prepare(ctx context.Context, req PrepareRequest) (Result, if !releaseVersion.MatchString(req.Version) { return Result{}, fmt.Errorf("refusing non-release version %q", req.Version) } + if err := t.loadEnvCredentials(); err != nil { + return Result{}, err + } unlock, held, err := lockState(ctx, t.StateDir, false) if err != nil { return Result{}, err diff --git a/internal/releaseupdate/transaction.go b/internal/releaseupdate/transaction.go index 279a045c8..30c52f52f 100644 --- a/internal/releaseupdate/transaction.go +++ b/internal/releaseupdate/transaction.go @@ -84,12 +84,17 @@ type Health interface { type Transaction struct { StateDir string BinDir string - Units Units - Images Images - Policy ImagePolicy - Database Database - Health Health - Progress func(string) + // ConfigPath is the bootstrap config file the install runs against. Its + // sibling env file supplies the credentials the systemd units would + // otherwise provide, above all the database password; empty means the + // default config path. + ConfigPath string + Units Units + Images Images + Policy ImagePolicy + Database Database + Health Health + Progress func(string) // HealthTimeout bounds the wait for the restarted daemon to report the // release; it must then stay healthy for Observe, checked every Poll. @@ -125,6 +130,9 @@ func JournalPath(stateDir string) string { return filepath.Join(stateDir, journa // on boot: it never waits for the lock, and a transaction that was prepared // but never started is abandoned rather than started unattended. func (t *Transaction) Run(ctx context.Context, recovering bool) error { + if err := t.loadEnvCredentials(); err != nil { + return err + } unlock, held, err := lockState(ctx, t.StateDir, !recovering) if err != nil { return err diff --git a/internal/releaseupdate/transaction_test.go b/internal/releaseupdate/transaction_test.go index d5b9c6ce4..6a51f175e 100644 --- a/internal/releaseupdate/transaction_test.go +++ b/internal/releaseupdate/transaction_test.go @@ -134,6 +134,14 @@ func crash(t *testing.T, tx *Transaction, h *fakeHost, phase string) { } func TestTransaction(t *testing.T) { + // The installer resolves the database password from the environment or + // the env file beside its config; pin both to this test's own files so + // the result never depends on the machine's real archie config. + t.Setenv(DatabasePasswordEnv, "test-password") + configPath := filepath.Join(t.TempDir(), "config.toml") + if err := os.WriteFile(configPath, []byte("database_url = \"postgres://archie@/archie?host=/tmp/archie-test\"\n"), 0o600); err != nil { + t.Fatal(err) + } type outcome struct { version, image string report string // health_check, or "" for no report @@ -179,7 +187,7 @@ func TestTransaction(t *testing.T) { } report := filepath.Join(root, "report.json") tx := &Transaction{ - StateDir: filepath.Join(root, "state"), BinDir: host.bin, + StateDir: filepath.Join(root, "state"), BinDir: host.bin, ConfigPath: configPath, Units: &host, Images: &host, Policy: &host, Database: &host, Health: &host, HealthTimeout: 20 * time.Millisecond, Observe: 5 * time.Millisecond, Poll: time.Millisecond, }