Support loading configurations from both YAML and env

This commit adds the `config#Load` function to load configurations from both
YAML files and environment variables. It handles scenarios where configurations
are loaded exclusively from YAML, combined with environment variables, or
entirely from environment variables if the YAML file is missing and no specific
configuration file is provided via command line flags.

Author: lippserd

config/config.go

@@ -51,6 +51,7 @@ import (
 	"github.com/goccy/go-yaml"
 	"github.com/jessevdk/go-flags"
 	"github.com/pkg/errors"
+	"io/fs"
 	"os"
 	"reflect"
 )
@@ -159,6 +160,122 @@ func FromEnv(v Validator, options EnvOptions) error {
 	return nil
 }
 
+// LoadOptions contains options for loading configuration from both files and environment variables.
+type LoadOptions struct {
+	// Flags provides access to specific command line flag values.
+	Flags Flags
+
+	// EnvOptions contains options for loading configuration from environment variables.
+	EnvOptions EnvOptions
+}
+
+// Load loads configuration from both YAML files and environment variables and
+// stores the result in the value pointed to by v.
+// If v is nil or not a struct pointer,
+// Load returns an [ErrInvalidArgument] error.
+//
+// It is possible to define default values via the struct tag `default`.
+//
+// The function also validates the configuration using the Validate method
+// of the provided [Validator] interface.
+// Any error returned from Validate is propagated with [ErrInvalidConfiguration] attached,
+// allowing errors.Is() checks on the returned errors to recognize both ErrInvalidConfiguration and
+// the original errors returned from Validate.
+//
+// This function handles configuration loading in three scenarios:
+//
+//  1. Load configuration exclusively from YAML files when no applicable environment variables are set.
+//  2. Combine YAML file and environment variable configurations, allowing environment variables to
+//     supplement or override possible incomplete YAML data.
+//  3. Load entirely from environment variables if the default YAML config file is missing and
+//     no specific config path is provided.
+//
+// Example usage:
+//
+//	const DefaultConfigPath = "/path/to/config.yml"
+//
+//	type Flags struct {
+//		Config string `short:"c" long:"config" description:"Path to config file"`
+//	}
+//
+//	func (f Flags) GetConfigPath() string {
+//		if f.Config == "" {
+//			return DefaultConfigPath
+//		}
+//
+//		return f.Config
+//	}
+//
+//	func (f Flags) IsExplicitConfigPath() bool {
+//		return f.Config != ""
+//	}
+//
+//	type Config struct {
+//		ServerAddress string `yaml:"server_address" env:"SERVER_ADDRESS" default:"localhost:8080"`
+//		TLS           config.TLS `yaml:",inline"`
+//	}
+//
+//	func (c *Config) Validate() error {
+//		if _, _, err := net.SplitHostPort(c.ServerAddress); err != nil {
+//			return errors.Wrapf(err, "invalid server address: %s", c.ServerAddress)
+//		}
+//
+//		if err := c.TLS.Validate(); err != nil {
+//			return errors.WithStack(err)
+//		}
+//
+//		return nil
+//	}
+//
+//	func main() {
+//		var flags Flags
+//		if err := config.ParseFlags(&flags); err != nil {
+//			log.Fatalf("error parsing flags: %v", err)
+//		}
+//
+//		var cfg Config
+//		if err := config.Load(&cfg, config.LoadOptions{Flags: flags, EnvOptions: config.EnvOptions{}}); err != nil {
+//			log.Fatalf("error loading config: %v", err)
+//		}
+//
+//		tlsCfg, err := cfg.TLS.MakeConfig("icinga.com")
+//		if err != nil {
+//			log.Fatalf("error creating TLS config: %v", err)
+//		}
+//
+//		// ...
+//	}
+func Load(v Validator, options LoadOptions) error {
+	if err := validateNonNilStructPointer(v); err != nil {
+		return errors.WithStack(err)
+	}
+
+	if err := FromYAMLFile(options.Flags.GetConfigPath(), v); err != nil {
+		// Allow continuation with FromEnv by handling:
+		//
+		// - ErrInvalidConfiguration:
+		//   The configuration may be incomplete and will be revalidated in FromEnv.
+		//
+		// - Non-existent file errors:
+		//   If no explicit config path is set, fallback to environment variables is allowed.
+		configIsInvalid := errors.Is(err, ErrInvalidConfiguration)
+		configFileDoesNotExist := errors.Is(err, fs.ErrNotExist) && !options.Flags.IsExplicitConfigPath()
+		if !(configIsInvalid || configFileDoesNotExist) {
+			return errors.WithStack(err)
+		}
+	}
+
+	// Call FromEnv regardless of the outcome from FromYAMLFile.
+	// If no environment variables are set, configuration relies entirely on YAML.
+	// Otherwise, environment variables can supplement, override YAML settings, or serve as the sole source.
+	// FromEnv also includes validation, ensuring completeness after considering both sources.
+	if err := FromEnv(v, options.EnvOptions); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
 // ParseFlags parses CLI flags and stores the result
 // in the value pointed to by v. If v is nil or not a struct pointer,
 // ParseFlags returns an [ErrInvalidArgument] error.