spf13--viper/viper.go

932 lines
26 KiB
Go
Raw Normal View History

2014-04-04 21:21:59 +00:00
// Copyright © 2014 Steve Francia <spf@spf13.com>.
//
// Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
2014-09-27 21:03:00 +00:00
// Viper is a application configuration system.
// It believes that applications can be configured a variety of ways
2014-10-24 19:38:01 +00:00
// via flags, ENVIRONMENT variables, configuration files retrieved
// from the file system, or a remote key/value store.
2014-09-27 21:03:00 +00:00
// Each item takes precedence over the item below it:
// overrides
2014-09-27 21:03:00 +00:00
// flag
// env
// config
2014-10-24 19:38:01 +00:00
// key/value store
2014-09-27 21:03:00 +00:00
// default
2014-04-04 21:21:59 +00:00
package viper
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
2014-10-24 19:38:01 +00:00
"reflect"
2014-04-05 05:19:39 +00:00
"strings"
2014-04-04 21:21:59 +00:00
"time"
"github.com/kr/pretty"
"github.com/mitchellh/mapstructure"
2014-04-04 21:21:59 +00:00
"github.com/spf13/cast"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/pflag"
2014-10-26 13:42:03 +00:00
crypt "github.com/xordataexchange/crypt/config"
2014-04-04 21:21:59 +00:00
)
var v *Viper
func init() {
v = New()
}
// Denotes encountering an unsupported
// configuration filetype.
type UnsupportedConfigError string
// Returns the formatted configuration error.
func (str UnsupportedConfigError) Error() string {
return fmt.Sprintf("Unsupported Config Type %q", string(str))
}
// Denotes encountering an unsupported remote
// provider. Currently only Etcd and Consul are
// supported.
type UnsupportedRemoteProviderError string
// Returns the formatted remote provider error.
func (str UnsupportedRemoteProviderError) Error() string {
return fmt.Sprintf("Unsupported Remote Provider Type %q", string(str))
}
// Denotes encountering an error while trying to
// pull the configuration from the remote provider.
type RemoteConfigError string
// Returns the formatted remote provider error
func (rce RemoteConfigError) Error() string {
return fmt.Sprintf("Remote Configurations Error: %s", string(rce))
}
// Viper is a prioritized configuration registry. It
// maintains a set of configuration sources, fetches
// values to populate those, and provides them according
// to the source's priority.
// The priority of the sources is the following:
// 1. overrides
// 2. flags
// 3. env. variables
// 4. config file
// 5. key/value store
// 6. defaults
//
// For example, if values from the following sources were loaded:
//
// Defaults : {
// "secret": "",
// "user": "default",
// "endpoint": "https://localhost"
// }
// Config : {
// "user": "root"
// "secret": "defaultsecret"
// }
// Env : {
// "secret": "somesecretkey"
// }
//
// The resulting config will have the following values:
//
// {
// "secret": "somesecretkey",
// "user": "root",
// "endpoint": "https://localhost"
// }
type Viper struct {
// Delimiter that separates a list of keys
// used to access a nested value in one go
keyDelim string
// A set of paths to look for the config file in
configPaths []string
// A set of remote providers to search for the configuration
remoteProviders []*remoteProvider
// Name of file to look for inside the path
configName string
configFile string
configType string
envPrefix string
automaticEnvApplied bool
2015-03-06 19:21:17 +00:00
envKeyReplacer *strings.Replacer
config map[string]interface{}
override map[string]interface{}
defaults map[string]interface{}
kvstore map[string]interface{}
pflags map[string]*pflag.Flag
env map[string]string
aliases map[string]string
}
// Returns an initialized Viper instance.
func New() *Viper {
v := new(Viper)
v.keyDelim = "."
v.configName = "config"
v.config = make(map[string]interface{})
v.override = make(map[string]interface{})
v.defaults = make(map[string]interface{})
v.kvstore = make(map[string]interface{})
v.pflags = make(map[string]*pflag.Flag)
v.env = make(map[string]string)
v.aliases = make(map[string]string)
wd, err := os.Getwd()
if err != nil {
jww.INFO.Println("Could not add cwd to search paths", err)
} else {
v.AddConfigPath(wd)
}
return v
}
// Intended for testing, will reset all to default settings.
// In the public interface for the viper package so applications
// can use it in their testing as well.
func Reset() {
v = New()
SupportedExts = []string{"json", "toml", "yaml", "yml"}
SupportedRemoteProviders = []string{"etcd", "consul"}
}
2014-10-24 19:38:01 +00:00
// remoteProvider stores the configuration necessary
// to connect to a remote key/value store.
// Optional secretKeyring to unencrypt encrypted values
// can be provided.
type remoteProvider struct {
provider string
endpoint string
path string
secretKeyring string
}
// Universally supported extensions.
var SupportedExts []string = []string{"json", "toml", "yaml", "yml", "properties", "props", "prop"}
2014-04-04 21:21:59 +00:00
// Universally supported remote providers.
var SupportedRemoteProviders []string = []string{"etcd", "consul"}
2014-04-04 21:21:59 +00:00
2014-07-11 14:42:07 +00:00
// Explicitly define the path, name and extension of the config file
// Viper will use this and not check any of the config paths
func SetConfigFile(in string) { v.SetConfigFile(in) }
func (v *Viper) SetConfigFile(in string) {
2014-04-04 21:21:59 +00:00
if in != "" {
v.configFile = in
2014-04-04 21:21:59 +00:00
}
}
// Define a prefix that ENVIRONMENT variables will use.
// E.g. if your prefix is "spf", the env registry
// will look for env. variables that start with "SPF_"
func SetEnvPrefix(in string) { v.SetEnvPrefix(in) }
func (v *Viper) SetEnvPrefix(in string) {
if in != "" {
v.envPrefix = in
}
}
func (v *Viper) mergeWithEnvPrefix(in string) string {
if v.envPrefix != "" {
return strings.ToUpper(v.envPrefix + "_" + in)
}
return strings.ToUpper(in)
}
2015-03-06 19:21:17 +00:00
// TODO: should getEnv logic be moved into find(). Can generalize the use of
// rewriting keys many things, Ex: Get('someKey') -> some_key
// (cammel case to snake case for JSON keys perhaps)
// getEnv s a wrapper around os.Getenv which replaces characters in the original
// key. This allows env vars which have different keys then the config object
// keys
func (v *Viper) getEnv(key string) string {
2015-03-06 19:21:17 +00:00
if v.envKeyReplacer != nil {
key = v.envKeyReplacer.Replace(key)
}
return os.Getenv(key)
}
// Return the file used to populate the config registry
func ConfigFileUsed() string { return v.ConfigFileUsed() }
func (v *Viper) ConfigFileUsed() string { return v.configFile }
2014-04-08 03:35:40 +00:00
// Add a path for Viper to search for the config file in.
2014-07-11 14:42:07 +00:00
// Can be called multiple times to define multiple search paths.
func AddConfigPath(in string) { v.AddConfigPath(in) }
func (v *Viper) AddConfigPath(in string) {
2014-04-04 21:21:59 +00:00
if in != "" {
absin := absPathify(in)
jww.INFO.Println("adding", absin, "to paths to search")
if !stringInSlice(absin, v.configPaths) {
v.configPaths = append(v.configPaths, absin)
2014-04-04 21:21:59 +00:00
}
}
}
2014-10-24 19:38:01 +00:00
// AddRemoteProvider adds a remote configuration source.
// Remote Providers are searched in the order they are added.
// provider is a string value, "etcd" or "consul" are currently supported.
// endpoint is the url. etcd requires http://ip:port consul requires ip:port
// path is the path in the k/v store to retrieve configuration
// To retrieve a config file called myapp.json from /configs/myapp.json
// you should set path to /configs and set config name (SetConfigName()) to
// "myapp"
func AddRemoteProvider(provider, endpoint, path string) error {
return v.AddRemoteProvider(provider, endpoint, path)
}
func (v *Viper) AddRemoteProvider(provider, endpoint, path string) error {
2014-10-24 19:38:01 +00:00
if !stringInSlice(provider, SupportedRemoteProviders) {
return UnsupportedRemoteProviderError(provider)
}
if provider != "" && endpoint != "" {
jww.INFO.Printf("adding %s:%s to remote provider list", provider, endpoint)
rp := &remoteProvider{
endpoint: endpoint,
provider: provider,
2014-10-27 16:21:03 +00:00
path: path,
2014-10-24 19:38:01 +00:00
}
if !v.providerPathExists(rp) {
v.remoteProviders = append(v.remoteProviders, rp)
2014-10-24 19:38:01 +00:00
}
}
return nil
}
// AddSecureRemoteProvider adds a remote configuration source.
// Secure Remote Providers are searched in the order they are added.
// provider is a string value, "etcd" or "consul" are currently supported.
// endpoint is the url. etcd requires http://ip:port consul requires ip:port
// secretkeyring is the filepath to your openpgp secret keyring. e.g. /etc/secrets/myring.gpg
// path is the path in the k/v store to retrieve configuration
// To retrieve a config file called myapp.json from /configs/myapp.json
// you should set path to /configs and set config name (SetConfigName()) to
// "myapp"
// Secure Remote Providers are implemented with github.com/xordataexchange/crypt
2014-10-27 16:21:03 +00:00
func AddSecureRemoteProvider(provider, endpoint, path, secretkeyring string) error {
return v.AddSecureRemoteProvider(provider, endpoint, path, secretkeyring)
}
func (v *Viper) AddSecureRemoteProvider(provider, endpoint, path, secretkeyring string) error {
2014-10-24 19:38:01 +00:00
if !stringInSlice(provider, SupportedRemoteProviders) {
return UnsupportedRemoteProviderError(provider)
}
if provider != "" && endpoint != "" {
jww.INFO.Printf("adding %s:%s to remote provider list", provider, endpoint)
rp := &remoteProvider{
endpoint: endpoint,
provider: provider,
2014-10-27 16:21:03 +00:00
path: path,
2014-10-24 19:38:01 +00:00
}
if !v.providerPathExists(rp) {
v.remoteProviders = append(v.remoteProviders, rp)
2014-10-24 19:38:01 +00:00
}
}
return nil
}
func (v *Viper) providerPathExists(p *remoteProvider) bool {
for _, y := range v.remoteProviders {
2014-10-24 19:38:01 +00:00
if reflect.DeepEqual(y, p) {
return true
}
}
return false
}
func (v *Viper) searchMap(source map[string]interface{}, path []string) interface{} {
if len(path) == 0 {
return source
}
if next, ok := source[path[0]]; ok {
switch next.(type) {
case map[string]interface{}:
// Type assertion is safe here since it is only reached
// if the type of `next` is the same as the type being asserted
return v.searchMap(next.(map[string]interface{}), path[1:])
default:
return next
}
} else {
return nil
}
}
// Viper is essentially repository for configurations
// Get can retrieve any value given the key to use
// Get has the behavior of returning the value associated with the first
// place from where it is set. Viper will check in the following order:
// override, flag, env, config file, key/value store, default
//
// Get returns an interface. For a specific value use one of the Get____ methods.
func Get(key string) interface{} { return v.Get(key) }
func (v *Viper) Get(key string) interface{} {
path := strings.Split(key, v.keyDelim)
val := v.find(strings.ToLower(key))
if val == nil {
source := v.find(path[0])
if source == nil {
return nil
}
if reflect.TypeOf(source).Kind() == reflect.Map {
val = v.searchMap(cast.ToStringMap(source), path[1:])
}
}
switch val.(type) {
case bool:
return cast.ToBool(val)
case string:
return cast.ToString(val)
case int64, int32, int16, int8, int:
return cast.ToInt(val)
case float64, float32:
return cast.ToFloat64(val)
case time.Time:
return cast.ToTime(val)
2015-02-19 03:03:20 +00:00
case time.Duration:
return cast.ToDuration(val)
case []string:
return val
}
return val
}
// Returns the value associated with the key as a string
func GetString(key string) string { return v.GetString(key) }
func (v *Viper) GetString(key string) string {
return cast.ToString(v.Get(key))
2014-04-04 21:21:59 +00:00
}
// Returns the value associated with the key asa boolean
func GetBool(key string) bool { return v.GetBool(key) }
func (v *Viper) GetBool(key string) bool {
return cast.ToBool(v.Get(key))
2014-04-04 21:21:59 +00:00
}
// Returns the value associated with the key as an integer
func GetInt(key string) int { return v.GetInt(key) }
func (v *Viper) GetInt(key string) int {
return cast.ToInt(v.Get(key))
2014-04-04 21:21:59 +00:00
}
// Returns the value associated with the key as a float64
func GetFloat64(key string) float64 { return v.GetFloat64(key) }
func (v *Viper) GetFloat64(key string) float64 {
return cast.ToFloat64(v.Get(key))
2014-04-04 21:21:59 +00:00
}
// Returns the value associated with the key as time
func GetTime(key string) time.Time { return v.GetTime(key) }
func (v *Viper) GetTime(key string) time.Time {
return cast.ToTime(v.Get(key))
2014-04-04 21:21:59 +00:00
}
// Returns the value associated with the key as a duration
2015-02-19 03:03:20 +00:00
func GetDuration(key string) time.Duration { return v.GetDuration(key) }
func (v *Viper) GetDuration(key string) time.Duration {
2015-02-19 03:03:20 +00:00
return cast.ToDuration(v.Get(key))
}
// Returns the value associated with the key as a slice of strings
func GetStringSlice(key string) []string { return v.GetStringSlice(key) }
func (v *Viper) GetStringSlice(key string) []string {
return cast.ToStringSlice(v.Get(key))
2014-04-05 05:19:39 +00:00
}
// Returns the value associated with the key as a map of interfaces
func GetStringMap(key string) map[string]interface{} { return v.GetStringMap(key) }
func (v *Viper) GetStringMap(key string) map[string]interface{} {
return cast.ToStringMap(v.Get(key))
2014-04-05 05:19:39 +00:00
}
// Returns the value associated with the key as a map of strings
func GetStringMapString(key string) map[string]string { return v.GetStringMapString(key) }
func (v *Viper) GetStringMapString(key string) map[string]string {
return cast.ToStringMapString(v.Get(key))
2014-04-04 21:21:59 +00:00
}
// Returns the size of the value associated with the given key
// in bytes.
func GetSizeInBytes(key string) uint { return v.GetSizeInBytes(key) }
func (v *Viper) GetSizeInBytes(key string) uint {
sizeStr := cast.ToString(v.Get(key))
return parseSizeInBytes(sizeStr)
}
// Takes a single key and marshals it into a Struct
func MarshalKey(key string, rawVal interface{}) error { return v.MarshalKey(key, rawVal) }
func (v *Viper) MarshalKey(key string, rawVal interface{}) error {
return mapstructure.Decode(v.Get(key), rawVal)
}
// Marshals the config into a Struct. Make sure that the tags
// on the fields of the structure are properly set.
func Marshal(rawVal interface{}) error { return v.Marshal(rawVal) }
func (v *Viper) Marshal(rawVal interface{}) error {
err := mapstructure.WeakDecode(v.AllSettings(), rawVal)
2014-10-24 19:38:01 +00:00
if err != nil {
return err
}
v.insensitiviseMaps()
return nil
}
// Bind a full flag set to the configuration, using each flag's long
// name as the config key.
func BindPFlags(flags *pflag.FlagSet) (err error) { return v.BindPFlags(flags) }
func (v *Viper) BindPFlags(flags *pflag.FlagSet) (err error) {
flags.VisitAll(func(flag *pflag.Flag) {
if err != nil {
// an error has been encountered in one of the previous flags
return
}
err = v.BindPFlag(flag.Name, flag)
switch flag.Value.Type() {
case "int", "int8", "int16", "int32", "int64":
v.SetDefault(flag.Name, cast.ToInt(flag.Value.String()))
case "bool":
v.SetDefault(flag.Name, cast.ToBool(flag.Value.String()))
default:
v.SetDefault(flag.Name, flag.Value.String())
}
})
return
}
2014-07-11 14:42:07 +00:00
// Bind a specific key to a flag (as used by cobra)
// Example(where serverCmd is a Cobra instance):
2014-07-11 14:42:07 +00:00
//
// serverCmd.Flags().Int("port", 1138, "Port to run Application server on")
// Viper.BindPFlag("port", serverCmd.Flags().Lookup("port"))
2014-07-11 14:42:07 +00:00
//
func BindPFlag(key string, flag *pflag.Flag) (err error) { return v.BindPFlag(key, flag) }
func (v *Viper) BindPFlag(key string, flag *pflag.Flag) (err error) {
if flag == nil {
return fmt.Errorf("flag for %q is nil", key)
}
v.pflags[strings.ToLower(key)] = flag
2014-07-11 14:28:03 +00:00
switch flag.Value.Type() {
case "int", "int8", "int16", "int32", "int64":
SetDefault(key, cast.ToInt(flag.Value.String()))
case "bool":
SetDefault(key, cast.ToBool(flag.Value.String()))
default:
SetDefault(key, flag.Value.String())
}
return nil
}
// Binds a Viper key to a ENV variable
2014-09-27 21:03:00 +00:00
// ENV variables are case sensitive
// If only a key is provided, it will use the env key matching the key, uppercased.
// EnvPrefix will be used when set when env name is not provided.
func BindEnv(input ...string) (err error) { return v.BindEnv(input...) }
func (v *Viper) BindEnv(input ...string) (err error) {
2014-09-27 21:03:00 +00:00
var key, envkey string
if len(input) == 0 {
return fmt.Errorf("BindEnv missing key to bind to")
}
key = strings.ToLower(input[0])
2014-09-27 21:03:00 +00:00
if len(input) == 1 {
envkey = v.mergeWithEnvPrefix(key)
2014-09-27 21:03:00 +00:00
} else {
envkey = input[1]
}
v.env[key] = envkey
2014-09-27 21:03:00 +00:00
return nil
}
// Given a key, find the value
// Viper will check in the following order:
// flag, env, config file, key/value store, default
// Viper will check to see if an alias exists first
func (v *Viper) find(key string) interface{} {
2014-04-04 21:21:59 +00:00
var val interface{}
var exists bool
2014-04-05 05:19:39 +00:00
// if the requested key is an alias, then return the proper key
key = v.realKey(key)
2014-04-04 21:21:59 +00:00
// PFlag Override first
flag, exists := v.pflags[key]
if exists {
if flag.Changed {
jww.TRACE.Println(key, "found in override (via pflag):", val)
return flag.Value.String()
}
}
val, exists = v.override[key]
2014-04-04 21:21:59 +00:00
if exists {
jww.TRACE.Println(key, "found in override:", val)
return val
}
if v.automaticEnvApplied {
// even if it hasn't been registered, if automaticEnv is used,
// check any Get request
2015-03-06 19:21:17 +00:00
if val = v.getEnv(v.mergeWithEnvPrefix(key)); val != "" {
jww.TRACE.Println(key, "found in environment with val:", val)
return val
}
}
envkey, exists := v.env[key]
2014-09-27 21:03:00 +00:00
if exists {
jww.TRACE.Println(key, "registered as env var", envkey)
2015-03-06 19:21:17 +00:00
if val = v.getEnv(envkey); val != "" {
2014-11-07 18:14:27 +00:00
jww.TRACE.Println(envkey, "found in environment with val:", val)
2014-09-27 21:03:00 +00:00
return val
} else {
jww.TRACE.Println(envkey, "env value unset:")
}
}
val, exists = v.config[key]
2014-04-04 21:21:59 +00:00
if exists {
jww.TRACE.Println(key, "found in config:", val)
return val
}
val, exists = v.kvstore[key]
2014-10-24 19:38:01 +00:00
if exists {
jww.TRACE.Println(key, "found in key/value store:", val)
return val
}
val, exists = v.defaults[key]
2014-04-04 21:21:59 +00:00
if exists {
jww.TRACE.Println(key, "found in defaults:", val)
return val
}
return nil
}
// Check to see if the key has been set in any of the data locations
func IsSet(key string) bool { return v.IsSet(key) }
func (v *Viper) IsSet(key string) bool {
t := v.Get(key)
2014-04-04 21:21:59 +00:00
return t != nil
}
// Have Viper check ENV variables for all
// keys set in config, default & flags
func AutomaticEnv() { v.AutomaticEnv() }
func (v *Viper) AutomaticEnv() {
v.automaticEnvApplied = true
}
2015-03-06 19:21:17 +00:00
// SetEnvKeyReplacer sets the strings.Replacer on the viper object
// Useful for mapping an environmental variable to a key that does
// not match it.
2015-03-06 19:21:17 +00:00
func SetEnvKeyReplacer(r *strings.Replacer) { v.SetEnvKeyReplacer(r) }
func (v *Viper) SetEnvKeyReplacer(r *strings.Replacer) {
2015-03-06 19:21:17 +00:00
v.envKeyReplacer = r
}
2014-07-11 14:42:07 +00:00
// Aliases provide another accessor for the same key.
// This enables one to change a name without breaking the application
func RegisterAlias(alias string, key string) { v.RegisterAlias(alias, key) }
func (v *Viper) RegisterAlias(alias string, key string) {
v.registerAlias(alias, strings.ToLower(key))
2014-04-05 05:19:39 +00:00
}
func (v *Viper) registerAlias(alias string, key string) {
2014-04-05 05:19:39 +00:00
alias = strings.ToLower(alias)
if alias != key && alias != v.realKey(key) {
_, exists := v.aliases[alias]
2014-04-05 05:19:39 +00:00
if !exists {
// if we alias something that exists in one of the maps to another
// name, we'll never be able to get that value using the original
// name, so move the config value to the new realkey.
if val, ok := v.config[alias]; ok {
delete(v.config, alias)
v.config[key] = val
}
if val, ok := v.kvstore[alias]; ok {
delete(v.kvstore, alias)
v.kvstore[key] = val
2014-10-24 19:38:01 +00:00
}
if val, ok := v.defaults[alias]; ok {
delete(v.defaults, alias)
v.defaults[key] = val
}
if val, ok := v.override[alias]; ok {
delete(v.override, alias)
v.override[key] = val
}
v.aliases[alias] = key
2014-04-05 05:19:39 +00:00
}
} else {
jww.WARN.Println("Creating circular reference alias", alias, key, v.realKey(key))
2014-04-05 05:19:39 +00:00
}
}
func (v *Viper) realKey(key string) string {
newkey, exists := v.aliases[key]
2014-04-05 05:19:39 +00:00
if exists {
jww.DEBUG.Println("Alias", key, "to", newkey)
return v.realKey(newkey)
2014-04-05 05:19:39 +00:00
} else {
return key
}
2014-04-04 21:21:59 +00:00
}
// Check to see if the given key (or an alias) is in the config file
func InConfig(key string) bool { return v.InConfig(key) }
func (v *Viper) InConfig(key string) bool {
2014-04-05 05:19:39 +00:00
// if the requested key is an alias, then return the proper key
key = v.realKey(key)
2014-04-05 05:19:39 +00:00
_, exists := v.config[key]
2014-04-04 21:21:59 +00:00
return exists
}
2014-07-11 14:42:07 +00:00
// Set the default value for this key.
// Default only used when no value is provided by the user via flag, config or ENV.
func SetDefault(key string, value interface{}) { v.SetDefault(key, value) }
func (v *Viper) SetDefault(key string, value interface{}) {
2014-04-04 21:21:59 +00:00
// If alias passed in, then set the proper default
key = v.realKey(strings.ToLower(key))
v.defaults[key] = value
2014-04-04 21:21:59 +00:00
}
// Sets the value for the key in the override regiser.
2014-10-24 19:38:01 +00:00
// Will be used instead of values obtained via
// flags, config file, ENV, default, or key/value store
func Set(key string, value interface{}) { v.Set(key, value) }
func (v *Viper) Set(key string, value interface{}) {
2014-04-04 21:21:59 +00:00
// If alias passed in, then set the proper override
key = v.realKey(strings.ToLower(key))
v.override[key] = value
}
2014-07-11 14:42:07 +00:00
// Viper will discover and load the configuration file from disk
2014-10-24 19:38:01 +00:00
// and key/value stores, searching in one of the defined paths.
func ReadInConfig() error { return v.ReadInConfig() }
func (v *Viper) ReadInConfig() error {
2014-04-04 21:21:59 +00:00
jww.INFO.Println("Attempting to read in config file")
if !stringInSlice(v.getConfigType(), SupportedExts) {
return UnsupportedConfigError(v.getConfigType())
2014-04-04 21:21:59 +00:00
}
file, err := ioutil.ReadFile(v.getConfigFile())
if err != nil {
return err
2014-04-04 21:21:59 +00:00
}
v.config = make(map[string]interface{})
2014-12-06 08:48:28 +00:00
v.marshalReader(bytes.NewReader(file), v.config)
return nil
2014-04-04 21:21:59 +00:00
}
// Attempts to get configuration from a remote source
// and read it in the remote configuration registry.
func ReadRemoteConfig() error { return v.ReadRemoteConfig() }
func (v *Viper) ReadRemoteConfig() error {
err := v.getKeyValueConfig()
if err != nil {
return err
}
return nil
}
// Marshall a Reader into a map
// Should probably be an unexported function
2014-12-06 08:48:28 +00:00
func marshalReader(in io.Reader, c map[string]interface{}) { v.marshalReader(in, c) }
func (v *Viper) marshalReader(in io.Reader, c map[string]interface{}) {
marshallConfigReader(in, c, v.getConfigType())
}
func (v *Viper) insensitiviseMaps() {
insensitiviseMap(v.config)
insensitiviseMap(v.defaults)
insensitiviseMap(v.override)
insensitiviseMap(v.kvstore)
2014-10-24 19:38:01 +00:00
}
// retrieve the first found remote configuration
func (v *Viper) getKeyValueConfig() error {
for _, rp := range v.remoteProviders {
val, err := v.getRemoteConfig(rp)
2014-10-24 19:38:01 +00:00
if err != nil {
2014-10-26 13:42:03 +00:00
continue
2014-10-24 19:38:01 +00:00
}
v.kvstore = val
2014-10-26 13:42:03 +00:00
return nil
2014-10-24 19:38:01 +00:00
}
return RemoteConfigError("No Files Found")
}
func (v *Viper) getRemoteConfig(provider *remoteProvider) (map[string]interface{}, error) {
2014-10-26 13:42:03 +00:00
var cm crypt.ConfigManager
var err error
if provider.secretKeyring != "" {
kr, err := os.Open(provider.secretKeyring)
defer kr.Close()
if err != nil {
return nil, err
}
2014-10-28 01:14:46 +00:00
if provider.provider == "etcd" {
cm, err = crypt.NewEtcdConfigManager([]string{provider.endpoint}, kr)
} else {
cm, err = crypt.NewConsulConfigManager([]string{provider.endpoint}, kr)
}
2014-10-26 13:42:03 +00:00
} else {
2014-10-28 01:14:46 +00:00
if provider.provider == "etcd" {
cm, err = crypt.NewStandardEtcdConfigManager([]string{provider.endpoint})
} else {
cm, err = crypt.NewStandardConsulConfigManager([]string{provider.endpoint})
}
2014-10-26 13:42:03 +00:00
}
if err != nil {
return nil, err
}
2014-10-27 16:21:03 +00:00
b, err := cm.Get(provider.path)
2014-10-26 13:42:03 +00:00
if err != nil {
return nil, err
}
reader := bytes.NewReader(b)
2014-12-06 08:48:28 +00:00
v.marshalReader(reader, v.kvstore)
return v.kvstore, err
2014-10-26 13:42:03 +00:00
}
// Return all keys regardless where they are set
func AllKeys() []string { return v.AllKeys() }
func (v *Viper) AllKeys() []string {
m := map[string]struct{}{}
for key, _ := range v.defaults {
m[key] = struct{}{}
}
for key, _ := range v.config {
m[key] = struct{}{}
}
for key, _ := range v.kvstore {
2014-10-24 19:38:01 +00:00
m[key] = struct{}{}
}
for key, _ := range v.override {
m[key] = struct{}{}
}
a := []string{}
for x, _ := range m {
a = append(a, x)
}
return a
}
// Return all settings as a map[string]interface{}
func AllSettings() map[string]interface{} { return v.AllSettings() }
func (v *Viper) AllSettings() map[string]interface{} {
m := map[string]interface{}{}
for _, x := range v.AllKeys() {
m[x] = v.Get(x)
}
return m
}
2014-07-11 14:42:07 +00:00
// Name for the config file.
// Does not include extension.
func SetConfigName(in string) { v.SetConfigName(in) }
func (v *Viper) SetConfigName(in string) {
2014-04-04 21:21:59 +00:00
if in != "" {
v.configName = in
2014-04-04 21:21:59 +00:00
}
}
// Sets the type of the configuration returned by the
// remote source, e.g. "json".
func SetConfigType(in string) { v.SetConfigType(in) }
func (v *Viper) SetConfigType(in string) {
2014-04-04 21:21:59 +00:00
if in != "" {
v.configType = in
2014-04-04 21:21:59 +00:00
}
}
func (v *Viper) getConfigType() string {
if v.configType != "" {
return v.configType
2014-04-04 21:21:59 +00:00
}
cf := v.getConfigFile()
ext := filepath.Ext(cf)
2014-04-04 21:21:59 +00:00
if len(ext) > 1 {
return ext[1:]
} else {
return ""
}
}
func (v *Viper) getConfigFile() string {
2014-04-04 21:21:59 +00:00
// if explicitly set, then use it
if v.configFile != "" {
return v.configFile
2014-04-04 21:21:59 +00:00
}
cf, err := v.findConfigFile()
2014-04-04 21:21:59 +00:00
if err != nil {
return ""
2014-04-04 21:21:59 +00:00
}
v.configFile = cf
return v.getConfigFile()
2014-04-04 21:21:59 +00:00
}
func (v *Viper) searchInPath(in string) (filename string) {
2014-04-04 21:21:59 +00:00
jww.DEBUG.Println("Searching for config in ", in)
for _, ext := range SupportedExts {
jww.DEBUG.Println("Checking for", filepath.Join(in, v.configName+"."+ext))
if b, _ := exists(filepath.Join(in, v.configName+"."+ext)); b {
jww.DEBUG.Println("Found: ", filepath.Join(in, v.configName+"."+ext))
return filepath.Join(in, v.configName+"."+ext)
2014-04-04 21:21:59 +00:00
}
}
return ""
}
// search all configPaths for any config file.
// Returns the first path that exists (and is a config file)
func (v *Viper) findConfigFile() (string, error) {
jww.INFO.Println("Searching for config in ", v.configPaths)
2014-04-04 21:21:59 +00:00
for _, cp := range v.configPaths {
file := v.searchInPath(cp)
2014-04-04 21:21:59 +00:00
if file != "" {
return file, nil
}
}
// try the current working directory
wd, _ := os.Getwd()
file := v.searchInPath(wd)
if file != "" {
return file, nil
}
return "", fmt.Errorf("config file not found in: %s", v.configPaths)
}
// Prints all configuration registries for debugging
// purposes.
func Debug() { v.Debug() }
func (v *Viper) Debug() {
fmt.Println("Aliases:")
pretty.Println(v.aliases)
fmt.Println("Override:")
pretty.Println(v.override)
fmt.Println("PFlags")
pretty.Println(v.pflags)
fmt.Println("Env:")
pretty.Println(v.env)
fmt.Println("Key/Value Store:")
pretty.Println(v.kvstore)
fmt.Println("Config:")
pretty.Println(v.config)
fmt.Println("Defaults:")
pretty.Println(v.defaults)
2014-04-04 21:21:59 +00:00
}