implement mcfg package, which includes both configuration, runtime setup, and organizing both into heirarchies
This commit is contained in:
Brian Picciano
parent
3f2f00d367
commit
3d43caba18
195
mcfg/cli.go
Normal file
195
mcfg/cli.go
Normal file
@ -0,0 +1,195 @@
|
||||
package mcfg
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// SourceCLI is a Source which will parse configuration from the CLI.
|
||||
//
|
||||
// Possible CLI options are generated by joining the Path to a Param, and its
|
||||
// name, with dashes. For example:
|
||||
//
|
||||
// cfg := mcfg.New().Child("foo").Child("bar")
|
||||
// addr := cfg.ParamString("addr", "", "Some address")
|
||||
// // the CLI option to fill addr will be "--foo-bar-addr"
|
||||
//
|
||||
// If the "-h" option is seen then a help page will be printed to
|
||||
// stdout and the process will exit. Since all normally-defined parameters must
|
||||
// being with double-dash ("--") they won't ever conflict with the help option.
|
||||
//
|
||||
type SourceCLI struct {
|
||||
Args []string // if nil then os.Args[1:] is used
|
||||
|
||||
DisableHelpPage bool
|
||||
}
|
||||
|
||||
const (
|
||||
cliKeyJoin = "-"
|
||||
cliKeyPrefix = "--"
|
||||
cliValSep = "="
|
||||
cliHelpArg = "-h"
|
||||
)
|
||||
|
||||
// Parse implements the method for the Source interface
|
||||
func (cli SourceCLI) Parse(cfg *Cfg) ([]ParamValue, error) {
|
||||
args := cli.Args
|
||||
if cli.Args == nil {
|
||||
args = os.Args[1:]
|
||||
}
|
||||
|
||||
pvM, err := cli.cliParamVals(cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pvs := make([]ParamValue, 0, len(args))
|
||||
var (
|
||||
key string
|
||||
pv ParamValue
|
||||
pvOk bool
|
||||
pvStrVal string
|
||||
pvStrValOk bool
|
||||
)
|
||||
for _, arg := range args {
|
||||
if pvOk {
|
||||
pvStrVal = arg
|
||||
pvStrValOk = true
|
||||
} else if !cli.DisableHelpPage && arg == cliHelpArg {
|
||||
cli.printHelp(os.Stdout, pvM)
|
||||
os.Stdout.Sync()
|
||||
os.Exit(1)
|
||||
} else {
|
||||
for key, pv = range pvM {
|
||||
if arg == key {
|
||||
pvOk = true
|
||||
break
|
||||
}
|
||||
|
||||
prefix := key + cliValSep
|
||||
if !strings.HasPrefix(arg, prefix) {
|
||||
continue
|
||||
}
|
||||
pvOk = true
|
||||
pvStrVal = strings.TrimPrefix(arg, prefix)
|
||||
pvStrValOk = true
|
||||
break
|
||||
}
|
||||
if !pvOk {
|
||||
return nil, fmt.Errorf("unexpected config parameter %q", arg)
|
||||
}
|
||||
}
|
||||
|
||||
// pvOk is always true at this point, and so pv is filled in
|
||||
|
||||
if pv.IsBool {
|
||||
// if it's a boolean we don't expect there to be a following value,
|
||||
// it's just a flag
|
||||
if pvStrValOk {
|
||||
return nil, fmt.Errorf("param %q is a boolean and cannot have a value", arg)
|
||||
}
|
||||
pv.Value = json.RawMessage("true")
|
||||
|
||||
} else if !pvStrValOk {
|
||||
// everything else should have a value. if pvStrVal isn't filled it
|
||||
// means the next arg should be one. Continue the loop, it'll get
|
||||
// filled with the next one (hopefully)
|
||||
continue
|
||||
|
||||
} else if pv.IsString && (pvStrVal == "" || pvStrVal[0] != '"') {
|
||||
pv.Value = json.RawMessage(`"` + pvStrVal + `"`)
|
||||
|
||||
} else {
|
||||
pv.Value = json.RawMessage(pvStrVal)
|
||||
}
|
||||
|
||||
pvs = append(pvs, pv)
|
||||
key = ""
|
||||
pv = ParamValue{}
|
||||
pvOk = false
|
||||
pvStrVal = ""
|
||||
pvStrValOk = false
|
||||
}
|
||||
if pvOk && !pvStrValOk {
|
||||
return nil, fmt.Errorf("param %q expected a value", key)
|
||||
}
|
||||
return pvs, nil
|
||||
}
|
||||
|
||||
func (cli SourceCLI) cliParamVals(cfg *Cfg) (map[string]ParamValue, error) {
|
||||
m := map[string]ParamValue{}
|
||||
for _, param := range cfg.Params {
|
||||
key := cliKeyPrefix
|
||||
if len(cfg.Path) > 0 {
|
||||
key += strings.Join(cfg.Path, cliKeyJoin) + cliKeyJoin
|
||||
}
|
||||
key += param.Name
|
||||
m[key] = ParamValue{
|
||||
Param: param,
|
||||
Path: cfg.Path,
|
||||
}
|
||||
}
|
||||
|
||||
for _, child := range cfg.Children {
|
||||
childM, err := cli.cliParamVals(child)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for key, pv := range childM {
|
||||
if _, ok := m[key]; ok {
|
||||
return nil, fmt.Errorf("multiple params use the same CLI arg %q", key)
|
||||
}
|
||||
m[key] = pv
|
||||
}
|
||||
}
|
||||
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (cli SourceCLI) printHelp(w io.Writer, pvM map[string]ParamValue) {
|
||||
type pvEntry struct {
|
||||
arg string
|
||||
ParamValue
|
||||
}
|
||||
|
||||
pvA := make([]pvEntry, 0, len(pvM))
|
||||
for arg, pv := range pvM {
|
||||
pvA = append(pvA, pvEntry{arg: arg, ParamValue: pv})
|
||||
}
|
||||
|
||||
sort.Slice(pvA, func(i, j int) bool {
|
||||
return pvA[i].arg < pvA[j].arg
|
||||
})
|
||||
|
||||
fmtDefaultVal := func(ptr interface{}) string {
|
||||
if ptr == nil {
|
||||
return ""
|
||||
}
|
||||
val := reflect.Indirect(reflect.ValueOf(ptr))
|
||||
zero := reflect.Zero(val.Type())
|
||||
if reflect.DeepEqual(val.Interface(), zero.Interface()) {
|
||||
return ""
|
||||
} else if val.Type().Kind() == reflect.String {
|
||||
return fmt.Sprintf("%q", val.Interface())
|
||||
}
|
||||
return fmt.Sprint(val.Interface())
|
||||
}
|
||||
|
||||
for _, pvE := range pvA {
|
||||
fmt.Fprintf(w, "\n%s", pvE.arg)
|
||||
if pvE.IsBool {
|
||||
fmt.Fprintf(w, " (Flag)")
|
||||
} else if defVal := fmtDefaultVal(pvE.Into); defVal != "" {
|
||||
fmt.Fprintf(w, " (Default: %s)", defVal)
|
||||
}
|
||||
fmt.Fprintf(w, "\n")
|
||||
if pvE.Usage != "" {
|
||||
fmt.Fprintln(w, "\t"+pvE.Usage)
|
||||
}
|
||||
}
|
||||
fmt.Fprintf(w, "\n")
|
||||
}
|
||||
313
mcfg/cli_test.go
Normal file
313
mcfg/cli_test.go
Normal file
@ -0,0 +1,313 @@
|
||||
package mcfg
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"strconv"
|
||||
. "testing"
|
||||
|
||||
"github.com/mediocregopher/mediocre-go-lib/mtest"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// * dimension
|
||||
// - dimension value
|
||||
//
|
||||
// * Cfg path
|
||||
// - New()
|
||||
// - New.Child("a")
|
||||
// - New.Child("a-b")
|
||||
// - New.Child("a=b")
|
||||
// * Param name
|
||||
// - normal
|
||||
// - w/ "-"
|
||||
// - w/ "=" ?
|
||||
// * Param type
|
||||
// - bool
|
||||
// - non-bool
|
||||
// * non-bool type
|
||||
// - int
|
||||
// - string
|
||||
// * Str value
|
||||
// - empty
|
||||
// - normal
|
||||
// - w/ -
|
||||
// - w/ =
|
||||
// * Value format
|
||||
// - w/ =
|
||||
// - w/o =
|
||||
|
||||
func combinate(slices ...[]string) [][]string {
|
||||
out := [][]string{{}}
|
||||
for _, slice := range slices {
|
||||
if len(slice) == 0 {
|
||||
continue
|
||||
}
|
||||
prev := out
|
||||
out = make([][]string, 0, len(prev)*len(slice))
|
||||
for _, prevSet := range prev {
|
||||
for _, sliceElem := range slice {
|
||||
prevSetCp := make([]string, len(prevSet), len(prevSet)+1)
|
||||
copy(prevSetCp, prevSet)
|
||||
prevSetCp = append(prevSetCp, sliceElem)
|
||||
out = append(out, prevSetCp)
|
||||
}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func TestCombinate(t *T) {
|
||||
type combTest struct {
|
||||
args [][]string
|
||||
exp [][]string
|
||||
}
|
||||
|
||||
tests := []combTest{
|
||||
{
|
||||
args: [][]string{},
|
||||
exp: [][]string{{}},
|
||||
},
|
||||
{
|
||||
args: [][]string{{"a"}},
|
||||
exp: [][]string{{"a"}},
|
||||
},
|
||||
{
|
||||
args: [][]string{{"a"}, {"b"}},
|
||||
exp: [][]string{{"a", "b"}},
|
||||
},
|
||||
{
|
||||
args: [][]string{{"a", "aa"}, {"b"}},
|
||||
exp: [][]string{
|
||||
{"a", "b"},
|
||||
{"aa", "b"},
|
||||
},
|
||||
},
|
||||
{
|
||||
args: [][]string{{"a"}, {"b", "bb"}},
|
||||
exp: [][]string{
|
||||
{"a", "b"},
|
||||
{"a", "bb"},
|
||||
},
|
||||
},
|
||||
{
|
||||
args: [][]string{{"a", "aa"}, {"b", "bb"}},
|
||||
exp: [][]string{
|
||||
{"a", "b"},
|
||||
{"aa", "b"},
|
||||
{"a", "bb"},
|
||||
{"aa", "bb"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for i, test := range tests {
|
||||
msgAndArgs := []interface{}{"test:%d args:%v", i, test.args}
|
||||
got := combinate(test.args...)
|
||||
assert.Len(t, got, len(test.exp), msgAndArgs...)
|
||||
for _, expHas := range test.exp {
|
||||
assert.Contains(t, got, expHas, msgAndArgs...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSourceCLI(t *T) {
|
||||
var (
|
||||
paths = []string{
|
||||
"root",
|
||||
"child",
|
||||
"childDash",
|
||||
"childEq",
|
||||
}
|
||||
|
||||
paramNames = []string{
|
||||
"normal",
|
||||
"wDash",
|
||||
"wEq",
|
||||
}
|
||||
|
||||
isBool = []string{
|
||||
"isBool",
|
||||
"isNotBool",
|
||||
}
|
||||
|
||||
nonBoolTypes = []string{
|
||||
"int",
|
||||
"str",
|
||||
}
|
||||
|
||||
nonBoolFmts = []string{
|
||||
"wEq",
|
||||
"woEq",
|
||||
}
|
||||
|
||||
nonBoolStrValues = []string{
|
||||
"empty",
|
||||
"normal",
|
||||
"wDash",
|
||||
"wEq",
|
||||
}
|
||||
)
|
||||
|
||||
type cliTest struct {
|
||||
path string
|
||||
name string
|
||||
isBool bool
|
||||
nonBoolType string
|
||||
nonBoolStrValue string
|
||||
nonBoolFmt string
|
||||
|
||||
// it's kinda hacky to make this a pointer, but it makes the code a lot
|
||||
// easier to read later
|
||||
exp *ParamValue
|
||||
}
|
||||
|
||||
var tests []cliTest
|
||||
for _, comb := range combinate(paths, paramNames, isBool) {
|
||||
var test cliTest
|
||||
test.path = comb[0]
|
||||
test.name = comb[1]
|
||||
test.isBool = comb[2] == "isBool"
|
||||
if test.isBool {
|
||||
tests = append(tests, test)
|
||||
continue
|
||||
}
|
||||
|
||||
for _, nonBoolComb := range combinate(nonBoolTypes, nonBoolFmts) {
|
||||
test.nonBoolType = nonBoolComb[0]
|
||||
test.nonBoolFmt = nonBoolComb[1]
|
||||
if test.nonBoolType != "str" {
|
||||
tests = append(tests, test)
|
||||
continue
|
||||
}
|
||||
for _, nonBoolStrValue := range nonBoolStrValues {
|
||||
test.nonBoolStrValue = nonBoolStrValue
|
||||
tests = append(tests, test)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
childName := mtest.RandHex(8)
|
||||
childDashName := mtest.RandHex(4) + "-" + mtest.RandHex(4)
|
||||
childEqName := mtest.RandHex(4) + "=" + mtest.RandHex(4)
|
||||
|
||||
var args []string
|
||||
rootCfg := New()
|
||||
childCfg := rootCfg.Child(childName)
|
||||
childDashCfg := rootCfg.Child(childDashName)
|
||||
childEqCfg := rootCfg.Child(childEqName)
|
||||
|
||||
for i := range tests {
|
||||
var pv ParamValue
|
||||
tests[i].exp = &pv
|
||||
|
||||
switch tests[i].name {
|
||||
case "normal":
|
||||
pv.Name = mtest.RandHex(8)
|
||||
case "wDash":
|
||||
pv.Name = mtest.RandHex(4) + "-" + mtest.RandHex(4)
|
||||
case "wEq":
|
||||
pv.Name = mtest.RandHex(4) + "=" + mtest.RandHex(4)
|
||||
}
|
||||
|
||||
pv.IsBool = tests[i].isBool
|
||||
pv.IsString = !tests[i].isBool && tests[i].nonBoolType == "str"
|
||||
|
||||
var arg string
|
||||
switch tests[i].path {
|
||||
case "root":
|
||||
rootCfg.ParamAdd(pv.Param)
|
||||
arg = "--" + pv.Name
|
||||
case "child":
|
||||
childCfg.ParamAdd(pv.Param)
|
||||
pv.Path = append(pv.Path, childName)
|
||||
arg = "--" + childName + "-" + pv.Name
|
||||
case "childDash":
|
||||
childDashCfg.ParamAdd(pv.Param)
|
||||
pv.Path = append(pv.Path, childDashName)
|
||||
arg = "--" + childDashName + "-" + pv.Name
|
||||
case "childEq":
|
||||
childEqCfg.ParamAdd(pv.Param)
|
||||
pv.Path = append(pv.Path, childEqName)
|
||||
arg = "--" + childEqName + "-" + pv.Name
|
||||
}
|
||||
|
||||
if pv.IsBool {
|
||||
pv.Value = json.RawMessage("true")
|
||||
args = append(args, arg)
|
||||
continue
|
||||
}
|
||||
|
||||
var val string
|
||||
switch tests[i].nonBoolType {
|
||||
case "int":
|
||||
val = strconv.Itoa(mtest.Rand.Int())
|
||||
pv.Value = json.RawMessage(val)
|
||||
case "str":
|
||||
switch tests[i].nonBoolStrValue {
|
||||
case "empty":
|
||||
// ez
|
||||
case "normal":
|
||||
val = mtest.RandHex(8)
|
||||
case "wDash":
|
||||
val = mtest.RandHex(4) + "-" + mtest.RandHex(4)
|
||||
case "wEq":
|
||||
val = mtest.RandHex(4) + "=" + mtest.RandHex(4)
|
||||
}
|
||||
pv.Value = json.RawMessage(`"` + val + `"`)
|
||||
}
|
||||
|
||||
switch tests[i].nonBoolFmt {
|
||||
case "wEq":
|
||||
arg += "=" + val
|
||||
args = append(args, arg)
|
||||
case "woEq":
|
||||
args = append(args, arg, val)
|
||||
}
|
||||
}
|
||||
|
||||
src := SourceCLI{Args: args}
|
||||
pvals, err := src.Parse(rootCfg)
|
||||
require.NoError(t, err)
|
||||
assert.Len(t, pvals, len(tests))
|
||||
|
||||
for _, test := range tests {
|
||||
assert.Contains(t, pvals, *test.exp)
|
||||
}
|
||||
|
||||
// an extra bogus param or value should generate an error
|
||||
src = SourceCLI{Args: append(args, "foo")}
|
||||
_, err = src.Parse(rootCfg)
|
||||
require.Error(t, err)
|
||||
|
||||
}
|
||||
|
||||
func TestSourceCLIHelp(t *T) {
|
||||
cfg := New()
|
||||
cfg.ParamInt("foo", 5, "Test int param")
|
||||
cfg.ParamBool("bar", "Test bool param")
|
||||
cfg.ParamString("baz", "baz", "Test string param")
|
||||
cfg.ParamString("baz2", "", "")
|
||||
src := SourceCLI{}
|
||||
|
||||
buf := new(bytes.Buffer)
|
||||
pvM, err := src.cliParamVals(cfg)
|
||||
require.NoError(t, err)
|
||||
SourceCLI{}.printHelp(buf, pvM)
|
||||
|
||||
exp := `
|
||||
--bar (Flag)
|
||||
Test bool param
|
||||
|
||||
--baz (Default: "baz")
|
||||
Test string param
|
||||
|
||||
--baz2
|
||||
|
||||
--foo (Default: 5)
|
||||
Test int param
|
||||
|
||||
`
|
||||
assert.Equal(t, exp, buf.String())
|
||||
}
|
||||
266
mcfg/mcfg.go
Normal file
266
mcfg/mcfg.go
Normal file
@ -0,0 +1,266 @@
|
||||
// Package mcfg provides a simple foundation for complex service/binary
|
||||
// configuration, initialization, and destruction
|
||||
package mcfg
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TODO Sources:
|
||||
// - Env
|
||||
// - Env file
|
||||
// - JSON file
|
||||
// - YAML file
|
||||
|
||||
// Hook describes a function which can have other Hook functions appended to it
|
||||
// via the Then method. A Hook is expected to return context.Canceled on context
|
||||
// cancellation.
|
||||
type Hook func(context.Context) error
|
||||
|
||||
// Nop returns a Hook which does nothing
|
||||
func Nop() Hook {
|
||||
return func(context.Context) error { return nil }
|
||||
}
|
||||
|
||||
// Then modifies the called upon Hook such that it will first perform whatever
|
||||
// it's original functionality was, and then if that doesn't return an error it
|
||||
// will subsequently perform the given Hook.
|
||||
func (h *Hook) Then(h2 Hook) {
|
||||
oldh := *h
|
||||
*h = func(ctx context.Context) error {
|
||||
if err := oldh(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
return h2(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
// TODO Having Also here might be more confusing than it's worth, since Child
|
||||
// effectively does the same thing wrt Hook handling
|
||||
|
||||
// Also modifies the called upon Hook such that it will perform the original
|
||||
// functionality at the same time as the given Hook, wait for both to complete,
|
||||
// and return an error if there is one.
|
||||
func (h *Hook) Also(h2 Hook) {
|
||||
oldh := *h
|
||||
*h = func(ctx context.Context) error {
|
||||
errCh := make(chan error, 1)
|
||||
go func() {
|
||||
errCh <- oldh(ctx)
|
||||
}()
|
||||
err := h2(ctx)
|
||||
if err := <-errCh; err != nil {
|
||||
return err
|
||||
}
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// ParamValue describes a value for a parameter which has been parsed by a
|
||||
// Source
|
||||
type ParamValue struct {
|
||||
Param
|
||||
Path []string // nil if root
|
||||
Value json.RawMessage
|
||||
}
|
||||
|
||||
// Source parses ParamValues out of a particular configuration source
|
||||
type Source interface {
|
||||
Parse(*Cfg) ([]ParamValue, error)
|
||||
}
|
||||
|
||||
// Cfg describes a set of configuration parameters and run-time behaviors.
|
||||
// Parameters are defined using the Param* methods, and run-time behaviors by
|
||||
// the Hook fields on this struct.
|
||||
//
|
||||
// Each Cfg can have child Cfg's spawned off of it using the Child method, which
|
||||
// allows for namespacing related params/behaviors into heirarchies.
|
||||
type Cfg struct {
|
||||
// Read-only. The set of names passed into Child methods used to generate
|
||||
// this Cfg and all of its parents. Path will be nil if this Cfg was created
|
||||
// with New and not a Child call.
|
||||
//
|
||||
// Examples:
|
||||
// New().Path is nil
|
||||
// New().Child("foo").Path is []string{"foo"}
|
||||
// New().Child("foo").Child("bar").Path is []string{"foo", "bar"}
|
||||
Path []string
|
||||
|
||||
// Read-only. The set of children spawned off of this Cfg via the Child
|
||||
// method, keyed by the children's names.
|
||||
Children map[string]*Cfg
|
||||
|
||||
// Read-only. The set of Params which have been added to the Cfg instance
|
||||
// via its Add method.
|
||||
Params map[string]Param
|
||||
|
||||
// Start hook is performed after configuration variables have been parsed
|
||||
// and populated. All Start hooks are expected to run in a finite amount of
|
||||
// time, any long running processes spun off from them should do so in a
|
||||
// separate go-routine
|
||||
Start Hook
|
||||
|
||||
// Default 2 minutes. Timeout within which the Start Hook (and the Start
|
||||
// Hooks of all children of this Cfg) must complete.
|
||||
StartTimeout time.Duration
|
||||
|
||||
// Stop hook is performed on interrupt signal, and should stop all
|
||||
// go-routines and close all resource handlers created during Start
|
||||
Stop Hook
|
||||
|
||||
// Default 30 seconds. Timeout within which the Stop Hook (and the Stop
|
||||
// Hooks of all children of this Cfg) must complete.
|
||||
StopTimeout time.Duration
|
||||
}
|
||||
|
||||
// New initializes and returns an empty Cfg with default values filled in
|
||||
func New() *Cfg {
|
||||
return &Cfg{
|
||||
Children: map[string]*Cfg{},
|
||||
Params: map[string]Param{},
|
||||
Start: Nop(),
|
||||
StartTimeout: 2 * time.Minute,
|
||||
Stop: Nop(),
|
||||
StopTimeout: 30 * time.Second,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Cfg) populateParams(src Source) error {
|
||||
pvs, err := src.Parse(c)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// first dedupe the params. We use this param struct as the key by which to
|
||||
// dedupe by. Its use depends on the json.Marshaler always ordering fields
|
||||
// in a marshaled struct the same way, which isn't the best assumption but
|
||||
// it's ok for now
|
||||
type param struct {
|
||||
Path []string `json:",omitempty"`
|
||||
Name string
|
||||
}
|
||||
|
||||
pvM := map[string]ParamValue{}
|
||||
for _, pv := range pvs {
|
||||
keyB, err := json.Marshal(param{Path: pv.Path, Name: pv.Name})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pvM[string(keyB)] = pv
|
||||
}
|
||||
|
||||
// check for required params, again using the param struct and the existing
|
||||
// pvM
|
||||
var requiredParams func(*Cfg) []param
|
||||
requiredParams = func(c *Cfg) []param {
|
||||
var out []param
|
||||
for _, p := range c.Params {
|
||||
if !p.Required {
|
||||
continue
|
||||
}
|
||||
out = append(out, param{Path: c.Path, Name: p.Name})
|
||||
}
|
||||
for _, child := range c.Children {
|
||||
out = append(out, requiredParams(child)...)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
for _, reqP := range requiredParams(c) {
|
||||
keyB, err := json.Marshal(reqP)
|
||||
if err != nil {
|
||||
return err
|
||||
} else if _, ok := pvM[string(keyB)]; !ok {
|
||||
return fmt.Errorf("param %s is required but wasn't populated by any configuration source", keyB)
|
||||
}
|
||||
}
|
||||
|
||||
for _, pv := range pvM {
|
||||
if pv.Into == nil {
|
||||
continue
|
||||
}
|
||||
if err := json.Unmarshal(pv.Value, pv.Into); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Run blocks while performing all steps of a Cfg run. The steps, in order, are;
|
||||
// * Populate all configuration parameters
|
||||
// * Recursively perform Start hooks, depth first
|
||||
// * Block till the passed in context is cancelled
|
||||
// * Recursively perform Stop hooks, depth first
|
||||
//
|
||||
// If any step returns an error then everything returns that error immediately.
|
||||
//
|
||||
// A caveat about Run is that the error case doesn't leave a lot of room for a
|
||||
// proper cleanup. If you care about that sort of thing you'll need to handle it
|
||||
// yourself.
|
||||
func (c *Cfg) Run(ctx context.Context, src Source) error {
|
||||
if err := c.populateParams(src); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
startCtx, cancel := context.WithTimeout(ctx, c.StartTimeout)
|
||||
err := c.startHooks(startCtx)
|
||||
cancel()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
<-ctx.Done()
|
||||
|
||||
stopCtx, cancel := context.WithTimeout(context.Background(), c.StopTimeout)
|
||||
defer cancel()
|
||||
return c.stopHooks(stopCtx)
|
||||
}
|
||||
|
||||
func (c *Cfg) startHooks(ctx context.Context) error {
|
||||
return c.recurseHooks(ctx, func(c *Cfg) Hook { return c.Start })
|
||||
}
|
||||
|
||||
func (c *Cfg) stopHooks(ctx context.Context) error {
|
||||
return c.recurseHooks(ctx, func(c *Cfg) Hook { return c.Stop })
|
||||
}
|
||||
|
||||
func (c *Cfg) recurseHooks(ctx context.Context, pickHook func(*Cfg) Hook) error {
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(len(c.Children))
|
||||
errCh := make(chan error, len(c.Children))
|
||||
for name := range c.Children {
|
||||
childCfg := c.Children[name]
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
if err := childCfg.recurseHooks(ctx, pickHook); err != nil {
|
||||
errCh <- err
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
close(errCh)
|
||||
if err := <-errCh; err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return pickHook(c)(ctx)
|
||||
}
|
||||
|
||||
// Child returns a sub-Cfg of the callee with the given name. The name will be
|
||||
// prepended to all configuration options created in the returned sub-Cfg, and
|
||||
// must not be empty.
|
||||
func (c *Cfg) Child(name string) *Cfg {
|
||||
if _, ok := c.Children[name]; ok {
|
||||
panic(fmt.Sprintf("child Cfg named %q already exists", name))
|
||||
}
|
||||
c2 := New()
|
||||
c2.Path = make([]string, 0, len(c.Path)+1)
|
||||
c2.Path = append(c2.Path, c.Path...)
|
||||
c2.Path = append(c2.Path, name)
|
||||
c.Children[name] = c2
|
||||
return c2
|
||||
}
|
||||
122
mcfg/mcfg_test.go
Normal file
122
mcfg/mcfg_test.go
Normal file
@ -0,0 +1,122 @@
|
||||
package mcfg
|
||||
|
||||
import (
|
||||
"context"
|
||||
. "testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestHook(t *T) {
|
||||
{ // test Then
|
||||
aCh := make(chan bool)
|
||||
bCh := make(chan bool)
|
||||
h := Nop()
|
||||
h.Then(func(context.Context) error {
|
||||
aCh <- true
|
||||
<-aCh
|
||||
return nil
|
||||
})
|
||||
h.Then(func(context.Context) error {
|
||||
bCh <- true
|
||||
<-bCh
|
||||
return nil
|
||||
})
|
||||
errCh := make(chan error)
|
||||
go func() {
|
||||
errCh <- h(nil)
|
||||
}()
|
||||
|
||||
assert.True(t, <-aCh)
|
||||
// make sure bCh isn't being written to till aCh is closed
|
||||
select {
|
||||
case <-bCh:
|
||||
assert.Fail(t, "bCh shouldn't be written to yet")
|
||||
case <-time.After(250 * time.Millisecond):
|
||||
close(aCh)
|
||||
}
|
||||
assert.True(t, <-bCh)
|
||||
// make sure errCh isn't being written to till bCh is closed
|
||||
select {
|
||||
case <-errCh:
|
||||
assert.Fail(t, "errCh shouldn't be written to yet")
|
||||
case <-time.After(250 * time.Millisecond):
|
||||
close(bCh)
|
||||
}
|
||||
assert.Nil(t, <-errCh)
|
||||
}
|
||||
|
||||
{ // test Also
|
||||
aCh := make(chan bool)
|
||||
bCh := make(chan bool)
|
||||
h := Nop()
|
||||
h.Also(func(context.Context) error {
|
||||
aCh <- true
|
||||
<-aCh
|
||||
return nil
|
||||
})
|
||||
h.Also(func(context.Context) error {
|
||||
bCh <- true
|
||||
<-bCh
|
||||
return nil
|
||||
})
|
||||
errCh := make(chan error)
|
||||
go func() {
|
||||
errCh <- h(nil)
|
||||
}()
|
||||
|
||||
// both channels should get written to, then closed, then errCh should
|
||||
// get written to
|
||||
assert.True(t, <-aCh)
|
||||
assert.True(t, <-bCh)
|
||||
// make sure errCh isn't being written to till both channels are written
|
||||
select {
|
||||
case <-errCh:
|
||||
assert.Fail(t, "errCh shouldn't be written to yet")
|
||||
case <-time.After(250 * time.Millisecond):
|
||||
close(aCh)
|
||||
close(bCh)
|
||||
}
|
||||
assert.Nil(t, <-errCh)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPopulateParams(t *T) {
|
||||
{
|
||||
cfg := New()
|
||||
a := cfg.ParamInt("a", 0, "")
|
||||
cfgChild := cfg.Child("foo")
|
||||
b := cfgChild.ParamInt("b", 0, "")
|
||||
c := cfgChild.ParamInt("c", 0, "")
|
||||
|
||||
err := cfg.populateParams(SourceCLI{
|
||||
Args: []string{"--a=1", "--foo-b=2"},
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, 1, *a)
|
||||
assert.Equal(t, 2, *b)
|
||||
assert.Equal(t, 0, *c)
|
||||
}
|
||||
|
||||
{ // test that required params are enforced
|
||||
cfg := New()
|
||||
a := cfg.ParamInt("a", 0, "")
|
||||
cfgChild := cfg.Child("foo")
|
||||
b := cfgChild.ParamInt("b", 0, "")
|
||||
c := cfgChild.ParamRequiredInt("c", "")
|
||||
|
||||
err := cfg.populateParams(SourceCLI{
|
||||
Args: []string{"--a=1", "--foo-b=2"},
|
||||
})
|
||||
assert.Error(t, err)
|
||||
|
||||
err = cfg.populateParams(SourceCLI{
|
||||
Args: []string{"--a=1", "--foo-b=2", "--foo-c=3"},
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, 1, *a)
|
||||
assert.Equal(t, 2, *b)
|
||||
assert.Equal(t, 3, *c)
|
||||
}
|
||||
}
|
||||
115
mcfg/param.go
Normal file
115
mcfg/param.go
Normal file
@ -0,0 +1,115 @@
|
||||
package mcfg
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/mediocregopher/mediocre-go-lib/mtime"
|
||||
)
|
||||
|
||||
// Param is a configuration parameter which can be added to a Cfg. The Param
|
||||
// will exist relative to a Cfg's Path. For example, a Param with name "addr"
|
||||
// under a Cfg with Path of []string{"foo","bar"} will be setabble on the CLI
|
||||
// via "--foo-bar-addr". Other configuration Sources may treat the path/name
|
||||
// differently, however.
|
||||
type Param struct {
|
||||
// How the parameter will be identified within a Cfg instance
|
||||
Name string
|
||||
// A helpful description of how a parameter is expected to be used
|
||||
Usage string
|
||||
|
||||
// If the parameter's value is expected to be read as a go string. This is
|
||||
// used for configuration sources like CLI which will automatically escape
|
||||
// the parameter's value with double-quotes
|
||||
IsString bool
|
||||
|
||||
// If the parameter's value is expected to be a boolean. This is used for
|
||||
// configuration sources like CLI which treat boolean parameters (aka flags)
|
||||
// differently.
|
||||
IsBool bool
|
||||
|
||||
// If true then the parameter _must_ be set by at least one configuration
|
||||
// source
|
||||
Required bool
|
||||
|
||||
// The pointer/interface into which the configuration value will be
|
||||
// json.Unmarshal'd. The value being pointed to also determines the default
|
||||
// value of the parameter.
|
||||
Into interface{}
|
||||
}
|
||||
|
||||
// ParamAdd adds the given Param to the Cfg. It will panic if a Param of the
|
||||
// same Name already exists in the Cfg.
|
||||
func (c *Cfg) ParamAdd(p Param) {
|
||||
if _, ok := c.Params[p.Name]; ok {
|
||||
panic(fmt.Sprintf("Cfg.Path:%#v name:%q already exists", c.Path, p.Name))
|
||||
}
|
||||
c.Params[p.Name] = p
|
||||
}
|
||||
|
||||
// ParamInt64 returns an *int64 which will be populated once the Cfg is run
|
||||
func (c *Cfg) ParamInt64(name string, defaultVal int64, usage string) *int64 {
|
||||
i := defaultVal
|
||||
c.ParamAdd(Param{Name: name, Usage: usage, Into: &i})
|
||||
return &i
|
||||
}
|
||||
|
||||
// ParamRequiredInt64 returns an *int64 which will be populated once the Cfg is
|
||||
// run, and which must be supplied by a configuration Source
|
||||
func (c *Cfg) ParamRequiredInt64(name string, usage string) *int64 {
|
||||
var i int64
|
||||
c.ParamAdd(Param{Name: name, Required: true, Usage: usage, Into: &i})
|
||||
return &i
|
||||
}
|
||||
|
||||
// ParamInt returns an *int which will be populated once the Cfg is run
|
||||
func (c *Cfg) ParamInt(name string, defaultVal int, usage string) *int {
|
||||
i := defaultVal
|
||||
c.ParamAdd(Param{Name: name, Usage: usage, Into: &i})
|
||||
return &i
|
||||
}
|
||||
|
||||
// ParamRequiredInt returns an *int which will be populated once the Cfg is run,
|
||||
// and which must be supplied by a configuration Source
|
||||
func (c *Cfg) ParamRequiredInt(name string, usage string) *int {
|
||||
var i int
|
||||
c.ParamAdd(Param{Name: name, Required: true, Usage: usage, Into: &i})
|
||||
return &i
|
||||
}
|
||||
|
||||
// ParamString returns a *string which will be populated once the Cfg is run
|
||||
func (c *Cfg) ParamString(name, defaultVal, usage string) *string {
|
||||
s := defaultVal
|
||||
c.ParamAdd(Param{Name: name, Usage: usage, IsString: true, Into: &s})
|
||||
return &s
|
||||
}
|
||||
|
||||
// ParamRequiredString returns a *string which will be populated once the Cfg is
|
||||
// run, and which must be supplied by a configuration Source
|
||||
func (c *Cfg) ParamRequiredString(name, usage string) *string {
|
||||
var s string
|
||||
c.ParamAdd(Param{Name: name, Required: true, Usage: usage, IsString: true, Into: &s})
|
||||
return &s
|
||||
}
|
||||
|
||||
// ParamBool returns a *bool which will be populated once the Cfg is run, and
|
||||
// which defaults to false if unconfigured
|
||||
func (c *Cfg) ParamBool(name, usage string) *bool {
|
||||
var b bool
|
||||
c.ParamAdd(Param{Name: name, Usage: usage, IsBool: true, Into: &b})
|
||||
return &b
|
||||
}
|
||||
|
||||
// ParamTS returns an *mtime.TS which will be populated once the Cfg is run
|
||||
func (c *Cfg) ParamTS(name string, defaultVal mtime.TS, usage string) *mtime.TS {
|
||||
t := defaultVal
|
||||
c.ParamAdd(Param{Name: name, Usage: usage, Into: &t})
|
||||
return &t
|
||||
}
|
||||
|
||||
// ParamDuration returns an *mtime.Duration which will be populated once the Cfg
|
||||
// is run
|
||||
func (c *Cfg) ParamDuration(name string, defaultVal mtime.Duration, usage string) *mtime.Duration {
|
||||
d := defaultVal
|
||||
c.ParamAdd(Param{Name: name, Usage: usage, IsString: true, Into: &d})
|
||||
return &d
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user