1 // Copyright © 2014 Steve Francia <spf@spf13.com>.

     2 //

     3 // Use of this source code is governed by an MIT-style

     4 // license that can be found in the LICENSE file.

     5 

     6 // Viper is a application configuration system.

     7 // It believes that applications can be configured a variety of ways

     8 // via flags, ENVIRONMENT variables, configuration files retrieved

     9 // from the file system, or a remote key/value store.

    10 

    11 // Each item takes precedence over the item below it:

    12 

    13 // overrides

    14 // flag

    15 // env

    16 // config

    17 // key/value store

    18 // default

    19 

    20 package viper

    21 

    22 import (

    23 	"bytes"

    24 	"encoding/csv"

    25 	"encoding/json"

    26 	"fmt"

    27 	"io"

    28 	"log"

    29 	"os"

    30 	"path/filepath"

    31 	"reflect"

    32 	"strings"

    33 	"time"

    34 

    35 	yaml "gopkg.in/yaml.v2"

    36 

    37 	"github.com/fsnotify/fsnotify"

    38 	"github.com/hashicorp/hcl"

    39 	"github.com/hashicorp/hcl/hcl/printer"

    40 	"github.com/magiconair/properties"

    41 	"github.com/mitchellh/mapstructure"

    42 	toml "github.com/pelletier/go-toml"

    43 	"github.com/spf13/afero"

    44 	"github.com/spf13/cast"

    45 	jww "github.com/spf13/jwalterweatherman"

    46 	"github.com/spf13/pflag"

    47 )

    48 

    49 // ConfigMarshalError happens when failing to marshal the configuration.

    50 type ConfigMarshalError struct {

    51 	err error

    52 }

    53 

    54 // Error returns the formatted configuration error.

    55 func (e ConfigMarshalError) Error() string {

    56 	return fmt.Sprintf("While marshaling config: %s", e.err.Error())

    57 }

    58 

    59 var v *Viper

    60 

    61 type RemoteResponse struct {

    62 	Value []byte

    63 	Error error

    64 }

    65 

    66 func init() {

    67 	v = New()

    68 }

    69 

    70 type remoteConfigFactory interface {

    71 	Get(rp RemoteProvider) (io.Reader, error)

    72 	Watch(rp RemoteProvider) (io.Reader, error)

    73 	WatchChannel(rp RemoteProvider) (<-chan *RemoteResponse, chan bool)

    74 }

    75 

    76 // RemoteConfig is optional, see the remote package

    77 var RemoteConfig remoteConfigFactory

    78 

    79 // UnsupportedConfigError denotes encountering an unsupported

    80 // configuration filetype.

    81 type UnsupportedConfigError string

    82 

    83 // Error returns the formatted configuration error.

    84 func (str UnsupportedConfigError) Error() string {

    85 	return fmt.Sprintf("Unsupported Config Type %q", string(str))

    86 }

    87 

    88 // UnsupportedRemoteProviderError denotes encountering an unsupported remote

    89 // provider. Currently only etcd and Consul are supported.

    90 type UnsupportedRemoteProviderError string

    91 

    92 // Error returns the formatted remote provider error.

    93 func (str UnsupportedRemoteProviderError) Error() string {

    94 	return fmt.Sprintf("Unsupported Remote Provider Type %q", string(str))

    95 }

    96 

    97 // RemoteConfigError denotes encountering an error while trying to

    98 // pull the configuration from the remote provider.

    99 type RemoteConfigError string

   100 

   101 // Error returns the formatted remote provider error

   102 func (rce RemoteConfigError) Error() string {

   103 	return fmt.Sprintf("Remote Configurations Error: %s", string(rce))

   104 }

   105 

   106 // ConfigFileNotFoundError denotes failing to find configuration file.

   107 type ConfigFileNotFoundError struct {

   108 	name, locations string

   109 }

   110 

   111 // Error returns the formatted configuration error.

   112 func (fnfe ConfigFileNotFoundError) Error() string {

   113 	return fmt.Sprintf("Config File %q Not Found in %q", fnfe.name, fnfe.locations)

   114 }

   115 

   116 // A DecoderConfigOption can be passed to viper.Unmarshal to configure

   117 // mapstructure.DecoderConfig options

   118 type DecoderConfigOption func(*mapstructure.DecoderConfig)

   119 

   120 // DecodeHook returns a DecoderConfigOption which overrides the default

   121 // DecoderConfig.DecodeHook value, the default is:

   122 //

   123 //  mapstructure.ComposeDecodeHookFunc(

   124 //		mapstructure.StringToTimeDurationHookFunc(),

   125 //		mapstructure.StringToSliceHookFunc(","),

   126 //	)

   127 func DecodeHook(hook mapstructure.DecodeHookFunc) DecoderConfigOption {

   128 	return func(c *mapstructure.DecoderConfig) {

   129 		c.DecodeHook = hook

   130 	}

   131 }

   132 

   133 // Viper is a prioritized configuration registry. It

   134 // maintains a set of configuration sources, fetches

   135 // values to populate those, and provides them according

   136 // to the source's priority.

   137 // The priority of the sources is the following:

   138 // 1. overrides

   139 // 2. flags

   140 // 3. env. variables

   141 // 4. config file

   142 // 5. key/value store

   143 // 6. defaults

   144 //

   145 // For example, if values from the following sources were loaded:

   146 //

   147 //  Defaults : {

   148 //  	"secret": "",

   149 //  	"user": "default",

   150 //  	"endpoint": "https://localhost"

   151 //  }

   152 //  Config : {

   153 //  	"user": "root"

   154 //  	"secret": "defaultsecret"

   155 //  }

   156 //  Env : {

   157 //  	"secret": "somesecretkey"

   158 //  }

   159 //

   160 // The resulting config will have the following values:

   161 //

   162 //	{

   163 //		"secret": "somesecretkey",

   164 //		"user": "root",

   165 //		"endpoint": "https://localhost"

   166 //	}

   167 type Viper struct {

   168 	// Delimiter that separates a list of keys

   169 	// used to access a nested value in one go

   170 	keyDelim string

   171 

   172 	// A set of paths to look for the config file in

   173 	configPaths []string

   174 

   175 	// The filesystem to read config from.

   176 	fs afero.Fs

   177 

   178 	// A set of remote providers to search for the configuration

   179 	remoteProviders []*defaultRemoteProvider

   180 

   181 	// Name of file to look for inside the path

   182 	configName string

   183 	configFile string

   184 	configType string

   185 	envPrefix  string

   186 

   187 	automaticEnvApplied bool

   188 	envKeyReplacer      *strings.Replacer

   189 

   190 	config         map[string]interface{}

   191 	override       map[string]interface{}

   192 	defaults       map[string]interface{}

   193 	kvstore        map[string]interface{}

   194 	pflags         map[string]FlagValue

   195 	env            map[string]string

   196 	aliases        map[string]string

   197 	typeByDefValue bool

   198 

   199 	// Store read properties on the object so that we can write back in order with comments.

   200 	// This will only be used if the configuration read is a properties file.

   201 	properties *properties.Properties

   202 

   203 	onConfigChange func(fsnotify.Event)

   204 }

   205 

   206 // New returns an initialized Viper instance.

   207 func New() *Viper {

   208 	v := new(Viper)

   209 	v.keyDelim = "."

   210 	v.configName = "config"

   211 	v.fs = afero.NewOsFs()

   212 	v.config = make(map[string]interface{})

   213 	v.override = make(map[string]interface{})

   214 	v.defaults = make(map[string]interface{})

   215 	v.kvstore = make(map[string]interface{})

   216 	v.pflags = make(map[string]FlagValue)

   217 	v.env = make(map[string]string)

   218 	v.aliases = make(map[string]string)

   219 	v.typeByDefValue = false

   220 

   221 	return v

   222 }

   223 

   224 // Intended for testing, will reset all to default settings.

   225 // In the public interface for the viper package so applications

   226 // can use it in their testing as well.

   227 func Reset() {

   228 	v = New()

   229 	SupportedExts = []string{"json", "toml", "yaml", "yml", "properties", "props", "prop", "hcl"}

   230 	SupportedRemoteProviders = []string{"etcd", "consul"}

   231 }

   232 

   233 type defaultRemoteProvider struct {

   234 	provider      string

   235 	endpoint      string

   236 	path          string

   237 	secretKeyring string

   238 }

   239 

   240 func (rp defaultRemoteProvider) Provider() string {

   241 	return rp.provider

   242 }

   243 

   244 func (rp defaultRemoteProvider) Endpoint() string {

   245 	return rp.endpoint

   246 }

   247 

   248 func (rp defaultRemoteProvider) Path() string {

   249 	return rp.path

   250 }

   251 

   252 func (rp defaultRemoteProvider) SecretKeyring() string {

   253 	return rp.secretKeyring

   254 }

   255 

   256 // RemoteProvider stores the configuration necessary

   257 // to connect to a remote key/value store.

   258 // Optional secretKeyring to unencrypt encrypted values

   259 // can be provided.

   260 type RemoteProvider interface {

   261 	Provider() string

   262 	Endpoint() string

   263 	Path() string

   264 	SecretKeyring() string

   265 }

   266 

   267 // SupportedExts are universally supported extensions.

   268 var SupportedExts = []string{"json", "toml", "yaml", "yml", "properties", "props", "prop", "hcl"}

   269 

   270 // SupportedRemoteProviders are universally supported remote providers.

   271 var SupportedRemoteProviders = []string{"etcd", "consul"}

   272 

   273 func OnConfigChange(run func(in fsnotify.Event)) { v.OnConfigChange(run) }

   274 func (v *Viper) OnConfigChange(run func(in fsnotify.Event)) {

   275 	v.onConfigChange = run

   276 }

   277 

   278 func WatchConfig() { v.WatchConfig() }

   279 func (v *Viper) WatchConfig() {

   280 	go func() {

   281 		watcher, err := fsnotify.NewWatcher()

   282 		if err != nil {

   283 			log.Fatal(err)

   284 		}

   285 		defer watcher.Close()

   286 

   287 		// we have to watch the entire directory to pick up renames/atomic saves in a cross-platform way

   288 		filename, err := v.getConfigFile()

   289 		if err != nil {

   290 			log.Println("error:", err)

   291 			return

   292 		}

   293 

   294 		configFile := filepath.Clean(filename)

   295 		configDir, _ := filepath.Split(configFile)

   296 

   297 		done := make(chan bool)

   298 		go func() {

   299 			for {

   300 				select {

   301 				case event := <-watcher.Events:

   302 					// we only care about the config file

   303 					if filepath.Clean(event.Name) == configFile {

   304 						if event.Op&fsnotify.Write == fsnotify.Write || event.Op&fsnotify.Create == fsnotify.Create {

   305 							err := v.ReadInConfig()

   306 							if err != nil {

   307 								log.Println("error:", err)

   308 							}

   309 							if v.onConfigChange != nil {

   310 								v.onConfigChange(event)

   311 							}

   312 						}

   313 					}

   314 				case err := <-watcher.Errors:

   315 					log.Println("error:", err)

   316 				}

   317 			}

   318 		}()

   319 

   320 		watcher.Add(configDir)

   321 		<-done

   322 	}()

   323 }

   324 

   325 // SetConfigFile explicitly defines the path, name and extension of the config file.

   326 // Viper will use this and not check any of the config paths.

   327 func SetConfigFile(in string) { v.SetConfigFile(in) }

   328 func (v *Viper) SetConfigFile(in string) {

   329 	if in != "" {

   330 		v.configFile = in

   331 	}

   332 }

   333 

   334 // SetEnvPrefix defines a prefix that ENVIRONMENT variables will use.

   335 // E.g. if your prefix is "spf", the env registry will look for env

   336 // variables that start with "SPF_".

   337 func SetEnvPrefix(in string) { v.SetEnvPrefix(in) }

   338 func (v *Viper) SetEnvPrefix(in string) {

   339 	if in != "" {

   340 		v.envPrefix = in

   341 	}

   342 }

   343 

   344 func (v *Viper) mergeWithEnvPrefix(in string) string {

   345 	if v.envPrefix != "" {

   346 		return strings.ToUpper(v.envPrefix + "_" + in)

   347 	}

   348 

   349 	return strings.ToUpper(in)

   350 }

   351 

   352 // TODO: should getEnv logic be moved into find(). Can generalize the use of

   353 // rewriting keys many things, Ex: Get('someKey') -> some_key

   354 // (camel case to snake case for JSON keys perhaps)

   355 

   356 // getEnv is a wrapper around os.Getenv which replaces characters in the original

   357 // key. This allows env vars which have different keys than the config object

   358 // keys.

   359 func (v *Viper) getEnv(key string) string {

   360 	if v.envKeyReplacer != nil {

   361 		key = v.envKeyReplacer.Replace(key)

   362 	}

   363 	return os.Getenv(key)

   364 }

   365 

   366 // ConfigFileUsed returns the file used to populate the config registry.

   367 func ConfigFileUsed() string            { return v.ConfigFileUsed() }

   368 func (v *Viper) ConfigFileUsed() string { return v.configFile }

   369 

   370 // AddConfigPath adds a path for Viper to search for the config file in.

   371 // Can be called multiple times to define multiple search paths.

   372 func AddConfigPath(in string) { v.AddConfigPath(in) }

   373 func (v *Viper) AddConfigPath(in string) {

   374 	if in != "" {

   375 		absin := absPathify(in)

   376 		jww.INFO.Println("adding", absin, "to paths to search")

   377 		if !stringInSlice(absin, v.configPaths) {

   378 			v.configPaths = append(v.configPaths, absin)

   379 		}

   380 	}

   381 }

   382 

   383 // AddRemoteProvider adds a remote configuration source.

   384 // Remote Providers are searched in the order they are added.

   385 // provider is a string value, "etcd" or "consul" are currently supported.

   386 // endpoint is the url.  etcd requires http://ip:port  consul requires ip:port

   387 // path is the path in the k/v store to retrieve configuration

   388 // To retrieve a config file called myapp.json from /configs/myapp.json

   389 // you should set path to /configs and set config name (SetConfigName()) to

   390 // "myapp"

   391 func AddRemoteProvider(provider, endpoint, path string) error {

   392 	return v.AddRemoteProvider(provider, endpoint, path)

   393 }

   394 func (v *Viper) AddRemoteProvider(provider, endpoint, path string) error {

   395 	if !stringInSlice(provider, SupportedRemoteProviders) {

   396 		return UnsupportedRemoteProviderError(provider)

   397 	}

   398 	if provider != "" && endpoint != "" {

   399 		jww.INFO.Printf("adding %s:%s to remote provider list", provider, endpoint)

   400 		rp := &defaultRemoteProvider{

   401 			endpoint: endpoint,

   402 			provider: provider,

   403 			path:     path,

   404 		}

   405 		if !v.providerPathExists(rp) {

   406 			v.remoteProviders = append(v.remoteProviders, rp)

   407 		}

   408 	}

   409 	return nil

   410 }

   411 

   412 // AddSecureRemoteProvider adds a remote configuration source.

   413 // Secure Remote Providers are searched in the order they are added.

   414 // provider is a string value, "etcd" or "consul" are currently supported.

   415 // endpoint is the url.  etcd requires http://ip:port  consul requires ip:port

   416 // secretkeyring is the filepath to your openpgp secret keyring.  e.g. /etc/secrets/myring.gpg

   417 // path is the path in the k/v store to retrieve configuration

   418 // To retrieve a config file called myapp.json from /configs/myapp.json

   419 // you should set path to /configs and set config name (SetConfigName()) to

   420 // "myapp"

   421 // Secure Remote Providers are implemented with github.com/xordataexchange/crypt

   422 func AddSecureRemoteProvider(provider, endpoint, path, secretkeyring string) error {

   423 	return v.AddSecureRemoteProvider(provider, endpoint, path, secretkeyring)

   424 }

   425 

   426 func (v *Viper) AddSecureRemoteProvider(provider, endpoint, path, secretkeyring string) error {

   427 	if !stringInSlice(provider, SupportedRemoteProviders) {

   428 		return UnsupportedRemoteProviderError(provider)

   429 	}

   430 	if provider != "" && endpoint != "" {

   431 		jww.INFO.Printf("adding %s:%s to remote provider list", provider, endpoint)

   432 		rp := &defaultRemoteProvider{

   433 			endpoint:      endpoint,

   434 			provider:      provider,

   435 			path:          path,

   436 			secretKeyring: secretkeyring,

   437 		}

   438 		if !v.providerPathExists(rp) {

   439 			v.remoteProviders = append(v.remoteProviders, rp)

   440 		}

   441 	}

   442 	return nil

   443 }

   444 

   445 func (v *Viper) providerPathExists(p *defaultRemoteProvider) bool {

   446 	for _, y := range v.remoteProviders {

   447 		if reflect.DeepEqual(y, p) {

   448 			return true

   449 		}

   450 	}

   451 	return false

   452 }

   453 

   454 // searchMap recursively searches for a value for path in source map.

   455 // Returns nil if not found.

   456 // Note: This assumes that the path entries and map keys are lower cased.

   457 func (v *Viper) searchMap(source map[string]interface{}, path []string) interface{} {

   458 	if len(path) == 0 {

   459 		return source

   460 	}

   461 

   462 	next, ok := source[path[0]]

   463 	if ok {

   464 		// Fast path

   465 		if len(path) == 1 {

   466 			return next

   467 		}

   468 

   469 		// Nested case

   470 		switch next.(type) {

   471 		case map[interface{}]interface{}:

   472 			return v.searchMap(cast.ToStringMap(next), path[1:])

   473 		case map[string]interface{}:

   474 			// Type assertion is safe here since it is only reached

   475 			// if the type of `next` is the same as the type being asserted

   476 			return v.searchMap(next.(map[string]interface{}), path[1:])

   477 		default:

   478 			// got a value but nested key expected, return "nil" for not found

   479 			return nil

   480 		}

   481 	}

   482 	return nil

   483 }

   484 

   485 // searchMapWithPathPrefixes recursively searches for a value for path in source map.

   486 //

   487 // While searchMap() considers each path element as a single map key, this

   488 // function searches for, and prioritizes, merged path elements.

   489 // e.g., if in the source, "foo" is defined with a sub-key "bar", and "foo.bar"

   490 // is also defined, this latter value is returned for path ["foo", "bar"].

   491 //

   492 // This should be useful only at config level (other maps may not contain dots

   493 // in their keys).

   494 //

   495 // Note: This assumes that the path entries and map keys are lower cased.

   496 func (v *Viper) searchMapWithPathPrefixes(source map[string]interface{}, path []string) interface{} {

   497 	if len(path) == 0 {

   498 		return source

   499 	}

   500 

   501 	// search for path prefixes, starting from the longest one

   502 	for i := len(path); i > 0; i-- {

   503 		prefixKey := strings.ToLower(strings.Join(path[0:i], v.keyDelim))

   504 

   505 		next, ok := source[prefixKey]

   506 		if ok {

   507 			// Fast path

   508 			if i == len(path) {

   509 				return next

   510 			}

   511 

   512 			// Nested case

   513 			var val interface{}

   514 			switch next.(type) {

   515 			case map[interface{}]interface{}:

   516 				val = v.searchMapWithPathPrefixes(cast.ToStringMap(next), path[i:])

   517 			case map[string]interface{}:

   518 				// Type assertion is safe here since it is only reached

   519 				// if the type of `next` is the same as the type being asserted

   520 				val = v.searchMapWithPathPrefixes(next.(map[string]interface{}), path[i:])

   521 			default:

   522 				// got a value but nested key expected, do nothing and look for next prefix

   523 			}

   524 			if val != nil {

   525 				return val

   526 			}

   527 		}

   528 	}

   529 

   530 	// not found

   531 	return nil

   532 }

   533 

   534 // isPathShadowedInDeepMap makes sure the given path is not shadowed somewhere

   535 // on its path in the map.

   536 // e.g., if "foo.bar" has a value in the given map, it “shadows”

   537 //       "foo.bar.baz" in a lower-priority map

   538 func (v *Viper) isPathShadowedInDeepMap(path []string, m map[string]interface{}) string {

   539 	var parentVal interface{}

   540 	for i := 1; i < len(path); i++ {

   541 		parentVal = v.searchMap(m, path[0:i])

   542 		if parentVal == nil {

   543 			// not found, no need to add more path elements

   544 			return ""

   545 		}

   546 		switch parentVal.(type) {

   547 		case map[interface{}]interface{}:

   548 			continue

   549 		case map[string]interface{}:

   550 			continue

   551 		default:

   552 			// parentVal is a regular value which shadows "path"

   553 			return strings.Join(path[0:i], v.keyDelim)

   554 		}

   555 	}

   556 	return ""

   557 }

   558 

   559 // isPathShadowedInFlatMap makes sure the given path is not shadowed somewhere

   560 // in a sub-path of the map.

   561 // e.g., if "foo.bar" has a value in the given map, it “shadows”

   562 //       "foo.bar.baz" in a lower-priority map

   563 func (v *Viper) isPathShadowedInFlatMap(path []string, mi interface{}) string {

   564 	// unify input map

   565 	var m map[string]interface{}

   566 	switch mi.(type) {

   567 	case map[string]string, map[string]FlagValue:

   568 		m = cast.ToStringMap(mi)

   569 	default:

   570 		return ""

   571 	}

   572 

   573 	// scan paths

   574 	var parentKey string

   575 	for i := 1; i < len(path); i++ {

   576 		parentKey = strings.Join(path[0:i], v.keyDelim)

   577 		if _, ok := m[parentKey]; ok {

   578 			return parentKey

   579 		}

   580 	}

   581 	return ""

   582 }

   583 

   584 // isPathShadowedInAutoEnv makes sure the given path is not shadowed somewhere

   585 // in the environment, when automatic env is on.

   586 // e.g., if "foo.bar" has a value in the environment, it “shadows”

   587 //       "foo.bar.baz" in a lower-priority map

   588 func (v *Viper) isPathShadowedInAutoEnv(path []string) string {

   589 	var parentKey string

   590 	var val string

   591 	for i := 1; i < len(path); i++ {

   592 		parentKey = strings.Join(path[0:i], v.keyDelim)

   593 		if val = v.getEnv(v.mergeWithEnvPrefix(parentKey)); val != "" {

   594 			return parentKey

   595 		}

   596 	}

   597 	return ""

   598 }

   599 

   600 // SetTypeByDefaultValue enables or disables the inference of a key value's

   601 // type when the Get function is used based upon a key's default value as

   602 // opposed to the value returned based on the normal fetch logic.

   603 //

   604 // For example, if a key has a default value of []string{} and the same key

   605 // is set via an environment variable to "a b c", a call to the Get function

   606 // would return a string slice for the key if the key's type is inferred by

   607 // the default value and the Get function would return:

   608 //

   609 //   []string {"a", "b", "c"}

   610 //

   611 // Otherwise the Get function would return:

   612 //

   613 //   "a b c"

   614 func SetTypeByDefaultValue(enable bool) { v.SetTypeByDefaultValue(enable) }

   615 func (v *Viper) SetTypeByDefaultValue(enable bool) {

   616 	v.typeByDefValue = enable

   617 }

   618 

   619 // GetViper gets the global Viper instance.

   620 func GetViper() *Viper {

   621 	return v

   622 }

   623 

   624 // Get can retrieve any value given the key to use.

   625 // Get is case-insensitive for a key.

   626 // Get has the behavior of returning the value associated with the first

   627 // place from where it is set. Viper will check in the following order:

   628 // override, flag, env, config file, key/value store, default

   629 //

   630 // Get returns an interface. For a specific value use one of the Get____ methods.

   631 func Get(key string) interface{} { return v.Get(key) }

   632 func (v *Viper) Get(key string) interface{} {

   633 	lcaseKey := strings.ToLower(key)

   634 	val := v.find(lcaseKey)

   635 	if val == nil {

   636 		return nil

   637 	}

   638 

   639 	if v.typeByDefValue {

   640 		// TODO(bep) this branch isn't covered by a single test.

   641 		valType := val

   642 		path := strings.Split(lcaseKey, v.keyDelim)

   643 		defVal := v.searchMap(v.defaults, path)

   644 		if defVal != nil {

   645 			valType = defVal

   646 		}

   647 

   648 		switch valType.(type) {

   649 		case bool:

   650 			return cast.ToBool(val)

   651 		case string:

   652 			return cast.ToString(val)

   653 		case int32, int16, int8, int:

   654 			return cast.ToInt(val)

   655 		case int64:

   656 			return cast.ToInt64(val)

   657 		case float64, float32:

   658 			return cast.ToFloat64(val)

   659 		case time.Time:

   660 			return cast.ToTime(val)

   661 		case time.Duration:

   662 			return cast.ToDuration(val)

   663 		case []string:

   664 			return cast.ToStringSlice(val)

   665 		}

   666 	}

   667 

   668 	return val

   669 }

   670 

   671 // Sub returns new Viper instance representing a sub tree of this instance.

   672 // Sub is case-insensitive for a key.

   673 func Sub(key string) *Viper { return v.Sub(key) }

   674 func (v *Viper) Sub(key string) *Viper {

   675 	subv := New()

   676 	data := v.Get(key)

   677 	if data == nil {

   678 		return nil

   679 	}

   680 

   681 	if reflect.TypeOf(data).Kind() == reflect.Map {

   682 		subv.config = cast.ToStringMap(data)

   683 		return subv

   684 	}

   685 	return nil

   686 }

   687 

   688 // GetString returns the value associated with the key as a string.

   689 func GetString(key string) string { return v.GetString(key) }

   690 func (v *Viper) GetString(key string) string {

   691 	return cast.ToString(v.Get(key))

   692 }

   693 

   694 // GetBool returns the value associated with the key as a boolean.

   695 func GetBool(key string) bool { return v.GetBool(key) }

   696 func (v *Viper) GetBool(key string) bool {

   697 	return cast.ToBool(v.Get(key))

   698 }

   699 

   700 // GetInt returns the value associated with the key as an integer.

   701 func GetInt(key string) int { return v.GetInt(key) }

   702 func (v *Viper) GetInt(key string) int {

   703 	return cast.ToInt(v.Get(key))

   704 }

   705 

   706 // GetInt32 returns the value associated with the key as an integer.

   707 func GetInt32(key string) int32 { return v.GetInt32(key) }

   708 func (v *Viper) GetInt32(key string) int32 {

   709 	return cast.ToInt32(v.Get(key))

   710 }

   711 

   712 // GetInt64 returns the value associated with the key as an integer.

   713 func GetInt64(key string) int64 { return v.GetInt64(key) }

   714 func (v *Viper) GetInt64(key string) int64 {

   715 	return cast.ToInt64(v.Get(key))

   716 }

   717 

   718 // GetFloat64 returns the value associated with the key as a float64.

   719 func GetFloat64(key string) float64 { return v.GetFloat64(key) }

   720 func (v *Viper) GetFloat64(key string) float64 {

   721 	return cast.ToFloat64(v.Get(key))

   722 }

   723 

   724 // GetTime returns the value associated with the key as time.

   725 func GetTime(key string) time.Time { return v.GetTime(key) }

   726 func (v *Viper) GetTime(key string) time.Time {

   727 	return cast.ToTime(v.Get(key))

   728 }

   729 

   730 // GetDuration returns the value associated with the key as a duration.

   731 func GetDuration(key string) time.Duration { return v.GetDuration(key) }

   732 func (v *Viper) GetDuration(key string) time.Duration {

   733 	return cast.ToDuration(v.Get(key))

   734 }

   735 

   736 // GetStringSlice returns the value associated with the key as a slice of strings.

   737 func GetStringSlice(key string) []string { return v.GetStringSlice(key) }

   738 func (v *Viper) GetStringSlice(key string) []string {

   739 	return cast.ToStringSlice(v.Get(key))

   740 }

   741 

   742 // GetStringMap returns the value associated with the key as a map of interfaces.

   743 func GetStringMap(key string) map[string]interface{} { return v.GetStringMap(key) }

   744 func (v *Viper) GetStringMap(key string) map[string]interface{} {

   745 	return cast.ToStringMap(v.Get(key))

   746 }

   747 

   748 // GetStringMapString returns the value associated with the key as a map of strings.

   749 func GetStringMapString(key string) map[string]string { return v.GetStringMapString(key) }

   750 func (v *Viper) GetStringMapString(key string) map[string]string {

   751 	return cast.ToStringMapString(v.Get(key))

   752 }

   753 

   754 // GetStringMapStringSlice returns the value associated with the key as a map to a slice of strings.

   755 func GetStringMapStringSlice(key string) map[string][]string { return v.GetStringMapStringSlice(key) }

   756 func (v *Viper) GetStringMapStringSlice(key string) map[string][]string {

   757 	return cast.ToStringMapStringSlice(v.Get(key))

   758 }

   759 

   760 // GetSizeInBytes returns the size of the value associated with the given key

   761 // in bytes.

   762 func GetSizeInBytes(key string) uint { return v.GetSizeInBytes(key) }

   763 func (v *Viper) GetSizeInBytes(key string) uint {

   764 	sizeStr := cast.ToString(v.Get(key))

   765 	return parseSizeInBytes(sizeStr)

   766 }

   767 

   768 // UnmarshalKey takes a single key and unmarshals it into a Struct.

   769 func UnmarshalKey(key string, rawVal interface{}, opts ...DecoderConfigOption) error {

   770 	return v.UnmarshalKey(key, rawVal, opts...)

   771 }

   772 func (v *Viper) UnmarshalKey(key string, rawVal interface{}, opts ...DecoderConfigOption) error {

   773 	err := decode(v.Get(key), defaultDecoderConfig(rawVal, opts...))

   774 

   775 	if err != nil {

   776 		return err

   777 	}

   778 

   779 	v.insensitiviseMaps()

   780 

   781 	return nil

   782 }

   783 

   784 // Unmarshal unmarshals the config into a Struct. Make sure that the tags

   785 // on the fields of the structure are properly set.

   786 func Unmarshal(rawVal interface{}, opts ...DecoderConfigOption) error {

   787 	return v.Unmarshal(rawVal, opts...)

   788 }

   789 func (v *Viper) Unmarshal(rawVal interface{}, opts ...DecoderConfigOption) error {

   790 	err := decode(v.AllSettings(), defaultDecoderConfig(rawVal, opts...))

   791 

   792 	if err != nil {

   793 		return err

   794 	}

   795 

   796 	v.insensitiviseMaps()

   797 

   798 	return nil

   799 }

   800 

   801 // defaultDecoderConfig returns default mapsstructure.DecoderConfig with suppot

   802 // of time.Duration values & string slices

   803 func defaultDecoderConfig(output interface{}, opts ...DecoderConfigOption) *mapstructure.DecoderConfig {

   804 	c := &mapstructure.DecoderConfig{

   805 		Metadata:         nil,

   806 		Result:           output,

   807 		WeaklyTypedInput: true,

   808 		DecodeHook: mapstructure.ComposeDecodeHookFunc(

   809 			mapstructure.StringToTimeDurationHookFunc(),

   810 			mapstructure.StringToSliceHookFunc(","),

   811 		),

   812 	}

   813 	for _, opt := range opts {

   814 		opt(c)

   815 	}

   816 	return c

   817 }

   818 

   819 // A wrapper around mapstructure.Decode that mimics the WeakDecode functionality

   820 func decode(input interface{}, config *mapstructure.DecoderConfig) error {

   821 	decoder, err := mapstructure.NewDecoder(config)

   822 	if err != nil {

   823 		return err

   824 	}

   825 	return decoder.Decode(input)

   826 }

   827 

   828 // UnmarshalExact unmarshals the config into a Struct, erroring if a field is nonexistent

   829 // in the destination struct.

   830 func (v *Viper) UnmarshalExact(rawVal interface{}) error {

   831 	config := defaultDecoderConfig(rawVal)

   832 	config.ErrorUnused = true

   833 

   834 	err := decode(v.AllSettings(), config)

   835 

   836 	if err != nil {

   837 		return err

   838 	}

   839 

   840 	v.insensitiviseMaps()

   841 

   842 	return nil

   843 }

   844 

   845 // BindPFlags binds a full flag set to the configuration, using each flag's long

   846 // name as the config key.

   847 func BindPFlags(flags *pflag.FlagSet) error { return v.BindPFlags(flags) }

   848 func (v *Viper) BindPFlags(flags *pflag.FlagSet) error {

   849 	return v.BindFlagValues(pflagValueSet{flags})

   850 }

   851 

   852 // BindPFlag binds a specific key to a pflag (as used by cobra).

   853 // Example (where serverCmd is a Cobra instance):

   854 //

   855 //	 serverCmd.Flags().Int("port", 1138, "Port to run Application server on")

   856 //	 Viper.BindPFlag("port", serverCmd.Flags().Lookup("port"))

   857 //

   858 func BindPFlag(key string, flag *pflag.Flag) error { return v.BindPFlag(key, flag) }

   859 func (v *Viper) BindPFlag(key string, flag *pflag.Flag) error {

   860 	return v.BindFlagValue(key, pflagValue{flag})

   861 }

   862 

   863 // BindFlagValues binds a full FlagValue set to the configuration, using each flag's long

   864 // name as the config key.

   865 func BindFlagValues(flags FlagValueSet) error { return v.BindFlagValues(flags) }

   866 func (v *Viper) BindFlagValues(flags FlagValueSet) (err error) {

   867 	flags.VisitAll(func(flag FlagValue) {

   868 		if err = v.BindFlagValue(flag.Name(), flag); err != nil {

   869 			return

   870 		}

   871 	})

   872 	return nil

   873 }

   874 

   875 // BindFlagValue binds a specific key to a FlagValue.

   876 // Example (where serverCmd is a Cobra instance):

   877 //

   878 //	 serverCmd.Flags().Int("port", 1138, "Port to run Application server on")

   879 //	 Viper.BindFlagValue("port", serverCmd.Flags().Lookup("port"))

   880 //

   881 func BindFlagValue(key string, flag FlagValue) error { return v.BindFlagValue(key, flag) }

   882 func (v *Viper) BindFlagValue(key string, flag FlagValue) error {

   883 	if flag == nil {

   884 		return fmt.Errorf("flag for %q is nil", key)

   885 	}

   886 	v.pflags[strings.ToLower(key)] = flag

   887 	return nil

   888 }

   889 

   890 // BindEnv binds a Viper key to a ENV variable.

   891 // ENV variables are case sensitive.

   892 // If only a key is provided, it will use the env key matching the key, uppercased.

   893 // EnvPrefix will be used when set when env name is not provided.

   894 func BindEnv(input ...string) error { return v.BindEnv(input...) }

   895 func (v *Viper) BindEnv(input ...string) error {

   896 	var key, envkey string

   897 	if len(input) == 0 {

   898 		return fmt.Errorf("BindEnv missing key to bind to")

   899 	}

   900 

   901 	key = strings.ToLower(input[0])

   902 

   903 	if len(input) == 1 {

   904 		envkey = v.mergeWithEnvPrefix(key)

   905 	} else {

   906 		envkey = input[1]

   907 	}

   908 

   909 	v.env[key] = envkey

   910 

   911 	return nil

   912 }

   913 

   914 // Given a key, find the value.

   915 // Viper will check in the following order:

   916 // flag, env, config file, key/value store, default.

   917 // Viper will check to see if an alias exists first.

   918 // Note: this assumes a lower-cased key given.

   919 func (v *Viper) find(lcaseKey string) interface{} {

   920 

   921 	var (

   922 		val    interface{}

   923 		exists bool

   924 		path   = strings.Split(lcaseKey, v.keyDelim)

   925 		nested = len(path) > 1

   926 	)

   927 

   928 	// compute the path through the nested maps to the nested value

   929 	if nested && v.isPathShadowedInDeepMap(path, castMapStringToMapInterface(v.aliases)) != "" {

   930 		return nil

   931 	}

   932 

   933 	// if the requested key is an alias, then return the proper key

   934 	lcaseKey = v.realKey(lcaseKey)

   935 	path = strings.Split(lcaseKey, v.keyDelim)

   936 	nested = len(path) > 1

   937 

   938 	// Set() override first

   939 	val = v.searchMap(v.override, path)

   940 	if val != nil {

   941 		return val

   942 	}

   943 	if nested && v.isPathShadowedInDeepMap(path, v.override) != "" {

   944 		return nil

   945 	}

   946 

   947 	// PFlag override next

   948 	flag, exists := v.pflags[lcaseKey]

   949 	if exists && flag.HasChanged() {

   950 		switch flag.ValueType() {

   951 		case "int", "int8", "int16", "int32", "int64":

   952 			return cast.ToInt(flag.ValueString())

   953 		case "bool":

   954 			return cast.ToBool(flag.ValueString())

   955 		case "stringSlice":

   956 			s := strings.TrimPrefix(flag.ValueString(), "[")

   957 			s = strings.TrimSuffix(s, "]")

   958 			res, _ := readAsCSV(s)

   959 			return res

   960 		default:

   961 			return flag.ValueString()

   962 		}

   963 	}

   964 	if nested && v.isPathShadowedInFlatMap(path, v.pflags) != "" {

   965 		return nil

   966 	}

   967 

   968 	// Env override next

   969 	if v.automaticEnvApplied {

   970 		// even if it hasn't been registered, if automaticEnv is used,

   971 		// check any Get request

   972 		if val = v.getEnv(v.mergeWithEnvPrefix(lcaseKey)); val != "" {

   973 			return val

   974 		}

   975 		if nested && v.isPathShadowedInAutoEnv(path) != "" {

   976 			return nil

   977 		}

   978 	}

   979 	envkey, exists := v.env[lcaseKey]

   980 	if exists {

   981 		if val = v.getEnv(envkey); val != "" {

   982 			return val

   983 		}

   984 	}

   985 	if nested && v.isPathShadowedInFlatMap(path, v.env) != "" {

   986 		return nil

   987 	}

   988 

   989 	// Config file next

   990 	val = v.searchMapWithPathPrefixes(v.config, path)

   991 	if val != nil {

   992 		return val

   993 	}

   994 	if nested && v.isPathShadowedInDeepMap(path, v.config) != "" {

   995 		return nil

   996 	}

   997 

   998 	// K/V store next

   999 	val = v.searchMap(v.kvstore, path)

  1000 	if val != nil {

  1001 		return val

  1002 	}

  1003 	if nested && v.isPathShadowedInDeepMap(path, v.kvstore) != "" {

  1004 		return nil

  1005 	}

  1006 

  1007 	// Default next

  1008 	val = v.searchMap(v.defaults, path)

  1009 	if val != nil {

  1010 		return val

  1011 	}

  1012 	if nested && v.isPathShadowedInDeepMap(path, v.defaults) != "" {

  1013 		return nil

  1014 	}

  1015 

  1016 	// last chance: if no other value is returned and a flag does exist for the value,

  1017 	// get the flag's value even if the flag's value has not changed

  1018 	if flag, exists := v.pflags[lcaseKey]; exists {

  1019 		switch flag.ValueType() {

  1020 		case "int", "int8", "int16", "int32", "int64":

  1021 			return cast.ToInt(flag.ValueString())

  1022 		case "bool":

  1023 			return cast.ToBool(flag.ValueString())

  1024 		case "stringSlice":

  1025 			s := strings.TrimPrefix(flag.ValueString(), "[")

  1026 			s = strings.TrimSuffix(s, "]")

  1027 			res, _ := readAsCSV(s)

  1028 			return res

  1029 		default:

  1030 			return flag.ValueString()

  1031 		}

  1032 	}

  1033 	// last item, no need to check shadowing

  1034 

  1035 	return nil

  1036 }

  1037 

  1038 func readAsCSV(val string) ([]string, error) {

  1039 	if val == "" {

  1040 		return []string{}, nil

  1041 	}

  1042 	stringReader := strings.NewReader(val)

  1043 	csvReader := csv.NewReader(stringReader)

  1044 	return csvReader.Read()

  1045 }

  1046 

  1047 // IsSet checks to see if the key has been set in any of the data locations.

  1048 // IsSet is case-insensitive for a key.

  1049 func IsSet(key string) bool { return v.IsSet(key) }

  1050 func (v *Viper) IsSet(key string) bool {

  1051 	lcaseKey := strings.ToLower(key)

  1052 	val := v.find(lcaseKey)

  1053 	return val != nil

  1054 }

  1055 

  1056 // AutomaticEnv has Viper check ENV variables for all.

  1057 // keys set in config, default & flags

  1058 func AutomaticEnv() { v.AutomaticEnv() }

  1059 func (v *Viper) AutomaticEnv() {

  1060 	v.automaticEnvApplied = true

  1061 }

  1062 

  1063 // SetEnvKeyReplacer sets the strings.Replacer on the viper object

  1064 // Useful for mapping an environmental variable to a key that does

  1065 // not match it.

  1066 func SetEnvKeyReplacer(r *strings.Replacer) { v.SetEnvKeyReplacer(r) }

  1067 func (v *Viper) SetEnvKeyReplacer(r *strings.Replacer) {

  1068 	v.envKeyReplacer = r

  1069 }

  1070 

  1071 // Aliases provide another accessor for the same key.

  1072 // This enables one to change a name without breaking the application

  1073 func RegisterAlias(alias string, key string) { v.RegisterAlias(alias, key) }

  1074 func (v *Viper) RegisterAlias(alias string, key string) {

  1075 	v.registerAlias(alias, strings.ToLower(key))

  1076 }

  1077 

  1078 func (v *Viper) registerAlias(alias string, key string) {

  1079 	alias = strings.ToLower(alias)

  1080 	if alias != key && alias != v.realKey(key) {

  1081 		_, exists := v.aliases[alias]

  1082 

  1083 		if !exists {

  1084 			// if we alias something that exists in one of the maps to another

  1085 			// name, we'll never be able to get that value using the original

  1086 			// name, so move the config value to the new realkey.

  1087 			if val, ok := v.config[alias]; ok {

  1088 				delete(v.config, alias)

  1089 				v.config[key] = val

  1090 			}

  1091 			if val, ok := v.kvstore[alias]; ok {

  1092 				delete(v.kvstore, alias)

  1093 				v.kvstore[key] = val

  1094 			}

  1095 			if val, ok := v.defaults[alias]; ok {

  1096 				delete(v.defaults, alias)

  1097 				v.defaults[key] = val

  1098 			}

  1099 			if val, ok := v.override[alias]; ok {

  1100 				delete(v.override, alias)

  1101 				v.override[key] = val

  1102 			}

  1103 			v.aliases[alias] = key

  1104 		}

  1105 	} else {

  1106 		jww.WARN.Println("Creating circular reference alias", alias, key, v.realKey(key))

  1107 	}

  1108 }

  1109 

  1110 func (v *Viper) realKey(key string) string {

  1111 	newkey, exists := v.aliases[key]

  1112 	if exists {

  1113 		jww.DEBUG.Println("Alias", key, "to", newkey)

  1114 		return v.realKey(newkey)

  1115 	}

  1116 	return key

  1117 }

  1118 

  1119 // InConfig checks to see if the given key (or an alias) is in the config file.

  1120 func InConfig(key string) bool { return v.InConfig(key) }

  1121 func (v *Viper) InConfig(key string) bool {

  1122 	// if the requested key is an alias, then return the proper key

  1123 	key = v.realKey(key)

  1124 

  1125 	_, exists := v.config[key]

  1126 	return exists

  1127 }

  1128 

  1129 // SetDefault sets the default value for this key.

  1130 // SetDefault is case-insensitive for a key.

  1131 // Default only used when no value is provided by the user via flag, config or ENV.

  1132 func SetDefault(key string, value interface{}) { v.SetDefault(key, value) }

  1133 func (v *Viper) SetDefault(key string, value interface{}) {

  1134 	// If alias passed in, then set the proper default

  1135 	key = v.realKey(strings.ToLower(key))