Monitor MachinePool Health based on standalone kustomizations

Makefile

@@ -358,7 +358,7 @@ PROTOC_GEN_GO_GRPC ?= $(LOCALBIN)/protoc-gen-go-grpc
 
 ## Tool Versions
 KUSTOMIZE_VERSION ?= v5.1.1
-VGOPATH_VERSION ?= v0.1.3
+VGOPATH_VERSION ?= v0.1.10
 CONTROLLER_TOOLS_VERSION ?= v0.20.0
 GEN_CRD_API_REFERENCE_DOCS_VERSION ?= v0.3.0
 ADDLICENSE_VERSION ?= v1.1.1

api/compute/v1alpha1/common.go

@@ -9,6 +9,10 @@ import (
 	corev1 "k8s.io/api/core/v1"
 )
 
+const (
+	NamespaceMachinePoolLease = "ironcore-machinepool-lease"
+)
+
 const (
 	MachineMachinePoolRefNameField  = "spec.machinePoolRef.name"
 	MachineMachineClassRefNameField = "spec.machineClassRef.name"

api/compute/v1alpha1/conditions.go

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: 2026 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+package v1alpha1
+
+import (
+	"slices"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// FindMachinePoolCondition returns a pointer to the condition of the given type,
+// or nil if no condition of that type is present.
+func FindMachinePoolCondition(conditions []MachinePoolCondition, typ MachinePoolConditionType) *MachinePoolCondition {
+	idx := slices.IndexFunc(conditions, func(cond MachinePoolCondition) bool {
+		return cond.Type == typ
+	})
+	if idx < 0 {
+		return nil
+	}
+	return &conditions[idx]
+}
+
+// SetMachinePoolCondition inserts or updates a condition of the given type in the
+// conditions slice. LastUpdateTime is always set to now. LastTransitionTime is set
+// to now only when the condition is newly inserted or its Status differs from the
+// previous value.
+func SetMachinePoolCondition(conditions []MachinePoolCondition, cond MachinePoolCondition) []MachinePoolCondition {
+	idx := slices.IndexFunc(conditions, func(c MachinePoolCondition) bool {
+		return c.Type == cond.Type
+	})
+
+	cond.LastUpdateTime = metav1.Now()
+
+	if idx < 0 || conditions[idx].Status != cond.Status {
+		cond.LastTransitionTime = metav1.Now()
+	} else {
+		cond.LastTransitionTime = conditions[idx].LastTransitionTime
+	}
+
+	if idx < 0 {
+		return append(conditions, cond)
+	}
+	conditions[idx] = cond
+	return conditions
+}

api/compute/v1alpha1/conditions_test.go

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2026 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+package v1alpha1_test
+
+import (
+	"testing"
+	"time"
+
+	computev1alpha1 "github.com/ironcore-dev/ironcore/api/compute/v1alpha1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TestFindMachinePoolCondition_returnsMatch(t *testing.T) {
+	conds := []computev1alpha1.MachinePoolCondition{
+		{Type: "Other", Status: corev1.ConditionTrue},
+		{Type: computev1alpha1.MachinePoolReady, Status: corev1.ConditionFalse, Reason: "X"},
+	}
+	got := computev1alpha1.FindMachinePoolCondition(conds, computev1alpha1.MachinePoolReady)
+	if got == nil || got.Reason != "X" {
+		t.Fatalf("expected Ready condition with reason X, got %+v", got)
+	}
+}
+
+func TestFindMachinePoolCondition_returnsNilWhenMissing(t *testing.T) {
+	conds := []computev1alpha1.MachinePoolCondition{{Type: "Other"}}
+	if got := computev1alpha1.FindMachinePoolCondition(conds, computev1alpha1.MachinePoolReady); got != nil {
+		t.Fatalf("expected nil, got %+v", got)
+	}
+}
+
+func TestSetMachinePoolCondition_appendsWhenAbsent(t *testing.T) {
+	out := computev1alpha1.SetMachinePoolCondition(nil, computev1alpha1.MachinePoolCondition{
+		Type:   computev1alpha1.MachinePoolReady,
+		Status: corev1.ConditionTrue,
+	})
+	if len(out) != 1 || out[0].Type != computev1alpha1.MachinePoolReady {
+		t.Fatalf("expected Ready appended, got %+v", out)
+	}
+	if out[0].LastTransitionTime.IsZero() {
+		t.Fatal("expected LastTransitionTime to be set on first append")
+	}
+	if out[0].LastUpdateTime.IsZero() {
+		t.Fatal("expected LastUpdateTime to be set on first append")
+	}
+}
+
+func TestSetMachinePoolCondition_updatesInPlaceWithoutTransition(t *testing.T) {
+	earlier := metav1.NewTime(time.Now().Add(-time.Hour))
+	in := []computev1alpha1.MachinePoolCondition{{
+		Type:               computev1alpha1.MachinePoolReady,
+		Status:             corev1.ConditionTrue,
+		LastTransitionTime: earlier,
+	}}
+	out := computev1alpha1.SetMachinePoolCondition(in, computev1alpha1.MachinePoolCondition{
+		Type:    computev1alpha1.MachinePoolReady,
+		Status:  corev1.ConditionTrue, // same status
+		Message: "still ready",
+	})
+	if !out[0].LastTransitionTime.Equal(&earlier) {
+		t.Fatalf("expected LastTransitionTime preserved when status unchanged, got %v", out[0].LastTransitionTime)
+	}
+	if out[0].LastUpdateTime.IsZero() {
+		t.Fatal("expected LastUpdateTime advanced")
+	}
+}
+
+func TestSetMachinePoolCondition_advancesTransitionWhenStatusChanges(t *testing.T) {
+	earlier := metav1.NewTime(time.Now().Add(-time.Hour))
+	in := []computev1alpha1.MachinePoolCondition{{
+		Type:               computev1alpha1.MachinePoolReady,
+		Status:             corev1.ConditionTrue,
+		LastTransitionTime: earlier,
+	}}
+	out := computev1alpha1.SetMachinePoolCondition(in, computev1alpha1.MachinePoolCondition{
+		Type:   computev1alpha1.MachinePoolReady,
+		Status: corev1.ConditionFalse,
+	})
+	if out[0].LastTransitionTime.Equal(&earlier) {
+		t.Fatal("expected LastTransitionTime to advance when status changes")
+	}
+}

api/compute/v1alpha1/machinepool_types.go

@@ -85,6 +85,11 @@ type MachinePoolAddress struct {
 // MachinePoolConditionType is a type a MachinePoolCondition can have.
 type MachinePoolConditionType string
 
+const (
+	// MachinePoolReady means the machine pool is healthy and ready to accept machines.
+	MachinePoolReady MachinePoolConditionType = "Ready"
+)
+
 // MachinePoolCondition is one of the conditions of a MachinePool.
 type MachinePoolCondition struct {
 	// Type is the type of the condition.
@@ -97,6 +102,8 @@ type MachinePoolCondition struct {
 	Message string `json:"message"`
 	// ObservedGeneration represents the .metadata.generation that the condition was set based upon.
 	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+	// LastUpdateTime is the last time this condition was updated.
+	LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"`
 	// LastTransitionTime is the last time the status of a condition has transitioned from one state to another.
 	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
 }

api/storage/v1alpha1/bucketpool_types.go

@@ -22,11 +22,38 @@ type BucketPoolSpec struct {
 // BucketPoolStatus defines the observed state of BucketPool
 type BucketPoolStatus struct {
 	// State represents the infrastructure state of a BucketPool.
-	State BucketPoolState `json:"state,omitempty"`
+	State      BucketPoolState       `json:"state,omitempty"`
+	Conditions []BucketPoolCondition `json:"conditions,omitempty"`
 	// AvailableBucketClasses list the references of any supported BucketClass of this pool
 	AvailableBucketClasses []corev1.LocalObjectReference `json:"availableBucketClasses,omitempty"`
 }
 
+// BucketPoolConditionType is a type a BucketPoolCondition can have.
+type BucketPoolConditionType string
+
+const (
+	// BucketPoolReady means the bucket pool is healthy and ready to accept buckets.
+	BucketPoolReady BucketPoolConditionType = "Ready"
+)
+
+// BucketPoolCondition is one of the conditions of a BucketPool.
+type BucketPoolCondition struct {
+	// Type is the type of the condition.
+	Type BucketPoolConditionType `json:"type"`
+	// Status is the status of the condition.
+	Status corev1.ConditionStatus `json:"status"`
+	// Reason is a machine-readable indication of why the condition is in a certain state.
+	Reason string `json:"reason"`
+	// Message is a human-readable explanation of why the condition has a certain reason / state.
+	Message string `json:"message"`
+	// ObservedGeneration represents the .metadata.generation that the condition was set based upon.
+	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+	// LastUpdateTime is the last time this condition was updated.
+	LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"`
+	// LastTransitionTime is the last time the status of a condition has transitioned from one state to another.
+	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
+}
+
 type BucketPoolState string
 
 const (

api/storage/v1alpha1/common.go

@@ -5,6 +5,11 @@ package v1alpha1
 
 import corev1 "k8s.io/api/core/v1"
 
+const (
+	NamespaceVolumePoolLease = "ironcore-volumepool-lease"
+	NamespaceBucketPoolLease = "ironcore-bucketpool-lease"
+)
+
 const (
 	VolumeVolumePoolRefNameField     = "spec.volumePoolRef.name"
 	VolumeVolumeClassRefNameField    = "spec.volumeClassRef.name"

api/storage/v1alpha1/volumepool_types.go

@@ -43,6 +43,11 @@ const (
 // VolumePoolConditionType is a type a VolumePoolCondition can have.
 type VolumePoolConditionType string
 
+const (
+	// VolumePoolReady means the volume pool is healthy and ready to accept volumes.
+	VolumePoolReady VolumePoolConditionType = "Ready"
+)
+
 // VolumePoolCondition is one of the conditions of a volume.
 type VolumePoolCondition struct {
 	// Type is the type of the condition.
@@ -55,6 +60,8 @@ type VolumePoolCondition struct {
 	Message string `json:"message"`
 	// ObservedGeneration represents the .metadata.generation that the condition was set based upon.
 	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+	// LastUpdateTime is the last time this condition was updated.
+	LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"`
 	// LastTransitionTime is the last time the status of a condition has transitioned from one state to another.
 	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
 }