Move defaulter functions to public methods with a convention

Preparing to generate direct defaulter access.

pkg/api/v1/defaults.go

@@ -25,234 +25,257 @@ import (
 
 func addDefaultingFuncs(scheme *runtime.Scheme) {
 	scheme.AddDefaultingFuncs(
-		func(obj *PodExecOptions) {
+		SetDefaults_PodExecOptions,
-			obj.Stdout = true
+		SetDefaults_PodAttachOptions,
-			obj.Stderr = true
+		SetDefaults_ReplicationController,
-		},
+		SetDefaults_Volume,
-		func(obj *PodAttachOptions) {
+		SetDefaults_ContainerPort,
-			obj.Stdout = true
+		SetDefaults_Container,
-			obj.Stderr = true
+		SetDefaults_ServiceSpec,
-		},
+		SetDefaults_Pod,
-		func(obj *ReplicationController) {
+		SetDefaults_PodSpec,
-			var labels map[string]string
+		SetDefaults_Probe,
-			if obj.Spec.Template != nil {
+		SetDefaults_Secret,
-				labels = obj.Spec.Template.Labels
+		SetDefaults_PersistentVolume,
-			}
+		SetDefaults_PersistentVolumeClaim,
-			// TODO: support templates defined elsewhere when we support them in the API
+		SetDefaults_ISCSIVolumeSource,
-			if labels != nil {
+		SetDefaults_Endpoints,
-				if len(obj.Spec.Selector) == 0 {
+		SetDefaults_HTTPGetAction,
-					obj.Spec.Selector = labels
+		SetDefaults_NamespaceStatus,
-				}
+		SetDefaults_Node,
-				if len(obj.Labels) == 0 {
+		SetDefaults_NodeStatus,
-					obj.Labels = labels
+		SetDefaults_ObjectFieldSelector,
-				}
+		SetDefaults_LimitRangeItem,
-			}
+		SetDefaults_ConfigMap,
-			if obj.Spec.Replicas == nil {
-				obj.Spec.Replicas = new(int32)
-				*obj.Spec.Replicas = 1
-			}
-		},
-		func(obj *Volume) {
-			if util.AllPtrFieldsNil(&obj.VolumeSource) {
-				obj.VolumeSource = VolumeSource{
-					EmptyDir: &EmptyDirVolumeSource{},
-				}
-			}
-		},
-		func(obj *ContainerPort) {
-			if obj.Protocol == "" {
-				obj.Protocol = ProtocolTCP
-			}
-		},
-		func(obj *Container) {
-			if obj.ImagePullPolicy == "" {
-				// Ignore error and assume it has been validated elsewhere
-				_, tag, _ := parsers.ParseImageName(obj.Image)
-
-				// Check image tag
-
-				if tag == "latest" {
-					obj.ImagePullPolicy = PullAlways
-				} else {
-					obj.ImagePullPolicy = PullIfNotPresent
-				}
-			}
-			if obj.TerminationMessagePath == "" {
-				obj.TerminationMessagePath = TerminationMessagePathDefault
-			}
-		},
-		func(obj *ServiceSpec) {
-			if obj.SessionAffinity == "" {
-				obj.SessionAffinity = ServiceAffinityNone
-			}
-			if obj.Type == "" {
-				obj.Type = ServiceTypeClusterIP
-			}
-			for i := range obj.Ports {
-				sp := &obj.Ports[i]
-				if sp.Protocol == "" {
-					sp.Protocol = ProtocolTCP
-				}
-				if sp.TargetPort == intstr.FromInt(0) || sp.TargetPort == intstr.FromString("") {
-					sp.TargetPort = intstr.FromInt(int(sp.Port))
-				}
-			}
-		},
-		func(obj *Pod) {
-			// If limits are specified, but requests are not, default requests to limits
-			// This is done here rather than a more specific defaulting pass on ResourceRequirements
-			// because we only want this defaulting semantic to take place on a Pod and not a PodTemplate
-			for i := range obj.Spec.Containers {
-				// set requests to limits if requests are not specified, but limits are
-				if obj.Spec.Containers[i].Resources.Limits != nil {
-					if obj.Spec.Containers[i].Resources.Requests == nil {
-						obj.Spec.Containers[i].Resources.Requests = make(ResourceList)
-					}
-					for key, value := range obj.Spec.Containers[i].Resources.Limits {
-						if _, exists := obj.Spec.Containers[i].Resources.Requests[key]; !exists {
-							obj.Spec.Containers[i].Resources.Requests[key] = *(value.Copy())
-						}
-					}
-				}
-			}
-		},
-		func(obj *PodSpec) {
-			if obj.DNSPolicy == "" {
-				obj.DNSPolicy = DNSClusterFirst
-			}
-			if obj.RestartPolicy == "" {
-				obj.RestartPolicy = RestartPolicyAlways
-			}
-			if obj.HostNetwork {
-				defaultHostNetworkPorts(&obj.Containers)
-			}
-			if obj.SecurityContext == nil {
-				obj.SecurityContext = &PodSecurityContext{}
-			}
-			if obj.TerminationGracePeriodSeconds == nil {
-				period := int64(DefaultTerminationGracePeriodSeconds)
-				obj.TerminationGracePeriodSeconds = &period
-			}
-		},
-		func(obj *Probe) {
-			if obj.TimeoutSeconds == 0 {
-				obj.TimeoutSeconds = 1
-			}
-			if obj.PeriodSeconds == 0 {
-				obj.PeriodSeconds = 10
-			}
-			if obj.SuccessThreshold == 0 {
-				obj.SuccessThreshold = 1
-			}
-			if obj.FailureThreshold == 0 {
-				obj.FailureThreshold = 3
-			}
-		},
-		func(obj *Secret) {
-			if obj.Type == "" {
-				obj.Type = SecretTypeOpaque
-			}
-		},
-		func(obj *PersistentVolume) {
-			if obj.Status.Phase == "" {
-				obj.Status.Phase = VolumePending
-			}
-			if obj.Spec.PersistentVolumeReclaimPolicy == "" {
-				obj.Spec.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimRetain
-			}
-		},
-		func(obj *PersistentVolumeClaim) {
-			if obj.Status.Phase == "" {
-				obj.Status.Phase = ClaimPending
-			}
-		},
-		func(obj *ISCSIVolumeSource) {
-			if obj.ISCSIInterface == "" {
-				obj.ISCSIInterface = "default"
-			}
-		},
-		func(obj *Endpoints) {
-			for i := range obj.Subsets {
-				ss := &obj.Subsets[i]
-				for i := range ss.Ports {
-					ep := &ss.Ports[i]
-					if ep.Protocol == "" {
-						ep.Protocol = ProtocolTCP
-					}
-				}
-			}
-		},
-		func(obj *HTTPGetAction) {
-			if obj.Path == "" {
-				obj.Path = "/"
-			}
-			if obj.Scheme == "" {
-				obj.Scheme = URISchemeHTTP
-			}
-		},
-		func(obj *NamespaceStatus) {
-			if obj.Phase == "" {
-				obj.Phase = NamespaceActive
-			}
-		},
-		func(obj *Node) {
-			if obj.Spec.ExternalID == "" {
-				obj.Spec.ExternalID = obj.Name
-			}
-		},
-		func(obj *NodeStatus) {
-			if obj.Allocatable == nil && obj.Capacity != nil {
-				obj.Allocatable = make(ResourceList, len(obj.Capacity))
-				for key, value := range obj.Capacity {
-					obj.Allocatable[key] = *(value.Copy())
-				}
-				obj.Allocatable = obj.Capacity
-			}
-		},
-		func(obj *ObjectFieldSelector) {
-			if obj.APIVersion == "" {
-				obj.APIVersion = "v1"
-			}
-		},
-		func(obj *LimitRangeItem) {
-			// for container limits, we apply default values
-			if obj.Type == LimitTypeContainer {
-
-				if obj.Default == nil {
-					obj.Default = make(ResourceList)
-				}
-				if obj.DefaultRequest == nil {
-					obj.DefaultRequest = make(ResourceList)
-				}
-
-				// If a default limit is unspecified, but the max is specified, default the limit to the max
-				for key, value := range obj.Max {
-					if _, exists := obj.Default[key]; !exists {
-						obj.Default[key] = *(value.Copy())
-					}
-				}
-				// If a default limit is specified, but the default request is not, default request to limit
-				for key, value := range obj.Default {
-					if _, exists := obj.DefaultRequest[key]; !exists {
-						obj.DefaultRequest[key] = *(value.Copy())
-					}
-				}
-				// If a default request is not specified, but the min is provided, default request to the min
-				for key, value := range obj.Min {
-					if _, exists := obj.DefaultRequest[key]; !exists {
-						obj.DefaultRequest[key] = *(value.Copy())
-					}
-				}
-			}
-		},
-		func(obj *ConfigMap) {
-			if obj.Data == nil {
-				obj.Data = make(map[string]string)
-			}
-		},
 	)
 }
 
+func SetDefaults_PodExecOptions(obj *PodExecOptions) {
+	obj.Stdout = true
+	obj.Stderr = true
+}
+func SetDefaults_PodAttachOptions(obj *PodAttachOptions) {
+	obj.Stdout = true
+	obj.Stderr = true
+}
+func SetDefaults_ReplicationController(obj *ReplicationController) {
+	var labels map[string]string
+	if obj.Spec.Template != nil {
+		labels = obj.Spec.Template.Labels
+	}
+	// TODO: support templates defined elsewhere when we support them in the API
+	if labels != nil {
+		if len(obj.Spec.Selector) == 0 {
+			obj.Spec.Selector = labels
+		}
+		if len(obj.Labels) == 0 {
+			obj.Labels = labels
+		}
+	}
+	if obj.Spec.Replicas == nil {
+		obj.Spec.Replicas = new(int32)
+		*obj.Spec.Replicas = 1
+	}
+}
+func SetDefaults_Volume(obj *Volume) {
+	if util.AllPtrFieldsNil(&obj.VolumeSource) {
+		obj.VolumeSource = VolumeSource{
+			EmptyDir: &EmptyDirVolumeSource{},
+		}
+	}
+}
+func SetDefaults_ContainerPort(obj *ContainerPort) {
+	if obj.Protocol == "" {
+		obj.Protocol = ProtocolTCP
+	}
+}
+func SetDefaults_Container(obj *Container) {
+	if obj.ImagePullPolicy == "" {
+		// Ignore error and assume it has been validated elsewhere
+		_, tag, _ := parsers.ParseImageName(obj.Image)
+
+		// Check image tag
+
+		if tag == "latest" {
+			obj.ImagePullPolicy = PullAlways
+		} else {
+			obj.ImagePullPolicy = PullIfNotPresent
+		}
+	}
+	if obj.TerminationMessagePath == "" {
+		obj.TerminationMessagePath = TerminationMessagePathDefault
+	}
+}
+func SetDefaults_ServiceSpec(obj *ServiceSpec) {
+	if obj.SessionAffinity == "" {
+		obj.SessionAffinity = ServiceAffinityNone
+	}
+	if obj.Type == "" {
+		obj.Type = ServiceTypeClusterIP
+	}
+	for i := range obj.Ports {
+		sp := &obj.Ports[i]
+		if sp.Protocol == "" {
+			sp.Protocol = ProtocolTCP
+		}
+		if sp.TargetPort == intstr.FromInt(0) || sp.TargetPort == intstr.FromString("") {
+			sp.TargetPort = intstr.FromInt(int(sp.Port))
+		}
+	}
+}
+func SetDefaults_Pod(obj *Pod) {
+	// If limits are specified, but requests are not, default requests to limits
+	// This is done here rather than a more specific defaulting pass on ResourceRequirements
+	// because we only want this defaulting semantic to take place on a Pod and not a PodTemplate
+	for i := range obj.Spec.Containers {
+		// set requests to limits if requests are not specified, but limits are
+		if obj.Spec.Containers[i].Resources.Limits != nil {
+			if obj.Spec.Containers[i].Resources.Requests == nil {
+				obj.Spec.Containers[i].Resources.Requests = make(ResourceList)
+			}
+			for key, value := range obj.Spec.Containers[i].Resources.Limits {
+				if _, exists := obj.Spec.Containers[i].Resources.Requests[key]; !exists {
+					obj.Spec.Containers[i].Resources.Requests[key] = *(value.Copy())
+				}
+			}
+		}
+	}
+}
+func SetDefaults_PodSpec(obj *PodSpec) {
+	if obj.DNSPolicy == "" {
+		obj.DNSPolicy = DNSClusterFirst
+	}
+	if obj.RestartPolicy == "" {
+		obj.RestartPolicy = RestartPolicyAlways
+	}
+	if obj.HostNetwork {
+		defaultHostNetworkPorts(&obj.Containers)
+	}
+	if obj.SecurityContext == nil {
+		obj.SecurityContext = &PodSecurityContext{}
+	}
+	if obj.TerminationGracePeriodSeconds == nil {
+		period := int64(DefaultTerminationGracePeriodSeconds)
+		obj.TerminationGracePeriodSeconds = &period
+	}
+}
+func SetDefaults_Probe(obj *Probe) {
+	if obj.TimeoutSeconds == 0 {
+		obj.TimeoutSeconds = 1
+	}
+	if obj.PeriodSeconds == 0 {
+		obj.PeriodSeconds = 10
+	}
+	if obj.SuccessThreshold == 0 {
+		obj.SuccessThreshold = 1
+	}
+	if obj.FailureThreshold == 0 {
+		obj.FailureThreshold = 3
+	}
+}
+func SetDefaults_Secret(obj *Secret) {
+	if obj.Type == "" {
+		obj.Type = SecretTypeOpaque
+	}
+}
+func SetDefaults_PersistentVolume(obj *PersistentVolume) {
+	if obj.Status.Phase == "" {
+		obj.Status.Phase = VolumePending
+	}
+	if obj.Spec.PersistentVolumeReclaimPolicy == "" {
+		obj.Spec.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimRetain
+	}
+}
+func SetDefaults_PersistentVolumeClaim(obj *PersistentVolumeClaim) {
+	if obj.Status.Phase == "" {
+		obj.Status.Phase = ClaimPending
+	}
+}
+func SetDefaults_ISCSIVolumeSource(obj *ISCSIVolumeSource) {
+	if obj.ISCSIInterface == "" {
+		obj.ISCSIInterface = "default"
+	}
+}
+func SetDefaults_Endpoints(obj *Endpoints) {
+	for i := range obj.Subsets {
+		ss := &obj.Subsets[i]
+		for i := range ss.Ports {
+			ep := &ss.Ports[i]
+			if ep.Protocol == "" {
+				ep.Protocol = ProtocolTCP
+			}
+		}
+	}
+}
+func SetDefaults_HTTPGetAction(obj *HTTPGetAction) {
+	if obj.Path == "" {
+		obj.Path = "/"
+	}
+	if obj.Scheme == "" {
+		obj.Scheme = URISchemeHTTP
+	}
+}
+func SetDefaults_NamespaceStatus(obj *NamespaceStatus) {
+	if obj.Phase == "" {
+		obj.Phase = NamespaceActive
+	}
+}
+func SetDefaults_Node(obj *Node) {
+	if obj.Spec.ExternalID == "" {
+		obj.Spec.ExternalID = obj.Name
+	}
+}
+func SetDefaults_NodeStatus(obj *NodeStatus) {
+	if obj.Allocatable == nil && obj.Capacity != nil {
+		obj.Allocatable = make(ResourceList, len(obj.Capacity))
+		for key, value := range obj.Capacity {
+			obj.Allocatable[key] = *(value.Copy())
+		}
+		obj.Allocatable = obj.Capacity
+	}
+}
+func SetDefaults_ObjectFieldSelector(obj *ObjectFieldSelector) {
+	if obj.APIVersion == "" {
+		obj.APIVersion = "v1"
+	}
+}
+func SetDefaults_LimitRangeItem(obj *LimitRangeItem) {
+	// for container limits, we apply default values
+	if obj.Type == LimitTypeContainer {
+
+		if obj.Default == nil {
+			obj.Default = make(ResourceList)
+		}
+		if obj.DefaultRequest == nil {
+			obj.DefaultRequest = make(ResourceList)
+		}
+
+		// If a default limit is unspecified, but the max is specified, default the limit to the max
+		for key, value := range obj.Max {
+			if _, exists := obj.Default[key]; !exists {
+				obj.Default[key] = *(value.Copy())
+			}
+		}
+		// If a default limit is specified, but the default request is not, default request to limit
+		for key, value := range obj.Default {
+			if _, exists := obj.DefaultRequest[key]; !exists {
+				obj.DefaultRequest[key] = *(value.Copy())
+			}
+		}
+		// If a default request is not specified, but the min is provided, default request to the min
+		for key, value := range obj.Min {
+			if _, exists := obj.DefaultRequest[key]; !exists {
+				obj.DefaultRequest[key] = *(value.Copy())
+			}
+		}
+	}
+}
+func SetDefaults_ConfigMap(obj *ConfigMap) {
+	if obj.Data == nil {
+		obj.Data = make(map[string]string)
+	}
+}
+
 // With host networking default all container ports to host ports.
 func defaultHostNetworkPorts(containers *[]Container) {
 	for i := range *containers {

pkg/apis/apps/v1alpha1/defaulting.go

@@ -23,22 +23,24 @@ import (
 
 func addDefaultingFuncs(scheme *runtime.Scheme) {
 	scheme.AddDefaultingFuncs(
-		func(obj *PetSet) {
+		SetDefaults_PetSet,
-			labels := obj.Spec.Template.Labels
-			if labels != nil {
-				if obj.Spec.Selector == nil {
-					obj.Spec.Selector = &unversioned.LabelSelector{
-						MatchLabels: labels,
-					}
-				}
-				if len(obj.Labels) == 0 {
-					obj.Labels = labels
-				}
-			}
-			if obj.Spec.Replicas == nil {
-				obj.Spec.Replicas = new(int32)
-				*obj.Spec.Replicas = 1
-			}
-		},
 	)
 }
+
+func SetDefaults_PetSet(obj *PetSet) {
+	labels := obj.Spec.Template.Labels
+	if labels != nil {
+		if obj.Spec.Selector == nil {
+			obj.Spec.Selector = &unversioned.LabelSelector{
+				MatchLabels: labels,
+			}
+		}
+		if len(obj.Labels) == 0 {
+			obj.Labels = labels
+		}
+	}
+	if obj.Spec.Replicas == nil {
+		obj.Spec.Replicas = new(int32)
+		*obj.Spec.Replicas = 1
+	}
+}

pkg/apis/autoscaling/v1/defaults.go

@@ -22,11 +22,13 @@ import (
 
 func addDefaultingFuncs(scheme *runtime.Scheme) {
 	scheme.AddDefaultingFuncs(
-		func(obj *HorizontalPodAutoscaler) {
+		SetDefaults_HorizontalPodAutoscaler,
-			if obj.Spec.MinReplicas == nil {
-				minReplicas := int32(1)
-				obj.Spec.MinReplicas = &minReplicas
-			}
-		},
 	)
 }
+
+func SetDefaults_HorizontalPodAutoscaler(obj *HorizontalPodAutoscaler) {
+	if obj.Spec.MinReplicas == nil {
+		minReplicas := int32(1)
+		obj.Spec.MinReplicas = &minReplicas
+	}
+}

pkg/apis/batch/v1/defaults.go

@@ -22,19 +22,21 @@ import (
 
 func addDefaultingFuncs(scheme *runtime.Scheme) {
 	scheme.AddDefaultingFuncs(
-		func(obj *Job) {
+		SetDefaults_Job,
-			// For a non-parallel job, you can leave both `.spec.completions` and
-			// `.spec.parallelism` unset.  When both are unset, both are defaulted to 1.
-			if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
-				obj.Spec.Completions = new(int32)
-				*obj.Spec.Completions = 1
-				obj.Spec.Parallelism = new(int32)
-				*obj.Spec.Parallelism = 1
-			}
-			if obj.Spec.Parallelism == nil {
-				obj.Spec.Parallelism = new(int32)
-				*obj.Spec.Parallelism = 1
-			}
-		},
 	)
 }
+
+func SetDefaults_Job(obj *Job) {
+	// For a non-parallel job, you can leave both `.spec.completions` and
+	// `.spec.parallelism` unset.  When both are unset, both are defaulted to 1.
+	if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
+		obj.Spec.Completions = new(int32)
+		*obj.Spec.Completions = 1
+		obj.Spec.Parallelism = new(int32)
+		*obj.Spec.Parallelism = 1
+	}
+	if obj.Spec.Parallelism == nil {
+		obj.Spec.Parallelism = new(int32)
+		*obj.Spec.Parallelism = 1
+	}
+}

pkg/apis/componentconfig/v1alpha1/defaults.go

@@ -28,72 +28,78 @@ import (
 
 func addDefaultingFuncs(scheme *runtime.Scheme) {
 	scheme.AddDefaultingFuncs(
-		func(obj *KubeProxyConfiguration) {
+		SetDefaults_KubeProxyConfiguration,
-			if obj.BindAddress == "" {
+		SetDefaults_KubeSchedulerConfiguration,
-				obj.BindAddress = "0.0.0.0"
+		SetDefaults_LeaderElectionConfiguration,
-			}
-			if obj.HealthzPort == 0 {
-				obj.HealthzPort = 10249
-			}
-			if obj.HealthzBindAddress == "" {
-				obj.HealthzBindAddress = "127.0.0.1"
-			}
-			if obj.OOMScoreAdj == nil {
-				temp := int32(qos.KubeProxyOOMScoreAdj)
-				obj.OOMScoreAdj = &temp
-			}
-			if obj.ResourceContainer == "" {
-				obj.ResourceContainer = "/kube-proxy"
-			}
-			if obj.IPTablesSyncPeriod.Duration == 0 {
-				obj.IPTablesSyncPeriod = unversioned.Duration{Duration: 30 * time.Second}
-			}
-			zero := unversioned.Duration{}
-			if obj.UDPIdleTimeout == zero {
-				obj.UDPIdleTimeout = unversioned.Duration{Duration: 250 * time.Millisecond}
-			}
-			if obj.ConntrackMax == 0 {
-				obj.ConntrackMax = 256 * 1024 // 4x default (64k)
-			}
-			if obj.IPTablesMasqueradeBit == nil {
-				temp := int32(14)
-				obj.IPTablesMasqueradeBit = &temp
-			}
-			if obj.ConntrackTCPEstablishedTimeout == zero {
-				obj.ConntrackTCPEstablishedTimeout = unversioned.Duration{Duration: 24 * time.Hour} // 1 day (1/5 default)
-			}
-		},
-		func(obj *KubeSchedulerConfiguration) {
-			if obj.Port == 0 {
-				obj.Port = ports.SchedulerPort
-			}
-			if obj.Address == "" {
-				obj.Address = "0.0.0.0"
-			}
-			if obj.AlgorithmProvider == "" {
-				obj.AlgorithmProvider = "DefaultProvider"
-			}
-			if obj.KubeAPIQPS == 0 {
-				obj.KubeAPIQPS = 50.0
-			}
-			if obj.KubeAPIBurst == 0 {
-				obj.KubeAPIBurst = 100
-			}
-			if obj.SchedulerName == "" {
-				obj.SchedulerName = api.DefaultSchedulerName
-			}
-		},
-		func(obj *LeaderElectionConfiguration) {
-			zero := unversioned.Duration{}
-			if obj.LeaseDuration == zero {
-				obj.LeaseDuration = unversioned.Duration{Duration: 15 * time.Second}
-			}
-			if obj.RenewDeadline == zero {
-				obj.RenewDeadline = unversioned.Duration{Duration: 10 * time.Second}
-			}
-			if obj.RetryPeriod == zero {
-				obj.RetryPeriod = unversioned.Duration{Duration: 2 * time.Second}
-			}
-		},
 	)
 }
+
+func SetDefaults_KubeProxyConfiguration(obj *KubeProxyConfiguration) {
+	if obj.BindAddress == "" {
+		obj.BindAddress = "0.0.0.0"
+	}
+	if obj.HealthzPort == 0 {
+		obj.HealthzPort = 10249
+	}
+	if obj.HealthzBindAddress == "" {
+		obj.HealthzBindAddress = "127.0.0.1"
+	}
+	if obj.OOMScoreAdj == nil {
+		temp := int32(qos.KubeProxyOOMScoreAdj)
+		obj.OOMScoreAdj = &temp
+	}
+	if obj.ResourceContainer == "" {
+		obj.ResourceContainer = "/kube-proxy"
+	}
+	if obj.IPTablesSyncPeriod.Duration == 0 {
+		obj.IPTablesSyncPeriod = unversioned.Duration{Duration: 30 * time.Second}
+	}
+	zero := unversioned.Duration{}
+	if obj.UDPIdleTimeout == zero {
+		obj.UDPIdleTimeout = unversioned.Duration{Duration: 250 * time.Millisecond}
+	}
+	if obj.ConntrackMax == 0 {
+		obj.ConntrackMax = 256 * 1024 // 4x default (64k)
+	}
+	if obj.IPTablesMasqueradeBit == nil {
+		temp := int32(14)
+		obj.IPTablesMasqueradeBit = &temp
+	}
+	if obj.ConntrackTCPEstablishedTimeout == zero {
+		obj.ConntrackTCPEstablishedTimeout = unversioned.Duration{Duration: 24 * time.Hour} // 1 day (1/5 default)
+	}
+}
+
+func SetDefaults_KubeSchedulerConfiguration(obj *KubeSchedulerConfiguration) {
+	if obj.Port == 0 {
+		obj.Port = ports.SchedulerPort
+	}
+	if obj.Address == "" {
+		obj.Address = "0.0.0.0"
+	}
+	if obj.AlgorithmProvider == "" {
+		obj.AlgorithmProvider = "DefaultProvider"
+	}
+	if obj.KubeAPIQPS == 0 {
+		obj.KubeAPIQPS = 50.0
+	}
+	if obj.KubeAPIBurst == 0 {
+		obj.KubeAPIBurst = 100
+	}
+	if obj.SchedulerName == "" {
+		obj.SchedulerName = api.DefaultSchedulerName
+	}
+}
+
+func SetDefaults_LeaderElectionConfiguration(obj *LeaderElectionConfiguration) {
+	zero := unversioned.Duration{}
+	if obj.LeaseDuration == zero {
+		obj.LeaseDuration = unversioned.Duration{Duration: 15 * time.Second}
+	}
+	if obj.RenewDeadline == zero {
+		obj.RenewDeadline = unversioned.Duration{Duration: 10 * time.Second}
+	}
+	if obj.RetryPeriod == zero {
+		obj.RetryPeriod = unversioned.Duration{Duration: 2 * time.Second}
+	}
+}

pkg/apis/extensions/v1beta1/defaults.go

@@ -23,122 +23,130 @@ import (
 
 func addDefaultingFuncs(scheme *runtime.Scheme) {
 	scheme.AddDefaultingFuncs(
-		func(obj *APIVersion) {
+		SetDefaults_DaemonSet,
-		},
+		SetDefaults_Deployment,
-		func(obj *DaemonSet) {
+		SetDefaults_Job,
-			labels := obj.Spec.Template.Labels
+		SetDefaults_HorizontalPodAutoscaler,
-
+		SetDefaults_ReplicaSet,
-			// TODO: support templates defined elsewhere when we support them in the API
-			if labels != nil {
-				if obj.Spec.Selector == nil {
-					obj.Spec.Selector = &LabelSelector{
-						MatchLabels: labels,
-					}
-				}
-				if len(obj.Labels) == 0 {
-					obj.Labels = labels
-				}
-			}
-		},
-		func(obj *Deployment) {
-			// Default labels and selector to labels from pod template spec.
-			labels := obj.Spec.Template.Labels
-
-			if labels != nil {
-				if obj.Spec.Selector == nil {
-					obj.Spec.Selector = &LabelSelector{MatchLabels: labels}
-				}
-				if len(obj.Labels) == 0 {
-					obj.Labels = labels
-				}
-			}
-			// Set DeploymentSpec.Replicas to 1 if it is not set.
-			if obj.Spec.Replicas == nil {
-				obj.Spec.Replicas = new(int32)
-				*obj.Spec.Replicas = 1
-			}
-			strategy := &obj.Spec.Strategy
-			// Set default DeploymentStrategyType as RollingUpdate.
-			if strategy.Type == "" {
-				strategy.Type = RollingUpdateDeploymentStrategyType
-			}
-			if strategy.Type == RollingUpdateDeploymentStrategyType {
-				if strategy.RollingUpdate == nil {
-					rollingUpdate := RollingUpdateDeployment{}
-					strategy.RollingUpdate = &rollingUpdate
-				}
-				if strategy.RollingUpdate.MaxUnavailable == nil {
-					// Set default MaxUnavailable as 1 by default.
-					maxUnavailable := intstr.FromInt(1)
-					strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
-				}
-				if strategy.RollingUpdate.MaxSurge == nil {
-					// Set default MaxSurge as 1 by default.
-					maxSurge := intstr.FromInt(1)
-					strategy.RollingUpdate.MaxSurge = &maxSurge
-				}
-			}
-		},
-		func(obj *Job) {
-			labels := obj.Spec.Template.Labels
-			// TODO: support templates defined elsewhere when we support them in the API
-			if labels != nil {
-				// if an autoselector is requested, we'll build the selector later with controller-uid and job-name
-				autoSelector := bool(obj.Spec.AutoSelector != nil && *obj.Spec.AutoSelector)
-
-				// otherwise, we are using a manual selector
-				manualSelector := !autoSelector
-
-				// and default behavior for an unspecified manual selector is to use the pod template labels
-				if manualSelector && obj.Spec.Selector == nil {
-					obj.Spec.Selector = &LabelSelector{
-						MatchLabels: labels,
-					}
-				}
-				if len(obj.Labels) == 0 {
-					obj.Labels = labels
-				}
-			}
-			// For a non-parallel job, you can leave both `.spec.completions` and
-			// `.spec.parallelism` unset.  When both are unset, both are defaulted to 1.
-			if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
-				obj.Spec.Completions = new(int32)
-				*obj.Spec.Completions = 1
-				obj.Spec.Parallelism = new(int32)
-				*obj.Spec.Parallelism = 1
-			}
-			if obj.Spec.Parallelism == nil {
-				obj.Spec.Parallelism = new(int32)
-				*obj.Spec.Parallelism = 1
-			}
-		},
-		func(obj *HorizontalPodAutoscaler) {
-			if obj.Spec.MinReplicas == nil {
-				minReplicas := int32(1)
-				obj.Spec.MinReplicas = &minReplicas
-			}
-			if obj.Spec.CPUUtilization == nil {
-				obj.Spec.CPUUtilization = &CPUTargetUtilization{TargetPercentage: 80}
-			}
-		},
-		func(obj *ReplicaSet) {
-			labels := obj.Spec.Template.Labels
-
-			// TODO: support templates defined elsewhere when we support them in the API
-			if labels != nil {
-				if obj.Spec.Selector == nil {
-					obj.Spec.Selector = &LabelSelector{
-						MatchLabels: labels,
-					}
-				}
-				if len(obj.Labels) == 0 {
-					obj.Labels = labels
-				}
-			}
-			if obj.Spec.Replicas == nil {
-				obj.Spec.Replicas = new(int32)
-				*obj.Spec.Replicas = 1
-			}
-		},
 	)
 }
+
+func SetDefaults_DaemonSet(obj *DaemonSet) {
+	labels := obj.Spec.Template.Labels
+
+	// TODO: support templates defined elsewhere when we support them in the API
+	if labels != nil {
+		if obj.Spec.Selector == nil {
+			obj.Spec.Selector = &LabelSelector{
+				MatchLabels: labels,
+			}
+		}
+		if len(obj.Labels) == 0 {
+			obj.Labels = labels
+		}
+	}
+}
+
+func SetDefaults_Deployment(obj *Deployment) {
+	// Default labels and selector to labels from pod template spec.
+	labels := obj.Spec.Template.Labels
+
+	if labels != nil {
+		if obj.Spec.Selector == nil {
+			obj.Spec.Selector = &LabelSelector{MatchLabels: labels}
+		}
+		if len(obj.Labels) == 0 {
+			obj.Labels = labels
+		}
+	}
+	// Set DeploymentSpec.Replicas to 1 if it is not set.
+	if obj.Spec.Replicas == nil {
+		obj.Spec.Replicas = new(int32)
+		*obj.Spec.Replicas = 1
+	}
+	strategy := &obj.Spec.Strategy
+	// Set default DeploymentStrategyType as RollingUpdate.
+	if strategy.Type == "" {
+		strategy.Type = RollingUpdateDeploymentStrategyType
+	}
+	if strategy.Type == RollingUpdateDeploymentStrategyType {
+		if strategy.RollingUpdate == nil {
+			rollingUpdate := RollingUpdateDeployment{}
+			strategy.RollingUpdate = &rollingUpdate
+		}
+		if strategy.RollingUpdate.MaxUnavailable == nil {
+			// Set default MaxUnavailable as 1 by default.
+			maxUnavailable := intstr.FromInt(1)
+			strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
+		}
+		if strategy.RollingUpdate.MaxSurge == nil {
+			// Set default MaxSurge as 1 by default.
+			maxSurge := intstr.FromInt(1)
+			strategy.RollingUpdate.MaxSurge = &maxSurge
+		}
+	}
+}
+
+func SetDefaults_Job(obj *Job) {
+	labels := obj.Spec.Template.Labels
+	// TODO: support templates defined elsewhere when we support them in the API
+	if labels != nil {
+		// if an autoselector is requested, we'll build the selector later with controller-uid and job-name
+		autoSelector := bool(obj.Spec.AutoSelector != nil && *obj.Spec.AutoSelector)
+
+		// otherwise, we are using a manual selector
+		manualSelector := !autoSelector
+
+		// and default behavior for an unspecified manual selector is to use the pod template labels
+		if manualSelector && obj.Spec.Selector == nil {
+			obj.Spec.Selector = &LabelSelector{
+				MatchLabels: labels,
+			}
+		}
+		if len(obj.Labels) == 0 {
+			obj.Labels = labels
+		}
+	}
+	// For a non-parallel job, you can leave both `.spec.completions` and
+	// `.spec.parallelism` unset.  When both are unset, both are defaulted to 1.
+	if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
+		obj.Spec.Completions = new(int32)
+		*obj.Spec.Completions = 1
+		obj.Spec.Parallelism = new(int32)
+		*obj.Spec.Parallelism = 1
+	}
+	if obj.Spec.Parallelism == nil {
+		obj.Spec.Parallelism = new(int32)
+		*obj.Spec.Parallelism = 1
+	}
+}
+
+func SetDefaults_HorizontalPodAutoscaler(obj *HorizontalPodAutoscaler) {
+	if obj.Spec.MinReplicas == nil {
+		minReplicas := int32(1)
+		obj.Spec.MinReplicas = &minReplicas
+	}
+	if obj.Spec.CPUUtilization == nil {
+		obj.Spec.CPUUtilization = &CPUTargetUtilization{TargetPercentage: 80}
+	}
+}
+
+func SetDefaults_ReplicaSet(obj *ReplicaSet) {
+	labels := obj.Spec.Template.Labels
+
+	// TODO: support templates defined elsewhere when we support them in the API
+	if labels != nil {
+		if obj.Spec.Selector == nil {
+			obj.Spec.Selector = &LabelSelector{
+				MatchLabels: labels,
+			}
+		}
+		if len(obj.Labels) == 0 {
+			obj.Labels = labels
+		}
+	}
+	if obj.Spec.Replicas == nil {
+		obj.Spec.Replicas = new(int32)
+		*obj.Spec.Replicas = 1
+	}
+}