116 lines
3.8 KiB
Go
116 lines
3.8 KiB
Go
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
|
|
}
|