170 lines
3.2 KiB
Go
170 lines
3.2 KiB
Go
package config
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/url"
|
|
"os"
|
|
"reflect"
|
|
"strings"
|
|
|
|
env "github.com/Netflix/go-env"
|
|
log "github.com/sirupsen/logrus"
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
var cfg *Config
|
|
|
|
func Get() *Config {
|
|
if cfg == nil {
|
|
c := defaultConfig()
|
|
c.Setup()
|
|
cfg = c
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
func defaultConfig() *Config {
|
|
return &Config{
|
|
Debug: false,
|
|
Listen: ListenConfig{
|
|
HTTP: "0.0.0.0:9000",
|
|
HTTPS: "0.0.0.0:9443",
|
|
LDAP: "0.0.0.0:3389",
|
|
LDAPS: "0.0.0.0:6636",
|
|
Metrics: "0.0.0.0:9300",
|
|
Debug: "0.0.0.0:9900",
|
|
},
|
|
Paths: PathsConfig{
|
|
Media: "./media",
|
|
},
|
|
LogLevel: "info",
|
|
ErrorReporting: ErrorReportingConfig{
|
|
Enabled: false,
|
|
SampleRate: 1,
|
|
},
|
|
}
|
|
}
|
|
|
|
func (c *Config) Setup(paths ...string) {
|
|
for _, path := range paths {
|
|
err := c.LoadConfig(path)
|
|
if err != nil {
|
|
log.WithError(err).Info("failed to load config, skipping")
|
|
}
|
|
}
|
|
err := c.fromEnv()
|
|
if err != nil {
|
|
log.WithError(err).Info("failed to load env vars")
|
|
}
|
|
c.configureLogger()
|
|
}
|
|
|
|
func (c *Config) LoadConfig(path string) error {
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return nil
|
|
}
|
|
return fmt.Errorf("failed to load config file: %w", err)
|
|
}
|
|
err = yaml.Unmarshal(raw, c)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to parse YAML: %w", err)
|
|
}
|
|
c.walkScheme(c)
|
|
log.WithField("path", path).Debug("Loaded config")
|
|
return nil
|
|
}
|
|
|
|
func (c *Config) fromEnv() error {
|
|
_, err := env.UnmarshalFromEnviron(c)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to load environment variables: %w", err)
|
|
}
|
|
c.walkScheme(c)
|
|
log.Debug("Loaded config from environment")
|
|
return nil
|
|
}
|
|
|
|
func (c *Config) walkScheme(v interface{}) {
|
|
rv := reflect.ValueOf(v)
|
|
if rv.Kind() != reflect.Ptr || rv.IsNil() {
|
|
return
|
|
}
|
|
|
|
rv = rv.Elem()
|
|
if rv.Kind() != reflect.Struct {
|
|
return
|
|
}
|
|
|
|
t := rv.Type()
|
|
for i := 0; i < rv.NumField(); i++ {
|
|
valueField := rv.Field(i)
|
|
switch valueField.Kind() {
|
|
case reflect.Struct:
|
|
if !valueField.Addr().CanInterface() {
|
|
continue
|
|
}
|
|
|
|
iface := valueField.Addr().Interface()
|
|
c.walkScheme(iface)
|
|
}
|
|
|
|
typeField := t.Field(i)
|
|
if typeField.Type.Kind() != reflect.String {
|
|
continue
|
|
}
|
|
valueField.SetString(c.parseScheme(valueField.String()))
|
|
}
|
|
}
|
|
|
|
func (c *Config) parseScheme(rawVal string) string {
|
|
u, err := url.Parse(rawVal)
|
|
if err != nil {
|
|
return rawVal
|
|
}
|
|
if u.Scheme == "env" {
|
|
e, ok := os.LookupEnv(u.Host)
|
|
if ok {
|
|
return e
|
|
}
|
|
return u.RawQuery
|
|
} else if u.Scheme == "file" {
|
|
d, err := os.ReadFile(u.Path)
|
|
if err != nil {
|
|
return u.RawQuery
|
|
}
|
|
return string(d)
|
|
}
|
|
return rawVal
|
|
}
|
|
|
|
func (c *Config) configureLogger() {
|
|
switch strings.ToLower(c.LogLevel) {
|
|
case "trace":
|
|
log.SetLevel(log.TraceLevel)
|
|
case "debug":
|
|
log.SetLevel(log.DebugLevel)
|
|
case "info":
|
|
log.SetLevel(log.InfoLevel)
|
|
case "warning":
|
|
log.SetLevel(log.WarnLevel)
|
|
case "error":
|
|
log.SetLevel(log.ErrorLevel)
|
|
default:
|
|
log.SetLevel(log.DebugLevel)
|
|
}
|
|
|
|
fm := log.FieldMap{
|
|
log.FieldKeyMsg: "event",
|
|
log.FieldKeyTime: "timestamp",
|
|
}
|
|
|
|
if c.Debug {
|
|
log.SetFormatter(&log.TextFormatter{FieldMap: fm})
|
|
} else {
|
|
log.SetFormatter(&log.JSONFormatter{FieldMap: fm, DisableHTMLEscape: true})
|
|
}
|
|
}
|