diff --git a/cmd/kube-proxy/app/BUILD b/cmd/kube-proxy/app/BUILD index b7d4a1815e3..eab363f0b42 100644 --- a/cmd/kube-proxy/app/BUILD +++ b/cmd/kube-proxy/app/BUILD @@ -18,7 +18,6 @@ go_library( ], importpath = "k8s.io/kubernetes/cmd/kube-proxy/app", deps = [ - "//pkg/apis/componentconfig:go_default_library", "//pkg/apis/core:go_default_library", "//pkg/kubelet/qos:go_default_library", "//pkg/master/ports:go_default_library", diff --git a/cmd/kube-proxy/app/server.go b/cmd/kube-proxy/app/server.go index c403b52a9d4..7ee8e15d42c 100644 --- a/cmd/kube-proxy/app/server.go +++ b/cmd/kube-proxy/app/server.go @@ -50,7 +50,6 @@ import ( clientcmdapi "k8s.io/client-go/tools/clientcmd/api" "k8s.io/client-go/tools/record" "k8s.io/kube-proxy/config/v1alpha1" - "k8s.io/kubernetes/pkg/apis/componentconfig" api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/kubelet/qos" "k8s.io/kubernetes/pkg/master/ports" @@ -131,16 +130,16 @@ func (o *Options) AddFlags(fs *pflag.FlagSet) { // All flags below here are deprecated and will eventually be removed. - fs.Var(componentconfig.IPVar{Val: &o.config.BindAddress}, "bind-address", "The IP address for the proxy server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") + fs.Var(utilflag.IPVar{Val: &o.config.BindAddress}, "bind-address", "The IP address for the proxy server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") fs.StringVar(&o.master, "master", o.master, "The address of the Kubernetes API server (overrides any value in kubeconfig)") fs.Int32Var(&o.healthzPort, "healthz-port", o.healthzPort, "The port to bind the health check server. Use 0 to disable.") - fs.Var(componentconfig.IPVar{Val: &o.config.HealthzBindAddress}, "healthz-bind-address", "The IP address and port for the health check server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") - fs.Var(componentconfig.IPVar{Val: &o.config.MetricsBindAddress}, "metrics-bind-address", "The IP address and port for the metrics server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") + fs.Var(utilflag.IPVar{Val: &o.config.HealthzBindAddress}, "healthz-bind-address", "The IP address and port for the health check server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") + fs.Var(utilflag.IPVar{Val: &o.config.MetricsBindAddress}, "metrics-bind-address", "The IP address and port for the metrics server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") fs.Int32Var(o.config.OOMScoreAdj, "oom-score-adj", utilpointer.Int32PtrDerefOr(o.config.OOMScoreAdj, int32(qos.KubeProxyOOMScoreAdj)), "The oom-score-adj value for kube-proxy process. Values must be within the range [-1000, 1000]") fs.StringVar(&o.config.ResourceContainer, "resource-container", o.config.ResourceContainer, "Absolute name of the resource-only container to create and run the Kube-proxy in (Default: /kube-proxy).") fs.MarkDeprecated("resource-container", "This feature will be removed in a later release.") fs.StringVar(&o.config.ClientConnection.Kubeconfig, "kubeconfig", o.config.ClientConnection.Kubeconfig, "Path to kubeconfig file with authorization information (the master location is set by the master flag).") - fs.Var(componentconfig.PortRangeVar{Val: &o.config.PortRange}, "proxy-port-range", "Range of host ports (beginPort-endPort, single port or beginPort+offset, inclusive) that may be consumed in order to proxy service traffic. If (unspecified, 0, or 0-0) then ports will be randomly chosen.") + fs.Var(utilflag.PortRangeVar{Val: &o.config.PortRange}, "proxy-port-range", "Range of host ports (beginPort-endPort, single port or beginPort+offset, inclusive) that may be consumed in order to proxy service traffic. If (unspecified, 0, or 0-0) then ports will be randomly chosen.") fs.StringVar(&o.config.HostnameOverride, "hostname-override", o.config.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname.") fs.Var(&o.config.Mode, "proxy-mode", "Which proxy mode to use: 'userspace' (older) or 'iptables' (faster) or 'ipvs' (experimental). If blank, use the best-available proxy (currently iptables). If the iptables proxy is selected, regardless of how, but the system's kernel or iptables versions are insufficient, this always falls back to the userspace proxy.") fs.Int32Var(o.config.IPTables.MasqueradeBit, "iptables-masquerade-bit", utilpointer.Int32PtrDerefOr(o.config.IPTables.MasqueradeBit, 14), "If using the pure iptables proxy, the bit of the fwmark space to mark packets requiring SNAT with. Must be within the range [0, 31].") diff --git a/cmd/kubelet/app/options/BUILD b/cmd/kubelet/app/options/BUILD index 7e4c72c915d..42ba81e5283 100644 --- a/cmd/kubelet/app/options/BUILD +++ b/cmd/kubelet/app/options/BUILD @@ -19,7 +19,6 @@ go_library( ], importpath = "k8s.io/kubernetes/cmd/kubelet/app/options", deps = [ - "//pkg/apis/componentconfig:go_default_library", "//pkg/apis/core:go_default_library", "//pkg/credentialprovider/azure:go_default_library", "//pkg/credentialprovider/gcp:go_default_library", @@ -30,6 +29,7 @@ go_library( "//pkg/kubelet/config:go_default_library", "//pkg/kubelet/types:go_default_library", "//pkg/master/ports:go_default_library", + "//pkg/util/flag:go_default_library", "//pkg/util/taints:go_default_library", "//pkg/version/verflag:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", diff --git a/cmd/kubelet/app/options/options.go b/cmd/kubelet/app/options/options.go index 79f42426c72..85d14f5a450 100644 --- a/cmd/kubelet/app/options/options.go +++ b/cmd/kubelet/app/options/options.go @@ -30,7 +30,6 @@ import ( utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/apiserver/pkg/util/flag" "k8s.io/kubelet/config/v1beta1" - "k8s.io/kubernetes/pkg/apis/componentconfig" "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/features" kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config" @@ -39,6 +38,7 @@ import ( "k8s.io/kubernetes/pkg/kubelet/config" kubetypes "k8s.io/kubernetes/pkg/kubelet/types" "k8s.io/kubernetes/pkg/master/ports" + utilflag "k8s.io/kubernetes/pkg/util/flag" utiltaints "k8s.io/kubernetes/pkg/util/taints" ) @@ -447,7 +447,7 @@ func AddKubeletConfigFlags(mainfs *pflag.FlagSet, c *kubeletconfig.KubeletConfig fs.DurationVar(&c.HTTPCheckFrequency.Duration, "http-check-frequency", c.HTTPCheckFrequency.Duration, "Duration between checking http for new data") fs.StringVar(&c.StaticPodURL, "manifest-url", c.StaticPodURL, "URL for accessing additional Pod specifications to run") fs.Var(flag.NewColonSeparatedMultimapStringString(&c.StaticPodURLHeader), "manifest-url-header", "Comma-separated list of HTTP headers to use when accessing the url provided to --manifest-url. Multiple headers with the same name will be added in the same order provided. This flag can be repeatedly invoked. For example: `--manifest-url-header 'a:hello,b:again,c:world' --manifest-url-header 'b:beautiful'`") - fs.Var(componentconfig.IPVar{Val: &c.Address}, "address", "The IP address for the Kubelet to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") + fs.Var(utilflag.IPVar{Val: &c.Address}, "address", "The IP address for the Kubelet to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") fs.Int32Var(&c.Port, "port", c.Port, "The port for the Kubelet to serve on.") fs.Int32Var(&c.ReadOnlyPort, "read-only-port", c.ReadOnlyPort, "The read-only port for the Kubelet to serve on with no authentication/authorization (set to 0 to disable)") @@ -499,7 +499,7 @@ func AddKubeletConfigFlags(mainfs *pflag.FlagSet, c *kubeletconfig.KubeletConfig fs.BoolVar(&c.EnableDebuggingHandlers, "enable-debugging-handlers", c.EnableDebuggingHandlers, "Enables server endpoints for log collection and local running of containers and commands") fs.BoolVar(&c.EnableContentionProfiling, "contention-profiling", c.EnableContentionProfiling, "Enable lock contention profiling, if profiling is enabled") fs.Int32Var(&c.HealthzPort, "healthz-port", c.HealthzPort, "The port of the localhost healthz endpoint (set to 0 to disable)") - fs.Var(componentconfig.IPVar{Val: &c.HealthzBindAddress}, "healthz-bind-address", "The IP address for the healthz server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") + fs.Var(utilflag.IPVar{Val: &c.HealthzBindAddress}, "healthz-bind-address", "The IP address for the healthz server to serve on (set to `0.0.0.0` for all IPv4 interfaces and `::` for all IPv6 interfaces)") fs.Int32Var(&c.OOMScoreAdj, "oom-score-adj", c.OOMScoreAdj, "The oom-score-adj value for kubelet process. Values must be within the range [-1000, 1000]") fs.StringVar(&c.ClusterDomain, "cluster-domain", c.ClusterDomain, "Domain for this cluster. If set, kubelet will configure all containers to search this domain in addition to the host's search domains") diff --git a/pkg/apis/componentconfig/helpers.go b/pkg/apis/componentconfig/helpers.go deleted file mode 100644 index a8fb98c1fad..00000000000 --- a/pkg/apis/componentconfig/helpers.go +++ /dev/null @@ -1,157 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -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 componentconfig - -import ( - "encoding/json" - "fmt" - "net" - "strconv" - - "k8s.io/api/core/v1" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/runtime" - utilnet "k8s.io/apimachinery/pkg/util/net" -) - -// used for validating command line opts -// TODO(mikedanese): remove these when we remove command line flags - -type IPVar struct { - Val *string -} - -func (v IPVar) Set(s string) error { - if len(s) == 0 { - v.Val = nil - return nil - } - if net.ParseIP(s) == nil { - return fmt.Errorf("%q is not a valid IP address", s) - } - if v.Val == nil { - // it's okay to panic here since this is programmer error - panic("the string pointer passed into IPVar should not be nil") - } - *v.Val = s - return nil -} - -func (v IPVar) String() string { - if v.Val == nil { - return "" - } - return *v.Val -} - -func (v IPVar) Type() string { - return "ip" -} - -// IPPortVar allows IP or IP:port formats. -type IPPortVar struct { - Val *string -} - -func (v IPPortVar) Set(s string) error { - if len(s) == 0 { - v.Val = nil - return nil - } - - if v.Val == nil { - // it's okay to panic here since this is programmer error - panic("the string pointer passed into IPPortVar should not be nil") - } - - // Both IP and IP:port are valid. - // Attempt to parse into IP first. - if net.ParseIP(s) != nil { - *v.Val = s - return nil - } - - // Can not parse into IP, now assume IP:port. - host, port, err := net.SplitHostPort(s) - if err != nil { - return fmt.Errorf("%q is not in a valid format (ip or ip:port): %v", s, err) - } - if net.ParseIP(host) == nil { - return fmt.Errorf("%q is not a valid IP address", host) - } - if _, err := strconv.Atoi(port); err != nil { - return fmt.Errorf("%q is not a valid number", port) - } - *v.Val = s - return nil -} - -func (v IPPortVar) String() string { - if v.Val == nil { - return "" - } - return *v.Val -} - -func (v IPPortVar) Type() string { - return "ipport" -} - -type PortRangeVar struct { - Val *string -} - -func (v PortRangeVar) Set(s string) error { - if _, err := utilnet.ParsePortRange(s); err != nil { - return fmt.Errorf("%q is not a valid port range: %v", s, err) - } - if v.Val == nil { - // it's okay to panic here since this is programmer error - panic("the string pointer passed into PortRangeVar should not be nil") - } - *v.Val = s - return nil -} - -func (v PortRangeVar) String() string { - if v.Val == nil { - return "" - } - return *v.Val -} - -func (v PortRangeVar) Type() string { - return "port-range" -} - -// ConvertObjToConfigMap converts an object to a ConfigMap. -// This is specifically meant for ComponentConfigs. -func ConvertObjToConfigMap(name string, obj runtime.Object) (*v1.ConfigMap, error) { - eJSONBytes, err := json.Marshal(obj) - if err != nil { - return nil, err - } - cm := &v1.ConfigMap{ - ObjectMeta: metav1.ObjectMeta{ - Name: name, - }, - Data: map[string]string{ - name: string(eJSONBytes[:]), - }, - } - return cm, nil -} diff --git a/pkg/util/flag/BUILD b/pkg/util/flag/BUILD index 2295ae5fb04..ac88251b33c 100644 --- a/pkg/util/flag/BUILD +++ b/pkg/util/flag/BUILD @@ -3,6 +3,7 @@ package(default_visibility = ["//visibility:public"]) load( "@io_bazel_rules_go//go:def.bzl", "go_library", + "go_test", ) go_library( @@ -10,6 +11,7 @@ go_library( srcs = ["flags.go"], importpath = "k8s.io/kubernetes/pkg/util/flag", deps = [ + "//staging/src/k8s.io/apimachinery/pkg/util/net:go_default_library", "//vendor/github.com/golang/glog:go_default_library", "//vendor/github.com/spf13/pflag:go_default_library", ], @@ -27,3 +29,10 @@ filegroup( srcs = [":package-srcs"], tags = ["automanaged"], ) + +go_test( + name = "go_default_test", + srcs = ["flags_test.go"], + embed = [":go_default_library"], + deps = ["//vendor/github.com/spf13/pflag:go_default_library"], +) diff --git a/pkg/util/flag/flags.go b/pkg/util/flag/flags.go index e55bac1121c..b58a52cc0e7 100644 --- a/pkg/util/flag/flags.go +++ b/pkg/util/flag/flags.go @@ -17,8 +17,14 @@ limitations under the License. package flag import ( + "fmt" + "net" + "strconv" + "github.com/golang/glog" "github.com/spf13/pflag" + + utilnet "k8s.io/apimachinery/pkg/util/net" ) // PrintFlags logs the flags in the flagset @@ -27,3 +33,129 @@ func PrintFlags(flags *pflag.FlagSet) { glog.V(1).Infof("FLAG: --%s=%q", flag.Name, flag.Value) }) } + +// TODO(mikedanese): remove these flag wrapper types when we remove command line flags + +var ( + _ pflag.Value = &IPVar{} + _ pflag.Value = &IPPortVar{} + _ pflag.Value = &PortRangeVar{} +) + +// IPVar is used for validating a command line option that represents an IP. It implements the pflag.Value interface +type IPVar struct { + Val *string +} + +// Set sets the flag value +func (v IPVar) Set(s string) error { + if len(s) == 0 { + v.Val = nil + return nil + } + if net.ParseIP(s) == nil { + return fmt.Errorf("%q is not a valid IP address", s) + } + if v.Val == nil { + // it's okay to panic here since this is programmer error + panic("the string pointer passed into IPVar should not be nil") + } + *v.Val = s + return nil +} + +// String returns the flag value +func (v IPVar) String() string { + if v.Val == nil { + return "" + } + return *v.Val +} + +// Type gets the flag type +func (v IPVar) Type() string { + return "ip" +} + +// IPPortVar is used for validating a command line option that represents an IP and a port. It implements the pflag.Value interface +type IPPortVar struct { + Val *string +} + +// Set sets the flag value +func (v IPPortVar) Set(s string) error { + if len(s) == 0 { + v.Val = nil + return nil + } + + if v.Val == nil { + // it's okay to panic here since this is programmer error + panic("the string pointer passed into IPPortVar should not be nil") + } + + // Both IP and IP:port are valid. + // Attempt to parse into IP first. + if net.ParseIP(s) != nil { + *v.Val = s + return nil + } + + // Can not parse into IP, now assume IP:port. + host, port, err := net.SplitHostPort(s) + if err != nil { + return fmt.Errorf("%q is not in a valid format (ip or ip:port): %v", s, err) + } + if net.ParseIP(host) == nil { + return fmt.Errorf("%q is not a valid IP address", host) + } + if _, err := strconv.Atoi(port); err != nil { + return fmt.Errorf("%q is not a valid number", port) + } + *v.Val = s + return nil +} + +// String returns the flag value +func (v IPPortVar) String() string { + if v.Val == nil { + return "" + } + return *v.Val +} + +// Type gets the flag type +func (v IPPortVar) Type() string { + return "ipport" +} + +// PortRangeVar is used for validating a command line option that represents a port range. It implements the pflag.Value interface +type PortRangeVar struct { + Val *string +} + +// Set sets the flag value +func (v PortRangeVar) Set(s string) error { + if _, err := utilnet.ParsePortRange(s); err != nil { + return fmt.Errorf("%q is not a valid port range: %v", s, err) + } + if v.Val == nil { + // it's okay to panic here since this is programmer error + panic("the string pointer passed into PortRangeVar should not be nil") + } + *v.Val = s + return nil +} + +// String returns the flag value +func (v PortRangeVar) String() string { + if v.Val == nil { + return "" + } + return *v.Val +} + +// Type gets the flag type +func (v PortRangeVar) Type() string { + return "port-range" +} diff --git a/pkg/apis/componentconfig/helpers_test.go b/pkg/util/flag/flags_test.go similarity index 99% rename from pkg/apis/componentconfig/helpers_test.go rename to pkg/util/flag/flags_test.go index 66e38e5a4c6..b60f8e0ea48 100644 --- a/pkg/apis/componentconfig/helpers_test.go +++ b/pkg/util/flag/flags_test.go @@ -14,7 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -package componentconfig +package flag import ( "strings"