Merge pull request #33352 from smarterclayton/unified_defaulters

Godeps/Godeps.json

@@ -2571,39 +2571,43 @@
 		},
 		{
 			"ImportPath": "k8s.io/gengo/args",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/deepcopy-gen/generators",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
+		},
+		{
+			"ImportPath": "k8s.io/gengo/examples/defaulter-gen/generators",
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/import-boss/generators",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/set-gen/generators",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/set-gen/sets",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/generator",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/namer",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/parser",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/types",
-			"Rev": "9d004f4877d8dc116a678d35e43498404625599d"
+			"Rev": "4a9ebbace691333e73f9978d798b1bad6c53a50d"
 		},
 		{
 			"ImportPath": "k8s.io/heapster/metrics/api/v1/types",

Makefile.generated_files

@@ -35,7 +35,7 @@ SHELL := /bin/bash
 # This rule collects all the generated file sets into a single rule.  Other
 # rules should depend on this to ensure generated files are rebuilt.
 .PHONY: generated_files
-generated_files: gen_deepcopy gen_conversion gen_openapi
+generated_files: gen_deepcopy gen_defaulter gen_conversion gen_openapi
 
 # Code-generation logic.
 #
@@ -287,6 +287,146 @@ $(DEEPCOPY_GEN):
 	touch $@
 
 #
+# Defaulter generation
+#
+# Any package that wants defaulter functions generated must include a
+# comment-tag in column 0 of one file of the form:
+#     // +k8s:defaulter-gen=<VALUE>
+#
+# The <VALUE> depends on context:
+#     on types:
+#       true:  always generate a defaulter for this type
+#       false: never generate a defaulter for this type
+#     on functions:
+#       covers: if the function name matches SetDefault_NAME, instructs
+#               the generator not to recurse
+#     on packages:
+#       FIELDNAME: any object with a field of this name is a candidate
+#                  for having a defaulter generated
+
+# The result file, in each pkg, of defaulter generation.
+DEFAULTER_BASENAME := $(GENERATED_FILE_PREFIX)defaults
+DEFAULTER_FILENAME := $(DEFAULTER_BASENAME).go
+
+# The tool used to generate defaulters.
+DEFAULTER_GEN := $(BIN_DIR)/defaulter-gen
+
+# All directories that request any form of defaulter generation.
+ifeq ($(DBG_MAKEFILE),1)
+    $(warning ***** finding all +k8s:defaulter-gen tags)
+endif
+DEFAULTER_DIRS := $(shell                                            \
+    grep --color=never -l '+k8s:defaulter-gen=' $(ALL_K8S_TAG_FILES) \
+        | xargs -n1 dirname                                          \
+        | sort -u                                                    \
+)
+
+DEFAULTER_FILES := $(addsuffix /$(DEFAULTER_FILENAME), $(DEFAULTER_DIRS))
+
+# This rule aggregates the set of files to generate and then generates them all
+# in a single run of the tool.
+.PHONY: gen_defaulter
+gen_defaulter: $(DEFAULTER_FILES)
+	if [[ -f $(META_DIR)/$(DEFAULTER_GEN).todo ]]; then                  \
+	    ./hack/run-in-gopath.sh $(DEFAULTER_GEN)                         \
+	        --v $(KUBE_VERBOSE)                                          \
+	        --logtostderr                                                \
+	        -i $$(cat $(META_DIR)/$(DEFAULTER_GEN).todo | paste -sd, -)  \
+	        --extra-peer-dirs $$(echo $(addprefix $(PRJ_SRC_PATH)/, $(DEFAULTER_DIRS)) | sed 's/ /,/g') \
+	        -O $(DEFAULTER_BASENAME);                                    \
+	fi
+
+# For each dir in DEFAULTER_DIRS, this establishes a dependency between the
+# output file and the input files that should trigger a rebuild.
+#
+# The variable value was set in $(GOFILES_META) and included as part of the
+# dependency management logic.
+#
+# Note that this is a deps-only statement, not a full rule (see below).  This
+# has to be done in a distinct step because wildcards don't work in static
+# pattern rules.
+#
+# The '$(eval)' is needed because this has a different RHS for each LHS, and
+# would otherwise produce results that make can't parse.
+#
+# We depend on the $(GOFILES_META).stamp to detect when the set of input files
+# has changed.  This allows us to detect deleted input files.
+$(foreach dir, $(DEFAULTER_DIRS), $(eval                                    \
+    $(dir)/$(DEFAULTER_FILENAME): $(META_DIR)/$(dir)/$(GOFILES_META).stamp  \
+                                   $(gofiles__$(dir))                       \
+))
+
+# For each dir in DEFAULTER_DIRS, for each target in $(defaulters__$(dir)),
+# this establishes a dependency between the output file and the input files
+# that should trigger a rebuild.
+#
+# The variable value was set in $(GOFILES_META) and included as part of the
+# dependency management logic.
+#
+# Note that this is a deps-only statement, not a full rule (see below).  This
+# has to be done in a distinct step because wildcards don't work in static
+# pattern rules.
+#
+# The '$(eval)' is needed because this has a different RHS for each LHS, and
+# would otherwise produce results that make can't parse.
+#
+# We depend on the $(GOFILES_META).stamp to detect when the set of input files
+# has changed.  This allows us to detect deleted input files.
+$(foreach dir, $(DEFAULTER_DIRS),                                               \
+    $(foreach tgt, $(defaulters__$(dir)), $(eval                                \
+        $(dir)/$(DEFAULTER_FILENAME): $(META_DIR)/$(tgt)/$(GOFILES_META).stamp  \
+                                       $(gofiles__$(tgt))                       \
+    ))                                                                          \
+)
+
+# Unilaterally remove any leftovers from previous runs.
+$(shell rm -f $(META_DIR)/$(DEFAULTER_GEN)*.todo)
+
+# How to regenerate defaulter code.  This is a little slow to run, so we batch
+# it up and trigger the batch from the 'generated_files' target.
+$(DEFAULTER_FILES): $(DEFAULTER_GEN)
+	mkdir -p $$(dirname $(META_DIR)/$(DEFAULTER_GEN))
+	echo $(PRJ_SRC_PATH)/$(@D) >> $(META_DIR)/$(DEFAULTER_GEN).todo
+
+# This calculates the dependencies for the generator tool, so we only rebuild
+# it when needed.  It is PHONY so that it always runs, but it only updates the
+# file if the contents have actually changed.  We 'sinclude' this later.
+.PHONY: $(META_DIR)/$(DEFAULTER_GEN).mk
+$(META_DIR)/$(DEFAULTER_GEN).mk:
+	mkdir -p $(@D);                                        \
+	(echo -n "$(DEFAULTER_GEN): ";                         \
+	 DIRECT=$$(go list -f '{{.Dir}} {{.Dir}}/*.go'         \
+	     ./cmd/libs/go2idl/defaulter-gen);                 \
+	 INDIRECT=$$(go list                                   \
+	     -f '{{range .Deps}}{{.}}{{"\n"}}{{end}}'          \
+	     ./cmd/libs/go2idl/defaulter-gen                   \
+	     | grep --color=never "^$(PRJ_SRC_PATH)"           \
+	     | sed 's|^$(PRJ_SRC_PATH)|./|'                    \
+	     | xargs go list -f '{{.Dir}} {{.Dir}}/*.go');     \
+	 echo $$DIRECT $$INDIRECT                              \
+	     | sed 's/ / \\=,/g'                               \
+	     | tr '=,' '\n\t';                                 \
+	) | sed "s|$$(pwd -P)/||" > $@.tmp;                    \
+	cmp -s $@.tmp $@ || cat $@.tmp > $@ && rm -f $@.tmp
+
+# Include dependency info for the generator tool.  This will cause the rule of
+# the same name to be considered and if it is updated, make will restart.
+sinclude $(META_DIR)/$(DEFAULTER_GEN).mk
+
+# How to build the generator tool.  The deps for this are defined in
+# the $(DEFAULTER_GEN).mk, above.
+#
+# A word on the need to touch: This rule might trigger if, for example, a
+# non-Go file was added or deleted from a directory on which this depends.
+# This target needs to be reconsidered, but Go realizes it doesn't actually
+# have to be rebuilt.  In that case, make will forever see the dependency as
+# newer than the binary, and try to rebuild it over and over.  So we touch it,
+# and make is happy.
+$(DEFAULTER_GEN):
+	hack/make-rules/build.sh cmd/libs/go2idl/defaulter-gen
+	touch $@
+
+#
 # Open-api generation
 #
 # Any package that wants open-api functions generated must include a
@@ -427,7 +567,7 @@ gen_conversion: $(CONVERSION_FILES)
 	if [[ -f $(META_DIR)/$(CONVERSION_GEN).todo ]]; then                  \
 	    ./hack/run-in-gopath.sh $(CONVERSION_GEN)                         \
 	        --v $(KUBE_VERBOSE)                                           \
-	        --logtostderr                                               \
+	        --logtostderr                                                 \
 	        -i $$(cat $(META_DIR)/$(CONVERSION_GEN).todo | paste -sd, -)  \
 	        -O $(CONVERSION_BASENAME);                                    \
 	fi

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

@@ -50,8 +50,10 @@ type ProxyServerConfig struct {
 }
 
 func NewProxyConfig() *ProxyServerConfig {
+	versioned := &v1alpha1.KubeProxyConfiguration{}
+	api.Scheme.Default(versioned)
 	cfg := componentconfig.KubeProxyConfiguration{}
-	api.Scheme.Convert(&v1alpha1.KubeProxyConfiguration{}, &cfg, nil)
+	api.Scheme.Convert(versioned, &cfg, nil)
 	return &ProxyServerConfig{
 		KubeProxyConfiguration: cfg,
 		ContentType:            "application/vnd.kubernetes.protobuf",

cmd/kubelet/app/options/options.go

@@ -64,8 +64,10 @@ type KubeletServer struct {
 
 // NewKubeletServer will create a new KubeletServer with default values.
 func NewKubeletServer() *KubeletServer {
+	versioned := &v1alpha1.KubeletConfiguration{}
+	api.Scheme.Default(versioned)
 	config := componentconfig.KubeletConfiguration{}
-	api.Scheme.Convert(&v1alpha1.KubeletConfiguration{}, &config, nil)
+	api.Scheme.Convert(versioned, &config, nil)
 	return &KubeletServer{
 		KubeConfig:           flag.NewStringFlag("/var/lib/kubelet/kubeconfig"),
 		RequireKubeConfig:    false, // in 1.5, default to true

cmd/kubelet/app/server.go

@@ -246,6 +246,7 @@ func initKubeletConfigSync(s *options.KubeletServer) (*componentconfig.KubeletCo
 		if err != nil {
 			return nil, err
 		}
+		api.Scheme.Default(&extKC)
 		kc := componentconfig.KubeletConfiguration{}
 		err = api.Scheme.Convert(&extKC, &kc, nil)
 		if err != nil {

cmd/libs/go2idl/conversion-gen/generators/conversion.go

@@ -36,6 +36,10 @@ import (
 // generator.
 type CustomArgs struct {
 	ExtraPeerDirs []string // Always consider these as last-ditch possibilities for conversions.
+	// SkipDefaulters indicates whether defaulter functions should be a part of conversion
+	// This field was introduced to ease the transition to removing defaulters from conversion.
+	// It will be removed in 1.6.
+	SkipDefaulters bool
 }
 
 // This is the comment tag that carries parameters for conversion generation.
@@ -242,10 +246,12 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 			glog.V(5).Infof("  no tag")
 			continue
 		}
+		skipDefaulters := false
 		if customArgs, ok := arguments.CustomArgs.(*CustomArgs); ok {
 			if len(customArgs.ExtraPeerDirs) > 0 {
 				peerPkgs = append(peerPkgs, customArgs.ExtraPeerDirs...)
 			}
+			skipDefaulters = customArgs.SkipDefaulters
 		}
 		// Make sure our peer-packages are added and fully parsed.
 		for _, pp := range peerPkgs {
@@ -261,7 +267,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 				HeaderText:  header,
 				GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
 					return []generator.Generator{
-						NewGenConversion(arguments.OutputFileBaseName, pkg.Path, manualConversions, manualDefaults, peerPkgs),
+						NewGenConversion(arguments.OutputFileBaseName, pkg.Path, manualConversions, manualDefaults, peerPkgs, !skipDefaulters),
 					}
 				},
 				FilterFunc: func(c *generator.Context, t *types.Type) bool {
@@ -307,9 +313,10 @@ type genConversion struct {
 	imports           namer.ImportTracker
 	types             []*types.Type
 	skippedFields     map[*types.Type][]string
+	includeDefaulters bool
 }
 
-func NewGenConversion(sanitizedName, targetPackage string, manualConversions conversionFuncMap, manualDefaulters defaulterFuncMap, peerPkgs []string) generator.Generator {
+func NewGenConversion(sanitizedName, targetPackage string, manualConversions conversionFuncMap, manualDefaulters defaulterFuncMap, peerPkgs []string, includeDefaulters bool) generator.Generator {
 	return &genConversion{
 		DefaultGen: generator.DefaultGen{
 			OptionalName: sanitizedName,
@@ -321,6 +328,7 @@ func NewGenConversion(sanitizedName, targetPackage string, manualConversions con
 		imports:           generator.NewImportTracker(),
 		types:             []*types.Type{},
 		skippedFields:     map[*types.Type][]string{},
+		includeDefaulters: includeDefaulters,
 	}
 }
 
@@ -470,7 +478,7 @@ func (g *genConversion) generateConversion(inType, outType *types.Type, sw *gene
 
 	sw.Do("func auto"+nameTmpl+"(in *$.inType|raw$, out *$.outType|raw$, s $.Scope|raw$) error {\n", args)
 	// if no defaulter of form SetDefaults_XXX is defined, do not inline a check for defaulting.
-	if function, ok := g.manualDefaulters[inType]; ok {
+	if function, ok := g.manualDefaulters[inType]; ok && g.includeDefaulters {
 		sw.Do("$.|raw$(in)\n", function)
 	}
 	g.generateFor(inType, outType, sw)

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

@@ -60,6 +60,7 @@ func main() {
 			"k8s.io/kubernetes/pkg/conversion",
 			"k8s.io/kubernetes/pkg/runtime",
 		},
+		SkipDefaulters: true,
 	}
 	pflag.CommandLine.StringSliceVar(&customArgs.ExtraPeerDirs, "extra-peer-dirs", customArgs.ExtraPeerDirs,
 		"Comma-separated list of import paths which are considered, after tag-specified peers, for conversions.")

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

+/*
+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.
+*/
+
+// defaulter-gen is a tool for auto-generating Defaulter functions.
+//
+// Given a list of input directories, it will scan for top level types
+// and generate efficient defaulters for an entire object from the sum
+// of the SetDefault_* methods contained in the object tree.
+//
+// Generation is governed by comment tags in the source.  Any package may
+// request defaulter generation by including one or more comment tags at
+// the package comment level:
+//
+//   // +k8s:defaulter-gen=<field-name-to-flag>
+//
+// which will create defaulters for any type that contains the provided
+// field name (if the type has defaulters). Any type may request explicit
+// defaulting by providing the comment tag:
+//
+//   // +k8s:defaulter-gen=true|false
+//
+// An existing defaulter method (`SetDefaults_TYPE`) can provide the
+// comment tag:
+//
+//   // +k8s:defaulter-gen=covers
+//
+// to indicate that the defaulter does not or should not call any nested
+// defaulters.
+package main
+
+import (
+	"path/filepath"
+
+	"k8s.io/gengo/args"
+	"k8s.io/gengo/examples/defaulter-gen/generators"
+
+	"github.com/golang/glog"
+	"github.com/spf13/pflag"
+)
+
+func main() {
+	arguments := args.Default()
+
+	// Override defaults.
+	arguments.OutputFileBaseName = "zz_generated.defaults"
+	arguments.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), "k8s.io/kubernetes/hack/boilerplate/boilerplate.go.txt")
+
+	// Custom args.
+	customArgs := &generators.CustomArgs{
+		ExtraPeerDirs: []string{},
+	}
+	pflag.CommandLine.StringSliceVar(&customArgs.ExtraPeerDirs, "extra-peer-dirs", customArgs.ExtraPeerDirs,
+		"Comma-separated list of import paths which are considered, after tag-specified peers, for conversions.")
+	arguments.CustomArgs = customArgs
+
+	// Run it.
+	if err := arguments.Execute(
+		generators.NameSystems(),
+		generators.DefaultNameSystem(),
+		generators.Packages,
+	); err != nil {
+		glog.Fatalf("Error: %v", err)
+	}
+	glog.V(2).Info("Completed successfully.")
+}

federation/apis/federation/v1beta1/doc.go

@@ -17,4 +17,5 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/federation/apis/federation
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 package v1beta1 // import "k8s.io/kubernetes/federation/apis/federation/v1beta1"

hack/.linted_packages

@@ -27,6 +27,7 @@ cmd/libs/go2idl/client-gen/test_apis/testgroup.k8s.io/install
 cmd/libs/go2idl/client-gen/testoutput/clientset_generated/test_internalclientset/typed/testgroup.k8s.io/unversioned
 cmd/libs/go2idl/conversion-gen
 cmd/libs/go2idl/deepcopy-gen
+cmd/libs/go2idl/defaulter-gen
 cmd/libs/go2idl/generator
 cmd/libs/go2idl/go-to-protobuf
 cmd/libs/go2idl/go-to-protobuf/protoc-gen-gogo

pkg/api/defaulting_test.go

+/*
+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 api_test
+
+import (
+	"math/rand"
+	"reflect"
+	"sort"
+	"testing"
+
+	"github.com/google/gofuzz"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/unversioned"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
+	batchv2alpha1 "k8s.io/kubernetes/pkg/apis/batch/v2alpha1"
+	extensionsv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/diff"
+)
+
+type orderedGroupVersionKinds []unversioned.GroupVersionKind
+
+func (o orderedGroupVersionKinds) Len() int      { return len(o) }
+func (o orderedGroupVersionKinds) Swap(i, j int) { o[i], o[j] = o[j], o[i] }
+func (o orderedGroupVersionKinds) Less(i, j int) bool {
+	return o[i].String() < o[j].String()
+}
+
+func TestVerifyDefaulting(t *testing.T) {
+	job := &batchv2alpha1.JobTemplate{}
+	batchv2alpha1.SetObjectDefaults_JobTemplate(job)
+	if job.Template.Spec.Template.Spec.DNSPolicy != apiv1.DNSClusterFirst {
+		t.Errorf("unexpected defaulting: %#v", job)
+	}
+}
+
+// TODO: add a reflexive test that verifies that all SetDefaults functions are registered
+func TestDefaulting(t *testing.T) {
+	// these are the known types with defaulters - you must add to this list if you add a top level defaulter
+	typesWithDefaulting := map[unversioned.GroupVersionKind]struct{}{
+		{Group: "", Version: "v1", Kind: "ConfigMap"}:                                             {},
+		{Group: "", Version: "v1", Kind: "ConfigMapList"}:                                         {},
+		{Group: "", Version: "v1", Kind: "Endpoints"}:                                             {},
+		{Group: "", Version: "v1", Kind: "EndpointsList"}:                                         {},
+		{Group: "", Version: "v1", Kind: "Namespace"}:                                             {},
+		{Group: "", Version: "v1", Kind: "NamespaceList"}:                                         {},
+		{Group: "", Version: "v1", Kind: "Node"}:                                                  {},
+		{Group: "", Version: "v1", Kind: "NodeList"}:                                              {},
+		{Group: "", Version: "v1", Kind: "PersistentVolume"}:                                      {},
+		{Group: "", Version: "v1", Kind: "PersistentVolumeList"}:                                  {},
+		{Group: "", Version: "v1", Kind: "PersistentVolumeClaim"}:                                 {},
+		{Group: "", Version: "v1", Kind: "PersistentVolumeClaimList"}:                             {},
+		{Group: "", Version: "v1", Kind: "PodAttachOptions"}:                                      {},
+		{Group: "", Version: "v1", Kind: "PodExecOptions"}:                                        {},
+		{Group: "", Version: "v1", Kind: "Pod"}:                                                   {},
+		{Group: "", Version: "v1", Kind: "PodList"}:                                               {},
+		{Group: "", Version: "v1", Kind: "PodTemplate"}:                                           {},
+		{Group: "", Version: "v1", Kind: "PodTemplateList"}:                                       {},
+		{Group: "", Version: "v1", Kind: "ReplicationController"}:                                 {},
+		{Group: "", Version: "v1", Kind: "ReplicationControllerList"}:                             {},
+		{Group: "", Version: "v1", Kind: "Secret"}:                                                {},
+		{Group: "", Version: "v1", Kind: "SecretList"}:                                            {},
+		{Group: "", Version: "v1", Kind: "Service"}:                                               {},
+		{Group: "", Version: "v1", Kind: "ServiceList"}:                                           {},
+		{Group: "apps", Version: "v1alpha1", Kind: "PetSet"}:                                      {},
+		{Group: "apps", Version: "v1alpha1", Kind: "PetSetList"}:                                  {},
+		{Group: "autoscaling", Version: "v1", Kind: "HorizontalPodAutoscaler"}:                    {},
+		{Group: "autoscaling", Version: "v1", Kind: "HorizontalPodAutoscalerList"}:                {},
+		{Group: "batch", Version: "v1", Kind: "Job"}:                                              {},
+		{Group: "batch", Version: "v1", Kind: "JobList"}:                                          {},
+		{Group: "batch", Version: "v2alpha1", Kind: "Job"}:                                        {},
+		{Group: "batch", Version: "v2alpha1", Kind: "JobList"}:                                    {},
+		{Group: "batch", Version: "v2alpha1", Kind: "JobTemplate"}:                                {},
+		{Group: "batch", Version: "v2alpha1", Kind: "ScheduledJob"}:                               {},
+		{Group: "batch", Version: "v2alpha1", Kind: "ScheduledJobList"}:                           {},
+		{Group: "componentconfig", Version: "v1alpha1", Kind: "KubeProxyConfiguration"}:           {},
+		{Group: "componentconfig", Version: "v1alpha1", Kind: "KubeSchedulerConfiguration"}:       {},
+		{Group: "componentconfig", Version: "v1alpha1", Kind: "KubeletConfiguration"}:             {},
+		{Group: "extensions", Version: "v1beta1", Kind: "DaemonSet"}:                              {},
+		{Group: "extensions", Version: "v1beta1", Kind: "DaemonSetList"}:                          {},
+		{Group: "extensions", Version: "v1beta1", Kind: "Deployment"}:                             {},
+		{Group: "extensions", Version: "v1beta1", Kind: "DeploymentList"}:                         {},
+		{Group: "extensions", Version: "v1beta1", Kind: "HorizontalPodAutoscaler"}:                {},
+		{Group: "extensions", Version: "v1beta1", Kind: "HorizontalPodAutoscalerList"}:            {},
+		{Group: "extensions", Version: "v1beta1", Kind: "Job"}:                                    {},
+		{Group: "extensions", Version: "v1beta1", Kind: "JobList"}:                                {},
+		{Group: "extensions", Version: "v1beta1", Kind: "ReplicaSet"}:                             {},
+		{Group: "extensions", Version: "v1beta1", Kind: "ReplicaSetList"}:                         {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "ClusterRoleBinding"}:     {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "ClusterRoleBindingList"}: {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "RoleBinding"}:            {},
+		{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Kind: "RoleBindingList"}:        {},
+	}
+
+	f := fuzz.New().NilChance(.5).NumElements(1, 1).RandSource(rand.NewSource(1))
+	f.Funcs(
+		func(s *runtime.RawExtension, c fuzz.Continue) {},
+		func(s *unversioned.LabelSelector, c fuzz.Continue) {
+			c.FuzzNoCustom(s)
+			s.MatchExpressions = nil // need to fuzz this specially
+		},
+		func(s *apiv1.ListOptions, c fuzz.Continue) {
+			c.FuzzNoCustom(s)
+			s.LabelSelector = "" // need to fuzz requirement strings specially
+			s.FieldSelector = "" // need to fuzz requirement strings specially
+		},
+		func(s *extensionsv1beta1.ScaleStatus, c fuzz.Continue) {
+			c.FuzzNoCustom(s)
+			s.TargetSelector = "" // need to fuzz requirement strings specially
+		},
+	)
+
+	scheme := api.Scheme
+	var testTypes orderedGroupVersionKinds
+	for gvk := range scheme.AllKnownTypes() {
+		if gvk.Version == runtime.APIVersionInternal {
+			continue
+		}
+		testTypes = append(testTypes, gvk)
+	}
+	sort.Sort(testTypes)
+
+	for _, gvk := range testTypes {
+		_, expectedChanged := typesWithDefaulting[gvk]
+		iter := 0
+		changedOnce := false
+		for {
+			if iter > *fuzzIters {
+				if !expectedChanged || changedOnce {
+					break
+				}
+				if iter > 200 {
+					t.Errorf("expected %s to trigger defaulting due to fuzzing", gvk)
+					break
+				}
+				// if we expected defaulting, continue looping until the fuzzer gives us one
+				// at worst, we will timeout
+			}
+			iter++
+
+			src, err := scheme.New(gvk)
+			if err != nil {
+				t.Fatal(err)
+			}
+			f.Fuzz(src)
+
+			src.GetObjectKind().SetGroupVersionKind(unversioned.GroupVersionKind{})
+
+			original, err := scheme.DeepCopy(src)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// get internal
+			withDefaults, _ := scheme.DeepCopy(src)
+			scheme.Default(withDefaults.(runtime.Object))
+
+			if !reflect.DeepEqual(original, withDefaults) {
+				changedOnce = true
+				if !expectedChanged {
+					t.Errorf("{Group: \"%s\", Version: \"%s\", Kind: \"%s\"} did not expect defaults to be set - update expected or check defaulter registering: %s", gvk.Group, gvk.Version, gvk.Kind, diff.ObjectReflectDiff(original, withDefaults))
+				}
+			}
+		}
+	}
+}
+
+func BenchmarkPodDefaulting(b *testing.B) {
+	f := fuzz.New().NilChance(.5).NumElements(1, 1).RandSource(rand.NewSource(1))
+	items := make([]apiv1.Pod, 100)
+	for i := range items {
+		f.Fuzz(&items[i])
+	}
+
+	scheme := api.Scheme
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		pod := &items[i%len(items)]
+
+		scheme.Default(pod)
+	}
+	b.StopTimer()
+}

pkg/api/unversioned/doc.go

@@ -16,5 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 package unversioned // import "k8s.io/kubernetes/pkg/api/unversioned"

pkg/api/v1/conversion.go

@@ -269,9 +269,6 @@ func addConversionFuncs(scheme *runtime.Scheme) error {
 }
 
 func Convert_v1_ReplicationController_to_extensions_ReplicaSet(in *ReplicationController, out *extensions.ReplicaSet, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*ReplicationController))(in)
-	}
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -288,9 +285,6 @@ func Convert_v1_ReplicationController_to_extensions_ReplicaSet(in *ReplicationCo
 }
 
 func Convert_v1_ReplicationControllerSpec_to_extensions_ReplicaSetSpec(in *ReplicationControllerSpec, out *extensions.ReplicaSetSpec, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*ReplicationControllerSpec))(in)
-	}
 	out.Replicas = *in.Replicas
 	if in.Selector != nil {
 		api.Convert_map_to_unversioned_LabelSelector(&in.Selector, out.Selector, s)
@@ -304,9 +298,6 @@ func Convert_v1_ReplicationControllerSpec_to_extensions_ReplicaSetSpec(in *Repli
 }
 
 func Convert_v1_ReplicationControllerStatus_to_extensions_ReplicaSetStatus(in *ReplicationControllerStatus, out *extensions.ReplicaSetStatus, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*ReplicationControllerStatus))(in)
-	}
 	out.Replicas = in.Replicas
 	out.FullyLabeledReplicas = in.FullyLabeledReplicas
 	out.ReadyReplicas = in.ReadyReplicas
@@ -316,9 +307,6 @@ func Convert_v1_ReplicationControllerStatus_to_extensions_ReplicaSetStatus(in *R
 }
 
 func Convert_extensions_ReplicaSet_to_v1_ReplicationController(in *extensions.ReplicaSet, out *ReplicationController, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*extensions.ReplicaSet))(in)
-	}
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -342,9 +330,6 @@ func Convert_extensions_ReplicaSet_to_v1_ReplicationController(in *extensions.Re
 }
 
 func Convert_extensions_ReplicaSetSpec_to_v1_ReplicationControllerSpec(in *extensions.ReplicaSetSpec, out *ReplicationControllerSpec, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*extensions.ReplicaSetSpec))(in)
-	}
 	out.Replicas = new(int32)
 	*out.Replicas = in.Replicas
 	out.MinReadySeconds = in.MinReadySeconds
@@ -360,9 +345,6 @@ func Convert_extensions_ReplicaSetSpec_to_v1_ReplicationControllerSpec(in *exten
 }
 
 func Convert_extensions_ReplicaSetStatus_to_v1_ReplicationControllerStatus(in *extensions.ReplicaSetStatus, out *ReplicationControllerStatus, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*extensions.ReplicaSetStatus))(in)
-	}
 	out.Replicas = in.Replicas
 	out.FullyLabeledReplicas = in.FullyLabeledReplicas
 	out.ReadyReplicas = in.ReadyReplicas
@@ -387,7 +369,9 @@ func Convert_api_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(in *a
 }
 
 func Convert_v1_ReplicationControllerSpec_To_api_ReplicationControllerSpec(in *ReplicationControllerSpec, out *api.ReplicationControllerSpec, s conversion.Scope) error {
-	out.Replicas = *in.Replicas
+	if in.Replicas != nil {
+		out.Replicas = *in.Replicas
+	}
 	out.MinReadySeconds = in.MinReadySeconds
 	out.Selector = in.Selector
 	if in.Template != nil {
@@ -644,6 +628,11 @@ func Convert_v1_Pod_To_api_Pod(in *Pod, out *api.Pod, s conversion.Scope) error
 		// taking responsibility to ensure mutation of in is not exposed
 		// back to the caller.
 		in.Spec.InitContainers = values
+		// Call defaulters explicitly until annotations are removed
+		for i := range in.Spec.InitContainers {
+			c := &in.Spec.InitContainers[i]
+			SetDefaults_Container(c)
+		}
 	}
 	// If there is a beta annotation, copy to alpha key.
 	// See commit log for PR #31026 for why we do this.

pkg/api/v1/defaults.go

@@ -24,6 +24,7 @@ import (
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
 		SetDefaults_PodExecOptions,
 		SetDefaults_PodAttachOptions,

pkg/api/v1/doc.go

@@ -17,6 +17,7 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/api
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 // Package v1 is the v1 version of the API.
 package v1 // import "k8s.io/kubernetes/pkg/api/v1"

pkg/apis/apps/v1alpha1/defaults.go

@@ -22,6 +22,7 @@ import (
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
 		SetDefaults_PetSet,
 	)

pkg/apis/apps/v1alpha1/doc.go

@@ -17,5 +17,6 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/apps
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/apps/v1alpha1"

pkg/apis/apps/v1alpha1/zz_generated.conversion.go

@@ -48,7 +48,6 @@ func RegisterConversions(scheme *runtime.Scheme) error {
 }
 
 func autoConvert_v1alpha1_PetSet_To_apps_PetSet(in *PetSet, out *apps.PetSet, s conversion.Scope) error {
-	SetDefaults_PetSet(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}

pkg/apis/apps/v1alpha1/zz_generated.defaults.go

+// +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 (
+	v1 "k8s.io/kubernetes/pkg/api/v1"
+	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(&PetSet{}, func(obj interface{}) { SetObjectDefaults_PetSet(obj.(*PetSet)) })
+	scheme.AddTypeDefaultingFunc(&PetSetList{}, func(obj interface{}) { SetObjectDefaults_PetSetList(obj.(*PetSetList)) })
+	return nil
+}
+
+func SetObjectDefaults_PetSet(in *PetSet) {
+	SetDefaults_PetSet(in)
+	v1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
+	for i := range in.Spec.Template.Spec.Volumes {
+		a := &in.Spec.Template.Spec.Volumes[i]
+		v1.SetDefaults_Volume(a)
+		if a.VolumeSource.Secret != nil {
+			v1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
+		}
+		if a.VolumeSource.ISCSI != nil {
+			v1.SetDefaults_ISCSIVolumeSource(a.VolumeSource.ISCSI)
+		}
+		if a.VolumeSource.RBD != nil {
+			v1.SetDefaults_RBDVolumeSource(a.VolumeSource.RBD)
+		}
+		if a.VolumeSource.DownwardAPI != nil {
+			v1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
+			for j := range a.VolumeSource.DownwardAPI.Items {
+				b := &a.VolumeSource.DownwardAPI.Items[j]
+				if b.FieldRef != nil {
+					v1.SetDefaults_ObjectFieldSelector(b.FieldRef)
+				}
+			}
+		}
+		if a.VolumeSource.ConfigMap != nil {
+			v1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
+		}
+		if a.VolumeSource.AzureDisk != nil {
+			v1.SetDefaults_AzureDiskVolumeSource(a.VolumeSource.AzureDisk)
+		}
+	}
+	for i := range in.Spec.Template.Spec.InitContainers {
+		a := &in.Spec.Template.Spec.InitContainers[i]
+		v1.SetDefaults_Container(a)
+		for j := range a.Ports {
+			b := &a.Ports[j]
+			v1.SetDefaults_ContainerPort(b)
+		}
+		for j := range a.Env {
+			b := &a.Env[j]
+			if b.ValueFrom != nil {
+				if b.ValueFrom.FieldRef != nil {
+					v1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
+				}
+			}
+		}
+		if a.LivenessProbe != nil {
+			v1.SetDefaults_Probe(a.LivenessProbe)
+			if a.LivenessProbe.Handler.HTTPGet != nil {
+				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.ReadinessProbe != nil {
+			v1.SetDefaults_Probe(a.ReadinessProbe)
+			if a.ReadinessProbe.Handler.HTTPGet != nil {
+				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.Lifecycle != nil {
+			if a.Lifecycle.PostStart != nil {
+				if a.Lifecycle.PostStart.HTTPGet != nil {
+					v1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
+				}
+			}
+			if a.Lifecycle.PreStop != nil {
+				if a.Lifecycle.PreStop.HTTPGet != nil {
+					v1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
+				}
+			}
+		}
+	}
+	for i := range in.Spec.Template.Spec.Containers {
+		a := &in.Spec.Template.Spec.Containers[i]
+		v1.SetDefaults_Container(a)
+		for j := range a.Ports {
+			b := &a.Ports[j]
+			v1.SetDefaults_ContainerPort(b)
+		}
+		for j := range a.Env {
+			b := &a.Env[j]
+			if b.ValueFrom != nil {
+				if b.ValueFrom.FieldRef != nil {
+					v1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
+				}
+			}
+		}
+		if a.LivenessProbe != nil {
+			v1.SetDefaults_Probe(a.LivenessProbe)
+			if a.LivenessProbe.Handler.HTTPGet != nil {
+				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.ReadinessProbe != nil {
+			v1.SetDefaults_Probe(a.ReadinessProbe)
+			if a.ReadinessProbe.Handler.HTTPGet != nil {
+				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.Lifecycle != nil {
+			if a.Lifecycle.PostStart != nil {
+				if a.Lifecycle.PostStart.HTTPGet != nil {
+					v1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
+				}
+			}
+			if a.Lifecycle.PreStop != nil {
+				if a.Lifecycle.PreStop.HTTPGet != nil {
+					v1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
+				}
+			}
+		}
+	}
+	for i := range in.Spec.VolumeClaimTemplates {
+		a := &in.Spec.VolumeClaimTemplates[i]
+		v1.SetDefaults_PersistentVolumeClaim(a)
+	}
+}
+
+func SetObjectDefaults_PetSetList(in *PetSetList) {
+	for i := range in.Items {
+		a := &in.Items[i]
+		SetObjectDefaults_PetSet(a)
+	}
+}

pkg/apis/authentication/v1beta1/doc.go

@@ -18,4 +18,5 @@ limitations under the License.
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/authentication
 // +groupName=authentication.k8s.io
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/authentication/v1beta1"

pkg/apis/authorization/v1beta1/doc.go

@@ -17,6 +17,7 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/authorization
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 // +groupName=authorization.k8s.io
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/authorization/v1beta1"

pkg/apis/autoscaling/v1/defaults.go

@@ -21,6 +21,7 @@ import (
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
 		SetDefaults_HorizontalPodAutoscaler,
 	)

pkg/apis/autoscaling/v1/doc.go

@@ -17,5 +17,6 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/autoscaling
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 package v1 // import "k8s.io/kubernetes/pkg/apis/autoscaling/v1"

pkg/apis/autoscaling/v1/zz_generated.conversion.go

@@ -77,7 +77,6 @@ func Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectRef
 }
 
 func autoConvert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
-	SetDefaults_HorizontalPodAutoscaler(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}

pkg/apis/autoscaling/v1/zz_generated.defaults.go

+// +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 v1
+
+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(&HorizontalPodAutoscaler{}, func(obj interface{}) { SetObjectDefaults_HorizontalPodAutoscaler(obj.(*HorizontalPodAutoscaler)) })
+	scheme.AddTypeDefaultingFunc(&HorizontalPodAutoscalerList{}, func(obj interface{}) {
+		SetObjectDefaults_HorizontalPodAutoscalerList(obj.(*HorizontalPodAutoscalerList))
+	})
+	return nil
+}
+
+func SetObjectDefaults_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler) {
+	SetDefaults_HorizontalPodAutoscaler(in)
+}
+
+func SetObjectDefaults_HorizontalPodAutoscalerList(in *HorizontalPodAutoscalerList) {
+	for i := range in.Items {
+		a := &in.Items[i]
+		SetObjectDefaults_HorizontalPodAutoscaler(a)
+	}
+}

pkg/apis/batch/v1/defaults.go

@@ -21,6 +21,7 @@ import (
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
 		SetDefaults_Job,
 	)

pkg/apis/batch/v1/doc.go

@@ -17,5 +17,6 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/batch
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 package v1 // import "k8s.io/kubernetes/pkg/apis/batch/v1"

pkg/apis/batch/v1/zz_generated.conversion.go

@@ -55,7 +55,6 @@ func RegisterConversions(scheme *runtime.Scheme) error {
 }
 
 func autoConvert_v1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
-	SetDefaults_Job(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}

pkg/apis/batch/v1/zz_generated.defaults.go

+// +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 v1
+
+import (
+	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	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(&Job{}, func(obj interface{}) { SetObjectDefaults_Job(obj.(*Job)) })
+	scheme.AddTypeDefaultingFunc(&JobList{}, func(obj interface{}) { SetObjectDefaults_JobList(obj.(*JobList)) })
+	return nil
+}
+
+func SetObjectDefaults_Job(in *Job) {
+	SetDefaults_Job(in)
+	api_v1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
+	for i := range in.Spec.Template.Spec.Volumes {
+		a := &in.Spec.Template.Spec.Volumes[i]
+		api_v1.SetDefaults_Volume(a)
+		if a.VolumeSource.Secret != nil {
+			api_v1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
+		}
+		if a.VolumeSource.ISCSI != nil {
+			api_v1.SetDefaults_ISCSIVolumeSource(a.VolumeSource.ISCSI)
+		}
+		if a.VolumeSource.RBD != nil {
+			api_v1.SetDefaults_RBDVolumeSource(a.VolumeSource.RBD)
+		}
+		if a.VolumeSource.DownwardAPI != nil {
+			api_v1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
+			for j := range a.VolumeSource.DownwardAPI.Items {
+				b := &a.VolumeSource.DownwardAPI.Items[j]
+				if b.FieldRef != nil {
+					api_v1.SetDefaults_ObjectFieldSelector(b.FieldRef)
+				}
+			}
+		}
+		if a.VolumeSource.ConfigMap != nil {
+			api_v1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
+		}
+		if a.VolumeSource.AzureDisk != nil {
+			api_v1.SetDefaults_AzureDiskVolumeSource(a.VolumeSource.AzureDisk)
+		}
+	}
+	for i := range in.Spec.Template.Spec.InitContainers {
+		a := &in.Spec.Template.Spec.InitContainers[i]
+		api_v1.SetDefaults_Container(a)
+		for j := range a.Ports {
+			b := &a.Ports[j]
+			api_v1.SetDefaults_ContainerPort(b)
+		}
+		for j := range a.Env {
+			b := &a.Env[j]
+			if b.ValueFrom != nil {
+				if b.ValueFrom.FieldRef != nil {
+					api_v1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
+				}
+			}
+		}
+		if a.LivenessProbe != nil {
+			api_v1.SetDefaults_Probe(a.LivenessProbe)
+			if a.LivenessProbe.Handler.HTTPGet != nil {
+				api_v1.SetDefaults_HTTPGetAction(a.LivenessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.ReadinessProbe != nil {
+			api_v1.SetDefaults_Probe(a.ReadinessProbe)
+			if a.ReadinessProbe.Handler.HTTPGet != nil {
+				api_v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.Lifecycle != nil {
+			if a.Lifecycle.PostStart != nil {
+				if a.Lifecycle.PostStart.HTTPGet != nil {
+					api_v1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
+				}
+			}
+			if a.Lifecycle.PreStop != nil {
+				if a.Lifecycle.PreStop.HTTPGet != nil {
+					api_v1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
+				}
+			}
+		}
+	}
+	for i := range in.Spec.Template.Spec.Containers {
+		a := &in.Spec.Template.Spec.Containers[i]
+		api_v1.SetDefaults_Container(a)
+		for j := range a.Ports {
+			b := &a.Ports[j]
+			api_v1.SetDefaults_ContainerPort(b)
+		}
+		for j := range a.Env {
+			b := &a.Env[j]
+			if b.ValueFrom != nil {
+				if b.ValueFrom.FieldRef != nil {
+					api_v1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
+				}
+			}
+		}
+		if a.LivenessProbe != nil {
+			api_v1.SetDefaults_Probe(a.LivenessProbe)
+			if a.LivenessProbe.Handler.HTTPGet != nil {
+				api_v1.SetDefaults_HTTPGetAction(a.LivenessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.ReadinessProbe != nil {
+			api_v1.SetDefaults_Probe(a.ReadinessProbe)
+			if a.ReadinessProbe.Handler.HTTPGet != nil {
+				api_v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.Handler.HTTPGet)
+			}
+		}
+		if a.Lifecycle != nil {
+			if a.Lifecycle.PostStart != nil {
+				if a.Lifecycle.PostStart.HTTPGet != nil {
+					api_v1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
+				}
+			}
+			if a.Lifecycle.PreStop != nil {
+				if a.Lifecycle.PreStop.HTTPGet != nil {
+					api_v1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
+				}
+			}
+		}
+	}
+}
+
+func SetObjectDefaults_JobList(in *JobList) {
+	for i := range in.Items {
+		a := &in.Items[i]
+		SetObjectDefaults_Job(a)
+	}
+}

pkg/apis/batch/v2alpha1/conversion.go

@@ -18,7 +18,6 @@ package v2alpha1
 
 import (
 	"fmt"
-	"reflect"
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
@@ -57,9 +56,6 @@ func addConversionFuncs(scheme *runtime.Scheme) error {
 }
 
 func Convert_batch_JobSpec_To_v2alpha1_JobSpec(in *batch.JobSpec, out *JobSpec, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*batch.JobSpec))(in)
-	}
 	out.Parallelism = in.Parallelism
 	out.Completions = in.Completions
 	out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds
@@ -86,9 +82,6 @@ func Convert_batch_JobSpec_To_v2alpha1_JobSpec(in *batch.JobSpec, out *JobSpec,
 }
 
 func Convert_v2alpha1_JobSpec_To_batch_JobSpec(in *JobSpec, out *batch.JobSpec, s conversion.Scope) error {
-	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
-		defaulting.(func(*JobSpec))(in)
-	}
 	out.Parallelism = in.Parallelism
 	out.Completions = in.Completions
 	out.ActiveDeadlineSeconds = in.ActiveDeadlineSeconds

pkg/apis/batch/v2alpha1/defaults.go

@@ -21,6 +21,7 @@ import (
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
 		SetDefaults_Job,
 		SetDefaults_ScheduledJob,

pkg/apis/batch/v2alpha1/doc.go

@@ -17,5 +17,6 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/batch
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 package v2alpha1 // import "k8s.io/kubernetes/pkg/apis/batch/v2alpha1"

pkg/apis/batch/v2alpha1/zz_generated.conversion.go

@@ -67,7 +67,6 @@ func RegisterConversions(scheme *runtime.Scheme) error {
 }
 
 func autoConvert_v2alpha1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
-	SetDefaults_Job(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -412,7 +411,6 @@ func Convert_unversioned_LabelSelectorRequirement_To_v2alpha1_LabelSelectorRequi
 }
 
 func autoConvert_v2alpha1_ScheduledJob_To_batch_ScheduledJob(in *ScheduledJob, out *batch.ScheduledJob, s conversion.Scope) error {
-	SetDefaults_ScheduledJob(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}

pkg/apis/certificates/v1alpha1/doc.go

@@ -17,6 +17,7 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/certificates
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 // +groupName=certificates.k8s.io
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/certificates/v1alpha1"

pkg/apis/componentconfig/v1alpha1/defaults.go

@@ -51,6 +51,7 @@ const (
 var zeroDuration = unversioned.Duration{}
 
 func addDefaultingFuncs(scheme *kruntime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
 		SetDefaults_KubeProxyConfiguration,
 		SetDefaults_KubeSchedulerConfiguration,

pkg/apis/componentconfig/v1alpha1/doc.go

@@ -17,5 +17,6 @@ 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"

pkg/apis/componentconfig/v1alpha1/zz_generated.conversion.go

@@ -48,7 +48,6 @@ func RegisterConversions(scheme *runtime.Scheme) error {
 }
 
 func autoConvert_v1alpha1_KubeProxyConfiguration_To_componentconfig_KubeProxyConfiguration(in *KubeProxyConfiguration, out *componentconfig.KubeProxyConfiguration, s conversion.Scope) error {
-	SetDefaults_KubeProxyConfiguration(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -109,7 +108,6 @@ func Convert_componentconfig_KubeProxyConfiguration_To_v1alpha1_KubeProxyConfigu
 }
 
 func autoConvert_v1alpha1_KubeSchedulerConfiguration_To_componentconfig_KubeSchedulerConfiguration(in *KubeSchedulerConfiguration, out *componentconfig.KubeSchedulerConfiguration, s conversion.Scope) error {
-	SetDefaults_KubeSchedulerConfiguration(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -164,7 +162,6 @@ func Convert_componentconfig_KubeSchedulerConfiguration_To_v1alpha1_KubeSchedule
 }
 
 func autoConvert_v1alpha1_KubeletConfiguration_To_componentconfig_KubeletConfiguration(in *KubeletConfiguration, out *componentconfig.KubeletConfiguration, s conversion.Scope) error {
-	SetDefaults_KubeletConfiguration(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -527,7 +524,6 @@ func Convert_componentconfig_KubeletConfiguration_To_v1alpha1_KubeletConfigurati
 }
 
 func autoConvert_v1alpha1_LeaderElectionConfiguration_To_componentconfig_LeaderElectionConfiguration(in *LeaderElectionConfiguration, out *componentconfig.LeaderElectionConfiguration, s conversion.Scope) error {
-	SetDefaults_LeaderElectionConfiguration(in)
 	if err := api.Convert_Pointer_bool_To_bool(&in.LeaderElect, &out.LeaderElect, s); err != nil {
 		return err
 	}

pkg/apis/componentconfig/v1alpha1/zz_generated.defaults.go

+// +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)
+}

pkg/apis/extensions/v1beta1/defaults.go

@@ -23,6 +23,7 @@ import (
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
 		SetDefaults_DaemonSet,
 		SetDefaults_Deployment,
@@ -71,7 +72,7 @@ func SetDefaults_Deployment(obj *Deployment) {
 	if strategy.Type == "" {
 		strategy.Type = RollingUpdateDeploymentStrategyType
 	}
-	if strategy.Type == RollingUpdateDeploymentStrategyType {
+	if strategy.Type == RollingUpdateDeploymentStrategyType || strategy.RollingUpdate != nil {
 		if strategy.RollingUpdate == nil {
 			rollingUpdate := RollingUpdateDeployment{}
 			strategy.RollingUpdate = &rollingUpdate

pkg/apis/extensions/v1beta1/doc.go

@@ -19,5 +19,6 @@ limitations under the License.
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/autoscaling
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/batch
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"

pkg/apis/extensions/v1beta1/zz_generated.conversion.go

@@ -319,7 +319,6 @@ func Convert_extensions_CustomMetricTargetList_To_v1beta1_CustomMetricTargetList
 }
 
 func autoConvert_v1beta1_DaemonSet_To_extensions_DaemonSet(in *DaemonSet, out *extensions.DaemonSet, s conversion.Scope) error {
-	SetDefaults_DaemonSet(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -476,7 +475,6 @@ func Convert_extensions_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in *extension
 }
 
 func autoConvert_v1beta1_Deployment_To_extensions_Deployment(in *Deployment, out *extensions.Deployment, s conversion.Scope) error {
-	SetDefaults_Deployment(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -851,7 +849,6 @@ func Convert_extensions_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in
 }
 
 func autoConvert_v1beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
-	SetDefaults_HorizontalPodAutoscaler(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -1322,7 +1319,6 @@ func Convert_extensions_IngressTLS_To_v1beta1_IngressTLS(in *extensions.IngressT
 }
 
 func autoConvert_v1beta1_Job_To_batch_Job(in *Job, out *batch.Job, s conversion.Scope) error {
-	SetDefaults_Job(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -1601,7 +1597,6 @@ func Convert_unversioned_LabelSelectorRequirement_To_v1beta1_LabelSelectorRequir
 }
 
 func autoConvert_v1beta1_NetworkPolicy_To_extensions_NetworkPolicy(in *NetworkPolicy, out *extensions.NetworkPolicy, s conversion.Scope) error {
-	SetDefaults_NetworkPolicy(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}
@@ -2106,7 +2101,6 @@ func Convert_extensions_PodSecurityPolicySpec_To_v1beta1_PodSecurityPolicySpec(i
 }
 
 func autoConvert_v1beta1_ReplicaSet_To_extensions_ReplicaSet(in *ReplicaSet, out *extensions.ReplicaSet, s conversion.Scope) error {
-	SetDefaults_ReplicaSet(in)
 	if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil {
 		return err
 	}

pkg/apis/imagepolicy/v1alpha1/doc.go

@@ -17,6 +17,7 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/imagepolicy
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 // +groupName=imagepolicy.k8s.io
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/imagepolicy/v1alpha1"

pkg/apis/policy/v1alpha1/doc.go

@@ -16,6 +16,7 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/policy
+// +k8s:defaulter-gen=TypeMeta
 
 // Package policy is for any kind of policy object.  Suitable examples, even if
 // they aren't all here, are PodDisruptionBudget, PodSecurityPolicy,

pkg/apis/rbac/v1alpha1/defaults.go

@@ -21,16 +21,20 @@ import (
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	RegisterDefaults(scheme)
 	return scheme.AddDefaultingFuncs(
-		func(obj *ClusterRoleBinding) {
-			if len(obj.RoleRef.APIGroup) == 0 {
-				obj.RoleRef.APIGroup = GroupName
-			}
-		},
-		func(obj *RoleBinding) {
-			if len(obj.RoleRef.APIGroup) == 0 {
-				obj.RoleRef.APIGroup = GroupName
-			}
-		},
+		SetDefaults_ClusterRoleBinding,
+		SetDefaults_RoleBinding,
 	)
 }
+
+func SetDefaults_ClusterRoleBinding(obj *ClusterRoleBinding) {
+	if len(obj.RoleRef.APIGroup) == 0 {
+		obj.RoleRef.APIGroup = GroupName
+	}
+}
+func SetDefaults_RoleBinding(obj *RoleBinding) {
+	if len(obj.RoleRef.APIGroup) == 0 {
+		obj.RoleRef.APIGroup = GroupName
+	}
+}

pkg/apis/rbac/v1alpha1/doc.go

@@ -17,6 +17,7 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/rbac
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 
 // +groupName=rbac.authorization.k8s.io
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/rbac/v1alpha1"

pkg/apis/rbac/v1alpha1/zz_generated.defaults.go

+// +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(&ClusterRoleBinding{}, func(obj interface{}) { SetObjectDefaults_ClusterRoleBinding(obj.(*ClusterRoleBinding)) })
+	scheme.AddTypeDefaultingFunc(&ClusterRoleBindingList{}, func(obj interface{}) { SetObjectDefaults_ClusterRoleBindingList(obj.(*ClusterRoleBindingList)) })
+	scheme.AddTypeDefaultingFunc(&RoleBinding{}, func(obj interface{}) { SetObjectDefaults_RoleBinding(obj.(*RoleBinding)) })
+	scheme.AddTypeDefaultingFunc(&RoleBindingList{}, func(obj interface{}) { SetObjectDefaults_RoleBindingList(obj.(*RoleBindingList)) })
+	return nil
+}
+
+func SetObjectDefaults_ClusterRoleBinding(in *ClusterRoleBinding) {
+	SetDefaults_ClusterRoleBinding(in)
+}
+
+func SetObjectDefaults_ClusterRoleBindingList(in *ClusterRoleBindingList) {
+	for i := range in.Items {
+		a := &in.Items[i]
+		SetObjectDefaults_ClusterRoleBinding(a)
+	}
+}
+
+func SetObjectDefaults_RoleBinding(in *RoleBinding) {
+	SetDefaults_RoleBinding(in)
+}
+
+func SetObjectDefaults_RoleBindingList(in *RoleBindingList) {
+	for i := range in.Items {
+		a := &in.Items[i]
+		SetObjectDefaults_RoleBinding(a)
+	}
+}

pkg/apis/storage/v1beta1/doc.go

@@ -18,4 +18,5 @@ limitations under the License.
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/storage
 // +groupName=storage.k8s.io
 // +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/storage/v1beta1"

pkg/client/unversioned/clientcmd/api/latest/latest.go

@@ -56,7 +56,7 @@ func init() {
 		panic(err)
 	}
 	yamlSerializer := json.NewYAMLSerializer(json.DefaultMetaFactory, Scheme, Scheme)
-	Codec = versioning.NewCodecForScheme(
+	Codec = versioning.NewDefaultingCodecForScheme(
 		Scheme,
 		yamlSerializer,
 		yamlSerializer,

pkg/conversion/converter.go

@@ -431,10 +431,10 @@ func (c *Converter) SetStructFieldCopy(srcFieldType interface{}, srcFieldName st
 }
 
 // RegisterDefaultingFunc registers a value-defaulting func with the Converter.
-// defaultingFunc must take one parameters: a pointer to the input type.
+// defaultingFunc must take one parameter: a pointer to the input type.
 //
 // Example:
-// c.RegisteDefaultingFunc(
+// c.RegisterDefaultingFunc(
 //         func(in *v1.Pod) {
 //                 // defaulting logic...
 //          })

pkg/kubemark/hollow_kubelet.go

@@ -103,6 +103,7 @@ func GetHollowKubeletConfig(
 	// Do the external -> internal conversion to make sure that defaults
 	// are set for fields not overridden in NewHollowKubelet.
 	tmp := &v1alpha1.KubeletConfiguration{}
+	api.Scheme.Default(tmp)
 	c := &componentconfig.KubeletConfiguration{}
 	api.Scheme.Convert(tmp, c, nil)
 

pkg/runtime/codec.go

@@ -76,6 +76,24 @@ func EncodeOrDie(e Encoder, obj Object) string {
 	return string(bytes)
 }
 
+// DefaultingSerializer invokes defaulting after decoding.
+type DefaultingSerializer struct {
+	Defaulter ObjectDefaulter
+	Decoder   Decoder
+	// Encoder is optional to allow this type to be used as both a Decoder and an Encoder
+	Encoder
+}
+
+// Decode performs a decode and then allows the defaulter to act on the provided object.
+func (d DefaultingSerializer) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, into Object) (Object, *unversioned.GroupVersionKind, error) {
+	obj, gvk, err := d.Decoder.Decode(data, defaultGVK, into)
+	if err != nil {
+		return obj, gvk, err
+	}
+	d.Defaulter.Default(obj)
+	return obj, gvk, nil
+}
+
 // UseOrCreateObject returns obj if the canonical ObjectKind returned by the provided typer matches gvk, or
 // invokes the ObjectCreator to instantiate a new gvk. Returns an error if the typer cannot find the object.
 func UseOrCreateObject(t ObjectTyper, c ObjectCreater, gvk unversioned.GroupVersionKind, obj Object) (Object, error) {

pkg/runtime/interfaces.go

@@ -169,6 +169,12 @@ type NestedObjectDecoder interface {
 ///////////////////////////////////////////////////////////////////////////////
 // Non-codec interfaces
 
+type ObjectDefaulter interface {
+	// Default takes an object (must be a pointer) and applies any default values.
+	// Defaulters may not error.
+	Default(in Object)
+}
+
 type ObjectVersioner interface {
 	ConvertToVersion(in Object, gv GroupVersioner) (out Object, err error)
 }

pkg/runtime/scheme.go

@@ -61,6 +61,10 @@ type Scheme struct {
 	// resource field labels in that version to internal version.
 	fieldLabelConversionFuncs map[string]map[string]FieldLabelConversionFunc
 
+	// defaulterFuncs is an array of interfaces to be called with an object to provide defaulting
+	// the provided object must be a pointer.
+	defaulterFuncs map[reflect.Type]func(interface{})
+
 	// converter stores all registered conversion functions. It also has
 	// default coverting behavior.
 	converter *conversion.Converter
@@ -82,6 +86,7 @@ func NewScheme() *Scheme {
 		unversionedKinds: map[string]reflect.Type{},
 		cloner:           conversion.NewCloner(),
 		fieldLabelConversionFuncs: map[string]map[string]FieldLabelConversionFunc{},
+		defaulterFuncs:            map[reflect.Type]func(interface{}){},
 	}
 	s.converter = conversion.NewConverter(s.nameFunc)
 
@@ -421,6 +426,22 @@ func (s *Scheme) AddDefaultingFuncs(defaultingFuncs ...interface{}) error {
 	return nil
 }
 
+// AddTypeDefaultingFuncs registers a function that is passed a pointer to an
+// object and can default fields on the object. These functions will be invoked
+// when Default() is called. The function will never be called unless the
+// defaulted object matches srcType. If this function is invoked twice with the
+// same srcType, the fn passed to the later call will be used instead.
+func (s *Scheme) AddTypeDefaultingFunc(srcType Object, fn func(interface{})) {
+	s.defaulterFuncs[reflect.TypeOf(srcType)] = fn
+}
+
+// Default sets defaults on the provided Object.
+func (s *Scheme) Default(src Object) {
+	if fn, ok := s.defaulterFuncs[reflect.TypeOf(src)]; ok {
+		fn(src)
+	}
+}
+
 // Copy does a deep copy of an API object.
 func (s *Scheme) Copy(src Object) (Object, error) {
 	dst, err := s.DeepCopy(src)

pkg/runtime/serializer/codec_factory.go

@@ -196,7 +196,7 @@ func (f CodecFactory) SupportedStreamingMediaTypes() []string {
 // TODO: make this call exist only in pkg/api, and initialize it with the set of default versions.
 //   All other callers will be forced to request a Codec directly.
 func (f CodecFactory) LegacyCodec(version ...unversioned.GroupVersion) runtime.Codec {
-	return versioning.NewCodecForScheme(f.scheme, f.legacySerializer, f.universal, unversioned.GroupVersions(version), runtime.InternalGroupVersioner)
+	return versioning.NewDefaultingCodecForScheme(f.scheme, f.legacySerializer, f.universal, unversioned.GroupVersions(version), runtime.InternalGroupVersioner)
 }
 
 // UniversalDeserializer can convert any stored data recognized by this factory into a Go object that satisfies
@@ -235,7 +235,7 @@ func (f CodecFactory) CodecForVersions(encoder runtime.Encoder, decoder runtime.
 	if decode == nil {
 		decode = runtime.InternalGroupVersioner
 	}
-	return versioning.NewCodecForScheme(f.scheme, encoder, decoder, encode, decode)
+	return versioning.NewDefaultingCodecForScheme(f.scheme, encoder, decoder, encode, decode)
 }
 
 // DecoderToVersion returns a decoder that targets the provided group version.

pkg/runtime/serializer/versioning/versioning.go

@@ -21,6 +21,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
+	utilruntime "k8s.io/kubernetes/pkg/util/runtime"
 )
 
 // NewCodecForScheme is a convenience method for callers that are using a scheme.
@@ -32,7 +33,19 @@ func NewCodecForScheme(
 	encodeVersion runtime.GroupVersioner,
 	decodeVersion runtime.GroupVersioner,
 ) runtime.Codec {
-	return NewCodec(encoder, decoder, runtime.UnsafeObjectConvertor(scheme), scheme, scheme, scheme, encodeVersion, decodeVersion)
+	return NewCodec(encoder, decoder, runtime.UnsafeObjectConvertor(scheme), scheme, scheme, scheme, nil, encodeVersion, decodeVersion)
+}
+
+// NewDefaultingCodecForScheme is a convenience method for callers that are using a scheme.
+func NewDefaultingCodecForScheme(
+	// TODO: I should be a scheme interface?
+	scheme *runtime.Scheme,
+	encoder runtime.Encoder,
+	decoder runtime.Decoder,
+	encodeVersion runtime.GroupVersioner,
+	decodeVersion runtime.GroupVersioner,
+) runtime.Codec {
+	return NewCodec(encoder, decoder, runtime.UnsafeObjectConvertor(scheme), scheme, scheme, scheme, scheme, encodeVersion, decodeVersion)
 }
 
 // NewCodec takes objects in their internal versions and converts them to external versions before
@@ -45,6 +58,7 @@ func NewCodec(
 	creater runtime.ObjectCreater,
 	copier runtime.ObjectCopier,
 	typer runtime.ObjectTyper,
+	defaulter runtime.ObjectDefaulter,
 	encodeVersion runtime.GroupVersioner,
 	decodeVersion runtime.GroupVersioner,
 ) runtime.Codec {
@@ -55,6 +69,7 @@ func NewCodec(
 		creater:   creater,
 		copier:    copier,
 		typer:     typer,
+		defaulter: defaulter,
 
 		encodeVersion: encodeVersion,
 		decodeVersion: decodeVersion,
@@ -69,6 +84,7 @@ type codec struct {
 	creater   runtime.ObjectCreater
 	copier    runtime.ObjectCopier
 	typer     runtime.ObjectTyper
+	defaulter runtime.ObjectDefaulter
 
 	encodeVersion runtime.GroupVersioner
 	decodeVersion runtime.GroupVersioner
@@ -102,11 +118,31 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
 			}
 			return into, gvk, nil
 		}
+
+		// perform defaulting if requested
+		if c.defaulter != nil {
+			// create a copy to ensure defaulting is not applied to the original versioned objects
+			if isVersioned {
+				copied, err := c.copier.Copy(obj)
+				if err != nil {
+					utilruntime.HandleError(err)
+					copied = obj
+				}
+				versioned.Objects = []runtime.Object{copied}
+			}
+			c.defaulter.Default(obj)
+		} else {
+			if isVersioned {
+				versioned.Objects = []runtime.Object{obj}
+			}
+		}
+
 		if err := c.convertor.Convert(obj, into, c.decodeVersion); err != nil {
 			return nil, gvk, err
 		}
+
 		if isVersioned {
-			versioned.Objects = []runtime.Object{obj, into}
+			versioned.Objects = append(versioned.Objects, into)
 			return versioned, gvk, nil
 		}
 		return into, gvk, nil
@@ -117,10 +153,17 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
 		// create a copy, because ConvertToVersion does not guarantee non-mutation of objects
 		copied, err := c.copier.Copy(obj)
 		if err != nil {
+			utilruntime.HandleError(err)
 			copied = obj
 		}
 		versioned.Objects = []runtime.Object{copied}
 	}
+
+	// perform defaulting if requested
+	if c.defaulter != nil {
+		c.defaulter.Default(obj)
+	}
+
 	out, err := c.convertor.ConvertToVersion(obj, c.decodeVersion)
 	if err != nil {
 		return nil, gvk, err

pkg/runtime/serializer/versioning/versioning_test.go

@@ -64,7 +64,7 @@ func (d *testNestedDecodable) DecodeNestedObjects(_ runtime.Decoder) error {
 func TestNestedDecode(t *testing.T) {
 	n := &testNestedDecodable{nestedErr: fmt.Errorf("unable to decode")}
 	decoder := &mockSerializer{obj: n}
-	codec := NewCodec(nil, decoder, nil, nil, nil, nil, nil, nil)
+	codec := NewCodec(nil, decoder, nil, nil, nil, nil, nil, nil, nil)
 	if _, _, err := codec.Decode([]byte(`{}`), nil, n); err != n.nestedErr {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -82,6 +82,7 @@ func TestNestedEncode(t *testing.T) {
 		&checkConvertor{obj: n2, groupVersion: unversioned.GroupVersion{Group: "other"}},
 		nil, nil,
 		&mockTyper{gvks: []unversioned.GroupVersionKind{{Kind: "test"}}},
+		nil,
 		unversioned.GroupVersion{Group: "other"}, nil,
 	)
 	if err := codec.Encode(n, ioutil.Discard); err != n2.nestedErr {
@@ -105,6 +106,7 @@ func TestDecode(t *testing.T) {
 		creater    runtime.ObjectCreater
 		copier     runtime.ObjectCopier
 		typer      runtime.ObjectTyper
+		defaulter  runtime.ObjectDefaulter
 		yaml       bool
 		pretty     bool
 
@@ -235,7 +237,7 @@ func TestDecode(t *testing.T) {
 
 	for i, test := range testCases {
 		t.Logf("%d", i)
-		s := NewCodec(test.serializer, test.serializer, test.convertor, test.creater, test.copier, test.typer, test.encodes, test.decodes)
+		s := NewCodec(test.serializer, test.serializer, test.convertor, test.creater, test.copier, test.typer, test.defaulter, test.encodes, test.decodes)
 		obj, gvk, err := s.Decode([]byte(`{}`), test.defaultGVK, test.into)
 
 		if !reflect.DeepEqual(test.expectedGVK, gvk) {

plugin/cmd/kube-scheduler/app/options/options.go

@@ -42,8 +42,10 @@ type SchedulerServer struct {
 
 // NewSchedulerServer creates a new SchedulerServer with default parameters
 func NewSchedulerServer() *SchedulerServer {
+	versioned := &v1alpha1.KubeSchedulerConfiguration{}
+	api.Scheme.Default(versioned)
 	cfg := componentconfig.KubeSchedulerConfiguration{}
-	api.Scheme.Convert(&v1alpha1.KubeSchedulerConfiguration{}, &cfg, nil)
+	api.Scheme.Convert(versioned, &cfg, nil)
 	cfg.LeaderElection.LeaderElect = true
 	s := SchedulerServer{
 		KubeSchedulerConfiguration: cfg,

plugin/pkg/scheduler/api/latest/latest.go

@@ -43,7 +43,7 @@ var Codec runtime.Codec
 
 func init() {
 	jsonSerializer := json.NewSerializer(json.DefaultMetaFactory, api.Scheme, api.Scheme, true)
-	Codec = versioning.NewCodecForScheme(
+	Codec = versioning.NewDefaultingCodecForScheme(
 		api.Scheme,
 		jsonSerializer,
 		jsonSerializer,

test/e2e_node/dynamic_kubelet_configuration_test.go

@@ -142,6 +142,8 @@ func decodeConfigz(resp *http.Response) (*componentconfig.KubeletConfiguration,
 		return nil, err
 	}
 
+	api.Scheme.Default(&configz.ComponentConfig)
+
 	err = api.Scheme.Convert(&configz.ComponentConfig, &kubeCfg, nil)
 	if err != nil {
 		return nil, err

test/integration/framework/serializer.go

@@ -58,9 +58,9 @@ func (s *wrappedSerializer) UniversalDeserializer() runtime.Decoder {
 }
 
 func (s *wrappedSerializer) EncoderForVersion(encoder runtime.Encoder, gv runtime.GroupVersioner) runtime.Encoder {
-	return versioning.NewCodec(encoder, nil, s.scheme, s.scheme, s.scheme, s.scheme, gv, nil)
+	return versioning.NewCodec(encoder, nil, s.scheme, s.scheme, s.scheme, s.scheme, s.scheme, gv, nil)
 }
 
 func (s *wrappedSerializer) DecoderToVersion(decoder runtime.Decoder, gv runtime.GroupVersioner) runtime.Decoder {
-	return versioning.NewCodec(nil, decoder, s.scheme, s.scheme, s.scheme, s.scheme, nil, gv)
+	return versioning.NewCodec(nil, decoder, s.scheme, s.scheme, s.scheme, s.scheme, s.scheme, nil, gv)
 }