feat: config rework (#2)

Author: james-d-elliott

config.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+
+	"authelia.com/tools/ac/consts"
+)
+
+func newConfigCmd(ctx *cmdctx) (cmd *cobra.Command) {
+	cmd = &cobra.Command{
+		Use:   "config",
+		Short: "Perform Config operations",
+	}
+
+	cmd.AddCommand(newConfigGenerateCmd(ctx))
+
+	return cmd
+}
+
+func newConfigGenerateCmd(ctx *cmdctx) (cmd *cobra.Command) {
+	cmd = &cobra.Command{
+		Use:   "generate [path]",
+		Short: "Generate a config from the templates",
+		Args:  cobra.MaximumNArgs(1),
+		RunE:  ctx.handleConfigGenerateRunE,
+	}
+
+	return cmd
+}
+
+func (ctx *cmdctx) handleConfigGenerateRunE(cmd *cobra.Command, args []string) (err error) {
+	var pathOut string
+
+	if pathOut, err = ctx.getConfigPathSingle(cmd, args); err != nil {
+		switch {
+		case errors.Is(err, errConfigNoPath), errors.Is(err, errConfigPathMoreThanOne):
+			return fmt.Errorf("error generating config: %w: specifying a path argument will avoid this error", err)
+		default:
+			return err
+		}
+	}
+
+	var (
+		f    *os.File
+		data []byte
+	)
+
+	switch ext := filepath.Ext(pathOut); ext {
+	case ".json":
+		if data, err = internalFS.ReadFile(path.Join("embed", "config", "config.json")); err != nil {
+			return err
+		}
+	case ".yml", ".yaml":
+		if data, err = internalFS.ReadFile(path.Join("embed", "config", "config.yaml")); err != nil {
+			return err
+		}
+	case ".tml", ".toml":
+		if data, err = internalFS.ReadFile(path.Join("embed", "config", "config.toml")); err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("error generating config: extension '%s' for file '%s' is not supported", ext, pathOut)
+	}
+
+	if f, err = os.OpenFile(pathOut, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0640); err != nil {
+		return err
+	}
+
+	defer f.Close()
+
+	if _, err = f.Write(data); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (ctx *cmdctx) getConfigPathSingle(cmd *cobra.Command, args []string) (path string, err error) {
+	if len(args) == 1 {
+		return args[0], nil
+	}
+
+	var configs []string
+
+	if configs, err = cmd.Flags().GetStringSlice(consts.Config); err != nil {
+		return "", err
+	}
+
+	switch len(configs) {
+	case 0:
+		return "", errConfigNoPath
+	case 1:
+		return configs[0], nil
+	default:
+		return "", errConfigPathMoreThanOne
+	}
+}
+
+var (
+	errConfigPathMoreThanOne = fmt.Errorf("error determining config output path: nore than one config path specified")
+	errConfigNoPath          = fmt.Errorf("error determining config output path: no config paths specified")
+)

config/config.go

@@ -0,0 +1,62 @@
+package config
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/knadh/koanf/parsers/toml"
+	"github.com/knadh/koanf/parsers/yaml"
+	"github.com/knadh/koanf/providers/confmap"
+	"github.com/knadh/koanf/providers/file"
+	"github.com/knadh/koanf/providers/posflag"
+	"github.com/knadh/koanf/v2"
+	"github.com/spf13/pflag"
+)
+
+func Load(paths []string, flags *pflag.FlagSet, flagsPrefix string) (config *Configuration, err error) {
+	ko := koanf.New(".")
+
+	kdefault := confmap.Provider(defaultConfig, ".")
+
+	if err = ko.Load(kdefault, nil); err != nil {
+		return nil, fmt.Errorf("error occurred loading default configuration: %w", err)
+	}
+
+	for _, path := range paths {
+		provider := file.Provider(path)
+
+		switch ext := filepath.Ext(path); ext {
+		case ".yaml", ".yml", ".json":
+			if err = ko.Load(provider, yaml.Parser()); err != nil {
+				return nil, fmt.Errorf("error occurred loading file configuration: %w", err)
+			}
+		case ".tml", ".toml":
+			if err = ko.Load(provider, toml.Parser()); err != nil {
+				return nil, fmt.Errorf("error occurred loading file configuration: %w", err)
+			}
+		default:
+			return nil, fmt.Errorf("error occurred loading file configuration: extension '%s' for file '%s' is not supported", ext, path)
+		}
+	}
+
+	kflags := posflag.ProviderWithFlag(flags, ".", ko, configCallbackPosFlag(flagsPrefix))
+
+	if err = ko.Load(kflags, nil); err != nil {
+		return nil, fmt.Errorf("error occurred loading flags configuration: %w", err)
+	}
+
+	config = &Configuration{}
+
+	if err = Unmarshal(ko, config); err != nil {
+		return nil, fmt.Errorf("error occurred unmarshalling configuration: %w", err)
+	}
+
+	return config, nil
+}
+
+var (
+	defaultConfig = map[string]any{
+		"server.port": 9019,
+		"storage":     "storage.yml",
+	}
+)

config/const.go

@@ -0,0 +1,6 @@
+package config
+
+const (
+	errFmtRequiredOptionOAuth2Bearer = "error validating configuration: oauth2: bearer: the '%s' value is required"
+	errFmtNotKnownOptionOAuth2Bearer = "error validating configuration: oauth2: bearer: the '%s' value of '%s' is not known"
+)

config_hook.go renamed to config/hook.go

@@ -1,12 +1,12 @@
-package main
+package config
 
 import (
 	"fmt"
 	"net/url"
 	"reflect"
 	"strings"
 
-	"github.com/mitchellh/mapstructure"
+	"github.com/go-viper/mapstructure/v2"
 	"github.com/spf13/pflag"
 )
 

koanf.go renamed to config/koanf.go

@@ -1,11 +1,11 @@
-package main
+package config
 
 import (
+	"github.com/go-viper/mapstructure/v2"
 	"github.com/knadh/koanf/v2"
-	"github.com/mitchellh/mapstructure"
 )
 
-func koUnmarshal(ko *koanf.Koanf, data any) (err error) {
+func Unmarshal(ko *koanf.Koanf, data any) (err error) {
 	c := koanf.UnmarshalConf{
 		DecoderConfig: &mapstructure.DecoderConfig{
 			DecodeHook: mapstructure.ComposeDecodeHookFunc(

config_schema.go renamed to config/schema.go

@@ -1,20 +1,25 @@
-package main
+package config
 
 import (
 	"net/url"
 )
 
-type Schema struct {
-	AutheliaURL *url.URL     `koanf:"authelia_url"`
-	Storage     string       `koanf:"storage"`
-	OAuth2      SchemaOAuth2 `koanf:"oauth2"`
+type Configuration struct {
+	AutheliaURL *url.URL `koanf:"authelia_url"`
+	Storage     string   `koanf:"storage"`
+	OAuth2      OAuth2   `koanf:"oauth2"`
+	Server      Server   `koanf:"server"`
 }
 
-type SchemaOAuth2 struct {
-	Bearer SchemaOAuth2Bearer `koanf:"bearer"`
+type Server struct {
+	Port uint16 `koanf:"port"`
 }
 
-type SchemaOAuth2Bearer struct {
+type OAuth2 struct {
+	Bearer OAuth2Bearer `koanf:"bearer"`
+}
+
+type OAuth2Bearer struct {
 	ID                      string   `koanf:"id"`
 	Secret                  string   `koanf:"secret"`
 	PAR                     bool     `koanf:"par"`

config/validate.go

@@ -0,0 +1,53 @@
+package config
+
+import (
+	"fmt"
+
+	"authelia.com/tools/ac/consts"
+)
+
+func (config *Configuration) Validate() (err error) {
+	if config.AutheliaURL == nil {
+		return fmt.Errorf("error validating configuration: the 'authelia_url' value is required")
+	}
+
+	if len(config.Storage) == 0 {
+		return fmt.Errorf("error validating configuration: the 'storage' value is required")
+	}
+
+	return nil
+}
+
+func (config *OAuth2Bearer) Validate() (err error) {
+	if len(config.ID) == 0 {
+		return fmt.Errorf(errFmtRequiredOptionOAuth2Bearer, consts.ID)
+	}
+
+	if len(config.Secret) == 0 {
+		return fmt.Errorf(errFmtRequiredOptionOAuth2Bearer, consts.Secret)
+	}
+
+	if len(config.Scope) == 0 {
+		return fmt.Errorf(errFmtRequiredOptionOAuth2Bearer, consts.Scope)
+	}
+
+	switch config.GrantType {
+	case "":
+		return fmt.Errorf(errFmtRequiredOptionOAuth2Bearer, consts.GrantType)
+	case consts.AuthorizationCode, consts.RefreshToken, consts.ClientCredentials:
+		break
+	default:
+		return fmt.Errorf(errFmtNotKnownOptionOAuth2Bearer, consts.GrantType, config.GrantType)
+	}
+
+	switch config.TokenEndpointAuthMethod {
+	case "":
+		return fmt.Errorf(errFmtRequiredOptionOAuth2Bearer, consts.TokenEndpointAuthMethod)
+	case consts.ClientSecretPost, consts.ClientSecretBasic:
+		break
+	default:
+		return fmt.Errorf(errFmtNotKnownOptionOAuth2Bearer, consts.TokenEndpointAuthMethod, config.TokenEndpointAuthMethod)
+	}
+
+	return nil
+}