More Go Vet Fixes

cmd/kube-controller-manager/app/options/options.go

@@ -56,19 +56,19 @@ func NewCMServer() *CMServer {
 			LookupCacheSizeForRC:              4096,
 			LookupCacheSizeForRS:              4096,
 			LookupCacheSizeForDaemonSet:       1024,
-			ServiceSyncPeriod:                 unversioned.Duration{5 * time.Minute},
-			NodeSyncPeriod:                    unversioned.Duration{10 * time.Second},
-			ResourceQuotaSyncPeriod:           unversioned.Duration{5 * time.Minute},
-			NamespaceSyncPeriod:               unversioned.Duration{5 * time.Minute},
-			PVClaimBinderSyncPeriod:           unversioned.Duration{10 * time.Minute},
-			HorizontalPodAutoscalerSyncPeriod: unversioned.Duration{30 * time.Second},
-			DeploymentControllerSyncPeriod:    unversioned.Duration{30 * time.Second},
-			MinResyncPeriod:                   unversioned.Duration{12 * time.Hour},
+			ServiceSyncPeriod:                 unversioned.Duration{Duration: 5 * time.Minute},
+			NodeSyncPeriod:                    unversioned.Duration{Duration: 10 * time.Second},
+			ResourceQuotaSyncPeriod:           unversioned.Duration{Duration: 5 * time.Minute},
+			NamespaceSyncPeriod:               unversioned.Duration{Duration: 5 * time.Minute},
+			PVClaimBinderSyncPeriod:           unversioned.Duration{Duration: 10 * time.Minute},
+			HorizontalPodAutoscalerSyncPeriod: unversioned.Duration{Duration: 30 * time.Second},
+			DeploymentControllerSyncPeriod:    unversioned.Duration{Duration: 30 * time.Second},
+			MinResyncPeriod:                   unversioned.Duration{Duration: 12 * time.Hour},
 			RegisterRetryCount:                10,
-			PodEvictionTimeout:                unversioned.Duration{5 * time.Minute},
-			NodeMonitorGracePeriod:            unversioned.Duration{40 * time.Second},
-			NodeStartupGracePeriod:            unversioned.Duration{60 * time.Second},
-			NodeMonitorPeriod:                 unversioned.Duration{5 * time.Second},
+			PodEvictionTimeout:                unversioned.Duration{Duration: 5 * time.Minute},
+			NodeMonitorGracePeriod:            unversioned.Duration{Duration: 40 * time.Second},
+			NodeStartupGracePeriod:            unversioned.Duration{Duration: 60 * time.Second},
+			NodeMonitorPeriod:                 unversioned.Duration{Duration: 5 * time.Second},
 			ClusterName:                       "kubernetes",
 			TerminatedPodGCThreshold:          12500,
 			VolumeConfiguration: componentconfig.VolumeConfiguration{
@@ -92,7 +92,7 @@ func NewCMServer() *CMServer {
 // AddFlags adds flags for a specific CMServer to the specified FlagSet
 func (s *CMServer) AddFlags(fs *pflag.FlagSet) {
 	fs.IntVar(&s.Port, "port", s.Port, "The port that the controller-manager's http service runs on")
-	fs.Var(componentconfig.IPVar{&s.Address}, "address", "The IP address to serve on (set to 0.0.0.0 for all interfaces)")
+	fs.Var(componentconfig.IPVar{Val: &s.Address}, "address", "The IP address to serve on (set to 0.0.0.0 for all interfaces)")
 	fs.StringVar(&s.CloudProvider, "cloud-provider", s.CloudProvider, "The provider for cloud services.  Empty string for no provider.")
 	fs.StringVar(&s.CloudConfigFile, "cloud-config", s.CloudConfigFile, "The path to the cloud provider configuration file.  Empty string for no configuration file.")
 	fs.IntVar(&s.ConcurrentEndpointSyncs, "concurrent-endpoint-syncs", s.ConcurrentEndpointSyncs, "The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load")

cmd/kube-proxy/app/options/options.go

@@ -60,15 +60,15 @@ func NewProxyConfig() *ProxyServerConfig {
 
 // AddFlags adds flags for a specific ProxyServer to the specified FlagSet
 func (s *ProxyServerConfig) AddFlags(fs *pflag.FlagSet) {
-	fs.Var(componentconfig.IPVar{&s.BindAddress}, "bind-address", "The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)")
+	fs.Var(componentconfig.IPVar{Val: &s.BindAddress}, "bind-address", "The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)")
 	fs.StringVar(&s.Master, "master", s.Master, "The address of the Kubernetes API server (overrides any value in kubeconfig)")
 	fs.IntVar(&s.HealthzPort, "healthz-port", s.HealthzPort, "The port to bind the health check server. Use 0 to disable.")
-	fs.Var(componentconfig.IPVar{&s.HealthzBindAddress}, "healthz-bind-address", "The IP address for the health check server to serve on, defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces)")
+	fs.Var(componentconfig.IPVar{Val: &s.HealthzBindAddress}, "healthz-bind-address", "The IP address for the health check server to serve on, defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces)")
 	fs.IntVar(s.OOMScoreAdj, "oom-score-adj", util.IntPtrDerefOr(s.OOMScoreAdj, qos.KubeProxyOOMScoreAdj), "The oom-score-adj value for kube-proxy process. Values must be within the range [-1000, 1000]")
 	fs.StringVar(&s.ResourceContainer, "resource-container", s.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(&s.Kubeconfig, "kubeconfig", s.Kubeconfig, "Path to kubeconfig file with authorization information (the master location is set by the master flag).")
-	fs.Var(componentconfig.PortRangeVar{&s.PortRange}, "proxy-port-range", "Range of host ports (beginPort-endPort, inclusive) that may be consumed in order to proxy service traffic. If unspecified (0-0) then ports will be randomly chosen.")
+	fs.Var(componentconfig.PortRangeVar{Val: &s.PortRange}, "proxy-port-range", "Range of host ports (beginPort-endPort, inclusive) that may be consumed in order to proxy service traffic. If unspecified (0-0) then ports will be randomly chosen.")
 	fs.StringVar(&s.HostnameOverride, "hostname-override", s.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname.")
 	fs.Var(&s.Mode, "proxy-mode", "Which proxy mode to use: 'userspace' (older) or 'iptables' (faster). If blank, look at the Node object on the Kubernetes API and respect the '"+ExperimentalProxyModeAnnotation+"' annotation if provided.  Otherwise 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.IntVar(s.IPTablesMasqueradeBit, "iptables-masquerade-bit", util.IntPtrDerefOr(s.IPTablesMasqueradeBit, 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].")

cmd/kubelet/app/options/options.go

@@ -68,7 +68,7 @@ func NewKubeletServer() *KubeletServer {
 		KubeletConfiguration: componentconfig.KubeletConfiguration{
 			Address:                     "0.0.0.0",
 			CAdvisorPort:                4194,
-			VolumeStatsAggPeriod:        unversioned.Duration{time.Minute},
+			VolumeStatsAggPeriod:        unversioned.Duration{Duration: time.Minute},
 			CertDirectory:               "/var/run/kubernetes",
 			CgroupRoot:                  "",
 			ConfigureCBR0:               false,
@@ -80,14 +80,14 @@ func NewKubeletServer() *KubeletServer {
 			EnableCustomMetrics:         false,
 			EnableDebuggingHandlers:     true,
 			EnableServer:                true,
-			FileCheckFrequency:          unversioned.Duration{20 * time.Second},
+			FileCheckFrequency:          unversioned.Duration{Duration: 20 * time.Second},
 			HealthzBindAddress:          "127.0.0.1",
 			HealthzPort:                 10248,
 			HostNetworkSources:          kubetypes.AllSource,
 			HostPIDSources:              kubetypes.AllSource,
 			HostIPCSources:              kubetypes.AllSource,
-			HTTPCheckFrequency:          unversioned.Duration{20 * time.Second},
-			ImageMinimumGCAge:           unversioned.Duration{2 * time.Minute},
+			HTTPCheckFrequency:          unversioned.Duration{Duration: 20 * time.Second},
+			ImageMinimumGCAge:           unversioned.Duration{Duration: 2 * time.Minute},
 			ImageGCHighThresholdPercent: 90,
 			ImageGCLowThresholdPercent:  80,
 			LowDiskSpaceThresholdMB:     256,
@@ -96,12 +96,12 @@ func NewKubeletServer() *KubeletServer {
 			MaxPerPodContainerCount:     2,
 			MaxOpenFiles:                1000000,
 			MaxPods:                     110,
-			MinimumGCAge:                unversioned.Duration{1 * time.Minute},
+			MinimumGCAge:                unversioned.Duration{Duration: 1 * time.Minute},
 			NetworkPluginDir:            "/usr/libexec/kubernetes/kubelet-plugins/net/exec/",
 			NetworkPluginName:           "",
 			NonMasqueradeCIDR:           "10.0.0.0/8",
 			VolumePluginDir:             "/usr/libexec/kubernetes/kubelet-plugins/volume/exec/",
-			NodeStatusUpdateFrequency:   unversioned.Duration{10 * time.Second},
+			NodeStatusUpdateFrequency:   unversioned.Duration{Duration: 10 * time.Second},
 			NodeLabels:                  make(map[string]string),
 			OOMScoreAdj:                 qos.KubeletOOMScoreAdj,
 			LockFilePath:                "",
@@ -118,14 +118,14 @@ func NewKubeletServer() *KubeletServer {
 			RootDirectory:                  defaultRootDir,
 			RuntimeCgroups:                 "",
 			SerializeImagePulls:            true,
-			StreamingConnectionIdleTimeout: unversioned.Duration{4 * time.Hour},
-			SyncFrequency:                  unversioned.Duration{1 * time.Minute},
+			StreamingConnectionIdleTimeout: unversioned.Duration{Duration: 4 * time.Hour},
+			SyncFrequency:                  unversioned.Duration{Duration: 1 * time.Minute},
 			SystemCgroups:                  "",
 			ReconcileCIDR:                  true,
 			KubeAPIQPS:                     5.0,
 			KubeAPIBurst:                   10,
 			ExperimentalFlannelOverlay:     experimentalFlannelOverlay,
-			OutOfDiskTransitionFrequency:   unversioned.Duration{5 * time.Minute},
+			OutOfDiskTransitionFrequency:   unversioned.Duration{Duration: 5 * time.Minute},
 			HairpinMode:                    componentconfig.PromiscuousBridge,
 			BabysitDaemons:                 false,
 		},
@@ -141,7 +141,7 @@ func (s *KubeletServer) AddFlags(fs *pflag.FlagSet) {
 	fs.StringVar(&s.ManifestURL, "manifest-url", s.ManifestURL, "URL for accessing the container manifest")
 	fs.StringVar(&s.ManifestURLHeader, "manifest-url-header", s.ManifestURLHeader, "HTTP header to use when accessing the manifest URL, with the key separated from the value with a ':', as in 'key:value'")
 	fs.BoolVar(&s.EnableServer, "enable-server", s.EnableServer, "Enable the Kubelet's server")
-	fs.Var(componentconfig.IPVar{&s.Address}, "address", "The IP address for the Kubelet to serve on (set to 0.0.0.0 for all interfaces)")
+	fs.Var(componentconfig.IPVar{Val: &s.Address}, "address", "The IP address for the Kubelet to serve on (set to 0.0.0.0 for all interfaces)")
 	fs.UintVar(&s.Port, "port", s.Port, "The port for the Kubelet to serve on.")
 	fs.UintVar(&s.ReadOnlyPort, "read-only-port", s.ReadOnlyPort, "The read-only port for the Kubelet to serve on with no authentication/authorization (set to 0 to disable)")
 	fs.StringVar(&s.TLSCertFile, "tls-cert-file", s.TLSCertFile, ""+
@@ -173,7 +173,7 @@ func (s *KubeletServer) AddFlags(fs *pflag.FlagSet) {
 	fs.Var(&s.KubeConfig, "kubeconfig", "Path to a kubeconfig file, specifying how to authenticate to API server (the master location is set by the api-servers flag).")
 	fs.UintVar(&s.CAdvisorPort, "cadvisor-port", s.CAdvisorPort, "The port of the localhost cAdvisor endpoint")
 	fs.IntVar(&s.HealthzPort, "healthz-port", s.HealthzPort, "The port of the localhost healthz endpoint")
-	fs.Var(componentconfig.IPVar{&s.HealthzBindAddress}, "healthz-bind-address", "The IP address for the healthz server to serve on, defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces)")
+	fs.Var(componentconfig.IPVar{Val: &s.HealthzBindAddress}, "healthz-bind-address", "The IP address for the healthz server to serve on, defaulting to 127.0.0.1 (set to 0.0.0.0 for all interfaces)")
 	fs.IntVar(&s.OOMScoreAdj, "oom-score-adj", s.OOMScoreAdj, "The oom-score-adj value for kubelet process. Values must be within the range [-1000, 1000]")
 	fs.StringSliceVar(&s.APIServerList, "api-servers", []string{}, "List of Kubernetes API servers for publishing events, and reading pods and services. (ip:port), comma separated.")
 	fs.BoolVar(&s.RegisterNode, "register-node", s.RegisterNode, "Register the node with the apiserver (defaults to true if --api-servers is set)")

cmd/kubelet/app/server.go

@@ -608,7 +608,7 @@ func RunKubelet(kcfg *KubeletConfig) error {
 	eventBroadcaster.StartLogging(glog.V(3).Infof)
 	if kcfg.EventClient != nil {
 		glog.V(4).Infof("Sending events to api server.")
-		eventBroadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{kcfg.EventClient.Events("")})
+		eventBroadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{Interface: kcfg.EventClient.Events("")})
 	} else {
 		glog.Warning("No api server defined - no events will be sent to API server.")
 	}

cmd/libs/go2idl/client-gen/generators/normalization/normalization.go

@@ -33,5 +33,5 @@ func Version(version string) string {
 }
 
 func GroupVersion(gv unversioned.GroupVersion) unversioned.GroupVersion {
-	return unversioned.GroupVersion{Group(gv.Group), Version(gv.Version)}
+	return unversioned.GroupVersion{Group: Group(gv.Group), Version: Version(gv.Version)}
 }

cmd/libs/go2idl/client-gen/main.go

@@ -97,9 +97,9 @@ func main() {
 		// We may change the output path later.
 		arguments.OutputPackagePath = "k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testoutput"
 		arguments.CustomArgs = clientgenargs.Args{
-			[]unversioned.GroupVersion{{"testgroup", ""}},
+			[]unversioned.GroupVersion{{Group: "testgroup", Version: ""}},
 			map[unversioned.GroupVersion]string{
-				unversioned.GroupVersion{"testgroup", ""}: "k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testdata/apis/testgroup",
+				unversioned.GroupVersion{Group: "testgroup", Version: ""}: "k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testdata/apis/testgroup",
 			},
 			"test_internalclientset",
 			"k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testoutput/clientset_generated/",

cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned/testgroup_test.go

@@ -109,7 +109,7 @@ func TestUpdateStatusTestType(t *testing.T) {
 				"name": "baz",
 			},
 		},
-		Status: testgroup.TestTypeStatus{"I'm in good status"},
+		Status: testgroup.TestTypeStatus{Blah: "I'm in good status"},
 	}
 	c := DecoratedSimpleClient{
 		simpleClient: simple.Client{

contrib/mesos/pkg/node/registrator_test.go

@@ -51,7 +51,7 @@ func calledOnce(h bool, ret runtime.Object, err error) (<-chan struct{}, func(co
 
 func TestRegister_withUnknownNode(t *testing.T) {
 	fc := &core.Fake{}
-	nodes := &fakeNodes{&fake.FakeNodes{&fake.FakeCore{fc}}}
+	nodes := &fakeNodes{&fake.FakeNodes{&fake.FakeCore{Fake: fc}}}
 	createCalled, createOnce := calledOnce(true, nil, nil)
 	fc.AddReactor("create", "nodes", createOnce)
 
@@ -84,7 +84,7 @@ func TestRegister_withUnknownNode(t *testing.T) {
 
 func TestRegister_withKnownNode(t *testing.T) {
 	fc := &core.Fake{}
-	nodes := &fakeNodes{&fake.FakeNodes{&fake.FakeCore{fc}}}
+	nodes := &fakeNodes{&fake.FakeNodes{&fake.FakeCore{Fake: fc}}}
 	updateCalled, updateOnce := calledOnce(true, nil, nil)
 	fc.AddReactor("update", "nodes", updateOnce)
 
@@ -122,9 +122,9 @@ func TestRegister_withSemiKnownNode(t *testing.T) {
 	// CreateOrUpdate should proceed to attempt an update.
 
 	fc := &core.Fake{}
-	nodes := &fakeNodes{&fake.FakeNodes{&fake.FakeCore{fc}}}
+	nodes := &fakeNodes{&fake.FakeNodes{&fake.FakeCore{Fake: fc}}}
 
-	createCalled, createOnce := calledOnce(true, nil, errors.NewAlreadyExists(unversioned.GroupResource{"", ""}, "nodes"))
+	createCalled, createOnce := calledOnce(true, nil, errors.NewAlreadyExists(unversioned.GroupResource{Group: "", Resource: ""}, "nodes"))
 	fc.AddReactor("create", "nodes", createOnce)
 
 	updateCalled, updateOnce := calledOnce(true, nil, nil)

contrib/mesos/pkg/node/statusupdater_test.go

@@ -39,8 +39,8 @@ func Test_nodeWithUpdatedStatus(t *testing.T) {
 					Status:             s,
 					Reason:             r,
 					Message:            "some message we don't care about here",
-					LastTransitionTime: unversioned.Time{now.Add(-time.Minute)},
-					LastHeartbeatTime:  unversioned.Time{now.Add(d)},
+					LastTransitionTime: unversioned.Time{Time: now.Add(-time.Minute)},
+					LastHeartbeatTime:  unversioned.Time{Time: now.Add(d)},
 				}},
 			},
 		}

contrib/mesos/pkg/scheduler/service/service.go

@@ -874,7 +874,7 @@ func (s *SchedulerServer) bootstrap(hks hyperkube.Interface, sc *schedcfg.Config
 	broadcaster := record.NewBroadcaster()
 	recorder := broadcaster.NewRecorder(api.EventSource{Component: api.DefaultSchedulerName})
 	broadcaster.StartLogging(log.Infof)
-	broadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{eventsClient.Events("")})
+	broadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{Interface: eventsClient.Events("")})
 
 	lw := cache.NewListWatchFromClient(s.client.CoreClient, "pods", api.NamespaceAll, fields.Everything())
 

pkg/api/helpers.go

@@ -342,13 +342,13 @@ func containsAccessMode(modes []PersistentVolumeAccessMode, mode PersistentVolum
 // ParseRFC3339 parses an RFC3339 date in either RFC3339Nano or RFC3339 format.
 func ParseRFC3339(s string, nowFn func() unversioned.Time) (unversioned.Time, error) {
 	if t, timeErr := time.Parse(time.RFC3339Nano, s); timeErr == nil {
-		return unversioned.Time{t}, nil
+		return unversioned.Time{Time: t}, nil
 	}
 	t, err := time.Parse(time.RFC3339, s)
 	if err != nil {
 		return unversioned.Time{}, err
 	}
-	return unversioned.Time{t}, nil
+	return unversioned.Time{Time: t}, nil
 }
 
 // NodeSelectorRequirementsAsSelector converts the []NodeSelectorRequirement api type into a struct that implements