package config import ( "math/bits" "strings" "time" "unicode" "github.com/spf13/cast" ) func panicOnErr(err error) { if err != nil { panic(err) } } // StringSlice reads configuration value // from c by name and casts it to []string. // // Panics if value can not be casted. func StringSlice(c *Config, name string) []string { x, err := cast.ToStringSliceE(c.Value(name)) panicOnErr(err) return x } // StringSliceSafe reads configuration value // from c by name and casts it to []string. // // Returns nil if value can not be casted. func StringSliceSafe(c *Config, name string) []string { return cast.ToStringSlice(c.Value(name)) } // String reads configuration value // from c by name and casts it to string. // // Panics if value can not be casted. func String(c *Config, name string) string { x, err := cast.ToStringE(c.Value(name)) panicOnErr(err) return x } // StringSafe reads configuration value // from c by name and casts it to string. // // Returns "" if value can not be casted. func StringSafe(c *Config, name string) string { return cast.ToString(c.Value(name)) } // Duration reads configuration value // from c by name and casts it to time.Duration. // // Panics if value can not be casted. func Duration(c *Config, name string) time.Duration { x, err := cast.ToDurationE(c.Value(name)) panicOnErr(err) return x } // DurationSafe reads configuration value // from c by name and casts it to time.Duration. // // Returns 0 if value can not be casted. func DurationSafe(c *Config, name string) time.Duration { return cast.ToDuration(c.Value(name)) } // Bool reads configuration value // from c by name and casts it to bool. // // Panics if value can not be casted. func Bool(c *Config, name string) bool { x, err := cast.ToBoolE(c.Value(name)) panicOnErr(err) return x } // BoolSafe reads configuration value // from c by name and casts it to bool. // // Returns false if value can not be casted. func BoolSafe(c *Config, name string) bool { return cast.ToBool(c.Value(name)) } // Uint32 reads configuration value // from c by name and casts it to uint32. // // Panics if value can not be casted. func Uint32(c *Config, name string) uint32 { x, err := cast.ToUint32E(c.Value(name)) panicOnErr(err) return x } // Uint32Safe reads configuration value // from c by name and casts it to uint32. // // Returns 0 if value can not be casted. func Uint32Safe(c *Config, name string) uint32 { return cast.ToUint32(c.Value(name)) } // Uint reads configuration value // from c by name and casts it to uint64. // // Panics if value can not be casted. func Uint(c *Config, name string) uint64 { x, err := cast.ToUint64E(c.Value(name)) panicOnErr(err) return x } // UintSafe reads configuration value // from c by name and casts it to uint64. // // Returns 0 if value can not be casted. func UintSafe(c *Config, name string) uint64 { return cast.ToUint64(c.Value(name)) } // Int reads configuration value // from c by name and casts it to int64. // // Panics if value can not be casted. func Int(c *Config, name string) int64 { x, err := cast.ToInt64E(c.Value(name)) panicOnErr(err) return x } // IntSafe reads configuration value // from c by name and casts it to int64. // // Returns 0 if value can not be casted. func IntSafe(c *Config, name string) int64 { return cast.ToInt64(c.Value(name)) } // SizeInBytesSafe reads configuration value // from c by name and casts it to size in bytes (uint64). // // The suffix can be single-letter (b, k, m, g, t) or with // an additional b at the end. Spaces between the number and the suffix // are allowed. All multipliers are power of 2 (i.e. k is for kibi-byte). // // Returns 0 if a value can't be casted. func SizeInBytesSafe(c *Config, name string) uint64 { s := StringSafe(c, name) return parseSizeInBytes(s) } // The following code is taken from https://github.com/spf13/viper/blob/master/util.go // with minor corrections (allow to use both `k` and `kb` forms. // Seems like viper allows to convert sizes but corresponding parser in `cast` package // is missing. // safeMul returns size*multiplier, rounding down to the // multiplier/1024 number of bytes. // Returns 0 if overflow is detected. func safeMul(size float64, multiplier uint64) uint64 { n := uint64(size) f := uint64((size - float64(n)) * 1024) if f != 0 && multiplier != 1 { s := n<<10 + f if s < n { return 0 } n = s multiplier >>= 10 } hi, lo := bits.Mul64(n, multiplier) if hi != 0 { return 0 } return lo } // parseSizeInBytes converts strings like 1GB or 12 mb into an unsigned integer number of bytes func parseSizeInBytes(sizeStr string) uint64 { sizeStr = strings.TrimSpace(sizeStr) lastChar := len(sizeStr) - 1 multiplier := uint64(1) if lastChar > 0 { if sizeStr[lastChar] == 'b' || sizeStr[lastChar] == 'B' { lastChar-- } if lastChar > 0 { switch unicode.ToLower(rune(sizeStr[lastChar])) { case 'k': multiplier = 1 << 10 sizeStr = strings.TrimSpace(sizeStr[:lastChar]) case 'm': multiplier = 1 << 20 sizeStr = strings.TrimSpace(sizeStr[:lastChar]) case 'g': multiplier = 1 << 30 sizeStr = strings.TrimSpace(sizeStr[:lastChar]) case 't': multiplier = 1 << 40 sizeStr = strings.TrimSpace(sizeStr[:lastChar]) default: multiplier = 1 sizeStr = strings.TrimSpace(sizeStr[:lastChar+1]) } } } size := cast.ToFloat64(sizeStr) return safeMul(size, multiplier) }