Update ingress godeps

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/defaults.go

@@ -17,20 +17,45 @@ limitations under the License.
 package v1alpha1
 
 import (
+	"path/filepath"
+	"runtime"
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/kubelet/qos"
+	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/master/ports"
-	"k8s.io/kubernetes/pkg/runtime"
+	kruntime "k8s.io/kubernetes/pkg/runtime"
 )
 
-func addDefaultingFuncs(scheme *runtime.Scheme) {
-	scheme.AddDefaultingFuncs(
+const (
+	defaultRootDir = "/var/lib/kubelet"
+
+	// When these values are updated, also update test/e2e/framework/util.go
+	defaultPodInfraContainerImageName    = "gcr.io/google_containers/pause"
+	defaultPodInfraContainerImageVersion = "3.0"
+	defaultPodInfraContainerImage        = defaultPodInfraContainerImageName +
+		"-" + runtime.GOARCH + ":" +
+		defaultPodInfraContainerImageVersion
+
+	// From pkg/kubelet/rkt/rkt.go to avoid circular import
+	defaultRktAPIServiceEndpoint = "localhost:15441"
+
+	AutoDetectCloudProvider = "auto-detect"
+
+	defaultIPTablesMasqueradeBit = 14
+	defaultIPTablesDropBit       = 15
+)
+
+var zeroDuration = unversioned.Duration{}
+
+func addDefaultingFuncs(scheme *kruntime.Scheme) error {
+	return scheme.AddDefaultingFuncs(
 		SetDefaults_KubeProxyConfiguration,
 		SetDefaults_KubeSchedulerConfiguration,
 		SetDefaults_LeaderElectionConfiguration,
+		SetDefaults_KubeletConfiguration,
 	)
 }
 
@@ -58,8 +83,12 @@ func SetDefaults_KubeProxyConfiguration(obj *KubeProxyConfiguration) {
 	if obj.UDPIdleTimeout == zero {
 		obj.UDPIdleTimeout = unversioned.Duration{Duration: 250 * time.Millisecond}
 	}
+	// If ConntrackMax is set, respect it.
 	if obj.ConntrackMax == 0 {
-		obj.ConntrackMax = 256 * 1024 // 4x default (64k)
+		// If ConntrackMax is *not* set, use per-core scaling.
+		if obj.ConntrackMaxPerCore == 0 {
+			obj.ConntrackMaxPerCore = 32 * 1024
+		}
 	}
 	if obj.IPTablesMasqueradeBit == nil {
 		temp := int32(14)
@@ -112,3 +141,222 @@ func SetDefaults_LeaderElectionConfiguration(obj *LeaderElectionConfiguration) {
 		obj.RetryPeriod = unversioned.Duration{Duration: 2 * time.Second}
 	}
 }
+
+func SetDefaults_KubeletConfiguration(obj *KubeletConfiguration) {
+	if obj.Address == "" {
+		obj.Address = "0.0.0.0"
+	}
+	if obj.CloudProvider == "" {
+		obj.CloudProvider = AutoDetectCloudProvider
+	}
+	if obj.CAdvisorPort == 0 {
+		obj.CAdvisorPort = 4194
+	}
+	if obj.VolumeStatsAggPeriod == zeroDuration {
+		obj.VolumeStatsAggPeriod = unversioned.Duration{Duration: time.Minute}
+	}
+	if obj.CertDirectory == "" {
+		obj.CertDirectory = "/var/run/kubernetes"
+	}
+	if obj.ConfigureCBR0 == nil {
+		obj.ConfigureCBR0 = boolVar(false)
+	}
+	if obj.CgroupsPerQOS == nil {
+		obj.CgroupsPerQOS = boolVar(false)
+	}
+	if obj.ContainerRuntime == "" {
+		obj.ContainerRuntime = "docker"
+	}
+	if obj.RuntimeRequestTimeout == zeroDuration {
+		obj.RuntimeRequestTimeout = unversioned.Duration{Duration: 2 * time.Minute}
+	}
+	if obj.CPUCFSQuota == nil {
+		obj.CPUCFSQuota = boolVar(true)
+	}
+	if obj.DockerExecHandlerName == "" {
+		obj.DockerExecHandlerName = "native"
+	}
+	if obj.DockerEndpoint == "" {
+		obj.DockerEndpoint = "unix:///var/run/docker.sock"
+	}
+	if obj.EventBurst == 0 {
+		obj.EventBurst = 10
+	}
+	if obj.EventRecordQPS == nil {
+		temp := int32(5)
+		obj.EventRecordQPS = &temp
+	}
+	if obj.EnableControllerAttachDetach == nil {
+		obj.EnableControllerAttachDetach = boolVar(true)
+	}
+	if obj.EnableDebuggingHandlers == nil {
+		obj.EnableDebuggingHandlers = boolVar(true)
+	}
+	if obj.EnableServer == nil {
+		obj.EnableServer = boolVar(true)
+	}
+	if obj.FileCheckFrequency == zeroDuration {
+		obj.FileCheckFrequency = unversioned.Duration{Duration: 20 * time.Second}
+	}
+	if obj.HealthzBindAddress == "" {
+		obj.HealthzBindAddress = "127.0.0.1"
+	}
+	if obj.HealthzPort == 0 {
+		obj.HealthzPort = 10248
+	}
+	if obj.HostNetworkSources == nil {
+		obj.HostNetworkSources = []string{kubetypes.AllSource}
+	}
+	if obj.HostPIDSources == nil {
+		obj.HostPIDSources = []string{kubetypes.AllSource}
+	}
+	if obj.HostIPCSources == nil {
+		obj.HostIPCSources = []string{kubetypes.AllSource}
+	}
+	if obj.HTTPCheckFrequency == zeroDuration {
+		obj.HTTPCheckFrequency = unversioned.Duration{Duration: 20 * time.Second}
+	}
+	if obj.ImageMinimumGCAge == zeroDuration {
+		obj.ImageMinimumGCAge = unversioned.Duration{Duration: 2 * time.Minute}
+	}
+	if obj.ImageGCHighThresholdPercent == nil {
+		temp := int32(90)
+		obj.ImageGCHighThresholdPercent = &temp
+	}
+	if obj.ImageGCLowThresholdPercent == nil {
+		temp := int32(80)
+		obj.ImageGCLowThresholdPercent = &temp
+	}
+	if obj.LowDiskSpaceThresholdMB == 0 {
+		obj.LowDiskSpaceThresholdMB = 256
+	}
+	if obj.MasterServiceNamespace == "" {
+		obj.MasterServiceNamespace = api.NamespaceDefault
+	}
+	if obj.MaxContainerCount == nil {
+		temp := int32(-1)
+		obj.MaxContainerCount = &temp
+	}
+	if obj.MaxPerPodContainerCount == 0 {
+		obj.MaxPerPodContainerCount = 1
+	}
+	if obj.MaxOpenFiles == 0 {
+		obj.MaxOpenFiles = 1000000
+	}
+	if obj.MaxPods == 0 {
+		obj.MaxPods = 110
+	}
+	if obj.MinimumGCAge == zeroDuration {
+		obj.MinimumGCAge = unversioned.Duration{Duration: 0}
+	}
+	if obj.NetworkPluginDir == "" {
+		obj.NetworkPluginDir = "/usr/libexec/kubernetes/kubelet-plugins/net/exec/"
+	}
+	if obj.NonMasqueradeCIDR == "" {
+		obj.NonMasqueradeCIDR = "10.0.0.0/8"
+	}
+	if obj.VolumePluginDir == "" {
+		obj.VolumePluginDir = "/usr/libexec/kubernetes/kubelet-plugins/volume/exec/"
+	}
+	if obj.NodeStatusUpdateFrequency == zeroDuration {
+		obj.NodeStatusUpdateFrequency = unversioned.Duration{Duration: 10 * time.Second}
+	}
+	if obj.OOMScoreAdj == nil {
+		temp := int32(qos.KubeletOOMScoreAdj)
+		obj.OOMScoreAdj = &temp
+	}
+	if obj.PodInfraContainerImage == "" {
+		obj.PodInfraContainerImage = defaultPodInfraContainerImage
+	}
+	if obj.Port == 0 {
+		obj.Port = ports.KubeletPort
+	}
+	if obj.ReadOnlyPort == 0 {
+		obj.ReadOnlyPort = ports.KubeletReadOnlyPort
+	}
+	if obj.RegisterNode == nil {
+		obj.RegisterNode = boolVar(true)
+	}
+	if obj.RegisterSchedulable == nil {
+		obj.RegisterSchedulable = boolVar(true)
+	}
+	if obj.RegistryBurst == 0 {
+		obj.RegistryBurst = 10
+	}
+	if obj.RegistryPullQPS == nil {
+		temp := int32(5)
+		obj.RegistryPullQPS = &temp
+	}
+	if obj.ResolverConfig == "" {
+		obj.ResolverConfig = kubetypes.ResolvConfDefault
+	}
+	if obj.RktAPIEndpoint == "" {
+		obj.RktAPIEndpoint = defaultRktAPIServiceEndpoint
+	}
+	if obj.RootDirectory == "" {
+		obj.RootDirectory = defaultRootDir
+	}
+	if obj.SerializeImagePulls == nil {
+		obj.SerializeImagePulls = boolVar(true)
+	}
+	if obj.SeccompProfileRoot == "" {
+		filepath.Join(defaultRootDir, "seccomp")
+	}
+	if obj.StreamingConnectionIdleTimeout == zeroDuration {
+		obj.StreamingConnectionIdleTimeout = unversioned.Duration{Duration: 4 * time.Hour}
+	}
+	if obj.SyncFrequency == zeroDuration {
+		obj.SyncFrequency = unversioned.Duration{Duration: 1 * time.Minute}
+	}
+	if obj.ReconcileCIDR == nil {
+		obj.ReconcileCIDR = boolVar(true)
+	}
+	if obj.ContentType == "" {
+		obj.ContentType = "application/vnd.kubernetes.protobuf"
+	}
+	if obj.KubeAPIQPS == nil {
+		temp := int32(5)
+		obj.KubeAPIQPS = &temp
+	}
+	if obj.KubeAPIBurst == 0 {
+		obj.KubeAPIBurst = 10
+	}
+	if obj.OutOfDiskTransitionFrequency == zeroDuration {
+		obj.OutOfDiskTransitionFrequency = unversioned.Duration{Duration: 5 * time.Minute}
+	}
+	if string(obj.HairpinMode) == "" {
+		obj.HairpinMode = PromiscuousBridge
+	}
+	if obj.EvictionHard == nil {
+		temp := "memory.available<100Mi"
+		obj.EvictionHard = &temp
+	}
+	if obj.EvictionPressureTransitionPeriod == zeroDuration {
+		obj.EvictionPressureTransitionPeriod = unversioned.Duration{Duration: 5 * time.Minute}
+	}
+	if obj.SystemReserved == nil {
+		obj.SystemReserved = make(map[string]string)
+	}
+	if obj.KubeReserved == nil {
+		obj.KubeReserved = make(map[string]string)
+	}
+	if obj.MakeIPTablesUtilChains == nil {
+		obj.MakeIPTablesUtilChains = boolVar(true)
+	}
+	if obj.IPTablesMasqueradeBit == nil {
+		temp := int32(defaultIPTablesMasqueradeBit)
+		obj.IPTablesMasqueradeBit = &temp
+	}
+	if obj.IPTablesDropBit == nil {
+		temp := int32(defaultIPTablesDropBit)
+		obj.IPTablesDropBit = &temp
+	}
+}
+
+func boolVar(b bool) *bool {
+	return &b
+}
+
+var (
+	defaultCfg = KubeletConfiguration{}
+)