Add glide.yaml and vendor deps

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "helpers.go",
+        "register.go",
+        "types.generated.go",
+        "types.go",
+        "zz_generated.deepcopy.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/conversion:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/runtime/schema:go_default_library",
+        "//pkg/util/config:go_default_library",
+        "//pkg/util/net:go_default_library",
+        "//vendor:github.com/ugorji/go/codec",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["helpers_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = ["//vendor:github.com/spf13/pflag"],
+)

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/OWNERS

@@ -0,0 +1,41 @@
+reviewers:
+- thockin
+- lavalamp
+- smarterclayton
+- wojtek-t
+- deads2k
+- yujuhong
+- derekwaynecarr
+- caesarxuchao
+- vishh
+- mikedanese
+- liggitt
+- nikhiljindal
+- bprashanth
+- gmarek
+- sttts
+- dchen1107
+- saad-ali
+- luxas
+- justinsb
+- pwittrock
+- ncdc
+- yifan-gu
+- mwielgus
+- timothysc
+- feiskyer
+- dims
+- errordeveloper
+- mtaufen
+- markturansky
+- freehan
+- mml
+- ingvagabund
+- cjcullen
+- mbohlool
+- jessfraz
+- david-mcmahon
+- therc
+- '249043822'
+- mqliang
+- mfanjie

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
+
+package componentconfig // import "k8s.io/kubernetes/pkg/apis/componentconfig"

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/helpers.go

@@ -0,0 +1,97 @@
+/*
+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 (
+	"fmt"
+	"net"
+
+	utilnet "k8s.io/kubernetes/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 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"
+}
+
+func (m *ProxyMode) Set(s string) error {
+	*m = ProxyMode(s)
+	return nil
+}
+
+func (m *ProxyMode) String() string {
+	if m != nil {
+		return string(*m)
+	}
+	return ""
+}
+
+func (m *ProxyMode) Type() string {
+	return "ProxyMode"
+}
+
+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"
+}

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/helpers_test.go

@@ -0,0 +1,71 @@
+/*
+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 (
+	"strings"
+	"testing"
+
+	"github.com/spf13/pflag"
+)
+
+func TestIPVar(t *testing.T) {
+	defaultIP := "0.0.0.0"
+	cases := []struct {
+		argc      string
+		expectErr bool
+		expectVal string
+	}{
+
+		{
+			argc:      "blah --ip=1.2.3.4",
+			expectVal: "1.2.3.4",
+		},
+		{
+			argc:      "blah --ip=1.2.3.4a",
+			expectErr: true,
+			expectVal: defaultIP,
+		},
+	}
+	for _, c := range cases {
+		fs := pflag.NewFlagSet("blah", pflag.PanicOnError)
+		ip := defaultIP
+		fs.Var(IPVar{&ip}, "ip", "the ip")
+
+		var err error
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					err = r.(error)
+				}
+			}()
+			fs.Parse(strings.Split(c.argc, " "))
+		}()
+
+		if c.expectErr && err == nil {
+			t.Errorf("did not observe an expected error")
+			continue
+		}
+		if !c.expectErr && err != nil {
+			t.Errorf("observed an unexpected error")
+			continue
+		}
+		if c.expectVal != ip {
+			t.Errorf("unexpected ip: expected %q, saw %q", c.expectVal, ip)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/install/BUILD

@@ -0,0 +1,22 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["install.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/apimachinery/announced:go_default_library",
+        "//pkg/apis/componentconfig:go_default_library",
+        "//pkg/apis/componentconfig/v1alpha1:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/install/install.go

@@ -0,0 +1,41 @@
+/*
+Copyright 2015 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 install installs the experimental API group, making it available as
+// an option to all of the API encoding/decoding machinery.
+package install
+
+import (
+	"k8s.io/kubernetes/pkg/apimachinery/announced"
+	"k8s.io/kubernetes/pkg/apis/componentconfig"
+	"k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"
+)
+
+func init() {
+	if err := announced.NewGroupMetaFactory(
+		&announced.GroupMetaFactoryArgs{
+			GroupName:                  componentconfig.GroupName,
+			VersionPreferenceOrder:     []string{v1alpha1.SchemeGroupVersion.Version},
+			ImportPrefix:               "k8s.io/kubernetes/pkg/apis/componentconfig",
+			AddInternalObjectsToScheme: componentconfig.AddToScheme,
+		},
+		announced.VersionToSchemeFunc{
+			v1alpha1.SchemeGroupVersion.Version: v1alpha1.AddToScheme,
+		},
+	).Announce().RegisterAndEnable(); err != nil {
+		panic(err)
+	}
+}

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/register.go

@@ -0,0 +1,57 @@
+/*
+Copyright 2015 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 (
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+)
+
+var (
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
+	AddToScheme   = SchemeBuilder.AddToScheme
+)
+
+// GroupName is the group name use in this package
+const GroupName = "componentconfig"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
+
+// Kind takes an unqualified kind and returns a Group qualified GroupKind
+func Kind(kind string) schema.GroupKind {
+	return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+func addKnownTypes(scheme *runtime.Scheme) error {
+	// TODO this will get cleaned up with the scheme types are fixed
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&KubeProxyConfiguration{},
+		&KubeSchedulerConfiguration{},
+		&KubeletConfiguration{},
+	)
+	return nil
+}
+
+func (obj *KubeProxyConfiguration) GetObjectKind() schema.ObjectKind     { return &obj.TypeMeta }
+func (obj *KubeSchedulerConfiguration) GetObjectKind() schema.ObjectKind { return &obj.TypeMeta }
+func (obj *KubeletConfiguration) GetObjectKind() schema.ObjectKind       { return &obj.TypeMeta }

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1/BUILD

@@ -0,0 +1,37 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "defaults.go",
+        "doc.go",
+        "register.go",
+        "types.go",
+        "zz_generated.conversion.go",
+        "zz_generated.deepcopy.go",
+        "zz_generated.defaults.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/apis/componentconfig:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/conversion:go_default_library",
+        "//pkg/kubelet/qos:go_default_library",
+        "//pkg/kubelet/types:go_default_library",
+        "//pkg/master/ports:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/runtime/schema:go_default_library",
+        "//pkg/util/config:go_default_library",
+    ],
+)

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

@@ -0,0 +1,419 @@
+/*
+Copyright 2015 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 v1alpha1
+
+import (
+	"path/filepath"
+	"runtime"
+	"time"
+
+	"k8s.io/kubernetes/pkg/api"
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/kubelet/qos"
+	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
+	"k8s.io/kubernetes/pkg/master/ports"
+	kruntime "k8s.io/kubernetes/pkg/runtime"
+)
+
+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 = metav1.Duration{}
+
+func addDefaultingFuncs(scheme *kruntime.Scheme) error {
+	RegisterDefaults(scheme)
+	return scheme.AddDefaultingFuncs(
+		SetDefaults_KubeProxyConfiguration,
+		SetDefaults_KubeSchedulerConfiguration,
+		SetDefaults_LeaderElectionConfiguration,
+		SetDefaults_KubeletConfiguration,
+	)
+}
+
+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 = metav1.Duration{Duration: 30 * time.Second}
+	}
+	zero := metav1.Duration{}
+	if obj.UDPIdleTimeout == zero {
+		obj.UDPIdleTimeout = metav1.Duration{Duration: 250 * time.Millisecond}
+	}
+	// If ConntrackMax is set, respect it.
+	if obj.ConntrackMax == 0 {
+		// If ConntrackMax is *not* set, use per-core scaling.
+		if obj.ConntrackMaxPerCore == 0 {
+			obj.ConntrackMaxPerCore = 32 * 1024
+		}
+		if obj.ConntrackMin == 0 {
+			obj.ConntrackMin = 128 * 1024
+		}
+	}
+	if obj.IPTablesMasqueradeBit == nil {
+		temp := int32(14)
+		obj.IPTablesMasqueradeBit = &temp
+	}
+	if obj.ConntrackTCPEstablishedTimeout == zero {
+		obj.ConntrackTCPEstablishedTimeout = metav1.Duration{Duration: 24 * time.Hour} // 1 day (1/5 default)
+	}
+	if obj.ConntrackTCPCloseWaitTimeout == zero {
+		// See https://github.com/kubernetes/kubernetes/issues/32551.
+		//
+		// CLOSE_WAIT conntrack state occurs when the the Linux kernel
+		// sees a FIN from the remote server. Note: this is a half-close
+		// condition that persists as long as the local side keeps the
+		// socket open. The condition is rare as it is typical in most
+		// protocols for both sides to issue a close; this typically
+		// occurs when the local socket is lazily garbage collected.
+		//
+		// If the CLOSE_WAIT conntrack entry expires, then FINs from the
+		// local socket will not be properly SNAT'd and will not reach the
+		// remote server (if the connection was subject to SNAT). If the
+		// remote timeouts for FIN_WAIT* states exceed the CLOSE_WAIT
+		// timeout, then there will be an inconsistency in the state of
+		// the connection and a new connection reusing the SNAT (src,
+		// port) pair may be rejected by the remote side with RST. This
+		// can cause new calls to connect(2) to return with ECONNREFUSED.
+		//
+		// We set CLOSE_WAIT to one hour by default to better match
+		// typical server timeouts.
+		obj.ConntrackTCPCloseWaitTimeout = metav1.Duration{Duration: 1 * time.Hour}
+	}
+}
+
+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.ContentType == "" {
+		obj.ContentType = "application/vnd.kubernetes.protobuf"
+	}
+	if obj.KubeAPIQPS == 0 {
+		obj.KubeAPIQPS = 50.0
+	}
+	if obj.KubeAPIBurst == 0 {
+		obj.KubeAPIBurst = 100
+	}
+	if obj.SchedulerName == "" {
+		obj.SchedulerName = api.DefaultSchedulerName
+	}
+	if obj.HardPodAffinitySymmetricWeight == 0 {
+		obj.HardPodAffinitySymmetricWeight = api.DefaultHardPodAffinitySymmetricWeight
+	}
+	if obj.FailureDomains == "" {
+		obj.FailureDomains = api.DefaultFailureDomains
+	}
+}
+
+func SetDefaults_LeaderElectionConfiguration(obj *LeaderElectionConfiguration) {
+	zero := metav1.Duration{}
+	if obj.LeaseDuration == zero {
+		obj.LeaseDuration = metav1.Duration{Duration: 15 * time.Second}
+	}
+	if obj.RenewDeadline == zero {
+		obj.RenewDeadline = metav1.Duration{Duration: 10 * time.Second}
+	}
+	if obj.RetryPeriod == zero {
+		obj.RetryPeriod = metav1.Duration{Duration: 2 * time.Second}
+	}
+}
+
+func SetDefaults_KubeletConfiguration(obj *KubeletConfiguration) {
+	if obj.Authentication.Anonymous.Enabled == nil {
+		obj.Authentication.Anonymous.Enabled = boolVar(true)
+	}
+	if obj.Authentication.Webhook.Enabled == nil {
+		obj.Authentication.Webhook.Enabled = boolVar(false)
+	}
+	if obj.Authentication.Webhook.CacheTTL == zeroDuration {
+		obj.Authentication.Webhook.CacheTTL = metav1.Duration{Duration: 2 * time.Minute}
+	}
+	if obj.Authorization.Mode == "" {
+		obj.Authorization.Mode = KubeletAuthorizationModeAlwaysAllow
+	}
+	if obj.Authorization.Webhook.CacheAuthorizedTTL == zeroDuration {
+		obj.Authorization.Webhook.CacheAuthorizedTTL = metav1.Duration{Duration: 5 * time.Minute}
+	}
+	if obj.Authorization.Webhook.CacheUnauthorizedTTL == zeroDuration {
+		obj.Authorization.Webhook.CacheUnauthorizedTTL = metav1.Duration{Duration: 30 * time.Second}
+	}
+
+	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 = metav1.Duration{Duration: time.Minute}
+	}
+	if obj.CertDirectory == "" {
+		obj.CertDirectory = "/var/run/kubernetes"
+	}
+	if obj.ExperimentalCgroupsPerQOS == nil {
+		obj.ExperimentalCgroupsPerQOS = boolVar(false)
+	}
+	if obj.ContainerRuntime == "" {
+		obj.ContainerRuntime = "docker"
+	}
+	if obj.RuntimeRequestTimeout == zeroDuration {
+		obj.RuntimeRequestTimeout = metav1.Duration{Duration: 2 * time.Minute}
+	}
+	if obj.CPUCFSQuota == nil {
+		obj.CPUCFSQuota = boolVar(true)
+	}
+	if obj.DockerExecHandlerName == "" {
+		obj.DockerExecHandlerName = "native"
+	}
+	if obj.DockerEndpoint == "" && runtime.GOOS != "windows" {
+		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 = metav1.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 = metav1.Duration{Duration: 20 * time.Second}
+	}
+	if obj.ImageMinimumGCAge == zeroDuration {
+		obj.ImageMinimumGCAge = metav1.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 = metav1.Duration{Duration: 0}
+	}
+	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 = metav1.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 == "" {
+		obj.SeccompProfileRoot = filepath.Join(defaultRootDir, "seccomp")
+	}
+	if obj.StreamingConnectionIdleTimeout == zeroDuration {
+		obj.StreamingConnectionIdleTimeout = metav1.Duration{Duration: 4 * time.Hour}
+	}
+	if obj.SyncFrequency == zeroDuration {
+		obj.SyncFrequency = metav1.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 = metav1.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 = metav1.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
+	}
+	if obj.ExperimentalCgroupsPerQOS == nil {
+		temp := false
+		obj.ExperimentalCgroupsPerQOS = &temp
+	}
+	if obj.CgroupDriver == "" {
+		obj.CgroupDriver = "cgroupfs"
+	}
+	// NOTE: this is for backwards compatibility with earlier releases where cgroup-root was optional.
+	// if cgroups per qos is not enabled, and cgroup-root is not specified, we need to default to the
+	// container runtime default and not default to the root cgroup.
+	if obj.ExperimentalCgroupsPerQOS != nil {
+		if *obj.ExperimentalCgroupsPerQOS {
+			if obj.CgroupRoot == "" {
+				obj.CgroupRoot = "/"
+			}
+		}
+	}
+}
+
+func boolVar(b bool) *bool {
+	return &b
+}
+
+var (
+	defaultCfg = KubeletConfiguration{}
+)

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

@@ -0,0 +1,22 @@
+/*
+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.
+*/
+
+// +k8s:deepcopy-gen=package,register
+// +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/componentconfig
+// +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
+
+package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"

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

@@ -0,0 +1,46 @@
+/*
+Copyright 2015 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 v1alpha1
+
+import (
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/runtime/schema"
+)
+
+// GroupName is the group name use in this package
+const GroupName = "componentconfig"
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
+
+var (
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, addDefaultingFuncs)
+	AddToScheme   = SchemeBuilder.AddToScheme
+)
+
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&KubeProxyConfiguration{},
+		&KubeSchedulerConfiguration{},
+		&KubeletConfiguration{},
+	)
+	return nil
+}
+
+func (obj *KubeProxyConfiguration) GetObjectKind() schema.ObjectKind     { return &obj.TypeMeta }
+func (obj *KubeSchedulerConfiguration) GetObjectKind() schema.ObjectKind { return &obj.TypeMeta }
+func (obj *KubeletConfiguration) GetObjectKind() schema.ObjectKind       { return &obj.TypeMeta }

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

@@ -0,0 +1,48 @@
+// +build !ignore_autogenerated
+
+/*
+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.
+*/
+
+// This file was autogenerated by defaulter-gen. Do not edit it manually!
+
+package v1alpha1
+
+import (
+	runtime "k8s.io/kubernetes/pkg/runtime"
+)
+
+// RegisterDefaults adds defaulters functions to the given scheme.
+// Public to allow building arbitrary schemes.
+// All generated defaulters are covering - they call all nested defaulters.
+func RegisterDefaults(scheme *runtime.Scheme) error {
+	scheme.AddTypeDefaultingFunc(&KubeProxyConfiguration{}, func(obj interface{}) { SetObjectDefaults_KubeProxyConfiguration(obj.(*KubeProxyConfiguration)) })
+	scheme.AddTypeDefaultingFunc(&KubeSchedulerConfiguration{}, func(obj interface{}) { SetObjectDefaults_KubeSchedulerConfiguration(obj.(*KubeSchedulerConfiguration)) })
+	scheme.AddTypeDefaultingFunc(&KubeletConfiguration{}, func(obj interface{}) { SetObjectDefaults_KubeletConfiguration(obj.(*KubeletConfiguration)) })
+	return nil
+}
+
+func SetObjectDefaults_KubeProxyConfiguration(in *KubeProxyConfiguration) {
+	SetDefaults_KubeProxyConfiguration(in)
+}
+
+func SetObjectDefaults_KubeSchedulerConfiguration(in *KubeSchedulerConfiguration) {
+	SetDefaults_KubeSchedulerConfiguration(in)
+	SetDefaults_LeaderElectionConfiguration(&in.LeaderElection)
+}
+
+func SetObjectDefaults_KubeletConfiguration(in *KubeletConfiguration) {
+	SetDefaults_KubeletConfiguration(in)
+}

vendor/k8s.io/kubernetes/pkg/apis/componentconfig/zz_generated.deepcopy.go

@@ -0,0 +1,482 @@
+// +build !ignore_autogenerated
+
+/*
+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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package componentconfig
+
+import (
+	conversion "k8s.io/kubernetes/pkg/conversion"
+	runtime "k8s.io/kubernetes/pkg/runtime"
+	config "k8s.io/kubernetes/pkg/util/config"
+	reflect "reflect"
+)
+
+func init() {
+	SchemeBuilder.Register(RegisterDeepCopies)
+}
+
+// RegisterDeepCopies adds deep-copy functions to the given scheme. Public
+// to allow building arbitrary schemes.
+func RegisterDeepCopies(scheme *runtime.Scheme) error {
+	return scheme.AddGeneratedDeepCopyFuncs(
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_IPVar, InType: reflect.TypeOf(&IPVar{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeControllerManagerConfiguration, InType: reflect.TypeOf(&KubeControllerManagerConfiguration{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeProxyConfiguration, InType: reflect.TypeOf(&KubeProxyConfiguration{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeSchedulerConfiguration, InType: reflect.TypeOf(&KubeSchedulerConfiguration{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeletAnonymousAuthentication, InType: reflect.TypeOf(&KubeletAnonymousAuthentication{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeletAuthentication, InType: reflect.TypeOf(&KubeletAuthentication{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeletAuthorization, InType: reflect.TypeOf(&KubeletAuthorization{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeletConfiguration, InType: reflect.TypeOf(&KubeletConfiguration{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeletWebhookAuthentication, InType: reflect.TypeOf(&KubeletWebhookAuthentication{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeletWebhookAuthorization, InType: reflect.TypeOf(&KubeletWebhookAuthorization{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_KubeletX509Authentication, InType: reflect.TypeOf(&KubeletX509Authentication{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_LeaderElectionConfiguration, InType: reflect.TypeOf(&LeaderElectionConfiguration{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_PersistentVolumeRecyclerConfiguration, InType: reflect.TypeOf(&PersistentVolumeRecyclerConfiguration{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_PortRangeVar, InType: reflect.TypeOf(&PortRangeVar{})},
+		conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_componentconfig_VolumeConfiguration, InType: reflect.TypeOf(&VolumeConfiguration{})},
+	)
+}
+
+func DeepCopy_componentconfig_IPVar(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*IPVar)
+		out := out.(*IPVar)
+		if in.Val != nil {
+			in, out := &in.Val, &out.Val
+			*out = new(string)
+			**out = **in
+		} else {
+			out.Val = nil
+		}
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeControllerManagerConfiguration(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeControllerManagerConfiguration)
+		out := out.(*KubeControllerManagerConfiguration)
+		out.TypeMeta = in.TypeMeta
+		out.Port = in.Port
+		out.Address = in.Address
+		out.UseServiceAccountCredentials = in.UseServiceAccountCredentials
+		out.CloudProvider = in.CloudProvider
+		out.CloudConfigFile = in.CloudConfigFile
+		out.ConcurrentEndpointSyncs = in.ConcurrentEndpointSyncs
+		out.ConcurrentRSSyncs = in.ConcurrentRSSyncs
+		out.ConcurrentRCSyncs = in.ConcurrentRCSyncs
+		out.ConcurrentServiceSyncs = in.ConcurrentServiceSyncs
+		out.ConcurrentResourceQuotaSyncs = in.ConcurrentResourceQuotaSyncs
+		out.ConcurrentDeploymentSyncs = in.ConcurrentDeploymentSyncs
+		out.ConcurrentDaemonSetSyncs = in.ConcurrentDaemonSetSyncs
+		out.ConcurrentJobSyncs = in.ConcurrentJobSyncs
+		out.ConcurrentNamespaceSyncs = in.ConcurrentNamespaceSyncs
+		out.ConcurrentSATokenSyncs = in.ConcurrentSATokenSyncs
+		out.LookupCacheSizeForRC = in.LookupCacheSizeForRC
+		out.LookupCacheSizeForRS = in.LookupCacheSizeForRS
+		out.LookupCacheSizeForDaemonSet = in.LookupCacheSizeForDaemonSet
+		out.ServiceSyncPeriod = in.ServiceSyncPeriod
+		out.NodeSyncPeriod = in.NodeSyncPeriod
+		out.RouteReconciliationPeriod = in.RouteReconciliationPeriod
+		out.ResourceQuotaSyncPeriod = in.ResourceQuotaSyncPeriod
+		out.NamespaceSyncPeriod = in.NamespaceSyncPeriod
+		out.PVClaimBinderSyncPeriod = in.PVClaimBinderSyncPeriod
+		out.MinResyncPeriod = in.MinResyncPeriod
+		out.TerminatedPodGCThreshold = in.TerminatedPodGCThreshold
+		out.HorizontalPodAutoscalerSyncPeriod = in.HorizontalPodAutoscalerSyncPeriod
+		out.DeploymentControllerSyncPeriod = in.DeploymentControllerSyncPeriod
+		out.PodEvictionTimeout = in.PodEvictionTimeout
+		out.DeletingPodsQps = in.DeletingPodsQps
+		out.DeletingPodsBurst = in.DeletingPodsBurst
+		out.NodeMonitorGracePeriod = in.NodeMonitorGracePeriod
+		out.RegisterRetryCount = in.RegisterRetryCount
+		out.NodeStartupGracePeriod = in.NodeStartupGracePeriod
+		out.NodeMonitorPeriod = in.NodeMonitorPeriod
+		out.ServiceAccountKeyFile = in.ServiceAccountKeyFile
+		out.ClusterSigningCertFile = in.ClusterSigningCertFile
+		out.ClusterSigningKeyFile = in.ClusterSigningKeyFile
+		out.ApproveAllKubeletCSRsForGroup = in.ApproveAllKubeletCSRsForGroup
+		out.EnableProfiling = in.EnableProfiling
+		out.ClusterName = in.ClusterName
+		out.ClusterCIDR = in.ClusterCIDR
+		out.ServiceCIDR = in.ServiceCIDR
+		out.NodeCIDRMaskSize = in.NodeCIDRMaskSize
+		out.AllocateNodeCIDRs = in.AllocateNodeCIDRs
+		out.ConfigureCloudRoutes = in.ConfigureCloudRoutes
+		out.RootCAFile = in.RootCAFile
+		out.ContentType = in.ContentType
+		out.KubeAPIQPS = in.KubeAPIQPS
+		out.KubeAPIBurst = in.KubeAPIBurst
+		out.LeaderElection = in.LeaderElection
+		out.VolumeConfiguration = in.VolumeConfiguration
+		out.ControllerStartInterval = in.ControllerStartInterval
+		out.EnableGarbageCollector = in.EnableGarbageCollector
+		out.ConcurrentGCSyncs = in.ConcurrentGCSyncs
+		out.NodeEvictionRate = in.NodeEvictionRate
+		out.SecondaryNodeEvictionRate = in.SecondaryNodeEvictionRate
+		out.LargeClusterSizeThreshold = in.LargeClusterSizeThreshold
+		out.UnhealthyZoneThreshold = in.UnhealthyZoneThreshold
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeProxyConfiguration(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeProxyConfiguration)
+		out := out.(*KubeProxyConfiguration)
+		out.TypeMeta = in.TypeMeta
+		out.BindAddress = in.BindAddress
+		out.ClusterCIDR = in.ClusterCIDR
+		out.HealthzBindAddress = in.HealthzBindAddress
+		out.HealthzPort = in.HealthzPort
+		out.HostnameOverride = in.HostnameOverride
+		if in.IPTablesMasqueradeBit != nil {
+			in, out := &in.IPTablesMasqueradeBit, &out.IPTablesMasqueradeBit
+			*out = new(int32)
+			**out = **in
+		} else {
+			out.IPTablesMasqueradeBit = nil
+		}
+		out.IPTablesSyncPeriod = in.IPTablesSyncPeriod
+		out.IPTablesMinSyncPeriod = in.IPTablesMinSyncPeriod
+		out.KubeconfigPath = in.KubeconfigPath
+		out.MasqueradeAll = in.MasqueradeAll
+		out.Master = in.Master
+		if in.OOMScoreAdj != nil {
+			in, out := &in.OOMScoreAdj, &out.OOMScoreAdj
+			*out = new(int32)
+			**out = **in
+		} else {
+			out.OOMScoreAdj = nil
+		}
+		out.Mode = in.Mode
+		out.PortRange = in.PortRange
+		out.ResourceContainer = in.ResourceContainer
+		out.UDPIdleTimeout = in.UDPIdleTimeout
+		out.ConntrackMax = in.ConntrackMax
+		out.ConntrackMaxPerCore = in.ConntrackMaxPerCore
+		out.ConntrackMin = in.ConntrackMin
+		out.ConntrackTCPEstablishedTimeout = in.ConntrackTCPEstablishedTimeout
+		out.ConntrackTCPCloseWaitTimeout = in.ConntrackTCPCloseWaitTimeout
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeSchedulerConfiguration(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeSchedulerConfiguration)
+		out := out.(*KubeSchedulerConfiguration)
+		out.TypeMeta = in.TypeMeta
+		out.Port = in.Port
+		out.Address = in.Address
+		out.AlgorithmProvider = in.AlgorithmProvider
+		out.PolicyConfigFile = in.PolicyConfigFile
+		out.EnableProfiling = in.EnableProfiling
+		out.EnableContentionProfiling = in.EnableContentionProfiling
+		out.ContentType = in.ContentType
+		out.KubeAPIQPS = in.KubeAPIQPS
+		out.KubeAPIBurst = in.KubeAPIBurst
+		out.SchedulerName = in.SchedulerName
+		out.HardPodAffinitySymmetricWeight = in.HardPodAffinitySymmetricWeight
+		out.FailureDomains = in.FailureDomains
+		out.LeaderElection = in.LeaderElection
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeletAnonymousAuthentication(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeletAnonymousAuthentication)
+		out := out.(*KubeletAnonymousAuthentication)
+		out.Enabled = in.Enabled
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeletAuthentication(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeletAuthentication)
+		out := out.(*KubeletAuthentication)
+		out.X509 = in.X509
+		out.Webhook = in.Webhook
+		out.Anonymous = in.Anonymous
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeletAuthorization(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeletAuthorization)
+		out := out.(*KubeletAuthorization)
+		out.Mode = in.Mode
+		out.Webhook = in.Webhook
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeletConfiguration(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeletConfiguration)
+		out := out.(*KubeletConfiguration)
+		out.TypeMeta = in.TypeMeta
+		out.PodManifestPath = in.PodManifestPath
+		out.SyncFrequency = in.SyncFrequency
+		out.FileCheckFrequency = in.FileCheckFrequency
+		out.HTTPCheckFrequency = in.HTTPCheckFrequency
+		out.ManifestURL = in.ManifestURL
+		out.ManifestURLHeader = in.ManifestURLHeader
+		out.EnableServer = in.EnableServer
+		out.Address = in.Address
+		out.Port = in.Port
+		out.ReadOnlyPort = in.ReadOnlyPort
+		out.TLSCertFile = in.TLSCertFile
+		out.TLSPrivateKeyFile = in.TLSPrivateKeyFile
+		out.CertDirectory = in.CertDirectory
+		out.Authentication = in.Authentication
+		out.Authorization = in.Authorization
+		out.HostnameOverride = in.HostnameOverride
+		out.PodInfraContainerImage = in.PodInfraContainerImage
+		out.DockerEndpoint = in.DockerEndpoint
+		out.RootDirectory = in.RootDirectory
+		out.SeccompProfileRoot = in.SeccompProfileRoot
+		out.AllowPrivileged = in.AllowPrivileged
+		if in.HostNetworkSources != nil {
+			in, out := &in.HostNetworkSources, &out.HostNetworkSources
+			*out = make([]string, len(*in))
+			copy(*out, *in)
+		} else {
+			out.HostNetworkSources = nil
+		}
+		if in.HostPIDSources != nil {
+			in, out := &in.HostPIDSources, &out.HostPIDSources
+			*out = make([]string, len(*in))
+			copy(*out, *in)
+		} else {
+			out.HostPIDSources = nil
+		}
+		if in.HostIPCSources != nil {
+			in, out := &in.HostIPCSources, &out.HostIPCSources
+			*out = make([]string, len(*in))
+			copy(*out, *in)
+		} else {
+			out.HostIPCSources = nil
+		}
+		out.RegistryPullQPS = in.RegistryPullQPS
+		out.RegistryBurst = in.RegistryBurst
+		out.EventRecordQPS = in.EventRecordQPS
+		out.EventBurst = in.EventBurst
+		out.EnableDebuggingHandlers = in.EnableDebuggingHandlers
+		out.MinimumGCAge = in.MinimumGCAge
+		out.MaxPerPodContainerCount = in.MaxPerPodContainerCount
+		out.MaxContainerCount = in.MaxContainerCount
+		out.CAdvisorPort = in.CAdvisorPort
+		out.HealthzPort = in.HealthzPort
+		out.HealthzBindAddress = in.HealthzBindAddress
+		out.OOMScoreAdj = in.OOMScoreAdj
+		out.RegisterNode = in.RegisterNode
+		out.ClusterDomain = in.ClusterDomain
+		out.MasterServiceNamespace = in.MasterServiceNamespace
+		out.ClusterDNS = in.ClusterDNS
+		out.StreamingConnectionIdleTimeout = in.StreamingConnectionIdleTimeout
+		out.NodeStatusUpdateFrequency = in.NodeStatusUpdateFrequency
+		out.ImageMinimumGCAge = in.ImageMinimumGCAge
+		out.ImageGCHighThresholdPercent = in.ImageGCHighThresholdPercent
+		out.ImageGCLowThresholdPercent = in.ImageGCLowThresholdPercent
+		out.LowDiskSpaceThresholdMB = in.LowDiskSpaceThresholdMB
+		out.VolumeStatsAggPeriod = in.VolumeStatsAggPeriod
+		out.NetworkPluginName = in.NetworkPluginName
+		out.NetworkPluginMTU = in.NetworkPluginMTU
+		out.NetworkPluginDir = in.NetworkPluginDir
+		out.CNIConfDir = in.CNIConfDir
+		out.CNIBinDir = in.CNIBinDir
+		out.VolumePluginDir = in.VolumePluginDir
+		out.CloudProvider = in.CloudProvider
+		out.CloudConfigFile = in.CloudConfigFile
+		out.KubeletCgroups = in.KubeletCgroups
+		out.ExperimentalCgroupsPerQOS = in.ExperimentalCgroupsPerQOS
+		out.CgroupDriver = in.CgroupDriver
+		out.RuntimeCgroups = in.RuntimeCgroups
+		out.SystemCgroups = in.SystemCgroups
+		out.CgroupRoot = in.CgroupRoot
+		out.ContainerRuntime = in.ContainerRuntime
+		out.RemoteRuntimeEndpoint = in.RemoteRuntimeEndpoint
+		out.RemoteImageEndpoint = in.RemoteImageEndpoint
+		out.RuntimeRequestTimeout = in.RuntimeRequestTimeout
+		out.RktPath = in.RktPath
+		out.ExperimentalMounterPath = in.ExperimentalMounterPath
+		out.RktAPIEndpoint = in.RktAPIEndpoint
+		out.RktStage1Image = in.RktStage1Image
+		out.LockFilePath = in.LockFilePath
+		out.ExitOnLockContention = in.ExitOnLockContention
+		out.HairpinMode = in.HairpinMode
+		out.BabysitDaemons = in.BabysitDaemons
+		out.MaxPods = in.MaxPods
+		out.NvidiaGPUs = in.NvidiaGPUs
+		out.DockerExecHandlerName = in.DockerExecHandlerName
+		out.PodCIDR = in.PodCIDR
+		out.ResolverConfig = in.ResolverConfig
+		out.CPUCFSQuota = in.CPUCFSQuota
+		out.Containerized = in.Containerized
+		out.MaxOpenFiles = in.MaxOpenFiles
+		out.ReconcileCIDR = in.ReconcileCIDR
+		out.RegisterSchedulable = in.RegisterSchedulable
+		out.ContentType = in.ContentType
+		out.KubeAPIQPS = in.KubeAPIQPS
+		out.KubeAPIBurst = in.KubeAPIBurst
+		out.SerializeImagePulls = in.SerializeImagePulls
+		out.OutOfDiskTransitionFrequency = in.OutOfDiskTransitionFrequency
+		out.NodeIP = in.NodeIP
+		if in.NodeLabels != nil {
+			in, out := &in.NodeLabels, &out.NodeLabels
+			*out = make(map[string]string)
+			for key, val := range *in {
+				(*out)[key] = val
+			}
+		} else {
+			out.NodeLabels = nil
+		}
+		out.NonMasqueradeCIDR = in.NonMasqueradeCIDR
+		out.EnableCustomMetrics = in.EnableCustomMetrics
+		out.EvictionHard = in.EvictionHard
+		out.EvictionSoft = in.EvictionSoft
+		out.EvictionSoftGracePeriod = in.EvictionSoftGracePeriod
+		out.EvictionPressureTransitionPeriod = in.EvictionPressureTransitionPeriod
+		out.EvictionMaxPodGracePeriod = in.EvictionMaxPodGracePeriod
+		out.EvictionMinimumReclaim = in.EvictionMinimumReclaim
+		out.PodsPerCore = in.PodsPerCore
+		out.EnableControllerAttachDetach = in.EnableControllerAttachDetach
+		if in.SystemReserved != nil {
+			in, out := &in.SystemReserved, &out.SystemReserved
+			*out = make(config.ConfigurationMap)
+			for key, val := range *in {
+				(*out)[key] = val
+			}
+		} else {
+			out.SystemReserved = nil
+		}
+		if in.KubeReserved != nil {
+			in, out := &in.KubeReserved, &out.KubeReserved
+			*out = make(config.ConfigurationMap)
+			for key, val := range *in {
+				(*out)[key] = val
+			}
+		} else {
+			out.KubeReserved = nil
+		}
+		out.ProtectKernelDefaults = in.ProtectKernelDefaults
+		out.MakeIPTablesUtilChains = in.MakeIPTablesUtilChains
+		out.IPTablesMasqueradeBit = in.IPTablesMasqueradeBit
+		out.IPTablesDropBit = in.IPTablesDropBit
+		if in.AllowedUnsafeSysctls != nil {
+			in, out := &in.AllowedUnsafeSysctls, &out.AllowedUnsafeSysctls
+			*out = make([]string, len(*in))
+			copy(*out, *in)
+		} else {
+			out.AllowedUnsafeSysctls = nil
+		}
+		out.FeatureGates = in.FeatureGates
+		out.EnableCRI = in.EnableCRI
+		out.ExperimentalFailSwapOn = in.ExperimentalFailSwapOn
+		out.ExperimentalCheckNodeCapabilitiesBeforeMount = in.ExperimentalCheckNodeCapabilitiesBeforeMount
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeletWebhookAuthentication(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeletWebhookAuthentication)
+		out := out.(*KubeletWebhookAuthentication)
+		out.Enabled = in.Enabled
+		out.CacheTTL = in.CacheTTL
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeletWebhookAuthorization(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeletWebhookAuthorization)
+		out := out.(*KubeletWebhookAuthorization)
+		out.CacheAuthorizedTTL = in.CacheAuthorizedTTL
+		out.CacheUnauthorizedTTL = in.CacheUnauthorizedTTL
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_KubeletX509Authentication(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*KubeletX509Authentication)
+		out := out.(*KubeletX509Authentication)
+		out.ClientCAFile = in.ClientCAFile
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_LeaderElectionConfiguration(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*LeaderElectionConfiguration)
+		out := out.(*LeaderElectionConfiguration)
+		out.LeaderElect = in.LeaderElect
+		out.LeaseDuration = in.LeaseDuration
+		out.RenewDeadline = in.RenewDeadline
+		out.RetryPeriod = in.RetryPeriod
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_PersistentVolumeRecyclerConfiguration(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*PersistentVolumeRecyclerConfiguration)
+		out := out.(*PersistentVolumeRecyclerConfiguration)
+		out.MaximumRetry = in.MaximumRetry
+		out.MinimumTimeoutNFS = in.MinimumTimeoutNFS
+		out.PodTemplateFilePathNFS = in.PodTemplateFilePathNFS
+		out.IncrementTimeoutNFS = in.IncrementTimeoutNFS
+		out.PodTemplateFilePathHostPath = in.PodTemplateFilePathHostPath
+		out.MinimumTimeoutHostPath = in.MinimumTimeoutHostPath
+		out.IncrementTimeoutHostPath = in.IncrementTimeoutHostPath
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_PortRangeVar(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*PortRangeVar)
+		out := out.(*PortRangeVar)
+		if in.Val != nil {
+			in, out := &in.Val, &out.Val
+			*out = new(string)
+			**out = **in
+		} else {
+			out.Val = nil
+		}
+		return nil
+	}
+}
+
+func DeepCopy_componentconfig_VolumeConfiguration(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*VolumeConfiguration)
+		out := out.(*VolumeConfiguration)
+		out.EnableHostPathProvisioning = in.EnableHostPathProvisioning
+		out.EnableDynamicProvisioning = in.EnableDynamicProvisioning
+		out.PersistentVolumeRecyclerConfiguration = in.PersistentVolumeRecyclerConfiguration
+		out.FlexVolumePluginDir = in.FlexVolumePluginDir
+		return nil
+	}
+}