// ParseConfig parses a config file, using the provided FlagSet to
// look up, parse, and store values.
func ParseConfig(flags *flag.FlagSet, f io.Reader) error {
scanner := bufio.NewScanner(f)
for scanner.Scan() {
line := strings.TrimSpace(scanner.Text())
if line == "" || strings.HasPrefix(line, "#") {
continue
}
bits := strings.SplitN(line, "=", 2)
if len(bits) != 2 {
return fmt.Errorf("illegal config line: `%s'", line)
}
key := strings.TrimSpace(bits[0])
value := strings.TrimSpace(bits[1])
if flag := flags.Lookup(key); flag == nil {
return fmt.Errorf("unknown option `%s'", key)
}
if err := flags.Set(key, value); err != nil {
return err
}
}
return nil
}
func lookupGeneric(name string, set *flag.FlagSet) interface{} {
f := set.Lookup(name)
if f != nil {
return f.Value
}
return nil
}
func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
visited := make(map[string]bool)
set.Visit(func(f *flag.Flag) {
visited[f.Name] = true
})
for _, f := range flags {
parts := strings.Split(f.getName(), ",")
if len(parts) == 1 {
continue
}
var ff *flag.Flag
for _, name := range parts {
name = strings.Trim(name, " ")
if visited[name] {
if ff != nil {
return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
}
ff = set.Lookup(name)
}
}
if ff == nil {
continue
}
for _, name := range parts {
name = strings.Trim(name, " ")
if !visited[name] {
copyFlag(name, ff, set)
}
}
}
return nil
}
func (c *Context) lookupString(name string, set *flag.FlagSet) string {
f := set.Lookup(name)
if f != nil {
return f.Value.String()
} else {
return ""
}
}
func lookupString(name string, set *flag.FlagSet) string {
f := set.Lookup(name)
if f != nil {
return f.Value.String()
}
return ""
}
//Retrieves the argument from the provided flagset with the give name
func getVal(set *flag.FlagSet, arg string) interface{} {
requestedFlag := set.Lookup(arg)
if requestedFlag == nil {
logrus.Debugf("Could not find requested flag: %s", arg)
return nil
}
return requestedFlag.Value.(flag.Getter).Get()
}
func DebugAddress(flags *flag.FlagSet) string {
dbgFlag := flags.Lookup(DebugFlag)
if dbgFlag == nil {
return ""
}
return dbgFlag.Value.String()
}
func lookupIntSlice(name string, set *flag.FlagSet) []int {
f := set.Lookup(name)
if f != nil {
return (f.Value.(*IntSlice)).Value()
}
return nil
}
func lookupStringSlice(name string, set *flag.FlagSet) []string {
f := set.Lookup(name)
if f != nil {
return (f.Value.(*StringSlice)).Value()
}
return nil
}
// FlagVisited determines whether the named flag has been visited in the FlagSet
// given. This is helpful if you want to have a flag that triggers an action
// when given, but is not a boolean flag.
func FlagVisited(name string, flags flag.FlagSet) (didFind bool) {
toFind := flags.Lookup(name)
flags.Visit(func(f *flag.Flag) {
if f == toFind {
didFind = true
}
})
return
}
func lookupBoolT(name string, set *flag.FlagSet) bool {
f := set.Lookup(name)
if f != nil {
parsed, err := strconv.ParseBool(f.Value.String())
if err != nil {
return false
}
return parsed
}
return false
}
func lookupDuration(name string, set *flag.FlagSet) time.Duration {
f := set.Lookup(name)
if f != nil {
val, err := time.ParseDuration(f.Value.String())
if err == nil {
return val
}
}
return 0
}
func lookupStringSlice(name string, set *flag.FlagSet) []string {
f := set.Lookup(name)
if f != nil {
parsed, err := (f.Value.(*StringSlice)).Value(), error(nil)
if err != nil {
return nil
}
return parsed
}
return nil
}
func lookupString(name string, set *flag.FlagSet) string {
f := set.Lookup(name)
if f != nil {
parsed, err := f.Value.String(), error(nil)
if err != nil {
return ""
}
return parsed
}
return ""
}
func lookupInt64(name string, set *flag.FlagSet) int64 {
f := set.Lookup(name)
if f != nil {
parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
if err != nil {
return 0
}
return parsed
}
return 0
}
func lookupGeneric(name string, set *flag.FlagSet) interface{} {
f := set.Lookup(name)
if f != nil {
parsed, err := f.Value, error(nil)
if err != nil {
return nil
}
return parsed
}
return nil
}
func lookupUint(name string, set *flag.FlagSet) uint {
f := set.Lookup(name)
if f != nil {
parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
if err != nil {
return 0
}
return uint(parsed)
}
return 0
}
// UpdateLoggingFlagsFromConfig extracts the logging-related options from
// the provided config and sets flags in the given flagset
func UpdateLoggingFlagsFromConfig(flagset *flag.FlagSet, conf *Config) {
err := flagset.Lookup("v").Value.Set(strconv.Itoa(conf.Verbosity))
if err != nil {
glog.Errorf("Failed to apply config.Verbosity to flag.v: %v", err)
}
err = flagset.Lookup("logtostderr").Value.Set("true")
if err != nil {
glog.Errorf("Failed to set flag.logtostderr to true: %v", err)
}
}
func SplitFlagsetFromArgs(flagset *flag.FlagSet, args []string) (flagsetArgs []string, additionalArgs []string) {
for _, f := range args {
if flagset.Lookup(getFlagName(f)) != nil {
flagsetArgs = append(flagsetArgs, f)
} else {
additionalArgs = append(additionalArgs, f)
}
}
return
}
func lookupInt(name string, set *flag.FlagSet) int {
f := set.Lookup(name)
if f != nil {
val, err := strconv.Atoi(f.Value.String())
if err != nil {
return 0
}
return val
}
return 0
}
func lookupFloat64(name string, set *flag.FlagSet) float64 {
f := set.Lookup(name)
if f != nil {
val, err := strconv.ParseFloat(f.Value.String(), 64)
if err != nil {
return 0
}
return val
}
return 0
}
func lookupInt(name string, set *flag.FlagSet) int {
f := set.Lookup(name)
if f != nil {
val, err := strconv.ParseInt(f.Value.String(), 0, 64)
if err != nil {
return 0
}
return int(val)
}
return 0
}
func (c *Context) lookupBool(name string, set *flag.FlagSet) bool {
f := set.Lookup(name)
if f != nil {
val, err := strconv.ParseBool(f.Value.String())
if err != nil {
return false
}
return val
}
return false
}
func completeFlags(cl CommandLine, flags *flag.FlagSet) (completions []string, rest CommandLine) {
if len(cl) == 0 {
return nil, cl
}
var inFlag string
for len(cl) > 1 {
w := cl[0]
if inFlag != "" {
inFlag = ""
} else if len(w) > 1 && w[0] == '-' && w != "--" {
if !strings.Contains(w, "=") {
var i int
for i = 0; i < len(w) && w[i] == '-'; i++ {
}
inFlag = w[i:]
}
if flag := flags.Lookup(inFlag); flag != nil {
if bf, ok := flag.Value.(boolFlag); ok && bf.IsBoolFlag() {
inFlag = ""
}
}
} else {
if w == "--" {
cl = cl[1:]
}
return nil, cl
}
cl = cl[1:]
}
if inFlag != "" {
// Complete a flag value. No-op for now.
return []string{}, nil
} else if len(cl[0]) > 0 && cl[0][0] == '-' {
// complete a flag name
prefix := strings.TrimLeft(cl[0], "-")
flags.VisitAll(func(f *flag.Flag) {
if strings.HasPrefix(f.Name, prefix) {
completions = append(completions, "-"+f.Name)
}
})
return completions, nil
}
if cl[0] == "" {
flags.VisitAll(func(f *flag.Flag) {
completions = append(completions, "-"+f.Name)
})
}
return completions, cl
}
// ParseFlags parses a map of parameter assignments that are defined by a FlagSet.
func ParseFlags(f *flag.FlagSet, values Values) error {
for name := range values {
if f.Lookup(name) == nil {
return fmt.Errorf("%s: no such parameter", name)
}
}
var err error
for name, value := range values {
err = f.Set(name, value)
if err != nil {
err = fmt.Errorf("%s: %s", name, err)
}
}
return err
}
func assignFlagSet(prefix string, res map[string]interface{}, flagSet *flag.FlagSet, actual map[string]string, isOverride bool) error {
for k, v := range res {
switch value := v.(type) {
case map[string]interface{}:
e := assignFlagSet(combineName(prefix, k), value, flagSet, actual, isOverride)
if nil != e {
return e
}
continue
case []interface{}:
case string:
case float64:
case bool:
case nil:
continue
default:
return fmt.Errorf("unsupported type for %s - %T", combineName(prefix, k), v)
}
nm := combineName(prefix, k)
if !isOverride {
if _, ok := actual[nm]; ok {
log.Printf("load flag '%s' from config is skipped.\n", nm)
continue
}
}
var g *flag.Flag
if nil == flagSet {
g = flag.Lookup(nm)
} else {
g = flagSet.Lookup(nm)
}
if nil == g {
log.Printf("flag '%s' is not defined.\n", nm)
continue
}
err := g.Value.Set(fmt.Sprint(v))
if nil != err {
return err
}
}
return nil
}
// UpdateLoggingFlagsFromConfig extracts the logging-related options from
// the provided config and sets flags in the given flagset
func UpdateLoggingFlagsFromConfig(flagset *flag.FlagSet, conf *Config) {
err := flagset.Lookup("v").Value.Set(strconv.Itoa(conf.Verbosity))
if err != nil {
glog.Errorf("Failed to apply config.Verbosity to flag.v: %v", err)
}
err = flagset.Lookup("logtostderr").Value.Set("true")
if err != nil {
glog.Errorf("Failed to set flag.logtostderr to true: %v", err)
}
if conf.Verbosity > 2 {
etcd.SetLogger(log.New(os.Stdout, "go-etcd", log.LstdFlags))
} else {
etcd.SetLogger(log.New(ioutil.Discard, "go-etcd", log.LstdFlags))
}
}
func mustHave(fset *flag.FlagSet, keys ...string) error {
for _, key := range keys {
found := false
fset.Visit(
func(f *flag.Flag) {
if f.Name == key {
found = true
}
})
if !found {
flag := fset.Lookup(key)
if flag == nil || flag.DefValue == "" {
return fmt.Errorf("Invalid flags. Flag '%s' is required for this operation", key)
}
}
}
return nil
}
func setupInternalFlags(fs *flag.FlagSet) {
if fs.Lookup("c") == nil {
fs.StringVar(&internalConfig.ConfigFile, "c", "", "Specify flagconf configuration")
} else if fs.Lookup("C") == nil {
fs.StringVar(&internalConfig.ConfigFile, "C", "", "Specify flagconf configuration")
} else if fs.Lookup("flagconfFile") == nil {
fs.StringVar(&internalConfig.ConfigFile, "flagconfFile", "", "Specify flagconf configuration")
}
if fs.Lookup("flagconfConfirm") == nil {
fs.BoolVar(&internalConfig.RequireConfirmation, "flagconfConfirm", false, "Require confirmation from user ro use flag configuration")
}
}
func peerTLSInfo(fs *flag.FlagSet) *TLSInfo {
return &TLSInfo{
CAFile: fs.Lookup("peer-ca-file").Value.String(),
CertFile: fs.Lookup("peer-cert-file").Value.String(),
KeyFile: fs.Lookup("peer-key-file").Value.String(),
}
}