1
0
Fork 0
mirror of https://github.com/TwiN/gatus.git synced 2024-12-14 11:58:04 +00:00
twin-gatus/config/config.go

176 lines
5.2 KiB
Go
Raw Normal View History

2019-09-06 04:01:48 +00:00
package config
import (
2019-10-20 02:03:55 +00:00
"errors"
"github.com/TwinProduction/gatus/alerting"
"github.com/TwinProduction/gatus/alerting/provider"
2019-09-07 00:25:31 +00:00
"github.com/TwinProduction/gatus/core"
"github.com/TwinProduction/gatus/security"
2019-09-06 04:01:48 +00:00
"gopkg.in/yaml.v2"
"io/ioutil"
"log"
"os"
2019-09-06 04:01:48 +00:00
)
2020-06-26 01:31:34 +00:00
const (
2020-09-26 19:15:50 +00:00
// DefaultConfigurationFilePath is the default path that will be used to search for the configuration file
// if a custom path isn't configured through the GATUS_CONFIG_FILE environment variable
2020-06-26 01:31:34 +00:00
DefaultConfigurationFilePath = "config/config.yaml"
)
2019-09-06 04:01:48 +00:00
2019-10-20 02:03:55 +00:00
var (
ErrNoServiceInConfig = errors.New("configuration file should contain at least 1 service")
ErrConfigFileNotFound = errors.New("configuration file not found")
ErrConfigNotLoaded = errors.New("configuration is nil")
ErrInvalidSecurityConfig = errors.New("invalid security configuration")
config *Config
2019-10-20 02:03:55 +00:00
)
2019-09-06 04:01:48 +00:00
2020-09-26 19:15:50 +00:00
// Config is the main configuration structure
2020-06-26 01:31:34 +00:00
type Config struct {
Metrics bool `yaml:"metrics"`
Debug bool `yaml:"debug"`
Security *security.Config `yaml:"security"`
Alerting *alerting.Config `yaml:"alerting"`
Services []*core.Service `yaml:"services"`
2020-06-26 01:31:34 +00:00
}
2019-09-06 04:01:48 +00:00
func Get() *Config {
if config == nil {
panic(ErrConfigNotLoaded)
2019-09-06 04:01:48 +00:00
}
return config
}
func Load(configFile string) error {
log.Printf("[config][Load] Reading configuration from configFile=%s", configFile)
cfg, err := readConfigurationFile(configFile)
if err != nil {
if os.IsNotExist(err) {
return ErrConfigFileNotFound
} else {
return err
}
}
config = cfg
return nil
}
func LoadDefaultConfiguration() error {
2020-06-26 01:31:34 +00:00
err := Load(DefaultConfigurationFilePath)
if err != nil {
if err == ErrConfigFileNotFound {
return Load("config/config.yml")
}
return err
}
return nil
}
2019-10-20 02:03:55 +00:00
func readConfigurationFile(fileName string) (config *Config, err error) {
var bytes []byte
if bytes, err = ioutil.ReadFile(fileName); err == nil {
2019-10-20 01:39:31 +00:00
// file exists, so we'll parse it and return it
2019-10-20 02:03:55 +00:00
return parseAndValidateConfigBytes(bytes)
2019-09-06 04:01:48 +00:00
}
2019-10-20 02:03:55 +00:00
return
2019-09-06 04:01:48 +00:00
}
2019-10-20 02:03:55 +00:00
func parseAndValidateConfigBytes(yamlBytes []byte) (config *Config, err error) {
// Expand environment variables
yamlBytes = []byte(os.ExpandEnv(string(yamlBytes)))
// Parse configuration file
2019-10-20 01:42:03 +00:00
err = yaml.Unmarshal(yamlBytes, &config)
2019-10-20 02:03:55 +00:00
// Check if the configuration file at least has services.
if config == nil || config.Services == nil || len(config.Services) == 0 {
2019-10-20 02:03:55 +00:00
err = ErrNoServiceInConfig
} else {
validateAlertingConfig(config)
validateSecurityConfig(config)
validateServicesConfig(config)
2019-09-07 00:25:31 +00:00
}
2019-10-20 01:42:03 +00:00
return
2019-09-06 04:01:48 +00:00
}
func validateServicesConfig(config *Config) {
for _, service := range config.Services {
if config.Debug {
log.Printf("[config][validateServicesConfig] Validating service '%s'", service.Name)
}
service.ValidateAndSetDefaults()
}
log.Printf("[config][validateServicesConfig] Validated %d services", len(config.Services))
}
func validateSecurityConfig(config *Config) {
if config.Security != nil {
if config.Security.IsValid() {
if config.Debug {
log.Printf("[config][validateSecurityConfig] Basic security configuration has been validated")
}
} else {
// If there was an attempt to configure security, then it must mean that some confidential or private
// data are exposed. As a result, we'll force a panic because it's better to be safe than sorry.
panic(ErrInvalidSecurityConfig)
}
}
}
func validateAlertingConfig(config *Config) {
if config.Alerting == nil {
log.Printf("[config][validateAlertingConfig] Alerting is not configured")
return
}
alertTypes := []core.AlertType{
core.SlackAlert,
core.TwilioAlert,
core.PagerDutyAlert,
core.CustomAlert,
}
var validProviders, invalidProviders []core.AlertType
for _, alertType := range alertTypes {
alertProvider := GetAlertingProviderByAlertType(config, alertType)
if alertProvider != nil {
if alertProvider.IsValid() {
validProviders = append(validProviders, alertType)
} else {
log.Printf("[config][validateAlertingConfig] Ignoring provider=%s because configuration is invalid", alertType)
invalidProviders = append(invalidProviders, alertType)
}
} else {
invalidProviders = append(invalidProviders, alertType)
}
}
log.Printf("[config][validateAlertingConfig] configuredProviders=%s; ignoredProviders=%s", validProviders, invalidProviders)
}
func GetAlertingProviderByAlertType(config *Config, alertType core.AlertType) provider.AlertProvider {
switch alertType {
case core.SlackAlert:
if config.Alerting.Slack == nil {
// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
return nil
}
return config.Alerting.Slack
case core.TwilioAlert:
if config.Alerting.Twilio == nil {
// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
return nil
}
return config.Alerting.Twilio
case core.PagerDutyAlert:
if config.Alerting.PagerDuty == nil {
// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
return nil
}
return config.Alerting.PagerDuty
case core.CustomAlert:
if config.Alerting.Custom == nil {
// Since we're returning an interface, we need to explicitly return nil, even if the provider itself is nil
return nil
}
return config.Alerting.Custom
}
return nil
}