You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
117 lines
3.1 KiB
117 lines
3.1 KiB
|
|
package config
|
|
|
|
import (
|
|
"github.com/naoina/toml"
|
|
"sync"
|
|
"time"
|
|
|
|
. "github.com/tendermint/go-common"
|
|
)
|
|
|
|
type Config interface {
|
|
Get(key string) interface{}
|
|
GetBool(key string) bool
|
|
GetFloat64(key string) float64
|
|
GetInt(key string) int
|
|
GetString(key string) string
|
|
GetStringMap(key string) map[string]interface{}
|
|
GetStringMapString(key string) map[string]string
|
|
GetStringSlice(key string) []string
|
|
GetTime(key string) time.Time
|
|
IsSet(key string) bool
|
|
Set(key string, value interface{})
|
|
}
|
|
|
|
type MapConfig struct {
|
|
required map[string]struct{} // blows up if trying to use before setting.
|
|
data map[string]interface{}
|
|
}
|
|
|
|
func ReadMapConfigFromFile(filePath string) (MapConfig, error) {
|
|
var configData = make(map[string]interface{})
|
|
fileBytes := MustReadFile(filePath)
|
|
err := toml.Unmarshal(fileBytes, configData)
|
|
if err != nil {
|
|
return MapConfig{}, err
|
|
}
|
|
return NewMapConfig(configData), nil
|
|
}
|
|
|
|
func NewMapConfig(data map[string]interface{}) MapConfig {
|
|
if data == nil {
|
|
data = make(map[string]interface{})
|
|
}
|
|
return MapConfig{
|
|
required: make(map[string]struct{}),
|
|
data: data,
|
|
}
|
|
}
|
|
|
|
func (cfg MapConfig) Get(key string) interface{} {
|
|
if _, ok := cfg.required[key]; ok {
|
|
PanicSanity(Fmt("config key %v is required but was not set.", key))
|
|
}
|
|
return cfg.data[key]
|
|
}
|
|
func (cfg MapConfig) GetBool(key string) bool { return cfg.Get(key).(bool) }
|
|
func (cfg MapConfig) GetFloat64(key string) float64 { return cfg.Get(key).(float64) }
|
|
func (cfg MapConfig) GetInt(key string) int { return cfg.Get(key).(int) }
|
|
func (cfg MapConfig) GetString(key string) string { return cfg.Get(key).(string) }
|
|
func (cfg MapConfig) GetStringMap(key string) map[string]interface{} {
|
|
return cfg.Get(key).(map[string]interface{})
|
|
}
|
|
func (cfg MapConfig) GetStringMapString(key string) map[string]string {
|
|
return cfg.Get(key).(map[string]string)
|
|
}
|
|
func (cfg MapConfig) GetStringSlice(key string) []string { return cfg.Get(key).([]string) }
|
|
func (cfg MapConfig) GetTime(key string) time.Time { return cfg.Get(key).(time.Time) }
|
|
func (cfg MapConfig) IsSet(key string) bool { _, ok := cfg.data[key]; return ok }
|
|
func (cfg MapConfig) Set(key string, value interface{}) {
|
|
delete(cfg.required, key)
|
|
cfg.data[key] = value
|
|
}
|
|
func (cfg MapConfig) SetDefault(key string, value interface{}) {
|
|
delete(cfg.required, key)
|
|
if cfg.IsSet(key) {
|
|
return
|
|
}
|
|
cfg.data[key] = value
|
|
}
|
|
func (cfg MapConfig) SetRequired(key string) {
|
|
if cfg.IsSet(key) {
|
|
return
|
|
}
|
|
cfg.required[key] = struct{}{}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// A little convenient hack to notify listeners upon config changes.
|
|
|
|
type Configurable func(Config)
|
|
|
|
var mtx sync.Mutex
|
|
var globalConfig Config
|
|
var confs []Configurable
|
|
|
|
func OnConfig(conf func(Config)) {
|
|
mtx.Lock()
|
|
defer mtx.Unlock()
|
|
|
|
confs = append(confs, conf)
|
|
if globalConfig != nil {
|
|
conf(globalConfig)
|
|
}
|
|
}
|
|
|
|
func ApplyConfig(config Config) {
|
|
mtx.Lock()
|
|
globalConfig = config
|
|
confsCopy := make([]Configurable, len(confs))
|
|
copy(confsCopy, confs)
|
|
mtx.Unlock()
|
|
|
|
for _, conf := range confsCopy {
|
|
conf(config)
|
|
}
|
|
}
|