taler-merchant-demos

config.go (9978B)

---

 // Package config reads the small subset of GNUnet-style configuration used by
 // the merchant demos.  It deliberately has no dependency on libgnunet or a
 // third-party INI parser.
 package config
 
 import (
 	"bufio"
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
 )
 
 // Config stores case-insensitive section and option names.
 type Config struct {
 	sections    map[string]map[string]string
 	sources     map[string]map[string]source
 	loadedFiles []string
 }
 
 type source struct {
 	filename string
 	line     int
 }
 
 const (
 	projectName    = "taler-merchant-demos"
 	configFilename = projectName + ".conf"
 	baseConfigEnv  = "TALER_MERCHANT_DEMOS_BASE_CONFIG"
 	prefixEnv      = "TALER_MERCHANT_DEMOS_PREFIX"
 )
 
 // Load reads defaults and then filename, matching the precedence used by the
 // other Taler components. An empty filename selects the first existing
 // component-specific user or system configuration file.
 func Load(filename string) (*Config, error) {
 	c := &Config{
 		sections: make(map[string]map[string]string),
 		sources:  make(map[string]map[string]source),
 	}
 	defaults := os.Getenv(baseConfigEnv)
 	if defaults == "" {
 		defaults = filepath.Join(installationPrefix(), "share", projectName, "config.d")
 	}
 	if err := c.loadDir(defaults); err != nil {
 		return nil, err
 	}
 	if filename == "" {
 		var err error
 		filename, err = defaultConfigFile()
 		if err != nil {
 			return nil, err
 		}
 		if filename == "" {
 			return c, nil
 		}
 	}
 	if err := c.loadFile(filename, make(map[string]bool)); err != nil {
 		return nil, err
 	}
 	return c, nil
 }
 
 func installationPrefix() string {
 	if prefix := os.Getenv(prefixEnv); prefix != "" {
 		return filepath.Clean(prefix)
 	}
 	executable, err := os.Executable()
 	if err == nil {
 		if resolved, resolveErr := filepath.EvalSymlinks(executable); resolveErr == nil {
 			executable = resolved
 		}
 		binDir := filepath.Dir(executable)
 		if filepath.Base(binDir) == "bin" {
 			return filepath.Dir(binDir)
 		}
 	}
 	return "/usr"
 }
 
 func defaultConfigFile() (string, error) {
 	var candidates []string
 	if xdg := os.Getenv("XDG_CONFIG_HOME"); xdg != "" {
 		candidates = append(candidates, filepath.Join(xdg, configFilename))
 	} else {
 		home, err := os.UserHomeDir()
 		if err != nil {
 			return "", fmt.Errorf("locate home directory: %w", err)
 		}
 		candidates = append(candidates, filepath.Join(home, ".config", configFilename))
 	}
 	candidates = append(candidates,
 		filepath.Join("/etc", configFilename),
 		filepath.Join("/etc", projectName, configFilename),
 	)
 	for _, filename := range candidates {
 		if _, err := os.Stat(filename); err == nil {
 			return filename, nil
 		} else if !errors.Is(err, os.ErrNotExist) {
 			return "", fmt.Errorf("inspect configuration %q: %w", filename, err)
 		}
 	}
 	return "", nil
 }
 
 func (c *Config) loadDir(dirname string) error {
 	entries, err := os.ReadDir(dirname)
 	if errors.Is(err, os.ErrNotExist) {
 		return nil
 	}
 	if err != nil {
 		return fmt.Errorf("read defaults directory %q: %w", dirname, err)
 	}
 	for _, entry := range entries {
 		if entry.IsDir() || filepath.Ext(entry.Name()) != ".conf" {
 			continue
 		}
 		if err := c.loadFile(filepath.Join(dirname, entry.Name()), make(map[string]bool)); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
 func (c *Config) loadFile(filename string, loading map[string]bool) error {
 	abs, err := filepath.Abs(filename)
 	if err != nil {
 		return err
 	}
 	if loading[abs] {
 		return fmt.Errorf("configuration include cycle at %q", filename)
 	}
 	loading[abs] = true
 	defer delete(loading, abs)
 
 	f, err := os.Open(abs)
 	if err != nil {
 		return fmt.Errorf("open configuration %q: %w", abs, err)
 	}
 	defer f.Close()
 	c.loadedFiles = append(c.loadedFiles, abs)
 
 	var section string
 	scanner := bufio.NewScanner(f)
 	for lineNo := 1; scanner.Scan(); lineNo++ {
 		line := strings.TrimSpace(scanner.Text())
 		if line == "" || strings.HasPrefix(line, "#") {
 			continue
 		}
 		if strings.HasPrefix(line, "@INLINE@") {
 			fields := strings.Fields(line)
 			if len(fields) != 2 {
 				return fmt.Errorf("%s:%d: malformed @INLINE@ directive", abs, lineNo)
 			}
 			included := fields[1]
 			if !filepath.IsAbs(included) {
 				included = filepath.Join(filepath.Dir(abs), included)
 			}
 			if err := c.loadFile(included, loading); err != nil {
 				return err
 			}
 			continue
 		}
 		if strings.HasPrefix(line, "[") {
 			if !strings.HasSuffix(line, "]") {
 				return fmt.Errorf("%s:%d: malformed section header", abs, lineNo)
 			}
 			section = normalize(strings.Trim(strings.TrimSpace(line[1:len(line)-1]), `"`))
 			if section == "" {
 				return fmt.Errorf("%s:%d: empty section name", abs, lineNo)
 			}
 			if c.sections[section] == nil {
 				c.sections[section] = make(map[string]string)
 				c.sources[section] = make(map[string]source)
 			}
 			continue
 		}
 		if section == "" {
 			return fmt.Errorf("%s:%d: option outside a section", abs, lineNo)
 		}
 		key, value, ok := strings.Cut(line, "=")
 		if !ok {
 			return fmt.Errorf("%s:%d: malformed option", abs, lineNo)
 		}
 		key = normalize(strings.TrimSpace(key))
 		value = strings.TrimSpace(value)
 		if strings.HasPrefix(value, `"`) {
 			if len(value) < 2 || !strings.HasSuffix(value, `"`) {
 				return fmt.Errorf("%s:%d: mismatched quotes", abs, lineNo)
 			}
 			value = value[1 : len(value)-1]
 		}
 		c.sections[section][key] = value
 		c.sources[section][key] = source{filename: abs, line: lineNo}
 	}
 	if err := scanner.Err(); err != nil {
 		return fmt.Errorf("read configuration %q: %w", abs, err)
 	}
 	return nil
 }
 
 func normalize(s string) string { return strings.ToLower(s) }
 
 // Dump writes the effective configuration with the source of every option.
 func (c *Config) Dump(w io.Writer) error {
 	sections := make([]string, 0, len(c.sections))
 	for section := range c.sections {
 		sections = append(sections, section)
 	}
 	sort.Strings(sections)
 
 	var output strings.Builder
 	output.WriteString("#\n# Configuration file load order:\n")
 	for _, filename := range c.loadedFiles {
 		fmt.Fprintf(&output, "# %s\n", filename)
 	}
 	output.WriteString("#\n\n")
 	for sectionIndex, section := range sections {
 		if sectionIndex > 0 {
 			output.WriteByte('\n')
 		}
 		fmt.Fprintf(&output, "[%s]\n\n", section)
 
 		options := make([]string, 0, len(c.sections[section]))
 		for option := range c.sections[section] {
 			options = append(options, option)
 		}
 		sort.Strings(options)
 		for _, option := range options {
 			source := c.sources[section][option]
 			fmt.Fprintf(&output, "# %s:%d\n%s = %s\n\n", source.filename, source.line, option, c.sections[section][option])
 		}
 	}
 	_, err := io.WriteString(w, output.String())
 	return err
 }
 
 // Get returns an option or an empty string when it is absent.
 func (c *Config) Get(section, option string) string {
 	return c.sections[normalize(section)][normalize(option)]
 }
 
 // Require returns a non-empty option or an actionable configuration error.
 func (c *Config) Require(section, option string) (string, error) {
 	value := c.Get(section, option)
 	if value == "" {
 		return "", fmt.Errorf("missing required option %s in section %s", strings.ToUpper(option), strings.ToUpper(section))
 	}
 	return value, nil
 }
 
 // Int parses a decimal integer option.  Missing options return fallback.
 func (c *Config) Int(section, option string, fallback int) (int, error) {
 	value := c.Get(section, option)
 	if value == "" {
 		return fallback, nil
 	}
 	n, err := strconv.Atoi(value)
 	if err != nil {
 		return 0, fmt.Errorf("option %s in section %s must be an integer: %w", strings.ToUpper(option), strings.ToUpper(section), err)
 	}
 	return n, nil
 }
 
 const maxExpansionDepth = 128
 
 // Filename expands the variable syntax used by Taler filenames. Values in
 // [PATHS] take precedence over environment variables, defaults and variable
 // values are expanded recursively, and unknown variables are left unchanged.
 func (c *Config) Filename(section, option string) string {
 	return c.expandFilename(c.Get(section, option), 0)
 }
 
 func (c *Config) expandFilename(value string, depth int) string {
 	if depth >= maxExpansionDepth || !strings.Contains(value, "$") {
 		return value
 	}
 	var expanded strings.Builder
 	for offset := 0; offset < len(value); {
 		if value[offset] != '$' {
 			expanded.WriteByte(value[offset])
 			offset++
 			continue
 		}
 		name, fallback, end, ok := filenameVariable(value, offset)
 		if !ok {
 			expanded.WriteByte(value[offset])
 			offset++
 			continue
 		}
 		replacement, found := c.pathVariable(name)
 		if !found && fallback != nil {
 			replacement, found = *fallback, true
 		}
 		if !found {
 			expanded.WriteString(value[offset:end])
 		} else {
 			expanded.WriteString(c.expandFilename(replacement, depth+1))
 		}
 		offset = end
 	}
 	return expanded.String()
 }
 
 func (c *Config) pathVariable(name string) (string, bool) {
 	if paths := c.sections[normalize("paths")]; paths != nil {
 		if value, ok := paths[normalize(name)]; ok {
 			return value, true
 		}
 	}
 	return os.LookupEnv(name)
 }
 
 func filenameVariable(value string, offset int) (name string, fallback *string, end int, ok bool) {
 	if offset+1 >= len(value) {
 		return "", nil, offset, false
 	}
 	if value[offset+1] != '{' {
 		end = offset + 1
 		for end < len(value) && isVariableCharacter(value[end]) {
 			end++
 		}
 		if end == offset+1 {
 			return "", nil, offset, false
 		}
 		return value[offset+1 : end], nil, end, true
 	}
 
 	level := 1
 	end = offset + 2
 	for end < len(value) && level > 0 {
 		switch value[end] {
 		case '{':
 			level++
 		case '}':
 			level--
 		}
 		end++
 	}
 	if level != 0 {
 		return "", nil, offset, false
 	}
 	contents := value[offset+2 : end-1]
 	if separator := strings.Index(contents, ":-"); separator >= 0 {
 		name = contents[:separator]
 		defaultValue := contents[separator+2:]
 		fallback = &defaultValue
 	} else {
 		name = contents
 	}
 	if name == "" {
 		return "", nil, offset, false
 	}
 	return name, fallback, end, true
 }
 
 func isVariableCharacter(value byte) bool {
 	return value >= 'a' && value <= 'z' || value >= 'A' && value <= 'Z' || value >= '0' && value <= '9' || value == '_'
 }