311 lines
7.1 KiB
Go
311 lines
7.1 KiB
Go
package configutil
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"sort"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/mitchellh/mapstructure"
|
|
)
|
|
|
|
// TODO (slackpad) - Trying out a different pattern here for config handling.
|
|
// These classes support the flag.Value interface but work in a manner where
|
|
// we can tell if they have been set. This lets us work with an all-pointer
|
|
// config structure and merge it in a clean-ish way. If this ends up being a
|
|
// good pattern we should pull this out into a reusable library.
|
|
|
|
// ConfigDecodeHook should be passed to mapstructure in order to decode into
|
|
// the *Value objects here.
|
|
var ConfigDecodeHook = mapstructure.ComposeDecodeHookFunc(
|
|
BoolToBoolValueFunc(),
|
|
StringToDurationValueFunc(),
|
|
StringToStringValueFunc(),
|
|
Float64ToUintValueFunc(),
|
|
)
|
|
|
|
// BoolValue provides a flag value that's aware if it has been set.
|
|
type BoolValue struct {
|
|
v *bool
|
|
}
|
|
|
|
// IsBoolFlag is an optional method of the flag.Value
|
|
// interface which marks this value as boolean when
|
|
// the return value is true. See flag.Value for details.
|
|
func (b *BoolValue) IsBoolFlag() bool {
|
|
return true
|
|
}
|
|
|
|
// Merge will overlay this value if it has been set.
|
|
func (b *BoolValue) Merge(onto *bool) {
|
|
if b.v != nil {
|
|
*onto = *(b.v)
|
|
}
|
|
}
|
|
|
|
// Set implements the flag.Value interface.
|
|
func (b *BoolValue) Set(v string) error {
|
|
if b.v == nil {
|
|
b.v = new(bool)
|
|
}
|
|
var err error
|
|
*(b.v), err = strconv.ParseBool(v)
|
|
return err
|
|
}
|
|
|
|
// String implements the flag.Value interface.
|
|
func (b *BoolValue) String() string {
|
|
var current bool
|
|
if b.v != nil {
|
|
current = *(b.v)
|
|
}
|
|
return fmt.Sprintf("%v", current)
|
|
}
|
|
|
|
// BoolToBoolValueFunc is a mapstructure hook that looks for an incoming bool
|
|
// mapped to a BoolValue and does the translation.
|
|
func BoolToBoolValueFunc() mapstructure.DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.Bool {
|
|
return data, nil
|
|
}
|
|
|
|
val := BoolValue{}
|
|
if t != reflect.TypeOf(val) {
|
|
return data, nil
|
|
}
|
|
|
|
val.v = new(bool)
|
|
*(val.v) = data.(bool)
|
|
return val, nil
|
|
}
|
|
}
|
|
|
|
// DurationValue provides a flag value that's aware if it has been set.
|
|
type DurationValue struct {
|
|
v *time.Duration
|
|
}
|
|
|
|
// Merge will overlay this value if it has been set.
|
|
func (d *DurationValue) Merge(onto *time.Duration) {
|
|
if d.v != nil {
|
|
*onto = *(d.v)
|
|
}
|
|
}
|
|
|
|
// Set implements the flag.Value interface.
|
|
func (d *DurationValue) Set(v string) error {
|
|
if d.v == nil {
|
|
d.v = new(time.Duration)
|
|
}
|
|
var err error
|
|
*(d.v), err = time.ParseDuration(v)
|
|
return err
|
|
}
|
|
|
|
// String implements the flag.Value interface.
|
|
func (d *DurationValue) String() string {
|
|
var current time.Duration
|
|
if d.v != nil {
|
|
current = *(d.v)
|
|
}
|
|
return current.String()
|
|
}
|
|
|
|
// StringToDurationValueFunc is a mapstructure hook that looks for an incoming
|
|
// string mapped to a DurationValue and does the translation.
|
|
func StringToDurationValueFunc() mapstructure.DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.String {
|
|
return data, nil
|
|
}
|
|
|
|
val := DurationValue{}
|
|
if t != reflect.TypeOf(val) {
|
|
return data, nil
|
|
}
|
|
if err := val.Set(data.(string)); err != nil {
|
|
return nil, err
|
|
}
|
|
return val, nil
|
|
}
|
|
}
|
|
|
|
// StringValue provides a flag value that's aware if it has been set.
|
|
type StringValue struct {
|
|
v *string
|
|
}
|
|
|
|
// Merge will overlay this value if it has been set.
|
|
func (s *StringValue) Merge(onto *string) {
|
|
if s.v != nil {
|
|
*onto = *(s.v)
|
|
}
|
|
}
|
|
|
|
// Set implements the flag.Value interface.
|
|
func (s *StringValue) Set(v string) error {
|
|
if s.v == nil {
|
|
s.v = new(string)
|
|
}
|
|
*(s.v) = v
|
|
return nil
|
|
}
|
|
|
|
// String implements the flag.Value interface.
|
|
func (s *StringValue) String() string {
|
|
var current string
|
|
if s.v != nil {
|
|
current = *(s.v)
|
|
}
|
|
return current
|
|
}
|
|
|
|
// StringToStringValueFunc is a mapstructure hook that looks for an incoming
|
|
// string mapped to a StringValue and does the translation.
|
|
func StringToStringValueFunc() mapstructure.DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.String {
|
|
return data, nil
|
|
}
|
|
|
|
val := StringValue{}
|
|
if t != reflect.TypeOf(val) {
|
|
return data, nil
|
|
}
|
|
val.v = new(string)
|
|
*(val.v) = data.(string)
|
|
return val, nil
|
|
}
|
|
}
|
|
|
|
// UintValue provides a flag value that's aware if it has been set.
|
|
type UintValue struct {
|
|
v *uint
|
|
}
|
|
|
|
// Merge will overlay this value if it has been set.
|
|
func (u *UintValue) Merge(onto *uint) {
|
|
if u.v != nil {
|
|
*onto = *(u.v)
|
|
}
|
|
}
|
|
|
|
// Set implements the flag.Value interface.
|
|
func (u *UintValue) Set(v string) error {
|
|
if u.v == nil {
|
|
u.v = new(uint)
|
|
}
|
|
parsed, err := strconv.ParseUint(v, 0, 64)
|
|
*(u.v) = (uint)(parsed)
|
|
return err
|
|
}
|
|
|
|
// String implements the flag.Value interface.
|
|
func (u *UintValue) String() string {
|
|
var current uint
|
|
if u.v != nil {
|
|
current = *(u.v)
|
|
}
|
|
return fmt.Sprintf("%v", current)
|
|
}
|
|
|
|
// Float64ToUintValueFunc is a mapstructure hook that looks for an incoming
|
|
// float64 mapped to a UintValue and does the translation.
|
|
func Float64ToUintValueFunc() mapstructure.DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.Float64 {
|
|
return data, nil
|
|
}
|
|
|
|
val := UintValue{}
|
|
if t != reflect.TypeOf(val) {
|
|
return data, nil
|
|
}
|
|
|
|
fv := data.(float64)
|
|
if fv < 0 {
|
|
return nil, fmt.Errorf("value cannot be negative")
|
|
}
|
|
|
|
// The standard guarantees at least this, and this is fine for
|
|
// values we expect to use in configs vs. being fancy with the
|
|
// machine's size for uint.
|
|
if fv > (1<<32 - 1) {
|
|
return nil, fmt.Errorf("value is too large")
|
|
}
|
|
|
|
val.v = new(uint)
|
|
*(val.v) = (uint)(fv)
|
|
return val, nil
|
|
}
|
|
}
|
|
|
|
// VisitFn is a callback that gets a chance to visit each file found during a
|
|
// traversal with visit().
|
|
type VisitFn func(path string) error
|
|
|
|
// Visit will call the visitor function on the path if it's a file, or for each
|
|
// file in the path if it's a directory. Directories will not be recursed into,
|
|
// and files in the directory will be visited in alphabetical order.
|
|
func Visit(path string, visitor VisitFn) error {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return fmt.Errorf("error reading %q: %v", path, err)
|
|
}
|
|
defer f.Close()
|
|
|
|
fi, err := f.Stat()
|
|
if err != nil {
|
|
return fmt.Errorf("error checking %q: %v", path, err)
|
|
}
|
|
|
|
if !fi.IsDir() {
|
|
if err := visitor(path); err != nil {
|
|
return fmt.Errorf("error in %q: %v", path, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
contents, err := f.Readdir(-1)
|
|
if err != nil {
|
|
return fmt.Errorf("error listing %q: %v", path, err)
|
|
}
|
|
|
|
sort.Sort(dirEnts(contents))
|
|
for _, fi := range contents {
|
|
if fi.IsDir() {
|
|
continue
|
|
}
|
|
|
|
fullPath := filepath.Join(path, fi.Name())
|
|
if err := visitor(fullPath); err != nil {
|
|
return fmt.Errorf("error in %q: %v", fullPath, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// dirEnts applies sort.Interface to directory entries for sorting by name.
|
|
type dirEnts []os.FileInfo
|
|
|
|
func (d dirEnts) Len() int { return len(d) }
|
|
func (d dirEnts) Less(i, j int) bool { return d[i].Name() < d[j].Name() }
|
|
func (d dirEnts) Swap(i, j int) { d[i], d[j] = d[j], d[i] }
|