555 lines
18 KiB
Go
555 lines
18 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"git.myservermanager.com/varakh/upda/util"
|
|
"github.com/adrg/xdg"
|
|
"go.uber.org/zap"
|
|
"go.uber.org/zap/zapcore"
|
|
"gorm.io/driver/postgres"
|
|
"gorm.io/driver/sqlite"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/logger"
|
|
"log"
|
|
"moul.io/zapgorm2"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type appConfig struct {
|
|
timeZone string
|
|
isDevelopment bool
|
|
isDebug bool
|
|
}
|
|
|
|
type webConfig struct {
|
|
title string
|
|
apiUrl string
|
|
}
|
|
|
|
type serverConfig struct {
|
|
port int
|
|
listen string
|
|
tlsEnabled bool
|
|
tlsCertPath string
|
|
tlsKeyPath string
|
|
timeout time.Duration
|
|
corsAllowCredentials bool
|
|
corsAllowOrigins []string
|
|
corsAllowMethods []string
|
|
corsAllowHeaders []string
|
|
corsExposeHeaders []string
|
|
}
|
|
|
|
type authConfig struct {
|
|
authMethod string
|
|
basicAuthUser string
|
|
basicAuthPassword string
|
|
basicAuthCredentials map[string]string
|
|
}
|
|
|
|
type taskConfig struct {
|
|
updateCleanStaleEnabled bool
|
|
updateCleanStaleInterval time.Duration
|
|
updateCleanStaleMaxAge time.Duration
|
|
eventCleanStaleEnabled bool
|
|
eventCleanStaleInterval time.Duration
|
|
eventCleanStaleMaxAge time.Duration
|
|
actionsEnqueueEnabled bool
|
|
actionsEnqueueInterval time.Duration
|
|
actionsEnqueueBatchSize int
|
|
actionsInvokeEnabled bool
|
|
actionsInvokeInterval time.Duration
|
|
actionsInvokeBatchSize int
|
|
actionsInvokeMaxRetries int
|
|
actionsCleanStaleEnabled bool
|
|
actionsCleanStaleInterval time.Duration
|
|
actionsCleanStaleMaxAge time.Duration
|
|
prometheusRefreshInterval time.Duration
|
|
}
|
|
|
|
type lockConfig struct {
|
|
redisEnabled bool
|
|
redisUrl string
|
|
}
|
|
|
|
type webhookConfig struct {
|
|
tokenLength int
|
|
}
|
|
|
|
type prometheusConfig struct {
|
|
enabled bool
|
|
path string
|
|
secureTokenEnabled bool
|
|
secureToken string
|
|
}
|
|
|
|
type Environment struct {
|
|
appConfig *appConfig
|
|
webConfig *webConfig
|
|
authConfig *authConfig
|
|
serverConfig *serverConfig
|
|
taskConfig *taskConfig
|
|
lockConfig *lockConfig
|
|
webhookConfig *webhookConfig
|
|
prometheusConfig *prometheusConfig
|
|
db *gorm.DB
|
|
}
|
|
|
|
func bootstrapEnvironment() *Environment {
|
|
var err error
|
|
|
|
// bootstrap logging (configured independently and required before any other action)
|
|
loggingLevel := os.Getenv(envLoggingLevel)
|
|
if loggingLevel == "" {
|
|
if err = os.Setenv(envLoggingLevel, loggingLevelDefault); err != nil {
|
|
log.Fatalf("Cannot set logging level: %v", err)
|
|
}
|
|
loggingLevel = os.Getenv(envLoggingLevel)
|
|
}
|
|
var level zap.AtomicLevel
|
|
if level, err = zap.ParseAtomicLevel(loggingLevel); err != nil {
|
|
log.Fatalf("Cannot parse logging level: %v", err)
|
|
}
|
|
loggingEncoding := os.Getenv(envLoggingEncoding)
|
|
if loggingEncoding == "" {
|
|
if err = os.Setenv(envLoggingEncoding, loggingEncodingDefault); err != nil {
|
|
log.Fatalf("Cannot set logging encoding: %v", err)
|
|
}
|
|
loggingEncoding = os.Getenv(envLoggingEncoding)
|
|
}
|
|
if loggingEncoding != "json" && loggingEncoding != "console" {
|
|
log.Fatalf("Cannot parse logging level: %v", errors.New("only 'json' and 'console' are allowed logging encodings"))
|
|
}
|
|
isDebug := level.Level() == zap.DebugLevel
|
|
isDevelopment := os.Getenv(envDevelopment) == "true"
|
|
var loggingEncoderConfig zapcore.EncoderConfig
|
|
if loggingEncoding == "json" {
|
|
loggingEncoderConfig = zap.NewProductionEncoderConfig()
|
|
} else {
|
|
loggingEncoderConfig = zap.NewDevelopmentEncoderConfig()
|
|
}
|
|
|
|
logPaths := []string{"stderr"}
|
|
loggingDirectory := os.Getenv(envLoggingDirectory)
|
|
|
|
if loggingDirectory != "" {
|
|
logFile := filepath.Join(loggingDirectory, loggingFileNameDefault)
|
|
|
|
if err = util.CreateFileWithParent(logFile); err != nil {
|
|
log.Fatalf("Log file '%s' cannot be created: %v", loggingDirectory, err)
|
|
}
|
|
|
|
logPaths = append(logPaths, logFile)
|
|
}
|
|
|
|
var zapConfig *zap.Config
|
|
if isDebug {
|
|
zapConfig = &zap.Config{
|
|
Level: level,
|
|
Development: isDevelopment,
|
|
Encoding: loggingEncoding,
|
|
EncoderConfig: loggingEncoderConfig,
|
|
OutputPaths: logPaths,
|
|
ErrorOutputPaths: logPaths,
|
|
}
|
|
} else {
|
|
zapConfig = &zap.Config{
|
|
Level: level,
|
|
Development: isDevelopment,
|
|
Sampling: &zap.SamplingConfig{
|
|
Initial: 100,
|
|
Thereafter: 100,
|
|
},
|
|
Encoding: loggingEncoding,
|
|
EncoderConfig: loggingEncoderConfig,
|
|
OutputPaths: logPaths,
|
|
ErrorOutputPaths: logPaths,
|
|
}
|
|
}
|
|
|
|
zapLogger := zap.Must(zapConfig.Build())
|
|
defer func(zapLogger *zap.Logger) {
|
|
_ = zapLogger.Sync()
|
|
}(zapLogger)
|
|
zap.ReplaceGlobals(zapLogger)
|
|
|
|
// assign defaults from given environment variables and validate
|
|
bootstrapFromEnvironmentAndValidate()
|
|
|
|
// parse environment variables in actual configuration structs
|
|
// app config
|
|
ac := &appConfig{
|
|
timeZone: os.Getenv(envTZ),
|
|
isDebug: isDebug,
|
|
isDevelopment: isDevelopment,
|
|
}
|
|
|
|
// web config
|
|
var webC *webConfig
|
|
webC = &webConfig{
|
|
title: os.Getenv(envWebTitle),
|
|
apiUrl: os.Getenv(envWebApiUrl),
|
|
}
|
|
|
|
// server config
|
|
var sc *serverConfig
|
|
|
|
var serverPort int
|
|
if serverPort, err = strconv.Atoi(os.Getenv(envServerPort)); err != nil {
|
|
zap.L().Sugar().Fatalf("Invalid server port. Reason: %v", err)
|
|
}
|
|
|
|
serverTlsEnabled := os.Getenv(envServerTlsEnabled) == "true"
|
|
|
|
if serverTlsEnabled {
|
|
failIfEnvKeyNotPresent(envServerTlsCertPath)
|
|
failIfEnvKeyNotPresent(envServerTlsKeyPath)
|
|
}
|
|
|
|
var serverTimeout time.Duration
|
|
var errParse error
|
|
if serverTimeout, errParse = time.ParseDuration(os.Getenv(envServerTimeout)); errParse != nil {
|
|
zap.L().Sugar().Fatalf("Could not parse timeout. Reason: %s", errParse.Error())
|
|
}
|
|
|
|
sc = &serverConfig{
|
|
port: serverPort,
|
|
timeout: serverTimeout,
|
|
listen: os.Getenv(envServerListen),
|
|
tlsEnabled: serverTlsEnabled,
|
|
tlsCertPath: os.Getenv(envServerTlsCertPath),
|
|
tlsKeyPath: os.Getenv(envServerTlsKeyPath),
|
|
corsAllowCredentials: os.Getenv(envCorsAllowCredentials) == "true",
|
|
corsExposeHeaders: []string{os.Getenv(envCorsExposeHeaders)},
|
|
corsAllowOrigins: []string{os.Getenv(envCorsAllowOrigins)},
|
|
corsAllowMethods: []string{os.Getenv(envCorsAllowMethods)},
|
|
corsAllowHeaders: []string{os.Getenv(envCorsAllowHeaders)},
|
|
}
|
|
|
|
authMode := os.Getenv(envAuthMode)
|
|
|
|
if authMode != authModeBasicSingle && authMode != authModeBasicCredentials {
|
|
zap.L().Sugar().Fatalln("Invalid auth mode. Reason: must be one of ['basic_single','basic_credentials'")
|
|
}
|
|
|
|
authC := &authConfig{
|
|
authMethod: authMode,
|
|
}
|
|
|
|
if authModeBasicSingle == authMode {
|
|
failIfEnvKeyNotPresent(envBasicAuthUser)
|
|
failIfEnvKeyNotPresent(envBasicAuthPassword)
|
|
authC.basicAuthUser = os.Getenv(envBasicAuthUser)
|
|
authC.basicAuthPassword = os.Getenv(envBasicAuthPassword)
|
|
}
|
|
if authModeBasicCredentials == authMode {
|
|
failIfEnvKeyNotPresent(envBasicAuthCredentials)
|
|
authC.basicAuthCredentials = parseBasicAuthCredentials(envBasicAuthCredentials)
|
|
}
|
|
|
|
// task config
|
|
var tc *taskConfig
|
|
|
|
updateCleanStaleInterval := parseDuration(envTaskUpdateCleanStaleInterval)
|
|
updateCleanStaleMaxAge := parseDuration(envTaskUpdateCleanStaleMaxAge)
|
|
eventCleanStaleMaxAge := parseDuration(envTaskEventCleanStaleMaxAge)
|
|
actionsCleanStaleMaxAge := parseDuration(envTaskActionsCleanStaleMaxAge)
|
|
eventCleanStaleInterval := parseDuration(envTaskEventCleanStaleInterval)
|
|
actionsEnqueueInterval := parseDuration(envTaskActionsEnqueueInterval)
|
|
actionsInvokeInterval := parseDuration(envTaskActionsInvokeInterval)
|
|
actionsCleanStaleInterval := parseDuration(envTaskActionsCleanStaleInterval)
|
|
prometheusRefreshInterval := parseDuration(envTaskPrometheusRefreshInterval)
|
|
|
|
var actionsEnqueueBatchSize int
|
|
if actionsEnqueueBatchSize, err = strconv.Atoi(os.Getenv(envTaskActionsEnqueueBatchSize)); err != nil {
|
|
zap.L().Sugar().Fatalf("Invalid actions enqueue batch size. Reason: %v", err)
|
|
}
|
|
if actionsEnqueueBatchSize <= 0 {
|
|
zap.L().Sugar().Fatalf("Invalid actions enqueue batch size, must be a positive number.")
|
|
}
|
|
|
|
var actionsInvokeBatchSize int
|
|
if actionsInvokeBatchSize, err = strconv.Atoi(os.Getenv(envTaskActionsInvokeBatchSize)); err != nil {
|
|
zap.L().Sugar().Fatalf("Invalid actions invoke batch size. Reason: %v", err)
|
|
}
|
|
if actionsInvokeBatchSize <= 0 {
|
|
zap.L().Sugar().Fatalf("Invalid actions invoke batch size, must be a positive number.")
|
|
}
|
|
|
|
var actionsInvokeMaxRetries int
|
|
if actionsInvokeMaxRetries, err = strconv.Atoi(os.Getenv(envTaskActionsInvokeMaxRetries)); err != nil {
|
|
zap.L().Sugar().Fatalf("Invalid actions invoke max retries. Reason: %v", err)
|
|
}
|
|
if actionsInvokeMaxRetries <= 0 {
|
|
zap.L().Sugar().Fatalf("Invalid actions invoke max retries, must be a positive number.")
|
|
}
|
|
|
|
tc = &taskConfig{
|
|
updateCleanStaleEnabled: os.Getenv(envTaskUpdateCleanStaleEnabled) == "true",
|
|
updateCleanStaleInterval: updateCleanStaleInterval,
|
|
updateCleanStaleMaxAge: updateCleanStaleMaxAge,
|
|
eventCleanStaleEnabled: os.Getenv(envTaskEventCleanStaleEnabled) == "true",
|
|
eventCleanStaleInterval: eventCleanStaleInterval,
|
|
eventCleanStaleMaxAge: eventCleanStaleMaxAge,
|
|
actionsEnqueueEnabled: os.Getenv(envTaskActionsEnqueueEnabled) == "true",
|
|
actionsEnqueueInterval: actionsEnqueueInterval,
|
|
actionsEnqueueBatchSize: actionsEnqueueBatchSize,
|
|
actionsInvokeEnabled: os.Getenv(envTaskActionsInvokeEnabled) == "true",
|
|
actionsInvokeInterval: actionsInvokeInterval,
|
|
actionsInvokeBatchSize: actionsInvokeBatchSize,
|
|
actionsInvokeMaxRetries: actionsInvokeMaxRetries,
|
|
actionsCleanStaleEnabled: os.Getenv(envTaskActionsCleanStaleEnabled) == "true",
|
|
actionsCleanStaleInterval: actionsCleanStaleInterval,
|
|
actionsCleanStaleMaxAge: actionsCleanStaleMaxAge,
|
|
prometheusRefreshInterval: prometheusRefreshInterval,
|
|
}
|
|
|
|
var lc *lockConfig
|
|
lc = &lockConfig{
|
|
redisEnabled: os.Getenv(envLockRedisEnabled) == "true",
|
|
redisUrl: os.Getenv(envLockRedisUrl),
|
|
}
|
|
|
|
webhookTokenLength := 32
|
|
if webhookTokenLength, err = strconv.Atoi(os.Getenv(envWebhooksTokenLength)); err != nil {
|
|
zap.L().Sugar().Fatalf("Invalid webhook token length. Reason: %v", err)
|
|
}
|
|
if webhookTokenLength <= 0 {
|
|
zap.L().Sugar().Fatalln("Invalid webhook token length. Reason: must be a positive number")
|
|
}
|
|
|
|
wc := &webhookConfig{
|
|
tokenLength: webhookTokenLength,
|
|
}
|
|
|
|
pc := &prometheusConfig{
|
|
enabled: os.Getenv(envPrometheusEnabled) == "true",
|
|
path: os.Getenv(envPrometheusMetricsPath),
|
|
secureTokenEnabled: os.Getenv(envPrometheusSecureTokenEnabled) == "true",
|
|
secureToken: os.Getenv(envPrometheusSecureToken),
|
|
}
|
|
|
|
if pc.enabled && pc.secureTokenEnabled {
|
|
failIfEnvKeyNotPresent(envPrometheusSecureToken)
|
|
}
|
|
|
|
// database setup
|
|
gormConfig := &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)}
|
|
if isDebug && isDevelopment {
|
|
gormZapLogger := zap.Must(zapConfig.Build())
|
|
defer func(gormZapLogger *zap.Logger) {
|
|
_ = gormZapLogger.Sync()
|
|
}(gormZapLogger)
|
|
gormLogger := zapgorm2.New(gormZapLogger)
|
|
gormConfig = &gorm.Config{Logger: gormLogger}
|
|
}
|
|
|
|
var db *gorm.DB
|
|
zap.L().Sugar().Infof("Using database type '%s'", os.Getenv(envDbType))
|
|
|
|
if os.Getenv(envDbType) == dbTypeSqlite {
|
|
if os.Getenv(envDbSqliteFile) == "" {
|
|
var defaultDbFile string
|
|
if defaultDbFile, err = xdg.DataFile(name + "/" + dbTypeSqliteDbNameDefault); err != nil {
|
|
zap.L().Sugar().Fatalf("Database file '%s' could not be created. Reason: %v", defaultDbFile, err)
|
|
}
|
|
setEnvKeyDefault(envDbSqliteFile, defaultDbFile)
|
|
}
|
|
|
|
dbFile := os.Getenv(envDbSqliteFile)
|
|
zap.L().Sugar().Infof("Using database file '%s'", dbFile)
|
|
|
|
if err = util.CreateFileWithParent(dbFile); err != nil {
|
|
zap.L().Sugar().Fatalf("Database file '%s' cannot be created: %v", dbFile, err)
|
|
}
|
|
|
|
if db, err = gorm.Open(sqlite.Open(dbFile), gormConfig); err != nil {
|
|
zap.L().Sugar().Fatalf("Could not setup database: %v", err)
|
|
}
|
|
|
|
if res := db.Exec("PRAGMA foreign_keys = ON"); res.Error != nil {
|
|
zap.L().Sugar().Fatalf("Could not execute foreign key for SQLite: %v", res.Error)
|
|
}
|
|
|
|
sqlDb, _ := db.DB()
|
|
sqlDb.SetMaxOpenConns(1)
|
|
zap.L().Sugar().Infof("SQLite: restricting max connections to '1'")
|
|
} else if os.Getenv(envDbType) == dbTypePostgres {
|
|
host := os.Getenv(envDbPostgresHost)
|
|
port := os.Getenv(envDbPostgresPort)
|
|
dbUser := os.Getenv(envDbPostgresUser)
|
|
dbPass := os.Getenv(envDbPostgresPassword)
|
|
dbName := os.Getenv(envDbPostgresName)
|
|
dbTZ := os.Getenv(envDbPostgresTimeZone)
|
|
|
|
if host == "" || port == "" || dbUser == "" || dbPass == "" || dbName == "" || dbTZ == "" {
|
|
zap.L().Sugar().Fatalf("Some configuration for database type '%s' is missing", os.Getenv(envDbType))
|
|
}
|
|
|
|
dsn := fmt.Sprintf("host=%v user=%v password=%v dbname=%v port=%v sslmode=disable TimeZone=%v", host, dbUser, dbPass, dbName, port, dbTZ)
|
|
if db, err = gorm.Open(postgres.Open(dsn), gormConfig); err != nil {
|
|
zap.L().Sugar().Fatalf("Could not setup database: %v", err)
|
|
}
|
|
} else {
|
|
zap.L().Sugar().Fatalf("Database type '%s' or '%s' is required", dbTypeSqlite, dbTypePostgres)
|
|
}
|
|
|
|
if db == nil {
|
|
zap.L().Sugar().Fatalf("Could not setup database")
|
|
}
|
|
|
|
env := &Environment{appConfig: ac,
|
|
webConfig: webC,
|
|
authConfig: authC,
|
|
serverConfig: sc,
|
|
taskConfig: tc,
|
|
lockConfig: lc,
|
|
webhookConfig: wc,
|
|
prometheusConfig: pc,
|
|
db: db}
|
|
|
|
if err = env.db.AutoMigrate(&Update{}, &Webhook{}, &Event{}, &Secret{}, &Action{}, &ActionInvocation{}); err != nil {
|
|
zap.L().Sugar().Fatalf("Could not migrate database schema: %s", err)
|
|
}
|
|
|
|
zap.L().Sugar().Infof("appConfig %+v", env.appConfig)
|
|
zap.L().Sugar().Infof("serverConfig %+v", env.serverConfig)
|
|
zap.L().Sugar().Infof("taskConfig %+v", env.taskConfig)
|
|
zap.L().Sugar().Infof("webhookConfig %+v", env.webhookConfig)
|
|
|
|
return env
|
|
}
|
|
|
|
func bootstrapFromEnvironmentAndValidate() {
|
|
failIfEnvKeyNotPresent(envSecret)
|
|
|
|
// auth mode
|
|
setEnvKeyDefault(envAuthMode, authModeDefault)
|
|
|
|
// app
|
|
setEnvKeyDefault(envTZ, tzDefault)
|
|
|
|
// web
|
|
setEnvKeyDefault(envWebTitle, webTitleDefault)
|
|
setEnvKeyDefault(envWebApiUrl, webApiUrlDefault)
|
|
|
|
// webhook
|
|
setEnvKeyDefault(envWebhooksTokenLength, webhooksTokenLengthDefault)
|
|
|
|
// lock
|
|
setEnvKeyDefault(envLockRedisEnabled, redisEnabledDefault)
|
|
|
|
// task
|
|
setEnvKeyDefault(envTaskUpdateCleanStaleEnabled, taskUpdateCleanStaleEnabledDefault)
|
|
setEnvKeyDefault(envTaskUpdateCleanStaleInterval, taskUpdateCleanStaleIntervalDefault)
|
|
setEnvKeyDefault(envTaskUpdateCleanStaleMaxAge, taskUpdateCleanStaleMaxAgeDefault)
|
|
|
|
setEnvKeyDefault(envTaskEventCleanStaleEnabled, taskEventCleanStaleEnabledDefault)
|
|
setEnvKeyDefault(envTaskEventCleanStaleInterval, taskEventCleanStaleIntervalDefault)
|
|
setEnvKeyDefault(envTaskEventCleanStaleMaxAge, taskEventCleanStaleMaxAgeDefault)
|
|
|
|
setEnvKeyDefault(envTaskActionsEnqueueEnabled, taskActionsEnqueueEnabledDefault)
|
|
setEnvKeyDefault(envTaskActionsEnqueueInterval, taskActionsEnqueueIntervalDefault)
|
|
setEnvKeyDefault(envTaskActionsEnqueueBatchSize, taskActionsEnqueueBatchSizeDefault)
|
|
|
|
setEnvKeyDefault(envTaskActionsInvokeEnabled, taskActionsInvokeEnabledDefault)
|
|
setEnvKeyDefault(envTaskActionsInvokeInterval, taskActionsInvokeIntervalDefault)
|
|
setEnvKeyDefault(envTaskActionsInvokeBatchSize, taskActionsInvokeBatchSizeDefault)
|
|
setEnvKeyDefault(envTaskActionsInvokeMaxRetries, taskActionsInvokeMaxRetriesDefault)
|
|
|
|
setEnvKeyDefault(envTaskActionsCleanStaleEnabled, taskActionsCleanStaleEnabledDefault)
|
|
setEnvKeyDefault(envTaskActionsCleanStaleInterval, taskActionsCleanStaleIntervalDefault)
|
|
setEnvKeyDefault(envTaskActionsCleanStaleMaxAge, taskActionsCleanStaleMaxAgeDefault)
|
|
|
|
setEnvKeyDefault(envTaskPrometheusRefreshInterval, taskPrometheusRefreshDefault)
|
|
|
|
// prometheus
|
|
setEnvKeyDefault(envPrometheusEnabled, prometheusEnabledDefault)
|
|
setEnvKeyDefault(envPrometheusMetricsPath, prometheusMetricsPathDefault)
|
|
setEnvKeyDefault(envPrometheusSecureTokenEnabled, prometheusSecureTokenEnabledDefault)
|
|
|
|
// db
|
|
setEnvKeyDefault(envDbType, dbTypeSqlite)
|
|
|
|
if os.Getenv(envDbType) == dbTypePostgres {
|
|
setEnvKeyDefault(envDbPostgresHost, dbTypePostgresHostDefault)
|
|
setEnvKeyDefault(envDbPostgresPort, dbTypePostgresPortDefault)
|
|
setEnvKeyDefault(envDbPostgresTimeZone, dbTypePostgresTZDefault)
|
|
}
|
|
|
|
// server
|
|
setEnvKeyDefault(envServerPort, serverPortDefault)
|
|
setEnvKeyDefault(envServerListen, serverListenDefault)
|
|
setEnvKeyDefault(envServerTlsEnabled, serverTlsEnabledDefault)
|
|
setEnvKeyDefault(envCorsAllowOrigins, corsAllowOriginsDefault)
|
|
setEnvKeyDefault(envCorsAllowMethods, corsAllowMethodsDefault)
|
|
setEnvKeyDefault(envCorsAllowHeaders, corsAllowHeadersDefault)
|
|
setEnvKeyDefault(envCorsAllowCredentials, corsAllowCredentialsDefault)
|
|
setEnvKeyDefault(envCorsExposeHeaders, corsExposeHeadersDefault)
|
|
setEnvKeyDefault(envServerTimeout, serverTimeoutDefault)
|
|
}
|
|
|
|
func failIfEnvKeyNotPresent(key string) {
|
|
if os.Getenv(key) == "" {
|
|
zap.L().Sugar().Fatalf("Not all required ENV variables given. Please set '%s'", key)
|
|
}
|
|
}
|
|
|
|
func setEnvKeyDefault(key string, defaultValue string) {
|
|
var err error
|
|
if os.Getenv(key) == "" {
|
|
if err = os.Setenv(key, defaultValue); err != nil {
|
|
zap.L().Sugar().Fatalf("Could not set default value for ENV variable '%s'", key)
|
|
}
|
|
|
|
zap.L().Sugar().Infof("Set '%s' to '%s'", key, defaultValue)
|
|
}
|
|
}
|
|
|
|
func parseDuration(envProperty string) time.Duration {
|
|
var duration time.Duration
|
|
var err error
|
|
|
|
if duration, err = time.ParseDuration(os.Getenv(envProperty)); err != nil {
|
|
zap.L().Sugar().Fatalf("Could not parse duration for '%s'. Reason: %s", envProperty, err.Error())
|
|
}
|
|
|
|
return duration
|
|
}
|
|
|
|
func parseBasicAuthCredentials(envProperty string) map[string]string {
|
|
if envProperty == "" {
|
|
zap.L().Sugar().Fatalln("Invalid env for parsing basic auth credentials")
|
|
}
|
|
credentialsFromEnv := os.Getenv(envProperty)
|
|
|
|
var credentials []string
|
|
credentials = strings.Split(credentialsFromEnv, ",")
|
|
|
|
basicAuthCredentials := make(map[string]string)
|
|
|
|
for _, c := range credentials {
|
|
pair := strings.Split(c, "=")
|
|
|
|
if len(pair) != 2 {
|
|
zap.L().Sugar().Fatalln("Invalid basic auth credentials. Reason: credentials must be specified with the = separator per credential entry")
|
|
}
|
|
|
|
if pair[0] == "" {
|
|
zap.L().Sugar().Fatalln("Invalid basic auth credentials. Reason: username must not be blank")
|
|
}
|
|
|
|
if pair[1] == "" {
|
|
zap.L().Sugar().Fatalln("Invalid basic auth credentials. Reason: password must not be blank")
|
|
}
|
|
|
|
basicAuthCredentials[pair[0]] = pair[1]
|
|
}
|
|
|
|
return basicAuthCredentials
|
|
}
|