147 lines
3.4 KiB
Go
147 lines
3.4 KiB
Go
// Package config implements a simple global configuration system that
|
|
// supports a file with key=value pairs and environment variables. Note
|
|
// that the config system is global.
|
|
//
|
|
// This package is intended to be used for small daemons: some configuration
|
|
// file is optionally populated at program start, then this is used to
|
|
// transparently look up configuration values from either that file or the
|
|
// environment.
|
|
package config
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"maps"
|
|
"os"
|
|
"sort"
|
|
"strings"
|
|
|
|
"git.wntrmute.dev/kyle/goutils/config/iniconf"
|
|
)
|
|
|
|
// NB: Rather than define a singleton type, everything is defined at
|
|
// the top-level
|
|
|
|
var (
|
|
vars = map[string]string{}
|
|
prefix = ""
|
|
)
|
|
|
|
// SetEnvPrefix sets the prefix for all environment variables; it's
|
|
// assumed to not be needed for files.
|
|
func SetEnvPrefix(pfx string) {
|
|
prefix = pfx
|
|
}
|
|
|
|
const keyValueSplitLength = 2
|
|
|
|
func addLine(line string) {
|
|
if strings.HasPrefix(line, "#") || line == "" {
|
|
return
|
|
}
|
|
|
|
lineParts := strings.SplitN(line, "=", keyValueSplitLength)
|
|
if len(lineParts) != keyValueSplitLength {
|
|
return // silently ignore empty keys
|
|
}
|
|
|
|
lineParts[0] = strings.TrimSpace(lineParts[0])
|
|
lineParts[1] = strings.TrimSpace(lineParts[1])
|
|
vars[lineParts[0]] = lineParts[1]
|
|
}
|
|
|
|
// LoadFile scans the file at 'path' for key=value pairs and adds them
|
|
// to the configuration.
|
|
func LoadFile(path string) error {
|
|
file, err := os.Open(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer file.Close()
|
|
|
|
scanner := bufio.NewScanner(file)
|
|
for scanner.Scan() {
|
|
line := strings.TrimSpace(scanner.Text())
|
|
addLine(line)
|
|
}
|
|
|
|
return scanner.Err()
|
|
}
|
|
|
|
// LoadFileFor scans the ini file at 'path', loading the default section
|
|
// and overriding any keys found under 'section'. If strict is true, the
|
|
// named section must exist (i.e., to catch typos in the section name).
|
|
func LoadFileFor(path, section string, strict bool) error {
|
|
cmap, err := iniconf.ParseFile(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
maps.Copy(vars, cmap[iniconf.DefaultSection])
|
|
|
|
smap, ok := cmap[section]
|
|
if !ok {
|
|
if strict {
|
|
return fmt.Errorf("config: section '%s' wasn't found in the config file", section)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
maps.Copy(vars, smap)
|
|
|
|
return nil
|
|
}
|
|
|
|
// Get retrieves a value from either a configuration file or the
|
|
// environment. Note that values from a file will override environment
|
|
// variables.
|
|
func Get(key string) string {
|
|
if v, ok := vars[key]; ok {
|
|
return v
|
|
}
|
|
return os.Getenv(prefix + key)
|
|
}
|
|
|
|
// GetDefault retrieves a value from either a configuration file or
|
|
// the environment. Note that value from a file will override
|
|
// environment variables. If a value isn't found (e.g., Get returns an
|
|
// empty string), the default value will be used.
|
|
func GetDefault(key, def string) string {
|
|
if v := Get(key); v != "" {
|
|
return v
|
|
}
|
|
return def
|
|
}
|
|
|
|
// Require retrieves a value from either a configuration file or the
|
|
// environment. If the key isn't present, it will panic.
|
|
func Require(key string) string {
|
|
if v, ok := vars[key]; ok {
|
|
return v
|
|
}
|
|
|
|
v, ok := os.LookupEnv(prefix + key)
|
|
if !ok {
|
|
var envMessage string
|
|
if prefix != "" {
|
|
envMessage = " (note: looked for the key " + prefix + key
|
|
envMessage += " in the local env)"
|
|
}
|
|
panic(fmt.Sprintf("missing required configuration value %s%s", key, envMessage))
|
|
}
|
|
|
|
return v
|
|
}
|
|
|
|
// ListKeys returns a slice of the currently known keys.
|
|
func ListKeys() []string {
|
|
var keyList []string
|
|
|
|
for k := range vars {
|
|
keyList = append(keyList, k)
|
|
}
|
|
|
|
sort.Strings(keyList)
|
|
return keyList
|
|
}
|