diff --git a/cmd/hyperkube/hyperkube.go b/cmd/hyperkube/hyperkube.go index 7b1ec231ccc9b..5272c5dd14158 100644 --- a/cmd/hyperkube/hyperkube.go +++ b/cmd/hyperkube/hyperkube.go @@ -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 { diff --git a/cmd/hyperkube/hyperkube_test.go b/cmd/hyperkube/hyperkube_test.go index 55f04978df38d..26cd6335e39f7 100644 --- a/cmd/hyperkube/hyperkube_test.go +++ b/cmd/hyperkube/hyperkube_test.go @@ -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") } diff --git a/contrib/mesos/cmd/km/hyperkube.go b/contrib/mesos/cmd/km/hyperkube.go index 47ddbd4536250..abce229b9eaae 100644 --- a/contrib/mesos/cmd/km/hyperkube.go +++ b/contrib/mesos/cmd/km/hyperkube.go @@ -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 { diff --git a/contrib/mesos/cmd/km/hyperkube_test.go b/contrib/mesos/cmd/km/hyperkube_test.go index a114c57a80267..74739710c4c01 100644 --- a/contrib/mesos/cmd/km/hyperkube_test.go +++ b/contrib/mesos/cmd/km/hyperkube_test.go @@ -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") } diff --git a/pkg/kubectl/cmd/util/factory.go b/pkg/kubectl/cmd/util/factory.go index 24e91ae9f5e1a..1383a10c7aaa2 100644 --- a/pkg/kubectl/cmd/util/factory.go +++ b/pkg/kubectl/cmd/util/factory.go @@ -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. diff --git a/pkg/util/flags.go b/pkg/util/flags.go index fb422c4cc116d..3d5799243cf19 100644 --- a/pkg/util/flags.go +++ b/pkg/util/flags.go @@ -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() } diff --git a/pkg/util/pflag_import.go b/pkg/util/pflag_import.go deleted file mode 100644 index 3e8d4d9ce8cc1..0000000000000 --- a/pkg/util/pflag_import.go +++ /dev/null @@ -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) - } - }) - } -}