Generic way to import 'flag' flags into the 'pflag' system.

pkg/kubectl/cmd/cmd.go

@@ -29,6 +29,7 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/clientcmd"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 
 	"github.com/golang/glog"
 	"github.com/spf13/cobra"
@@ -100,12 +101,11 @@ Find more information at https://github.com/GoogleCloudPlatform/kubernetes.`,
 		Run: runHelp,
 	}
 
+	util.AddAllFlagsToPFlagSet(cmds.PersistentFlags())
 	f.ClientConfig = getClientConfig(cmds)
 
 	// Globally persistent flags across all subcommands.
 	// TODO Change flag names to consts to allow safer lookup from subcommands.
-	// TODO Add a verbose flag that turns on glog logging. Probably need a way
-	// to do that automatically for every subcommand.
 	cmds.PersistentFlags().Bool(FlagMatchBinaryVersion, false, "Require server version to match client version")
 	cmds.PersistentFlags().String("ns-path", os.Getenv("HOME")+"/.kubernetes_ns", "Path to the namespace info file that holds the namespace context to use for CLI requests.")
 	cmds.PersistentFlags().StringP("namespace", "n", "", "If present, the namespace scope for this CLI request.")

pkg/util/plog_import.go

@@ -0,0 +1,78 @@
+/*
+Copyright 2015 Google Inc. 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,
+	}
+	pv.flagType = reflect.TypeOf(v).Elem().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
+}
+
+// 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) {
+	fs.Var(wrapFlagValue(f.Value), f.Name, f.Usage)
+}
+
+// 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)
+	})
+}
+
+// Adds all of the top level 'flag' package flags to a 'pflag.FlagSet'.
+func AddAllFlagsToPFlagSet(fs *pflag.FlagSet) {
+	AddFlagSetToPFlagSet(flag.CommandLine, fs)
+}