github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-25 12:43:23 +00:00
Code Issues Projects Releases Wiki Activity

Use pflag functions instead of ours.

Browse Source
This commit is contained in:
Eric Paris 2015-08-16 23:33:44 -07:00
parent 681ee126ff
commit bcf912667b
7 changed files with 20 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/hyperkube/hyperkube.go
View File

@ -77,8 +77,8 @@ func (hk *HyperKube) Flags() *pflag.FlagSet {
// These will add all of the "global" flags (defined with both the
// flag and pflag packages) to the new flag set we have.
util.AddFlagSetToPFlagSet(flag.CommandLine, hk.baseFlags)
util.AddPFlagSetToPFlagSet(pflag.CommandLine, hk.baseFlags)
hk.baseFlags.AddGoFlagSet(flag.CommandLine)
hk.baseFlags.AddFlagSet(pflag.CommandLine)
}
return hk.baseFlags
@ -154,7 +154,7 @@ func (hk *HyperKube) Run(args []string) error {
return err
}
util.AddPFlagSetToPFlagSet(hk.Flags(), s.Flags())
s.Flags().AddFlagSet(hk.Flags())
err = s.Flags().Parse(args)
if err != nil || hk.helpFlagVal {
if err != nil {

4
cmd/hyperkube/hyperkube_test.go
View File

@ -126,7 +126,7 @@ func TestServerHelp(t *testing.T) {
x := runFull(t, "hyperkube test1 --help")
assert.NoError(t, x.err)
assert.Contains(t, x.output, "A simple server named test1")
assert.Contains(t, x.output, "--help=false: help for hyperkube")
assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
assert.NotContains(t, x.output, "test1 Run")
}
@ -134,7 +134,7 @@ func TestServerFlagsBad(t *testing.T) {
x := runFull(t, "hyperkube test1 --bad-flag")
assert.EqualError(t, x.err, "unknown flag: --bad-flag")
assert.Contains(t, x.output, "A simple server named test1")
assert.Contains(t, x.output, "--help=false: help for hyperkube")
assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
assert.NotContains(t, x.output, "test1 Run")
}

6
contrib/mesos/cmd/km/hyperkube.go
View File

@ -75,8 +75,8 @@ func (hk *HyperKube) Flags() *pflag.FlagSet {
// These will add all of the "global" flags (defined with both the
// flag and pflag packages) to the new flag set we have.
util.AddFlagSetToPFlagSet(flag.CommandLine, hk.baseFlags)
util.AddPFlagSetToPFlagSet(pflag.CommandLine, hk.baseFlags)
hk.baseFlags.AddGoFlagSet(flag.CommandLine)
hk.baseFlags.AddFlagSet(pflag.CommandLine)
}
return hk.baseFlags
@ -152,7 +152,7 @@ func (hk *HyperKube) Run(args []string) error {
return err
}
util.AddPFlagSetToPFlagSet(hk.Flags(), s.Flags())
s.Flags().AddFlagSet(hk.Flags())
err = s.Flags().Parse(args)
if err != nil || hk.helpFlagVal {
if err != nil {

4
contrib/mesos/cmd/km/hyperkube_test.go
View File

@ -125,7 +125,7 @@ func TestServerHelp(t *testing.T) {
x := runFull(t, "hyperkube test1 --help")
assert.NoError(t, x.err)
assert.Contains(t, x.output, "A simple server named test1")
assert.Contains(t, x.output, "--help=false: help for hyperkube")
assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
assert.NotContains(t, x.output, "test1 Run")
}
@ -133,7 +133,7 @@ func TestServerFlagsBad(t *testing.T) {
x := runFull(t, "hyperkube test1 --bad-flag")
assert.EqualError(t, x.err, "unknown flag: --bad-flag")
assert.Contains(t, x.output, "A simple server named test1")
assert.Contains(t, x.output, "--help=false: help for hyperkube")
assert.Contains(t, x.output, "--help[=false]: help for hyperkube")
assert.NotContains(t, x.output, "test1 Run")
}

6
pkg/kubectl/cmd/util/factory.go
View File

@ -271,11 +271,11 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
// BindFlags adds any flags that are common to all kubectl sub commands.
func (f *Factory) BindFlags(flags *pflag.FlagSet) {
// any flags defined by external projects (not part of pflags)
util.AddFlagSetToPFlagSet(flag.CommandLine, flags)
flags.AddGoFlagSet(flag.CommandLine)
// This is necessary as github.com/spf13/cobra doesn't support "global"
// pflags currently. See https://github.com/spf13/cobra/issues/44.
util.AddPFlagSetToPFlagSet(pflag.CommandLine, flags)
flags.AddFlagSet(pflag.CommandLine)
// Hack for global access to validation flag.
// TODO: Refactor out after configuration flag overhaul.
@ -284,7 +284,7 @@ func (f *Factory) BindFlags(flags *pflag.FlagSet) {
}
// Merge factory's flags
util.AddPFlagSetToPFlagSet(f.flags, flags)
flags.AddFlagSet(f.flags)
// Globally persistent flags across all subcommands.
// TODO Change flag names to consts to allow safer lookup from subcommands.

11
pkg/util/flags.go
View File

@ -16,10 +16,13 @@ limitations under the License.
package util
import "strings"
import (
goflag "flag"
"strings"
import "github.com/spf13/pflag"
import "github.com/golang/glog"
"github.com/golang/glog"
"github.com/spf13/pflag"
)
// WordSepNormalizeFunc changes all flags that contain "_" separators
func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
@ -43,6 +46,6 @@ func WarnWordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedNam
// InitFlags normalizes and parses the command line flags
func InitFlags() {
pflag.CommandLine.SetNormalizeFunc(WordSepNormalizeFunc)
AddAllFlagsToPFlags()
pflag.CommandLine.AddGoFlagSet(goflag.CommandLine)
pflag.Parse()
}

109
pkg/util/pflag_import.go
View File

@ -1,109 +0,0 @@
/*
Copyright 2015 The Kubernetes Authors All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package util
import (
"flag"
"reflect"
"strings"
"github.com/spf13/pflag"
)
// flagValueWrapper implements pflag.Value around a flag.Value. The main
// difference here is the addition of the Type method that returns a string
// name of the type. As this is generally unknown, we approximate that with
// reflection.
type flagValueWrapper struct {
inner flag.Value
flagType string
}
func wrapFlagValue(v flag.Value) pflag.Value {
// If the flag.Value happens to also be a pflag.Value, just use it directly.
if pv, ok := v.(pflag.Value); ok {
return pv
}
pv := &flagValueWrapper{
inner: v,
}
t := reflect.TypeOf(v)
if t.Kind() == reflect.Interface || t.Kind() == reflect.Ptr {
t = t.Elem()
}
pv.flagType = t.Name()
pv.flagType = strings.TrimSuffix(pv.flagType, "Value")
return pv
}
func (v *flagValueWrapper) String() string {
return v.inner.String()
}
func (v *flagValueWrapper) Set(s string) error {
return v.inner.Set(s)
}
func (v *flagValueWrapper) Type() string {
return v.flagType
}
type boolFlag interface {
flag.Value
IsBoolFlag() bool
}
func (v *flagValueWrapper) IsBoolFlag() bool {
if bv, ok := v.inner.(boolFlag); ok {
return bv.IsBoolFlag()
}
return false
}
// Imports a 'flag.Flag' into a 'pflag.FlagSet'. The "short" option is unset
// and the type is inferred using reflection.
func addFlagToPFlagSet(f *flag.Flag, fs *pflag.FlagSet) {
if fs.Lookup(f.Name) == nil {
fs.Var(wrapFlagValue(f.Value), f.Name, f.Usage)
}
}
// AddFlagSetToPFlagSet adds all of the flags in a 'flag.FlagSet' package flags to a 'pflag.FlagSet'.
func AddFlagSetToPFlagSet(fsIn *flag.FlagSet, fsOut *pflag.FlagSet) {
fsIn.VisitAll(func(f *flag.Flag) {
addFlagToPFlagSet(f, fsOut)
})
}
// AddAllFlagsToPFlags adds all of the top level 'flag' package flags to the top level 'pflag' flags.
func AddAllFlagsToPFlags() {
AddFlagSetToPFlagSet(flag.CommandLine, pflag.CommandLine)
}
// AddPFlagSetToPFlagSet merges the flags of fsFrom into fsTo.
func AddPFlagSetToPFlagSet(fsFrom *pflag.FlagSet, fsTo *pflag.FlagSet) {
if fsFrom != nil && fsTo != nil {
fsFrom.VisitAll(func(f *pflag.Flag) {
if fsTo.Lookup(f.Name) == nil {
fsTo.AddFlag(f)
}
})
}
}