mirror of
https://github.com/cozystack/cozystack.git
synced 2026-11-02 18:16:53 +09:00
Aleksei Sviridkin
4225be12cc
The binder is the only writer of a claim's placement, so budget and capacity checks that admission already ran cannot be raced past by two replicas. Every event collapses into one pass over all GPU objects, which serializes the decisions without per-object locks, and claims are read past the cache so a unit booked in the last pass is never booked again from a stale view. A VM starts through its launcher pod, which the pod webhook holds at a scheduling gate. The pass creates the VMI's template claims, gathers the whole set onto one node that every class of the set tolerates and has room on, then pins the pod there and removes the gate in one update, since the API server lets a pod's node affinity change only while the pod is gated. A set that cannot be placed keeps its pod gated with a condition on its claims and a Warning event on the VMI, once per change of reason, so the VM waits for capacity instead of being refused into KubeVirt's backoff. The set goes only to a node the pod's own node selector and required affinity accept and, when the VMI has a volume bound to a node's PersistentVolume, that volume reaches. Gated pods go before moves and new orders. A pin cannot be undone, so a pinned pod its node refuses for lack of resources is deleted and the node is skipped for that set for ten minutes, or until its allocatable, taints or readiness change. The template claims of the set go with its failed VMI, so the controller also keeps the rejection in memory for the VM's next VMI. Only a VMI whose pod is already pinned is deleted to free a claim whose node cannot keep it; a VMI whose pod is gated has its set gathered instead. The full pass also moves held sets off nodes that cannot keep them, rebinds Lost sets before new orders, and binds new orders onto the fullest node with room. Finalizers and usage records run with the feature disabled too, so turning GPU off never hangs a namespace or class deletion. Each usage record is owned by its claim and sits under no WorkloadMonitor, so no tenant label can add or drop one, and garbage collection removes it with the claim. Without a monitor label the Workload controller would take such a record for an orphan, so it now leaves a record owned by a GPUClaim to that owner. The claims one VM names move, go Lost and are rebound as a set. Every pass restores that invariant before it places anything, gathering a set left partly Lost, by a write that failed half way or by a VMI that ended next to held members, onto one node or sending all of it to Lost, so each later step only ever changes whole sets. A Lost claim already counts against its tenant's budgets, so the pod of its still running VMI is not counted again under a raw GPU key; for node capacity it is, since the claim itself holds no units. A pod is a VMI's launcher only when the VMI lists it in status.activePods, because whoever creates a pod sets its owner reference. The KubeVirt watches start once KubeVirt serves its kinds, whose CRDs a fresh install adds after this controller starts. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin <f@lex.la>
95 lines
2.7 KiB
Go
95 lines
2.7 KiB
Go
package controller
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"time"
|
|
|
|
corev1 "k8s.io/api/core/v1"
|
|
apierrors "k8s.io/apimachinery/pkg/api/errors"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
ctrl "sigs.k8s.io/controller-runtime"
|
|
"sigs.k8s.io/controller-runtime/pkg/client"
|
|
"sigs.k8s.io/controller-runtime/pkg/log"
|
|
|
|
cozyv1alpha1 "github.com/cozystack/cozystack/api/v1alpha1"
|
|
"github.com/cozystack/cozystack/internal/gpu/model"
|
|
)
|
|
|
|
const (
|
|
deletionRequeueDelay = 30 * time.Second
|
|
)
|
|
|
|
// WorkloadMonitorReconciler reconciles a WorkloadMonitor object
|
|
type WorkloadReconciler struct {
|
|
client.Client
|
|
Scheme *runtime.Scheme
|
|
}
|
|
|
|
// workload_controller.go
|
|
func (r *WorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
|
|
log := log.FromContext(ctx)
|
|
|
|
w := &cozyv1alpha1.Workload{}
|
|
if err := r.Get(ctx, req.NamespacedName, w); err != nil {
|
|
if apierrors.IsNotFound(err) {
|
|
return ctrl.Result{}, nil
|
|
}
|
|
return ctrl.Result{}, err
|
|
}
|
|
|
|
// A GPU usage record has no monitor: its GPUClaim owns it, deletes it
|
|
// when the claim stops holding GPUs, and garbage collection removes it
|
|
// with the claim.
|
|
if model.OwnedByClaim(w) {
|
|
return ctrl.Result{}, nil
|
|
}
|
|
|
|
// If my monitor is gone, delete me.
|
|
monName, has := w.Labels["workloads.cozystack.io/monitor"]
|
|
if !has {
|
|
return ctrl.Result{}, client.IgnoreNotFound(r.Delete(ctx, w))
|
|
}
|
|
monitor := &cozyv1alpha1.WorkloadMonitor{}
|
|
if err := r.Get(ctx, client.ObjectKey{Namespace: w.Namespace, Name: monName}, monitor); apierrors.IsNotFound(err) {
|
|
// Monitor is gone → delete the Workload. Ignore NotFound here, too.
|
|
return ctrl.Result{}, client.IgnoreNotFound(r.Delete(ctx, w))
|
|
} else if err != nil {
|
|
// Some other error fetching the monitor
|
|
log.Error(err, "failed to get WorkloadMonitor", "monitor", monName)
|
|
return ctrl.Result{}, err
|
|
}
|
|
|
|
return ctrl.Result{}, nil
|
|
}
|
|
|
|
// SetupWithManager registers our controller with the Manager and sets up watches.
|
|
func (r *WorkloadReconciler) SetupWithManager(mgr ctrl.Manager) error {
|
|
return ctrl.NewControllerManagedBy(mgr).
|
|
// Watch Workload objects
|
|
For(&cozyv1alpha1.Workload{}).
|
|
Complete(r)
|
|
}
|
|
|
|
func getMonitoredObject(w *cozyv1alpha1.Workload) client.Object {
|
|
switch {
|
|
case strings.HasPrefix(w.Name, "pvc-"):
|
|
obj := &corev1.PersistentVolumeClaim{}
|
|
obj.Name = strings.TrimPrefix(w.Name, "pvc-")
|
|
obj.Namespace = w.Namespace
|
|
return obj
|
|
case strings.HasPrefix(w.Name, "svc-"):
|
|
obj := &corev1.Service{}
|
|
obj.Name = strings.TrimPrefix(w.Name, "svc-")
|
|
obj.Namespace = w.Namespace
|
|
return obj
|
|
case strings.HasPrefix(w.Name, "pod-"):
|
|
obj := &corev1.Pod{}
|
|
obj.Name = strings.TrimPrefix(w.Name, "pod-")
|
|
obj.Namespace = w.Namespace
|
|
return obj
|
|
}
|
|
var obj client.Object
|
|
return obj
|
|
}
|