change preempting to PreemptionPolicy

pkg/apis/scheduling/BUILD

@@ -9,7 +9,6 @@ load(
 go_library(
     name = "go_default_library",
     srcs = [
-        "annotations.go",
         "doc.go",
         "helpers.go",
         "register.go",
@@ -18,6 +17,7 @@ go_library(
     ],
     importpath = "k8s.io/kubernetes/pkg/apis/scheduling",
     deps = [
+        "//pkg/apis/core:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
@@ -37,6 +37,7 @@ filegroup(
         ":package-srcs",
         "//pkg/apis/scheduling/fuzzer:all-srcs",
         "//pkg/apis/scheduling/install:all-srcs",
+        "//pkg/apis/scheduling/util:all-srcs",
         "//pkg/apis/scheduling/v1:all-srcs",
         "//pkg/apis/scheduling/v1alpha1:all-srcs",
         "//pkg/apis/scheduling/v1beta1:all-srcs",

pkg/apis/scheduling/annotations.go

@@ -1,21 +0,0 @@
-/*
-Copyright 2019 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 scheduling
-
-// PreemptingAnnotation is the annotation which holds preempting
-// when converting the `Preempting` field from scheduling/v1
-const PreemptingAnnotation = "scheduling.k8s.io/preempting"

pkg/apis/scheduling/fuzzer/BUILD

@@ -10,8 +10,11 @@ go_library(
     srcs = ["fuzzer.go"],
     importpath = "k8s.io/kubernetes/pkg/apis/scheduling/fuzzer",
     deps = [
+        "//pkg/apis/core:go_default_library",
         "//pkg/apis/scheduling:go_default_library",
+        "//pkg/features:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
         "//vendor/github.com/google/gofuzz:go_default_library",
     ],
 )

pkg/apis/scheduling/fuzzer/fuzzer.go

@@ -19,7 +19,10 @@ package fuzzer
 import (
 	"github.com/google/gofuzz"
 	runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/apis/core"
 	"k8s.io/kubernetes/pkg/apis/scheduling"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 // Funcs returns the fuzzer functions for the scheduling api group.
@@ -27,9 +30,9 @@ var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
 	return []interface{}{
 		func(s *scheduling.PriorityClass, c fuzz.Continue) {
 			c.FuzzNoCustom(s)
-			if s.Preempting == nil {
-				preempting := scheduling.DefaultPreempting
-				s.Preempting = &preempting
+			if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && s.PreemptionPolicy == nil {
+				preemptLowerPriority := core.PreemptLowerPriority
+				s.PreemptionPolicy = &preemptLowerPriority
 			}
 		},
 	}

pkg/apis/scheduling/types.go

@@ -16,7 +16,10 @@ limitations under the License.
 
 package scheduling
 
-import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/apis/core"
+)
 
 const (
 	// DefaultPriorityWhenNoDefaultClassExists is used to set priority of pods
@@ -36,8 +39,6 @@ const (
 	SystemClusterCritical = SystemPriorityClassPrefix + "cluster-critical"
 	// SystemNodeCritical is the system priority class name that represents node-critical.
 	SystemNodeCritical = SystemPriorityClassPrefix + "node-critical"
-	// The default value for preempting attribute.
-	DefaultPreempting = true
 )
 
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
@@ -67,10 +68,10 @@ type PriorityClass struct {
 	// +optional
 	Description string
 
-	// Preempting specifies whether a pod with this PriorityClass could start a preemption process.
-	// If this field is missing, the PriorityClass is considered a preempting class by default.
+	// PreemptionPolicy it the Policy for preempting pods with lower priority.
+	// This field is alpha-level and is only honored by servers that enable the NonPreemptingPriority feature.
 	// +optional
-	Preempting *bool
+	PreemptionPolicy *core.PreemptionPolicy
 }
 
 // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

pkg/apis/scheduling/util/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["util.go"],
+    importpath = "k8s.io/kubernetes/pkg/apis/scheduling/util",
+    deps = [
+        "//pkg/apis/scheduling:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/scheduling:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
+    ],
+)

pkg/apis/scheduling/util/util.go

@@ -0,0 +1,40 @@
+/*
+Copyright 2019 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 util
+
+import (
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/apis/scheduling"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+// DropDisabledFields removes disabled fields from the PriorityClass object.
+func DropDisabledFields(class, oldClass *scheduling.PriorityClass) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && !preemptingPriorityInUse(oldClass) {
+		class.PreemptionPolicy = nil
+	}
+}
+
+func preemptingPriorityInUse(oldClass *scheduling.PriorityClass) bool {
+	if oldClass == nil {
+		return false
+	}
+	if oldClass.PreemptionPolicy != nil {
+		return true
+	}
+	return false
+}

pkg/apis/scheduling/util/util_test.go

@@ -0,0 +1,109 @@
+/*
+Copyright 2019 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 util
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/util/diff"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	featuregatetesting "k8s.io/component-base/featuregate/testing"
+	"k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/apis/scheduling"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func TestDropNonPreemptingPriority(t *testing.T) {
+	pcWithoutNonPreemptingPriority := func() *scheduling.PriorityClass {
+		return &scheduling.PriorityClass{}
+	}
+	pcWithNonPreemptingPriority := func() *scheduling.PriorityClass {
+		preemptionPolicy := core.PreemptNever
+		return &scheduling.PriorityClass{
+			PreemptionPolicy: &preemptionPolicy,
+		}
+	}
+
+	pcInfo := []struct {
+		description              string
+		hasNonPreemptingPriority bool
+		pc                       func() *scheduling.PriorityClass
+	}{
+		{
+			description:              "PriorityClass Without NonPreemptingPriority",
+			hasNonPreemptingPriority: false,
+			pc:                       pcWithoutNonPreemptingPriority,
+		},
+		{
+			description:              "PriorityClass With NonPreemptingPriority",
+			hasNonPreemptingPriority: true,
+			pc:                       pcWithNonPreemptingPriority,
+		},
+		{
+			description:              "is nil",
+			hasNonPreemptingPriority: false,
+			pc:                       func() *scheduling.PriorityClass { return nil },
+		},
+	}
+
+	for _, enabled := range []bool{true, false} {
+		for _, oldPriorityClassInfo := range pcInfo {
+			for _, newPriorityClassInfo := range pcInfo {
+				oldPriorityClassHasNonPreemptingPriority, oldPriorityClass := oldPriorityClassInfo.hasNonPreemptingPriority, oldPriorityClassInfo.pc()
+				newPriorityClassHasNonPreemptingPriority, newPriorityClass := newPriorityClassInfo.hasNonPreemptingPriority, newPriorityClassInfo.pc()
+				if newPriorityClass == nil {
+					continue
+				}
+
+				t.Run(fmt.Sprintf("feature enabled=%v, old PriorityClass %v, new PriorityClass %v", enabled, oldPriorityClassInfo.description, newPriorityClassInfo.description), func(t *testing.T) {
+					defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, enabled)()
+
+					DropDisabledFields(newPriorityClass, oldPriorityClass)
+
+					// old PriorityClass should never be changed
+					if !reflect.DeepEqual(oldPriorityClass, oldPriorityClassInfo.pc()) {
+						t.Errorf("old PriorityClass changed: %v", diff.ObjectReflectDiff(oldPriorityClass, oldPriorityClassInfo.pc()))
+					}
+
+					switch {
+					case enabled || oldPriorityClassHasNonPreemptingPriority:
+						// new PriorityClass should not be changed if the feature is enabled, or if the old PriorityClass had NonPreemptingPriority
+						if !reflect.DeepEqual(newPriorityClass, newPriorityClassInfo.pc()) {
+							t.Errorf("new PriorityClass changed: %v", diff.ObjectReflectDiff(newPriorityClass, newPriorityClassInfo.pc()))
+						}
+					case newPriorityClassHasNonPreemptingPriority:
+						// new PriorityClass should be changed
+						if reflect.DeepEqual(newPriorityClass, newPriorityClassInfo.pc()) {
+							t.Errorf("new PriorityClass was not changed")
+						}
+						// new PriorityClass should not have NonPreemptingPriority
+						if !reflect.DeepEqual(newPriorityClass, pcWithoutNonPreemptingPriority()) {
+							t.Errorf("new PriorityClass had PriorityClassNonPreemptingPriority: %v", diff.ObjectReflectDiff(newPriorityClass, pcWithoutNonPreemptingPriority()))
+						}
+					default:
+						// new PriorityClass should not need to be changed
+						if !reflect.DeepEqual(newPriorityClass, newPriorityClassInfo.pc()) {
+							t.Errorf("new PriorityClass changed: %v", diff.ObjectReflectDiff(newPriorityClass, newPriorityClassInfo.pc()))
+						}
+					}
+				})
+			}
+		}
+	}
+}

pkg/apis/scheduling/v1/BUILD

@@ -12,11 +12,15 @@ go_library(
     importpath = "k8s.io/kubernetes/pkg/apis/scheduling/v1",
     visibility = ["//visibility:public"],
     deps = [
+        "//pkg/apis/core:go_default_library",
         "//pkg/apis/scheduling:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/api/scheduling/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
     ],
 )
 
@@ -41,8 +45,11 @@ go_test(
     deps = [
         "//pkg/api/legacyscheme:go_default_library",
         "//pkg/api/testapi:go_default_library",
-        "//pkg/apis/scheduling:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/api/scheduling/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
     ],
 )

pkg/apis/scheduling/v1/defaults.go

@@ -17,9 +17,11 @@ limitations under the License.
 package v1
 
 import (
+	apiv1 "k8s.io/api/core/v1"
 	"k8s.io/api/scheduling/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/kubernetes/pkg/apis/scheduling"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
@@ -29,9 +31,8 @@ func addDefaultingFuncs(scheme *runtime.Scheme) error {
 // SetDefaults_PriorityClass sets additional defaults compared to its counterpart
 // in extensions.
 func SetDefaults_PriorityClass(obj *v1.PriorityClass) {
-	if obj.Preempting == nil {
-		// Set Preempting as true by default.
-		Preempting := scheduling.DefaultPreempting
-		obj.Preempting = &Preempting
+	if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && obj.PreemptionPolicy == nil {
+		preemptLowerPriority := apiv1.PreemptLowerPriority
+		obj.PreemptionPolicy = &preemptLowerPriority
 	}
 }

pkg/apis/scheduling/v1/defaults_test.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2015 The Kubernetes Authors.
+Copyright 2019 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.
@@ -24,9 +24,12 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 
+	apiv1 "k8s.io/api/core/v1"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	// enforce that all types are installed
 	_ "k8s.io/kubernetes/pkg/api/testapi"
-	"k8s.io/kubernetes/pkg/apis/scheduling"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {
@@ -50,10 +53,14 @@ func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {
 	return obj3
 }
 
-func TestSetDefaultPreempting(t *testing.T) {
+func TestSetDefaultPreemptionPolicy(t *testing.T) {
 	priorityClass := &v1.PriorityClass{}
+
+	// set NonPreemptingPriority true
+	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, true)()
+
 	output := roundTrip(t, runtime.Object(priorityClass)).(*v1.PriorityClass)
-	if output.Preempting == nil || *output.Preempting != scheduling.DefaultPreempting {
-		t.Errorf("Expected enableServiceLinks value: %+v\ngot: %+v\n", scheduling.DefaultPreempting, *output.Preempting)
+	if output.PreemptionPolicy == nil || *output.PreemptionPolicy != apiv1.PreemptLowerPriority {
+		t.Errorf("Expected PriorityClass.PreemptionPolicy value: %+v\ngot: %+v\n", apiv1.PreemptLowerPriority, output.PreemptionPolicy)
 	}
 }

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

@@ -23,9 +23,11 @@ package v1
 import (
 	unsafe "unsafe"
 
+	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/api/scheduling/v1"
 	conversion "k8s.io/apimachinery/pkg/conversion"
 	runtime "k8s.io/apimachinery/pkg/runtime"
+	core "k8s.io/kubernetes/pkg/apis/core"
 	scheduling "k8s.io/kubernetes/pkg/apis/scheduling"
 )
 
@@ -64,7 +66,7 @@ func autoConvert_v1_PriorityClass_To_scheduling_PriorityClass(in *v1.PriorityCla
 	out.Value = in.Value
 	out.GlobalDefault = in.GlobalDefault
 	out.Description = in.Description
-	out.Preempting = (*bool)(unsafe.Pointer(in.Preempting))
+	out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
 	return nil
 }
 
@@ -78,7 +80,7 @@ func autoConvert_scheduling_PriorityClass_To_v1_PriorityClass(in *scheduling.Pri
 	out.Value = in.Value
 	out.GlobalDefault = in.GlobalDefault
 	out.Description = in.Description
-	out.Preempting = (*bool)(unsafe.Pointer(in.Preempting))
+	out.PreemptionPolicy = (*corev1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
 	return nil
 }
 

pkg/apis/scheduling/v1alpha1/BUILD

@@ -1,14 +1,11 @@
 package(default_visibility = ["//visibility:public"])
 
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-)
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
     srcs = [
-        "conversion.go",
+        "defaults.go",
         "doc.go",
         "register.go",
         "zz_generated.conversion.go",
@@ -16,11 +13,15 @@ go_library(
     ],
     importpath = "k8s.io/kubernetes/pkg/apis/scheduling/v1alpha1",
     deps = [
+        "//pkg/apis/core:go_default_library",
         "//pkg/apis/scheduling:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/api/scheduling/v1alpha1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
     ],
 )
 
@@ -36,3 +37,19 @@ filegroup(
     srcs = [":package-srcs"],
     tags = ["automanaged"],
 )
+
+go_test(
+    name = "go_default_test",
+    srcs = ["defaults_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/api/scheduling/v1alpha1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
+    ],
+)

pkg/apis/scheduling/v1alpha1/conversion.go

@@ -1,70 +0,0 @@
-/*
-Copyright 2019 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/api/scheduling/v1alpha1"
-	"k8s.io/apimachinery/pkg/conversion"
-	"k8s.io/kubernetes/pkg/apis/scheduling"
-	"strconv"
-)
-
-func Convert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(in *scheduling.PriorityClass, out *v1alpha1.PriorityClass, s conversion.Scope) error {
-	if err := autoConvert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(in, out, s); err != nil {
-		return err
-	}
-	out.ObjectMeta.Annotations = deepCopyStringMap(out.Annotations)
-
-	if in.Preempting != nil {
-		if out.ObjectMeta.Annotations == nil {
-			out.ObjectMeta.Annotations = make(map[string]string)
-		}
-		out.ObjectMeta.Annotations[scheduling.PreemptingAnnotation] = strconv.FormatBool(*(in.Preempting))
-	}
-	return nil
-}
-
-func Convert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(in *v1alpha1.PriorityClass, out *scheduling.PriorityClass, s conversion.Scope) error {
-	if err := autoConvert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(in, out, s); err != nil {
-		return err
-	}
-	out.ObjectMeta.Annotations = deepCopyStringMap(out.Annotations)
-
-	if in.ObjectMeta.Annotations != nil {
-		if _, ok := in.ObjectMeta.Annotations[scheduling.PreemptingAnnotation]; ok {
-			preempting, err := strconv.ParseBool(in.ObjectMeta.Annotations[scheduling.PreemptingAnnotation])
-			if err != nil {
-				return err
-			}
-			out.Preempting = &preempting
-			delete(out.ObjectMeta.Annotations, scheduling.PreemptingAnnotation)
-		}
-	} else {
-		preempting := scheduling.DefaultPreempting
-		out.Preempting = &preempting
-	}
-
-	return nil
-}
-
-func deepCopyStringMap(m map[string]string) map[string]string {
-	ret := make(map[string]string, len(m))
-	for k, v := range m {
-		ret[k] = v
-	}
-	return ret
-}

pkg/apis/scheduling/v1alpha1/defaults.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2019 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 (
+	apiv1 "k8s.io/api/core/v1"
+	"k8s.io/api/scheduling/v1alpha1"
+	"k8s.io/apimachinery/pkg/runtime"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	return RegisterDefaults(scheme)
+}
+
+// SetDefaults_PriorityClass sets additional defaults compared to its counterpart
+// in extensions.
+func SetDefaults_PriorityClass(obj *v1alpha1.PriorityClass) {
+	if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && obj.PreemptionPolicy == nil {
+		preemptLowerPriority := apiv1.PreemptLowerPriority
+		obj.PreemptionPolicy = &preemptLowerPriority
+	}
+}

pkg/apis/scheduling/v1alpha1/defaults_test.go

@@ -0,0 +1,66 @@
+/*
+Copyright 2019 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_test
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/scheduling/v1alpha1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+
+	apiv1 "k8s.io/api/core/v1"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	featuregatetesting "k8s.io/component-base/featuregate/testing"
+	// enforce that all types are installed
+	_ "k8s.io/kubernetes/pkg/api/testapi"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {
+	codec := legacyscheme.Codecs.LegacyCodec(v1alpha1.SchemeGroupVersion)
+	data, err := runtime.Encode(codec, obj)
+	if err != nil {
+		t.Errorf("%v\n %#v", err, obj)
+		return nil
+	}
+	obj2, err := runtime.Decode(codec, data)
+	if err != nil {
+		t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj)
+		return nil
+	}
+	obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object)
+	err = legacyscheme.Scheme.Convert(obj2, obj3, nil)
+	if err != nil {
+		t.Errorf("%v\nSource: %#v", err, obj2)
+		return nil
+	}
+	return obj3
+}
+
+func TestSetDefaultPreempting(t *testing.T) {
+	priorityClass := &v1alpha1.PriorityClass{}
+
+	// set NonPreemptingPriority true
+	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, true)()
+
+	output := roundTrip(t, runtime.Object(priorityClass)).(*v1alpha1.PriorityClass)
+	if output.PreemptionPolicy == nil || *output.PreemptionPolicy != apiv1.PreemptLowerPriority {
+		t.Errorf("Expected PriorityClass.Preempting value: %+v\ngot: %+v\n", apiv1.PreemptLowerPriority, output.PreemptionPolicy)
+	}
+}

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

@@ -21,9 +21,13 @@ limitations under the License.
 package v1alpha1
 
 import (
+	unsafe "unsafe"
+
+	v1 "k8s.io/api/core/v1"
 	v1alpha1 "k8s.io/api/scheduling/v1alpha1"
 	conversion "k8s.io/apimachinery/pkg/conversion"
 	runtime "k8s.io/apimachinery/pkg/runtime"
+	core "k8s.io/kubernetes/pkg/apis/core"
 	scheduling "k8s.io/kubernetes/pkg/apis/scheduling"
 )
 
@@ -54,16 +58,6 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
-	if err := s.AddConversionFunc((*scheduling.PriorityClass)(nil), (*v1alpha1.PriorityClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(a.(*scheduling.PriorityClass), b.(*v1alpha1.PriorityClass), scope)
-	}); err != nil {
-		return err
-	}
-	if err := s.AddConversionFunc((*v1alpha1.PriorityClass)(nil), (*scheduling.PriorityClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(a.(*v1alpha1.PriorityClass), b.(*scheduling.PriorityClass), scope)
-	}); err != nil {
-		return err
-	}
 	return nil
 }
 
@@ -72,31 +66,32 @@ func autoConvert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(in *v1alpha1
 	out.Value = in.Value
 	out.GlobalDefault = in.GlobalDefault
 	out.Description = in.Description
+	out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
 	return nil
 }
 
+// Convert_v1alpha1_PriorityClass_To_scheduling_PriorityClass is an autogenerated conversion function.
+func Convert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(in *v1alpha1.PriorityClass, out *scheduling.PriorityClass, s conversion.Scope) error {
+	return autoConvert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(in, out, s)
+}
+
 func autoConvert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(in *scheduling.PriorityClass, out *v1alpha1.PriorityClass, s conversion.Scope) error {
 	out.ObjectMeta = in.ObjectMeta
 	out.Value = in.Value
 	out.GlobalDefault = in.GlobalDefault
 	out.Description = in.Description
-	// WARNING: in.Preempting requires manual conversion: does not exist in peer-type
+	out.PreemptionPolicy = (*v1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
 	return nil
 }
 
+// Convert_scheduling_PriorityClass_To_v1alpha1_PriorityClass is an autogenerated conversion function.
+func Convert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(in *scheduling.PriorityClass, out *v1alpha1.PriorityClass, s conversion.Scope) error {
+	return autoConvert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(in, out, s)
+}
+
 func autoConvert_v1alpha1_PriorityClassList_To_scheduling_PriorityClassList(in *v1alpha1.PriorityClassList, out *scheduling.PriorityClassList, s conversion.Scope) error {
 	out.ListMeta = in.ListMeta
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]scheduling.PriorityClass, len(*in))
-		for i := range *in {
-			if err := Convert_v1alpha1_PriorityClass_To_scheduling_PriorityClass(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
+	out.Items = *(*[]scheduling.PriorityClass)(unsafe.Pointer(&in.Items))
 	return nil
 }
 
@@ -107,17 +102,7 @@ func Convert_v1alpha1_PriorityClassList_To_scheduling_PriorityClassList(in *v1al
 
 func autoConvert_scheduling_PriorityClassList_To_v1alpha1_PriorityClassList(in *scheduling.PriorityClassList, out *v1alpha1.PriorityClassList, s conversion.Scope) error {
 	out.ListMeta = in.ListMeta
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]v1alpha1.PriorityClass, len(*in))
-		for i := range *in {
-			if err := Convert_scheduling_PriorityClass_To_v1alpha1_PriorityClass(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
+	out.Items = *(*[]v1alpha1.PriorityClass)(unsafe.Pointer(&in.Items))
 	return nil
 }
 

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

@@ -21,6 +21,7 @@ limitations under the License.
 package v1alpha1
 
 import (
+	v1alpha1 "k8s.io/api/scheduling/v1alpha1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 )
 
@@ -28,5 +29,18 @@ import (
 // Public to allow building arbitrary schemes.
 // All generated defaulters are covering - they call all nested defaulters.
 func RegisterDefaults(scheme *runtime.Scheme) error {
+	scheme.AddTypeDefaultingFunc(&v1alpha1.PriorityClass{}, func(obj interface{}) { SetObjectDefaults_PriorityClass(obj.(*v1alpha1.PriorityClass)) })
+	scheme.AddTypeDefaultingFunc(&v1alpha1.PriorityClassList{}, func(obj interface{}) { SetObjectDefaults_PriorityClassList(obj.(*v1alpha1.PriorityClassList)) })
 	return nil
 }
+
+func SetObjectDefaults_PriorityClass(in *v1alpha1.PriorityClass) {
+	SetDefaults_PriorityClass(in)
+}
+
+func SetObjectDefaults_PriorityClassList(in *v1alpha1.PriorityClassList) {
+	for i := range in.Items {
+		a := &in.Items[i]
+		SetObjectDefaults_PriorityClass(a)
+	}
+}

pkg/apis/scheduling/v1beta1/BUILD

@@ -1,14 +1,11 @@
 package(default_visibility = ["//visibility:public"])
 
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-)
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
     srcs = [
-        "conversion.go",
+        "defaults.go",
         "doc.go",
         "register.go",
         "zz_generated.conversion.go",
@@ -16,11 +13,15 @@ go_library(
     ],
     importpath = "k8s.io/kubernetes/pkg/apis/scheduling/v1beta1",
     deps = [
+        "//pkg/apis/core:go_default_library",
         "//pkg/apis/scheduling:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/api/scheduling/v1beta1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
     ],
 )
 
@@ -36,3 +37,19 @@ filegroup(
     srcs = [":package-srcs"],
     tags = ["automanaged"],
 )
+
+go_test(
+    name = "go_default_test",
+    srcs = ["defaults_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/features:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
+        "//staging/src/k8s.io/api/scheduling/v1beta1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
+    ],
+)

pkg/apis/scheduling/v1beta1/conversion.go

@@ -1,67 +0,0 @@
-/*
-Copyright 2019 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 v1beta1
-
-import (
-	"k8s.io/api/scheduling/v1beta1"
-	"k8s.io/apimachinery/pkg/conversion"
-	"k8s.io/kubernetes/pkg/apis/scheduling"
-	"strconv"
-)
-
-func Convert_scheduling_PriorityClass_To_v1beta1_PriorityClass(in *scheduling.PriorityClass, out *v1beta1.PriorityClass, s conversion.Scope) error {
-	if err := autoConvert_scheduling_PriorityClass_To_v1beta1_PriorityClass(in, out, s); err != nil {
-		return err
-	}
-	out.ObjectMeta.Annotations = deepCopyStringMap(out.Annotations)
-	if in.Preempting != nil {
-		if out.ObjectMeta.Annotations == nil {
-			out.ObjectMeta.Annotations = make(map[string]string)
-		}
-		out.ObjectMeta.Annotations[scheduling.PreemptingAnnotation] = strconv.FormatBool(*(in.Preempting))
-	}
-	return nil
-}
-
-func Convert_v1beta1_PriorityClass_To_scheduling_PriorityClass(in *v1beta1.PriorityClass, out *scheduling.PriorityClass, s conversion.Scope) error {
-	if err := autoConvert_v1beta1_PriorityClass_To_scheduling_PriorityClass(in, out, s); err != nil {
-		return err
-	}
-	out.ObjectMeta.Annotations = deepCopyStringMap(out.Annotations)
-	if out.ObjectMeta.Annotations != nil {
-		if _, ok := out.ObjectMeta.Annotations[scheduling.PreemptingAnnotation]; ok {
-			preempting, err := strconv.ParseBool(out.ObjectMeta.Annotations[scheduling.PreemptingAnnotation])
-			if err != nil {
-				return err
-			}
-			out.Preempting = &preempting
-			delete(out.ObjectMeta.Annotations, scheduling.PreemptingAnnotation)
-		}
-	} else {
-		preempting := scheduling.DefaultPreempting
-		out.Preempting = &preempting
-	}
-	return nil
-}
-
-func deepCopyStringMap(m map[string]string) map[string]string {
-	ret := make(map[string]string, len(m))
-	for k, v := range m {
-		ret[k] = v
-	}
-	return ret
-}

pkg/apis/scheduling/v1beta1/defaults.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2019 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 v1beta1
+
+import (
+	apiv1 "k8s.io/api/core/v1"
+	"k8s.io/api/scheduling/v1beta1"
+	"k8s.io/apimachinery/pkg/runtime"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func addDefaultingFuncs(scheme *runtime.Scheme) error {
+	return RegisterDefaults(scheme)
+}
+
+// SetDefaults_PriorityClass sets additional defaults compared to its counterpart
+// in extensions.
+func SetDefaults_PriorityClass(obj *v1beta1.PriorityClass) {
+	if utilfeature.DefaultFeatureGate.Enabled(features.NonPreemptingPriority) && obj.PreemptionPolicy == nil {
+		preemptLowerPriority := apiv1.PreemptLowerPriority
+		obj.PreemptionPolicy = &preemptLowerPriority
+	}
+}

pkg/apis/scheduling/v1beta1/defaults_test.go

@@ -0,0 +1,66 @@
+/*
+Copyright 2019 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 v1beta1_test
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/api/scheduling/v1beta1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+
+	apiv1 "k8s.io/api/core/v1"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	featuregatetesting "k8s.io/component-base/featuregate/testing"
+	// enforce that all types are installed
+	_ "k8s.io/kubernetes/pkg/api/testapi"
+	"k8s.io/kubernetes/pkg/features"
+)
+
+func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {
+	codec := legacyscheme.Codecs.LegacyCodec(v1beta1.SchemeGroupVersion)
+	data, err := runtime.Encode(codec, obj)
+	if err != nil {
+		t.Errorf("%v\n %#v", err, obj)
+		return nil
+	}
+	obj2, err := runtime.Decode(codec, data)
+	if err != nil {
+		t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj)
+		return nil
+	}
+	obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object)
+	err = legacyscheme.Scheme.Convert(obj2, obj3, nil)
+	if err != nil {
+		t.Errorf("%v\nSource: %#v", err, obj2)
+		return nil
+	}
+	return obj3
+}
+
+func TestSetDefaultPreempting(t *testing.T) {
+	priorityClass := &v1beta1.PriorityClass{}
+
+	// set NonPreemptingPriority true
+	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.NonPreemptingPriority, true)()
+
+	output := roundTrip(t, runtime.Object(priorityClass)).(*v1beta1.PriorityClass)
+	if output.PreemptionPolicy == nil || *output.PreemptionPolicy != apiv1.PreemptLowerPriority {
+		t.Errorf("Expected PriorityClass.Preempting value: %+v\ngot: %+v\n", apiv1.PreemptLowerPriority, output.PreemptionPolicy)
+	}
+}

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

@@ -21,9 +21,13 @@ limitations under the License.
 package v1beta1
 
 import (
+	unsafe "unsafe"
+
+	v1 "k8s.io/api/core/v1"
 	v1beta1 "k8s.io/api/scheduling/v1beta1"
 	conversion "k8s.io/apimachinery/pkg/conversion"
 	runtime "k8s.io/apimachinery/pkg/runtime"
+	core "k8s.io/kubernetes/pkg/apis/core"
 	scheduling "k8s.io/kubernetes/pkg/apis/scheduling"
 )
 
@@ -54,16 +58,6 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
-	if err := s.AddConversionFunc((*scheduling.PriorityClass)(nil), (*v1beta1.PriorityClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_scheduling_PriorityClass_To_v1beta1_PriorityClass(a.(*scheduling.PriorityClass), b.(*v1beta1.PriorityClass), scope)
-	}); err != nil {
-		return err
-	}
-	if err := s.AddConversionFunc((*v1beta1.PriorityClass)(nil), (*scheduling.PriorityClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_v1beta1_PriorityClass_To_scheduling_PriorityClass(a.(*v1beta1.PriorityClass), b.(*scheduling.PriorityClass), scope)
-	}); err != nil {
-		return err
-	}
 	return nil
 }
 
@@ -72,31 +66,32 @@ func autoConvert_v1beta1_PriorityClass_To_scheduling_PriorityClass(in *v1beta1.P
 	out.Value = in.Value
 	out.GlobalDefault = in.GlobalDefault
 	out.Description = in.Description
+	out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
 	return nil
 }
 
+// Convert_v1beta1_PriorityClass_To_scheduling_PriorityClass is an autogenerated conversion function.
+func Convert_v1beta1_PriorityClass_To_scheduling_PriorityClass(in *v1beta1.PriorityClass, out *scheduling.PriorityClass, s conversion.Scope) error {
+	return autoConvert_v1beta1_PriorityClass_To_scheduling_PriorityClass(in, out, s)
+}
+
 func autoConvert_scheduling_PriorityClass_To_v1beta1_PriorityClass(in *scheduling.PriorityClass, out *v1beta1.PriorityClass, s conversion.Scope) error {
 	out.ObjectMeta = in.ObjectMeta
 	out.Value = in.Value
 	out.GlobalDefault = in.GlobalDefault
 	out.Description = in.Description
-	// WARNING: in.Preempting requires manual conversion: does not exist in peer-type
+	out.PreemptionPolicy = (*v1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
 	return nil
 }
 
+// Convert_scheduling_PriorityClass_To_v1beta1_PriorityClass is an autogenerated conversion function.
+func Convert_scheduling_PriorityClass_To_v1beta1_PriorityClass(in *scheduling.PriorityClass, out *v1beta1.PriorityClass, s conversion.Scope) error {
+	return autoConvert_scheduling_PriorityClass_To_v1beta1_PriorityClass(in, out, s)
+}
+
 func autoConvert_v1beta1_PriorityClassList_To_scheduling_PriorityClassList(in *v1beta1.PriorityClassList, out *scheduling.PriorityClassList, s conversion.Scope) error {
 	out.ListMeta = in.ListMeta
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]scheduling.PriorityClass, len(*in))
-		for i := range *in {
-			if err := Convert_v1beta1_PriorityClass_To_scheduling_PriorityClass(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
+	out.Items = *(*[]scheduling.PriorityClass)(unsafe.Pointer(&in.Items))
 	return nil
 }
 
@@ -107,17 +102,7 @@ func Convert_v1beta1_PriorityClassList_To_scheduling_PriorityClassList(in *v1bet
 
 func autoConvert_scheduling_PriorityClassList_To_v1beta1_PriorityClassList(in *scheduling.PriorityClassList, out *v1beta1.PriorityClassList, s conversion.Scope) error {
 	out.ListMeta = in.ListMeta
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]v1beta1.PriorityClass, len(*in))
-		for i := range *in {
-			if err := Convert_scheduling_PriorityClass_To_v1beta1_PriorityClass(&(*in)[i], &(*out)[i], s); err != nil {
-				return err
-			}
-		}
-	} else {
-		out.Items = nil
-	}
+	out.Items = *(*[]v1beta1.PriorityClass)(unsafe.Pointer(&in.Items))
 	return nil
 }
 

pkg/apis/scheduling/v1beta1/zz_generated.defaults.go

@@ -21,6 +21,7 @@ limitations under the License.
 package v1beta1
 
 import (
+	v1beta1 "k8s.io/api/scheduling/v1beta1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 )
 
@@ -28,5 +29,18 @@ import (
 // Public to allow building arbitrary schemes.
 // All generated defaulters are covering - they call all nested defaulters.
 func RegisterDefaults(scheme *runtime.Scheme) error {
+	scheme.AddTypeDefaultingFunc(&v1beta1.PriorityClass{}, func(obj interface{}) { SetObjectDefaults_PriorityClass(obj.(*v1beta1.PriorityClass)) })
+	scheme.AddTypeDefaultingFunc(&v1beta1.PriorityClassList{}, func(obj interface{}) { SetObjectDefaults_PriorityClassList(obj.(*v1beta1.PriorityClassList)) })
 	return nil
 }
+
+func SetObjectDefaults_PriorityClass(in *v1beta1.PriorityClass) {
+	SetDefaults_PriorityClass(in)
+}
+
+func SetObjectDefaults_PriorityClassList(in *v1beta1.PriorityClassList) {
+	for i := range in.Items {
+		a := &in.Items[i]
+		SetObjectDefaults_PriorityClass(a)
+	}
+}

pkg/apis/scheduling/validation/validation.go

@@ -41,6 +41,9 @@ func ValidatePriorityClass(pc *scheduling.PriorityClass) field.ErrorList {
 		// Non-system critical priority classes are not allowed to have a value larger than HighestUserDefinablePriority.
 		allErrs = append(allErrs, field.Forbidden(field.NewPath("value"), fmt.Sprintf("maximum allowed value of a user defined priority is %v", scheduling.HighestUserDefinablePriority)))
 	}
+	if pc.PreemptionPolicy != nil {
+		allErrs = append(allErrs, apivalidation.ValidatePreemptionPolicy(pc.PreemptionPolicy, field.NewPath("preemptionPolicy"))...)
+	}
 	return allErrs
 }
 
@@ -52,5 +55,7 @@ func ValidatePriorityClassUpdate(pc, oldPc *scheduling.PriorityClass) field.Erro
 	if pc.Value != oldPc.Value {
 		allErrs = append(allErrs, field.Forbidden(field.NewPath("Value"), "may not be changed in an update."))
 	}
+	// PreemptionPolicy is immutable and is checked by the ObjectMeta validator.
+	allErrs = append(allErrs, apivalidation.ValidateImmutableField(pc.PreemptionPolicy, oldPc.PreemptionPolicy, field.NewPath("preemptionPolicy"))...)
 	return allErrs
 }

pkg/apis/scheduling/zz_generated.deepcopy.go

@@ -22,6 +22,7 @@ package scheduling
 
 import (
 	runtime "k8s.io/apimachinery/pkg/runtime"
+	core "k8s.io/kubernetes/pkg/apis/core"
 )
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
@@ -29,9 +30,9 @@ func (in *PriorityClass) DeepCopyInto(out *PriorityClass) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	if in.Preempting != nil {
-		in, out := &in.Preempting, &out.Preempting
-		*out = new(bool)
+	if in.PreemptionPolicy != nil {
+		in, out := &in.PreemptionPolicy, &out.PreemptionPolicy
+		*out = new(core.PreemptionPolicy)
 		**out = **in
 	}
 	return