feat: initial commit

internal/config/admin_server.go

@@ -0,0 +1,27 @@
+package config
+
+type AdminServerConfig struct {
+	HTTP HTTPConfig `yaml:"http"`
+	CORS CORSConfig `yaml:"cors"`
+	Auth AuthConfig `yaml:"auth"`
+}
+
+func NewDefaultAdminServerConfig() AdminServerConfig {
+	return AdminServerConfig{
+		HTTP: NewHTTPConfig("127.0.0.1", 8081),
+		CORS: NewDefaultCORSConfig(),
+		Auth: NewDefaultAuthConfig(),
+	}
+}
+
+type AuthConfig struct {
+	Issuer     InterpolatedString `yaml:"issuer"`
+	PrivateKey InterpolatedString `yaml:"privateKey"`
+}
+
+func NewDefaultAuthConfig() AuthConfig {
+	return AuthConfig{
+		Issuer:     "http://127.0.0.1:8081",
+		PrivateKey: "admin-key.json",
+	}
+}

internal/config/config.go

@@ -0,0 +1,64 @@
+package config
+
+import (
+	"io"
+	"io/ioutil"
+
+	"github.com/pkg/errors"
+	"gopkg.in/yaml.v3"
+)
+
+// Config definition
+type Config struct {
+	Admin  AdminServerConfig `yaml:"admin"`
+	Proxy  ProxyServerConfig `yaml:"proxy"`
+	Redis  RedisConfig       `yaml:"redis"`
+	Logger LoggerConfig      `yaml:"logger"`
+}
+
+// NewFromFile retrieves the configuration from the given file
+func NewFromFile(path string) (*Config, error) {
+	config := NewDefault()
+
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, errors.Wrapf(err, "could not read file '%s'", path)
+	}
+
+	if err := yaml.Unmarshal(data, config); err != nil {
+		return nil, errors.Wrapf(err, "could not unmarshal configuration")
+	}
+
+	return config, nil
+}
+
+// NewDumpDefault dump the new default configuration
+func NewDumpDefault() *Config {
+	config := NewDefault()
+
+	return config
+}
+
+// NewDefault return new default configuration
+func NewDefault() *Config {
+	return &Config{
+		Admin:  NewDefaultAdminServerConfig(),
+		Proxy:  NewDefaultProxyServerConfig(),
+		Logger: NewDefaultLoggerConfig(),
+		Redis:  NewDefaultRedisConfig(),
+	}
+}
+
+// Dump the given configuration in the given writer
+func Dump(config *Config, w io.Writer) error {
+	data, err := yaml.Marshal(config)
+	if err != nil {
+		return errors.Wrap(err, "could not dump config")
+	}
+
+	if _, err := w.Write(data); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}

internal/config/config_test.go

@@ -0,0 +1,16 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+)
+
+func TestConfigLoad(t *testing.T) {
+	filepath := "./testdata/config.yml"
+
+	_, err := NewFromFile(filepath)
+	if err != nil {
+		t.Fatal(errors.WithStack(err))
+	}
+}

internal/config/cors.go

@@ -0,0 +1,20 @@
+package config
+
+type CORSConfig struct {
+	AllowedOrigins   InterpolatedStringSlice `yaml:"allowedOrigins"`
+	AllowCredentials InterpolatedBool        `yaml:"allowCredentials"`
+	AllowedMethods   InterpolatedStringSlice `yaml:"allowMethods"`
+	AllowedHeaders   InterpolatedStringSlice `yaml:"allowedHeaders"`
+	Debug            InterpolatedBool        `yaml:"debug"`
+}
+
+// NewDefaultCorsConfig return the default CORS configuration.
+func NewDefaultCORSConfig() CORSConfig {
+	return CORSConfig{
+		AllowedOrigins:   InterpolatedStringSlice{"http://localhost:3001"},
+		AllowCredentials: true,
+		AllowedMethods:   InterpolatedStringSlice{"POST", "GET", "PUT", "DELETE"},
+		AllowedHeaders:   InterpolatedStringSlice{"Origin", "Accept", "Content-Type", "Authorization", "Sentry-Trace"},
+		Debug:            false,
+	}
+}

internal/config/environment.go

@@ -0,0 +1,125 @@
+package config
+
+import (
+	"os"
+	"regexp"
+	"strconv"
+
+	"github.com/pkg/errors"
+	"gopkg.in/yaml.v3"
+)
+
+var reVar = regexp.MustCompile(`^\${(\w+)}$`)
+
+type InterpolatedString string
+
+func (is *InterpolatedString) UnmarshalYAML(value *yaml.Node) error {
+	var str string
+
+	if err := value.Decode(&str); err != nil {
+		return errors.WithStack(err)
+	}
+
+	if match := reVar.FindStringSubmatch(str); len(match) > 0 {
+		*is = InterpolatedString(os.Getenv(match[1]))
+	} else {
+		*is = InterpolatedString(str)
+	}
+
+	return nil
+}
+
+type InterpolatedInt int
+
+func (ii *InterpolatedInt) UnmarshalYAML(value *yaml.Node) error {
+	var str string
+
+	if err := value.Decode(&str); err != nil {
+		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into string", value.Value, value.Line)
+	}
+
+	if match := reVar.FindStringSubmatch(str); len(match) > 0 {
+		str = os.Getenv(match[1])
+	}
+
+	intVal, err := strconv.ParseInt(str, 10, 32)
+	if err != nil {
+		return errors.Wrapf(err, "could not parse int '%v',  line '%d'", str, value.Line)
+	}
+
+	*ii = InterpolatedInt(int(intVal))
+
+	return nil
+}
+
+type InterpolatedBool bool
+
+func (ib *InterpolatedBool) UnmarshalYAML(value *yaml.Node) error {
+	var str string
+
+	if err := value.Decode(&str); err != nil {
+		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into string", value.Value, value.Line)
+	}
+
+	if match := reVar.FindStringSubmatch(str); len(match) > 0 {
+		str = os.Getenv(match[1])
+	}
+
+	boolVal, err := strconv.ParseBool(str)
+	if err != nil {
+		return errors.Wrapf(err, "could not parse bool '%v',  line '%d'", str, value.Line)
+	}
+
+	*ib = InterpolatedBool(boolVal)
+
+	return nil
+}
+
+type InterpolatedMap map[string]interface{}
+
+func (im *InterpolatedMap) UnmarshalYAML(value *yaml.Node) error {
+	var data map[string]interface{}
+
+	if err := value.Decode(&data); err != nil {
+		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into map", value.Value, value.Line)
+	}
+
+	for key, value := range data {
+		strVal, ok := value.(string)
+		if !ok {
+			continue
+		}
+
+		if match := reVar.FindStringSubmatch(strVal); len(match) > 0 {
+			strVal = os.Getenv(match[1])
+		}
+
+		data[key] = strVal
+	}
+
+	*im = data
+
+	return nil
+}
+
+type InterpolatedStringSlice []string
+
+func (iss *InterpolatedStringSlice) UnmarshalYAML(value *yaml.Node) error {
+	var data []string
+
+	if err := value.Decode(&data); err != nil {
+		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into map", value.Value, value.Line)
+	}
+
+	for index, value := range data {
+		if match := reVar.FindStringSubmatch(value); len(match) > 0 {
+			value = os.Getenv(match[1])
+		}
+
+		data[index] = value
+	}
+
+	*iss = data
+
+	return nil
+}

internal/config/http.go

@@ -0,0 +1,13 @@
+package config
+
+type HTTPConfig struct {
+	Host InterpolatedString `yaml:"host"`
+	Port InterpolatedInt    `yaml:"port"`
+}
+
+func NewHTTPConfig(host string, port int) HTTPConfig {
+	return HTTPConfig{
+		Host: InterpolatedString(host),
+		Port: InterpolatedInt(port),
+	}
+}

internal/config/logger.go

@@ -0,0 +1,15 @@
+package config
+
+import "gitlab.com/wpetit/goweb/logger"
+
+type LoggerConfig struct {
+	Level  InterpolatedInt    `yaml:"level"`
+	Format InterpolatedString `yaml:"format"`
+}
+
+func NewDefaultLoggerConfig() LoggerConfig {
+	return LoggerConfig{
+		Level:  InterpolatedInt(logger.LevelInfo),
+		Format: InterpolatedString(logger.FormatHuman),
+	}
+}

internal/config/proxy_server.go

@@ -0,0 +1,11 @@
+package config
+
+type ProxyServerConfig struct {
+	HTTP HTTPConfig `yaml:"http"`
+}
+
+func NewDefaultProxyServerConfig() ProxyServerConfig {
+	return ProxyServerConfig{
+		HTTP: NewHTTPConfig("0.0.0.0", 8080),
+	}
+}

internal/config/redis.go

@@ -0,0 +1,19 @@
+package config
+
+const (
+	RedisModeSimple   = "simple"
+	RedisModeSentinel = "sentinel"
+	RedisModeCluster  = "cluster"
+)
+
+type RedisConfig struct {
+	Adresses InterpolatedStringSlice `yaml:"addresses"`
+	Master   InterpolatedString      `yaml:"master"`
+}
+
+func NewDefaultRedisConfig() RedisConfig {
+	return RedisConfig{
+		Adresses: InterpolatedStringSlice{"localhost:6379"},
+		Master:   "",
+	}
+}

internal/config/testdata/config.yml

@@ -0,0 +1,6 @@
+logger:
+  level: 0
+  format: human
+http:
+  host: "0.0.0.0"
+  port: 3000