DRA: remove immediate allocation

As agreed in kubernetes/enhancements#4709, immediate
allocation is one of those features which can be removed because it makes no
sense for structured parameters and the justification for classic DRA is weak.

api/openapi-spec/v3/apis__resource.k8s.io__v1alpha2_openapi.json

@@ -762,10 +762,6 @@
       "io.k8s.api.resource.v1alpha2.ResourceClaimSpec": {
         "description": "ResourceClaimSpec defines how a resource is to be allocated.",
         "properties": {
-          "allocationMode": {
-            "description": "Allocation can start immediately or when a Pod wants to use the resource. \"WaitForFirstConsumer\" is the default.",
-            "type": "string"
-          },
           "parametersRef": {
             "allOf": [
               {

pkg/apis/resource/fuzzer/fuzzer.go

@@ -17,24 +17,10 @@ limitations under the License.
 package fuzzer
 
 import (
-	fuzz "github.com/google/gofuzz"
-
 	runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/kubernetes/pkg/apis/resource"
 )
 
 // Funcs contains the fuzzer functions for the resource group.
 var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
-	return []interface{}{
-		func(obj *resource.ResourceClaimSpec, c fuzz.Continue) {
-			c.FuzzNoCustom(obj) // fuzz self without calling this function again
-
-			// Custom fuzzing for allocation mode: pick one valid mode randomly.
-			modes := []resource.AllocationMode{
-				resource.AllocationModeImmediate,
-				resource.AllocationModeWaitForFirstConsumer,
-			}
-			obj.AllocationMode = modes[c.Rand.Intn(len(modes))]
-		},
-	}
+	return nil
 }

pkg/apis/resource/types.go

@@ -62,33 +62,7 @@ type ResourceClaimSpec struct {
 	// The object must be in the same namespace as the ResourceClaim.
 	// +optional
 	ParametersRef *ResourceClaimParametersReference
-
-	// Allocation can start immediately or when a Pod wants to use the
-	// resource. "WaitForFirstConsumer" is the default.
-	// +optional
-	AllocationMode AllocationMode
-}
-
-// AllocationMode describes whether a ResourceClaim gets allocated immediately
-// when it gets created (AllocationModeImmediate) or whether allocation is
-// delayed until it is needed for a Pod
-// (AllocationModeWaitForFirstConsumer). Other modes might get added in the
-// future.
-type AllocationMode string
-
-const (
-	// When a ResourceClaim has AllocationModeWaitForFirstConsumer, allocation is
-	// delayed until a Pod gets scheduled that needs the ResourceClaim. The
-	// scheduler will consider all resource requirements of that Pod and
-	// trigger allocation for a node that fits the Pod.
-	AllocationModeWaitForFirstConsumer AllocationMode = "WaitForFirstConsumer"
-
-	// When a ResourceClaim has AllocationModeImmediate, allocation starts
-	// as soon as the ResourceClaim gets created. This is done without
-	// considering the needs of Pods that will use the ResourceClaim
-	// because those Pods are not known yet.
-	AllocationModeImmediate AllocationMode = "Immediate"
-)
+}
 
 // ResourceClaimStatus tracks whether the resource has been allocated and what
 // the resulting attributes are.

pkg/apis/resource/v1alpha2/defaults.go

@@ -17,16 +17,9 @@ limitations under the License.
 package v1alpha2
 
 import (
-	"k8s.io/api/resource/v1alpha2"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 
 func addDefaultingFuncs(scheme *runtime.Scheme) error {
 	return RegisterDefaults(scheme)
 }
-
-func SetDefaults_ResourceClaimSpec(obj *v1alpha2.ResourceClaimSpec) {
-	if obj.AllocationMode == "" {
-		obj.AllocationMode = v1alpha2.AllocationModeWaitForFirstConsumer
-	}
-}

pkg/apis/resource/validation/validation.go

@@ -46,14 +46,9 @@ func validateResourceClaimSpec(spec *resource.ResourceClaimSpec, fldPath *field.
 		allErrs = append(allErrs, field.Invalid(fldPath.Child("resourceClassName"), spec.ResourceClassName, msg))
 	}
 	allErrs = append(allErrs, validateResourceClaimParametersRef(spec.ParametersRef, fldPath.Child("parametersRef"))...)
-	if !supportedAllocationModes.Has(string(spec.AllocationMode)) {
-		allErrs = append(allErrs, field.NotSupported(fldPath.Child("allocationMode"), spec.AllocationMode, supportedAllocationModes.List()))
-	}
 	return allErrs
 }
 
-var supportedAllocationModes = sets.NewString(string(resource.AllocationModeImmediate), string(resource.AllocationModeWaitForFirstConsumer))
-
 // It would have been nice to use Go generics to reuse the same validation
 // function for Kind and Name in both types, but generics cannot be used to
 // access common fields in structs.

pkg/apis/resource/validation/validation_resourceclaim_test.go

@@ -42,14 +42,11 @@ func testClaim(name, namespace string, spec resource.ResourceClaimSpec) *resourc
 }
 
 func TestValidateClaim(t *testing.T) {
-	validMode := resource.AllocationModeImmediate
-	invalidMode := resource.AllocationMode("invalid")
 	goodName := "foo"
 	badName := "!@#$%^"
 	goodNS := "ns"
 	goodClaimSpec := resource.ResourceClaimSpec{
 		ResourceClassName: goodName,
-		AllocationMode:    validMode,
 	}
 	now := metav1.Now()
 	badValue := "spaces not allowed"
@@ -200,14 +197,6 @@ func TestValidateClaim(t *testing.T) {
 				return claim
 			}(),
 		},
-		"bad-mode": {
-			wantFailures: field.ErrorList{field.NotSupported(field.NewPath("spec", "allocationMode"), invalidMode, supportedAllocationModes.List())},
-			claim: func() *resource.ResourceClaim {
-				claim := testClaim(goodName, goodNS, goodClaimSpec)
-				claim.Spec.AllocationMode = invalidMode
-				return claim
-			}(),
-		},
 		"good-parameters": {
 			claim: func() *resource.ResourceClaim {
 				claim := testClaim(goodName, goodNS, goodClaimSpec)
@@ -279,7 +268,6 @@ func TestValidateClaimUpdate(t *testing.T) {
 	}
 	validClaim := testClaim("foo", "ns", resource.ResourceClaimSpec{
 		ResourceClassName: name,
-		AllocationMode:    resource.AllocationModeImmediate,
 		ParametersRef:     parameters,
 	})
 
@@ -316,18 +304,6 @@ func TestValidateClaimUpdate(t *testing.T) {
 				return claim
 			},
 		},
-		"invalid-update-mode": {
-			wantFailures: field.ErrorList{field.Invalid(field.NewPath("spec"), func() resource.ResourceClaimSpec {
-				spec := validClaim.Spec.DeepCopy()
-				spec.AllocationMode = resource.AllocationModeWaitForFirstConsumer
-				return *spec
-			}(), "field is immutable")},
-			oldClaim: validClaim,
-			update: func(claim *resource.ResourceClaim) *resource.ResourceClaim {
-				claim.Spec.AllocationMode = resource.AllocationModeWaitForFirstConsumer
-				return claim
-			},
-		},
 	}
 
 	for name, scenario := range scenarios {
@@ -343,7 +319,6 @@ func TestValidateClaimStatusUpdate(t *testing.T) {
 	invalidName := "!@#$%^"
 	validClaim := testClaim("foo", "ns", resource.ResourceClaimSpec{
 		ResourceClassName: "valid",
-		AllocationMode:    resource.AllocationModeImmediate,
 	})
 
 	validAllocatedClaim := validClaim.DeepCopy()

pkg/apis/resource/validation/validation_resourceclaimtemplate_test.go

@@ -40,14 +40,11 @@ func testClaimTemplate(name, namespace string, spec resource.ResourceClaimSpec)
 }
 
 func TestValidateClaimTemplate(t *testing.T) {
-	validMode := resource.AllocationModeImmediate
-	invalidMode := resource.AllocationMode("invalid")
 	goodName := "foo"
 	badName := "!@#$%^"
 	goodNS := "ns"
 	goodClaimSpec := resource.ResourceClaimSpec{
 		ResourceClassName: goodName,
-		AllocationMode:    validMode,
 	}
 	now := metav1.Now()
 	badValue := "spaces not allowed"
@@ -198,14 +195,6 @@ func TestValidateClaimTemplate(t *testing.T) {
 				return template
 			}(),
 		},
-		"bad-mode": {
-			wantFailures: field.ErrorList{field.NotSupported(field.NewPath("spec", "spec", "allocationMode"), invalidMode, supportedAllocationModes.List())},
-			template: func() *resource.ResourceClaimTemplate {
-				template := testClaimTemplate(goodName, goodNS, goodClaimSpec)
-				template.Spec.Spec.AllocationMode = invalidMode
-				return template
-			}(),
-		},
 		"good-parameters": {
 			template: func() *resource.ResourceClaimTemplate {
 				template := testClaimTemplate(goodName, goodNS, goodClaimSpec)
@@ -277,7 +266,6 @@ func TestValidateClaimTemplateUpdate(t *testing.T) {
 	}
 	validClaimTemplate := testClaimTemplate("foo", "ns", resource.ResourceClaimSpec{
 		ResourceClassName: name,
-		AllocationMode:    resource.AllocationModeImmediate,
 		ParametersRef:     parameters,
 	})
 
@@ -314,18 +302,6 @@ func TestValidateClaimTemplateUpdate(t *testing.T) {
 				return template
 			},
 		},
-		"invalid-update-mode": {
-			wantFailures: field.ErrorList{field.Invalid(field.NewPath("spec"), func() resource.ResourceClaimTemplateSpec {
-				spec := validClaimTemplate.Spec.DeepCopy()
-				spec.Spec.AllocationMode = resource.AllocationModeWaitForFirstConsumer
-				return *spec
-			}(), "field is immutable")},
-			oldClaimTemplate: validClaimTemplate,
-			update: func(template *resource.ResourceClaimTemplate) *resource.ResourceClaimTemplate {
-				template.Spec.Spec.AllocationMode = resource.AllocationModeWaitForFirstConsumer
-				return template
-			},
-		},
 	}
 
 	for name, scenario := range scenarios {