add preemptive scheduling logic

Author: Diaphteiros

api/clusters/v1alpha1/cluster_types.go

@@ -152,3 +152,19 @@ func (c *Cluster) GetRequestUIDs() sets.Set[string] {
 	}
 	return res
 }
+
+// GetPreemptiveTenancyCount works like GetTenancyCount, but for preemptive ClusterRequests.
+func (c *Cluster) GetPreemptiveTenancyCount() int {
+	return c.GetPreemptiveRequestUIDs().Len()
+}
+
+// GetPreemptiveRequestUIDs returns the UIDs of all preemptive ClusterRequests that have marked this cluster with a corresponding finalizer.
+func (c *Cluster) GetPreemptiveRequestUIDs() sets.Set[string] {
+	res := sets.New[string]()
+	for _, fin := range c.Finalizers {
+		if strings.HasPrefix(fin, PreemptiveRequestFinalizerOnClusterPrefix) {
+			res.Insert(strings.TrimPrefix(fin, PreemptiveRequestFinalizerOnClusterPrefix))
+		}
+	}
+	return res
+}

api/clusters/v1alpha1/clusterrequest_types.go

@@ -9,6 +9,13 @@ type ClusterRequestSpec struct {
 	// Purpose is the purpose of the requested cluster.
 	// +kubebuilder:validation:MinLength=1
 	Purpose string `json:"purpose"`
+
+	// Preemptive determines whether the request is preemptive.
+	// Preemptive requests are used to create clusters in advance, so that they are ready when needed.
+	// AccessRequests for preemptive clusters are not allowed.
+	// +optional
+	// +kubebuilder:default=false
+	Preemptive bool `json:"preemptive,omitempty"`
 }
 
 // +kubebuilder:validation:XValidation:rule="!has(oldSelf.cluster) || has(self.cluster)", message="cluster may not be removed once set"
@@ -46,9 +53,11 @@ func (p RequestPhase) IsPending() bool {
 // +kubebuilder:resource:shortName=cr;creq
 // +kubebuilder:metadata:labels="openmcp.cloud/cluster=platform"
 // +kubebuilder:selectablefield:JSONPath=".spec.purpose"
+// +kubebuilder:selectablefield:JSONPath=".spec.preemptive"
 // +kubebuilder:selectablefield:JSONPath=".status.phase"
 // +kubebuilder:printcolumn:JSONPath=".spec.purpose",name="Purpose",type=string
 // +kubebuilder:printcolumn:JSONPath=".status.phase",name="Phase",type=string
+// +kubebuilder:printcolumn:JSONPath=".spec.preemptive",name="Preemptive",type=string
 // +kubebuilder:printcolumn:JSONPath=".status.cluster.name",name="Cluster",type=string
 // +kubebuilder:printcolumn:JSONPath=".status.cluster.namespace",name="Cluster-NS",type=string
 
@@ -67,7 +76,7 @@ type ClusterRequest struct {
 type ClusterRequestList struct {
 	metav1.TypeMeta `json:",inline"`
 	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []Cluster `json:"items"`
+	Items           []ClusterRequest `json:"items"`
 }
 
 func init() {
@@ -77,5 +86,9 @@ func init() {
 // FinalizerForCluster returns the finalizer that is used to mark that a specific request has pointed to a specific cluster.
 // Apart from preventing the Cluster's deletion, this information is used to recover the Cluster if the status of the ClusterRequest ever gets lost.
 func (cr *ClusterRequest) FinalizerForCluster() string {
-	return RequestFinalizerOnClusterPrefix + string(cr.UID)
+	prefix := RequestFinalizerOnClusterPrefix
+	if cr.Spec.Preemptive {
+		prefix = PreemptiveRequestFinalizerOnClusterPrefix
+	}
+	return prefix + string(cr.UID)
 }

api/clusters/v1alpha1/constants.go

@@ -82,4 +82,6 @@ const (
 	ClusterRequestFinalizer = GroupName + "/request"
 	// RequestFinalizerOnClusterPrefix is the prefix for the finalizers that mark a Cluster as being referenced by a ClusterRequest.
 	RequestFinalizerOnClusterPrefix = "request." + GroupName + "/"
+	// PreemptiveRequestFinalizerOnClusterPrefix is the prefix for the finalizers that mark a Cluster as being referenced by a preemptive ClusterRequest.
+	PreemptiveRequestFinalizerOnClusterPrefix = "preemptive." + GroupName + "/"
 )

api/clusters/v1alpha1/zz_generated.deepcopy.go

@@ -26,6 +26,9 @@ spec:
     - jsonPath: .status.phase
       name: Phase
       type: string
+    - jsonPath: .spec.preemptive
+      name: Preemptive
+      type: string
     - jsonPath: .status.cluster.name
       name: Cluster
       type: string
@@ -56,6 +59,13 @@ spec:
             type: object
           spec:
             properties:
+              preemptive:
+                default: false
+                description: |-
+                  Preemptive determines whether the request is preemptive.
+                  Preemptive requests are used to create clusters in advance, so that they are ready when needed.
+                  AccessRequests for preemptive clusters are not allowed.
+                type: boolean
               purpose:
                 description: Purpose is the purpose of the requested cluster.
                 minLength: 1
@@ -158,6 +168,7 @@ spec:
         type: object
     selectableFields:
     - jsonPath: .spec.purpose
+    - jsonPath: .spec.preemptive
     - jsonPath: .status.phase
     served: true
     storage: true

api/crds/manifests/clusters.openmcp.cloud_clusterrequests.yaml

@@ -120,3 +120,11 @@ For clusters with unlimited tenancy count, `metadata.generateName` takes precede
 By default, the scheduler marks every `Cluster` that it has created itself with a `clusters.openmcp.cloud/delete-without-requests: "true"` label. When a `ClusterRequest` is deleted, the scheduler removes the request's finalizers from all clusters and if it was the last request finalizer on that cluster and the cluster has the aforementioned label, the scheduler will delete the cluster.
 
 To prevent the scheduler from deleting a cluster that was created by it after the last request finalizer has been removed from the `Cluster` resource, add the label with any value except `"true"` to the cluster's template in the scheduler configuration.
+
+Note that the `ClusterRequest` resource is removed immediately and does not wait for potential deletion of the corresponding cluster.
+
+## Preemptive Scheduling
+
+To avoid long waiting times for `ClusterRequest`s, it is possible to request clusters preemptively. A `ClusterRequest` with `spec.preemptive` set to `true` is referred to as a 'preemptive request'. These requests behave like regular requests, with one important difference: a regular request prefers taking over an existing `Cluster` belonging to a preemptive request over creating a new `Cluster`. If that happens, the replaced preemptive request will be rescheduled, potentially resulting in a new `Cluster`.
+
+Think of preemptive requests as reservations for clusters (or workload capacity on shared clusters) which are used by regular requests.

docs/controller/scheduler.md

@@ -172,3 +172,13 @@ func (c *SchedulerConfig) Complete(fldPath *field.Path) error {
 
 	return nil
 }
+
+func (cd *ClusterDefinition) IsExclusive() bool {
+	return cd.Template.Spec.Tenancy == clustersv1alpha1.TENANCY_EXCLUSIVE
+}
+func (cd *ClusterDefinition) IsShared() bool {
+	return cd.Template.Spec.Tenancy == clustersv1alpha1.TENANCY_SHARED
+}
+func (cd *ClusterDefinition) IsSharedUnlimitedly() bool {
+	return cd.IsShared() && cd.TenancyCount == 0
+}