// Loading configuration from yaml file
func getConfig(c *cli.Context) (config.Config, error) {
yamlPath := c.GlobalString("config")
conf := config.Config{}
err := configor.Load(&conf, yamlPath)
return conf, err
}
func TestLoadConfigurationByEnvironment(t *testing.T) {
config := generateDefaultConfig()
config2 := struct {
APPName string
}{
APPName: "config2",
}
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
defer os.Remove(file.Name())
configBytes, _ := yaml.Marshal(config)
config2Bytes, _ := yaml.Marshal(config2)
ioutil.WriteFile(file.Name()+".yaml", configBytes, 0644)
defer os.Remove(file.Name() + ".yaml")
ioutil.WriteFile(file.Name()+".production.yaml", config2Bytes, 0644)
defer os.Remove(file.Name() + ".production.yaml")
var result Config
os.Setenv("CONFIGOR_ENV", "production")
defer os.Setenv("CONFIGOR_ENV", "")
if err := configor.Load(&result, file.Name()+".yaml"); err != nil {
t.Errorf("No error should happen when load configurations, but got %v", err)
}
var defaultConfig = generateDefaultConfig()
defaultConfig.APPName = "config2"
if !reflect.DeepEqual(result, defaultConfig) {
t.Errorf("result should be load configurations by environment correctly")
}
}
}
func TestResetPrefixToBlank(t *testing.T) {
config := generateDefaultConfig()
if bytes, err := json.Marshal(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
defer os.Remove(file.Name())
file.Write(bytes)
var result Config
os.Setenv("CONFIGOR_ENV_PREFIX", "-")
os.Setenv("APPNAME", "config2")
os.Setenv("DB_NAME", "db_name")
defer os.Setenv("CONFIGOR_ENV_PREFIX", "")
defer os.Setenv("APPNAME", "")
defer os.Setenv("DB_NAME", "")
configor.Load(&result, file.Name())
var defaultConfig = generateDefaultConfig()
defaultConfig.APPName = "config2"
defaultConfig.DB.Name = "db_name"
if !reflect.DeepEqual(result, defaultConfig) {
t.Errorf("result should equal to original configuration")
}
}
}
}
func init() {
if err := configor.Load(&Config, "config/database.yml", "config/smtp.yml"); err != nil {
panic(err)
}
View = render.New()
}
func main() {
filepaths, _ := filepath.Glob("db/seeds/data/*.yml")
if err := configor.Load(&Seeds, filepaths...); err != nil {
panic(err)
}
truncateTables()
createRecords()
}
func init() {
Fake, _ = faker.New("en")
Fake.Rand = rand.New(rand.NewSource(42))
rand.Seed(time.Now().UnixNano())
filepaths, _ := filepath.Glob("db/seeds/data/*.yml")
if err := configor.Load(&Seeds, filepaths...); err != nil {
panic(err)
}
}
func init() {
if err := configor.Load(&Config, "config/database.yml", "config/smtp.yml"); err != nil {
panic(err)
}
View = render.New()
htmlSanitizer := bluemonday.UGCPolicy()
View.RegisterFuncMap("raw", func(str string) template.HTML {
return template.HTML(htmlSanitizer.Sanitize(str))
})
}
func init() {
err := configor.Load(&config, "./config/verify_faces.json")
if err != nil {
myFatal("Read config file error: ", err)
}
for i, _ := range config.FaceRecServers {
if len(config.FaceRecServers[i].Url) == 0 {
config.FaceRecServers[i].Url = config.FaceRecServers[i].Host + ":" + config.FaceRecServers[i].Port
}
}
}
func TestLoadNormalConfig(t *testing.T) {
config := generateDefaultConfig()
if bytes, err := json.Marshal(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
file.Write(bytes)
var result Config
configor.Load(&result, file.Name())
if !reflect.DeepEqual(result, config) {
t.Errorf("result should equal to original configuration")
}
}
} else {
t.Errorf("failed to marshal config")
}
}
func TestMissingRequiredValue(t *testing.T) {
config := generateDefaultConfig()
config.DB.Password = ""
if bytes, err := json.Marshal(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
file.Write(bytes)
var result Config
if err := configor.Load(&result, file.Name()); err == nil {
t.Errorf("Should got error when load configuration missing db password")
}
}
} else {
t.Errorf("failed to marshal config")
}
}
func TestLoadTOMLConfigWithTomlExtension(t *testing.T) {
config := generateDefaultConfig()
var buffer bytes.Buffer
if err := toml.NewEncoder(&buffer).Encode(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor.toml"); err == nil {
defer file.Close()
defer os.Remove(file.Name())
file.Write(buffer.Bytes())
var result Config
configor.Load(&result, file.Name())
if !reflect.DeepEqual(result, config) {
t.Errorf("result should equal to original configuration")
}
}
} else {
t.Errorf("failed to marshal config")
}
}
func TestReadFromEnvironmentWithSpecifiedEnvName(t *testing.T) {
config := generateDefaultConfig()
if bytes, err := json.Marshal(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
file.Write(bytes)
var result Config
os.Setenv("DBPassword", "db_password")
configor.Load(&result, file.Name())
var defaultConfig = generateDefaultConfig()
defaultConfig.DB.Password = "******"
if !reflect.DeepEqual(result, defaultConfig) {
t.Errorf("result should equal to original configuration")
}
}
}
}
func TestDefaultValue(t *testing.T) {
config := generateDefaultConfig()
config.APPName = ""
config.DB.Port = 0
if bytes, err := json.Marshal(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
file.Write(bytes)
var result Config
configor.Load(&result, file.Name())
if !reflect.DeepEqual(result, generateDefaultConfig()) {
t.Errorf("result should be set default value correctly")
}
}
} else {
t.Errorf("failed to marshal config")
}
}
func TestAnonymousStruct(t *testing.T) {
config := generateDefaultConfig()
if bytes, err := json.Marshal(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
defer os.Remove(file.Name())
file.Write(bytes)
var result Config
os.Setenv("CONFIGOR_DESCRIPTION", "environment description")
defer os.Setenv("CONFIGOR_DESCRIPTION", "")
configor.Load(&result, file.Name())
var defaultConfig = generateDefaultConfig()
defaultConfig.Anonymous.Description = "environment description"
if !reflect.DeepEqual(result, defaultConfig) {
t.Errorf("result should equal to original configuration")
}
}
}
}
func TestOverwriteConfigurationWithEnvironmentWithDefaultPrefix(t *testing.T) {
config := generateDefaultConfig()
if bytes, err := json.Marshal(config); err == nil {
if file, err := ioutil.TempFile("/tmp", "configor"); err == nil {
defer file.Close()
file.Write(bytes)
var result Config
os.Setenv("CONFIGOR_APPNAME", "config2")
os.Setenv("CONFIGOR_DB_NAME", "db_name")
configor.Load(&result, file.Name())
os.Setenv("CONFIGOR_APPNAME", "")
os.Setenv("CONFIGOR_DB_NAME", "")
var defaultConfig = generateDefaultConfig()
defaultConfig.APPName = "config2"
defaultConfig.DB.Name = "db_name"
if !reflect.DeepEqual(result, defaultConfig) {
t.Errorf("result should equal to original configuration")
}
}
}
}
func init() {
err := configor.Load(&config, "./config/server_config.json")
if err != nil {
myFatal("Read config file error: ", err)
}
}
func init() {
err := configor.Load(&config, "./config/image_classify.json")
if err != nil {
myFatal("Read config file error: ", err)
}
}
func init() {
if err := configor.Load(&Config, "config/database.yml"); err != nil {
panic(err)
}
}
func readConfig(parse bool) {
var err error
// Set defaults
ConfigYAML.UDPServiceAddress = defaultUDPServiceAddress
ConfigYAML.TCPServiceAddress = defaultTCPServiceAddress
ConfigYAML.MaxUDPPacketSize = maxUDPPacket
ConfigYAML.BackendType = defaultBackendType
ConfigYAML.PostFlushCmd = "stdout"
ConfigYAML.GraphiteAddress = defaultGraphiteAddress
ConfigYAML.OpenTSDBAddress = defaultOpenTSDBAddress
ConfigYAML.FlushInterval = flushInterval
ConfigYAML.LogLevel = "error"
ConfigYAML.ShowVersion = false
ConfigYAML.DeleteGauges = true
ConfigYAML.ResetCounters = true
ConfigYAML.PersistCountKeys = 0
ConfigYAML.StatsPrefix = statsPrefixName
ConfigYAML.StoreDb = dbPath
ConfigYAML.Prefix = ""
ConfigYAML.ExtraTags = ""
ConfigYAML.PercentThreshold = Percentiles{}
// Percentiles{{Float: 50.0, Str: "50"}, {Float: 80.0, Str: "80"}, {Float: 90.0, Str: "90"}, {Float: 95.0, Str: "95"}}
ConfigYAML.PrintConfig = false
ConfigYAML.LogName = "stdout"
ConfigYAML.LogToSyslog = true
ConfigYAML.SyslogUDPAddress = "localhost:514"
Config = ConfigYAML
os.Setenv("CONFIGOR_ENV_PREFIX", "SD")
configFile = flag.String("config", "", "Configuration file name (warning not error if not exists). Standard: "+configPath)
flag.StringVar(&Config.UDPServiceAddress, "udp-addr", ConfigYAML.UDPServiceAddress, "UDP listen service address")
flag.StringVar(&Config.TCPServiceAddress, "tcp-addr", ConfigYAML.TCPServiceAddress, "TCP listen service address, if set")
flag.Int64Var(&Config.MaxUDPPacketSize, "max-udp-packet-size", ConfigYAML.MaxUDPPacketSize, "Maximum UDP packet size")
flag.StringVar(&Config.BackendType, "backend-type", ConfigYAML.BackendType, "MANDATORY: Backend to use: graphite, opentsdb, external, dummy")
flag.StringVar(&Config.PostFlushCmd, "post-flush-cmd", ConfigYAML.PostFlushCmd, "Command to run on each flush")
flag.StringVar(&Config.GraphiteAddress, "graphite", ConfigYAML.GraphiteAddress, "Graphite service address")
flag.StringVar(&Config.OpenTSDBAddress, "opentsdb", ConfigYAML.OpenTSDBAddress, "OpenTSDB service address")
flag.Int64Var(&Config.FlushInterval, "flush-interval", ConfigYAML.FlushInterval, "Flush interval (seconds)")
flag.StringVar(&Config.LogLevel, "log-level", ConfigYAML.LogLevel, "Set log level (debug,info,warn,error,fatal)")
flag.BoolVar(&Config.ShowVersion, "version", ConfigYAML.ShowVersion, "Print version string")
flag.BoolVar(&Config.DeleteGauges, "delete-gauges", ConfigYAML.DeleteGauges, "Don't send values to graphite for inactive gauges, as opposed to sending the previous value")
flag.BoolVar(&Config.ResetCounters, "reset-counters", ConfigYAML.ResetCounters, "Reset counters after sending value to backend (send rate) or send cumulated value (artificial counter - eg. for OpenTSDB & Grafana)")
flag.Int64Var(&Config.PersistCountKeys, "persist-count-keys", ConfigYAML.PersistCountKeys, "Number of flush-intervals to persist count keys")
flag.StringVar(&Config.StatsPrefix, "stats-prefix", ConfigYAML.StatsPrefix, "Name for internal application metrics (no prefix prepended)")
flag.StringVar(&Config.StoreDb, "store-db", ConfigYAML.StoreDb, "Name of database for permanent counters storage (for conversion from rate to counter)")
flag.StringVar(&Config.Prefix, "prefix", ConfigYAML.Prefix, "Prefix for all stats")
flag.StringVar(&Config.ExtraTags, "extra-tags", ConfigYAML.ExtraTags, "Default tags added to all measures in format: tag1=value1 tag2=value2")
flag.Var(&Config.PercentThreshold, "percent-threshold", "Percentile calculation for timers (0-100, may be given multiple times)")
flag.BoolVar(&Config.PrintConfig, "print-config", ConfigYAML.PrintConfig, "Print config in YAML format")
flag.StringVar(&Config.LogName, "log-name", ConfigYAML.LogName, "Name of file to log into. If \"stdout\" than logs to stdout.If empty logs go to /dev/null")
flag.BoolVar(&Config.LogToSyslog, "log-to-syslopg", ConfigYAML.LogToSyslog, "Log to syslog")
flag.StringVar(&Config.SyslogUDPAddress, "syslog-udp-address", ConfigYAML.SyslogUDPAddress, "Syslog address with port number eg. localhost:514. If empty log to unix socket")
if parse {
flag.Parse()
}
if len(*configFile) > 0 {
if _, err = os.Stat(*configFile); os.IsNotExist(err) {
fmt.Printf("# Warning: No config file: %s\n", *configFile)
*configFile = ""
}
if len(*configFile) > 0 {
err = configor.Load(&ConfigYAML, *configFile)
if err != nil {
fmt.Printf("Error loading config file: %s\n", err)
} else {
// set configs read form YAML file
// save 2 flags
tmpConfig := Config
// Overwites flags
Config = ConfigYAML
// restore 2 flags
Config.ShowVersion = tmpConfig.ShowVersion
Config.PrintConfig = tmpConfig.PrintConfig
}
}
// visitor := func(a *flag.Flag) {
// fmt.Println(">", a.Name, "value=", a.Value)
// switch a.Name {
// case "print-config", "version":
// break
// case "udp-addr":
// ConfigYAML.UDPServiceAddress = a.Value.(string)
// default:
// fmt.Printf("Internal Config Error - unknown variable: %s\n", a.Name)
// os.Exit(1)
// }
//
// }
// flag.Visit(visitor)
}
// Normalize prefix
Config.Prefix = normalizeDot(Config.Prefix, true)
// Normalize internal metrics name
Config.StatsPrefix = normalizeDot(Config.StatsPrefix, true)
// calculate extraFlags hash
Config.ExtraTagsHash, err = parseExtraTags(Config.ExtraTags)
if err != nil {
fmt.Printf("Extra Tags: \"%s\" - %s\n", Config.ExtraTags, err)
os.Exit(1)
}
// Set InternalLogLevel
Config.InternalLogLevel, err = log.ParseLevel(Config.LogLevel)
if err != nil {
fmt.Printf("Invalid log level: \"%s\"\n", Config.LogLevel)
os.Exit(1)
}
}
/*
ConfigLoad loads configuration settings from files and environment
variables. Note, this function exits on error, since without config we can't
do anything.
We prefer settings in config file in current dir (or the current dir's parent
dir if the useparentdir option is true (used for test scripts)) over config file
in home directory over config file in dir pointed to by WR_CONFIG_DIR.
The deployment argument determines if we read .wr_config.production.yml or
.wr_config.development.yml; we always read .wr_config.yml. If the empty
string is supplied, deployment is development if you're in the git repository
directory. Otherwise, deployment is taken from the environment variable
WR_DEPLOYMENT, and if that's not set it defaults to production.
Multiple of these files can be used to have settings that are common to
multiple users and deployments, and settings specific to users or deployments.
Settings found in no file can be set with the environment variable
WR_<setting name in caps>, eg.
export WR_MANAGER_PORT="11301"
*/
func ConfigLoad(deployment string, useparentdir bool) Config {
pwd, err := os.Getwd()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
if useparentdir {
pwd = filepath.Dir(pwd)
}
// if deployment not set on the command line
if deployment != "development" && deployment != "production" {
deployment = DefaultDeployment()
}
os.Setenv("CONFIGOR_ENV", deployment)
os.Setenv("CONFIGOR_ENV_PREFIX", "WR")
ConfigDeploymentBasename := ".wr_config." + deployment + ".yml"
// read the config files. We have to check file existence before passing
// these to configor.Load, or it will complain
var configFiles []string
configFile := filepath.Join(pwd, configCommonBasename)
_, err = os.Stat(configFile)
if _, err2 := os.Stat(filepath.Join(pwd, ConfigDeploymentBasename)); err == nil || err2 == nil {
configFiles = append(configFiles, configFile)
}
home := os.Getenv("HOME")
if home != "" {
configFile = filepath.Join(home, configCommonBasename)
_, err = os.Stat(configFile)
if _, err2 := os.Stat(filepath.Join(home, ConfigDeploymentBasename)); err == nil || err2 == nil {
configFiles = append(configFiles, configFile)
}
}
if configDir := os.Getenv("WR_CONFIG_DIR"); configDir != "" {
configFile = filepath.Join(configDir, configCommonBasename)
_, err = os.Stat(configFile)
if _, err2 := os.Stat(filepath.Join(configDir, ConfigDeploymentBasename)); err == nil || err2 == nil {
configFiles = append(configFiles, configFile)
}
}
config := Config{}
configor.Load(&config, configFiles...)
config.Deployment = deployment
// convert the possible ~/ in Manager_dir to abs path to user's home
if home != "" && strings.HasPrefix(config.ManagerDir, "~/") {
mdir := strings.TrimLeft(config.ManagerDir, "~/")
mdir = filepath.Join(home, mdir)
config.ManagerDir = mdir
}
config.ManagerDir += "_" + deployment
// create the manager dir now, or else we're doomed to failure
err = os.MkdirAll(config.ManagerDir, 0700)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
// convert the possible relative paths in Manager_*_file to abs paths in
// Manager_dir
if !filepath.IsAbs(config.ManagerPidFile) {
config.ManagerPidFile = filepath.Join(config.ManagerDir, config.ManagerPidFile)
}
if !filepath.IsAbs(config.ManagerLogFile) {
config.ManagerLogFile = filepath.Join(config.ManagerDir, config.ManagerLogFile)
}
if !filepath.IsAbs(config.ManagerDbFile) {
config.ManagerDbFile = filepath.Join(config.ManagerDir, config.ManagerDbFile)
}
if !filepath.IsAbs(config.ManagerDbBkFile) {
//*** we need to support this being on a different machine, possibly on an S3-style object store
config.ManagerDbBkFile = filepath.Join(config.ManagerDir, config.ManagerDbBkFile)
}
// if not explicitly set, calculate ports that no one else would be
// assigned by us (and hope no other software is using it...)
if config.ManagerPort == "" {
config.ManagerPort = calculatePort(config.Deployment, "cli")
}
if config.ManagerWeb == "" {
config.ManagerWeb = calculatePort(config.Deployment, "webi")
}
return config
}
func main() {
configor.Load(&Config, "../config/config.json")
fmt.Printf("config: %#v", Config.APPName)
}