[rsc-controller] Add ReplicatedVolumeOperation API and rolling operations support

Introduce ReplicatedVolumeOperation (RVO) API for managing rolling
configuration updates and eligible nodes conflict resolution.

API changes:
- Add ReplicatedVolumeOperation type with Spec (Type, ReplicatedVolumeName,
  ResolveEligibleNodesConflict) and Status (Conditions)
- Add RollingOperationsCursor and SortSalt to ReplicatedStorageClassStatus
- Add LastOperation field to ReplicatedVolumeStatus for UI observability
- Add RSCRVOLockFinalizer and OperationCursorLabelKey constants

RSC controller changes:
- Add RVO watch with predicates (Completed condition changes)
- Add RVO indexes (by RSC owner ref, by RV owner ref)
- Implement selectTargetRollingOperations with filter-before-compute
  optimization (reduces hash computations from O(N) to O(C))
- Implement round-robin cursor-based volume selection with budget limits
- Add removeRVOLockFinalizers for cleanup when cursor advances
- Add defensive check for empty cursor label (migration safety)

Performance:
- Add go-performance-patterns.mdc rule with Schwartzian transform
  and filter-before-compute patterns

Tests:
- Add 36 new unit tests for rolling operations logic

Signed-off-by: Ivan Ogurchenok <ivan.ogurchenok@flant.com>

Author: IvanOgurchenok

.cursor/rules/go-performance-patterns.mdc

@@ -0,0 +1,141 @@
+---
+description: Go performance patterns for sorting and iteration. Apply when reviewing code with sort.Slice over collections that may have 100+ items with non-trivial comparators, or when expensive operations are applied to collections before filtering.
+alwaysApply: false
+---
+
+See `rfc-like-mdc.mdc` for normative keywords (BCP 14 / RFC 2119 / RFC 8174) and general .mdc writing conventions.
+
+# Go performance patterns
+
+## Schwartzian transform for sorting (SHOULD)
+
+When sorting slices where:
+- the comparator calls **expensive functions** (hash computations, string formatting, allocations), AND
+- the slice may contain **100+ items** in production scenarios,
+
+you SHOULD use the **Schwartzian transform** (decorate-sort-undecorate) pattern:
+
+1. **Decorate**: Precompute expensive values into a temporary struct slice — O(N)
+2. **Sort**: Sort by precomputed values (cheap comparison) — O(N log N) comparisons
+3. **Undecorate**: Extract results — O(N)
+
+This reduces expensive computations from O(N log N) to O(N).
+
+### Why it matters
+
+| Items | Comparisons (sort) | Hash calls (naive) | Hash calls (optimized) |
+|-------|-------------------|--------------------|------------------------|
+| 100   | ~665              | ~1330              | 100                    |
+| 500   | ~4483             | ~8966              | 500                    |
+| 1000  | ~9966             | ~19932             | 1000                   |
+
+### Example (GOOD)
+
+```go
+// sortItemsByExpensiveKey sorts items using Schwartzian transform.
+// Precomputes keys to avoid O(N log N) expensive calls.
+func sortItemsByExpensiveKey(items []Item) []Item {
+    // Decorate: precompute keys once.
+    type decorated struct {
+        item *Item
+        key  string
+    }
+    tmp := make([]decorated, len(items))
+    for i := range items {
+        tmp[i] = decorated{
+            item: &items[i],
+            key:  expensiveKeyComputation(items[i]),
+        }
+    }
+
+    // Sort by precomputed key.
+    sort.SliceStable(tmp, func(i, j int) bool {
+        return tmp[i].key < tmp[j].key
+    })
+
+    // Undecorate: extract sorted items.
+    result := make([]Item, len(tmp))
+    for i, d := range tmp {
+        result[i] = *d.item
+    }
+    return result
+}
+```
+
+### Example (BAD)
+
+```go
+// BAD: expensiveKeyComputation called O(N log N) times
+sort.SliceStable(items, func(i, j int) bool {
+    return expensiveKeyComputation(items[i]) < expensiveKeyComputation(items[j])
+})
+```
+
+### When reviewing code
+
+When you see `sort.Slice` / `sort.SliceStable` with a non-trivial comparator:
+
+1. ASK about expected collection size in production
+2. ASK about comparator cost (allocations, hashing, formatting)
+3. SUGGEST Schwartzian transform if:
+   - Collection may have 100+ items, AND
+   - Comparator is more expensive than simple field access
+
+---
+
+## Filter before compute (SHOULD)
+
+When processing a collection with expensive per-element operations (hashing, serialization, complex computations), you SHOULD filter the collection **before** applying those operations.
+
+### Rationale
+
+If only M of N elements need processing, filtering first reduces expensive operations from O(N) to O(M).
+
+### Example (BAD)
+
+```go
+// BAD: computes expensive values for ALL N items, then filters
+sortedAll := sortByExpensiveHash(items) // N hash calls
+var candidates []Item
+for _, item := range sortedAll {
+    if needsProcessing(item) { // cheap check
+        candidates = append(candidates, item)
+    }
+}
+// Only M candidates actually needed, but we computed N hashes
+```
+
+### Example (GOOD)
+
+```go
+// GOOD: filter first, then compute only for candidates
+var candidates []Item
+for i := range items {
+    if needsProcessing(&items[i]) { // cheap check: O(N)
+        candidates = append(candidates, items[i])
+    }
+}
+// Now compute expensive values only for M candidates
+sortedCandidates := sortByExpensiveHash(candidates) // M hash calls
+```
+
+### Combining with Schwartzian transform
+
+When both patterns apply:
+
+1. **Filter** to candidates — O(N) cheap checks
+2. **Decorate** candidates with expensive keys — O(M) expensive calls
+3. **Sort** by precomputed keys — O(M log M) cheap comparisons
+4. **Undecorate** (if needed) — O(M)
+
+This reduces expensive computations from O(N + N log N) to O(M).
+
+### When reviewing code
+
+When you see expensive operations applied to a collection before filtering:
+
+1. ASK: "Can we filter first to reduce the set?"
+2. CHECK: Is the filter condition cheap (simple field checks, map lookups)?
+3. SUGGEST filter-before-compute if:
+   - Only a subset M of N items need the expensive operation, AND
+   - The filter condition is significantly cheaper than the expensive operation

api/v1alpha1/finalizers.go

@@ -21,3 +21,7 @@ const AgentFinalizer = "sds-replicated-volume.deckhouse.io/agent"
 const ControllerFinalizer = "sds-replicated-volume.deckhouse.io/controller"
 
 const RSCControllerFinalizer = "sds-replicated-volume.deckhouse.io/rsc-controller"
+
+// RSCRVOLockFinalizer is set by the RSC controller on RVO objects to prevent
+// garbage collection until the rolling update cursor has moved forward.
+const RSCRVOLockFinalizer = "sds-replicated-volume.deckhouse.io/rsc-rvo-lock"

api/v1alpha1/labels.go

@@ -34,4 +34,8 @@ const (
 
 	// AgentNodeLabelKey is the label key for selecting nodes where the agent should run.
 	AgentNodeLabelKey = "storage.deckhouse.io/sds-replicated-volume-node"
+
+	// OperationCursorLabelKey is the label key for storing the cursor value on RVO objects.
+	// Used to reliably identify which cursor the operation belongs to without parsing the name.
+	OperationCursorLabelKey = labelPrefix + "operation-cursor"
 )

api/v1alpha1/register.go

@@ -52,6 +52,8 @@ func addKnownTypes(scheme *runtime.Scheme) error {
 		&ReplicatedVolumeAttachmentList{},
 		&ReplicatedVolumeReplica{},
 		&ReplicatedVolumeReplicaList{},
+		&ReplicatedVolumeOperation{},
+		&ReplicatedVolumeOperationList{},
 		&DRBDResource{},
 		&DRBDResourceList{},
 		&DRBDResourceOperation{},

api/v1alpha1/rsc_types.go

@@ -332,6 +332,15 @@ type ReplicatedStorageClassStatus struct {
 	// Volumes provides aggregated volume statistics.
 	// Always present (may have total=0).
 	Volumes ReplicatedStorageClassVolumesSummary `json:"volumes"`
+
+	// SortSalt is a random value used for deterministic volume sorting during rolling operations.
+	// Generated when rolling operations start, cleared when all volumes are aligned.
+	// +optional
+	SortSalt string `json:"sortSalt,omitempty"`
+	// RollingOperationsCursor tracks the last processed volume hash during rolling operations.
+	// Used for round-robin processing of volumes (both config updates and conflict resolutions).
+	// +optional
+	RollingOperationsCursor string `json:"rollingOperationsCursor,omitempty"`
 }
 
 // ReplicatedStorageClassEligibleNodesWorldState tracks external state that affects eligible nodes.

api/v1alpha1/rv_types.go

@@ -136,6 +136,11 @@ type ReplicatedVolumeStatus struct {
 	// EligibleNodesViolations lists replicas placed on non-eligible nodes.
 	// +optional
 	EligibleNodesViolations []ReplicatedVolumeEligibleNodesViolation `json:"eligibleNodesViolations,omitempty"`
+
+	// LastOperation tracks the most recent rolling operation for this volume.
+	// Provides observability for kubectl and UI.
+	// +optional
+	LastOperation *ReplicatedVolumeLastOperation `json:"lastOperation,omitempty"`
 }
 
 // DeviceMinor is a DRBD device minor number.
@@ -290,3 +295,23 @@ const (
 )
 
 func (r ReplicatedVolumeEligibleNodesViolationReason) String() string { return string(r) }
+
+// ReplicatedVolumeLastOperation tracks the most recent rolling operation for a volume.
+// Provides observability for kubectl get and UI.
+// +kubebuilder:object:generate=true
+type ReplicatedVolumeLastOperation struct {
+	// Type is the operation type (UpdateConfiguration or ResolveEligibleNodesConflict).
+	Type string `json:"type"`
+	// Name is the ReplicatedVolumeOperation resource name.
+	Name string `json:"name"`
+	// CreatedAt is when the operation was created.
+	CreatedAt metav1.Time `json:"createdAt"`
+	// CompletedAt is when the operation completed (nil if still in progress).
+	// +optional
+	CompletedAt *metav1.Time `json:"completedAt,omitempty"`
+	// Status is the operation status: Pending, InProgress, Succeeded, or Failed.
+	Status string `json:"status"`
+	// Message provides additional information about the operation status.
+	// +optional
+	Message string `json:"message,omitempty"`
+}

api/v1alpha1/rvo_conditions.go

@@ -0,0 +1,31 @@
+/*
+Copyright 2026 Flant JSC
+
+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
+
+const (
+	// ReplicatedVolumeOperationCondCompletedType indicates whether the operation has completed.
+	// When status is True, the operation finished (check reason for success/failure).
+	// When status is False, the operation is still in progress or pending.
+	//
+	// Reasons describe completion state.
+	ReplicatedVolumeOperationCondCompletedType             = "Completed"
+	ReplicatedVolumeOperationCondCompletedReasonFailed     = "Failed"     // Operation failed.
+	ReplicatedVolumeOperationCondCompletedReasonInProgress = "InProgress" // Operation is being processed.
+	ReplicatedVolumeOperationCondCompletedReasonPending    = "Pending"    // Operation is waiting to be processed.
+	ReplicatedVolumeOperationCondCompletedReasonSucceeded  = "Succeeded"  // Operation completed successfully.
+	ReplicatedVolumeOperationCondCompletedReasonVolumeGone = "VolumeGone" // Target volume no longer exists.
+)

api/v1alpha1/rvo_types.go

@@ -0,0 +1,134 @@
+/*
+Copyright 2026 Flant JSC
+
+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 (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// ReplicatedVolumeOperation represents an operation to update volume configuration
+// or resolve eligible nodes conflicts for a ReplicatedVolume.
+//
+// +kubebuilder:object:generate=true
+// +kubebuilder:object:root=true
+// +kubebuilder:subresource:status
+// +kubebuilder:resource:scope=Cluster,shortName=rvo
+// +kubebuilder:metadata:labels=module=sds-replicated-volume
+// +kubebuilder:printcolumn:name="Volume",type=string,JSONPath=".spec.replicatedVolumeName"
+// +kubebuilder:printcolumn:name="Type",type=string,JSONPath=".spec.type"
+// +kubebuilder:printcolumn:name="Completed",type=string,JSONPath=".status.conditions[?(@.type=='Completed')].status"
+// +kubebuilder:printcolumn:name="Age",type=date,JSONPath=".metadata.creationTimestamp"
+type ReplicatedVolumeOperation struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata"`
+
+	Spec ReplicatedVolumeOperationSpec `json:"spec"`
+	// +patchStrategy=merge
+	Status ReplicatedVolumeOperationStatus `json:"status,omitempty" patchStrategy:"merge"`
+}
+
+// +kubebuilder:object:generate=true
+// +kubebuilder:object:root=true
+// +kubebuilder:resource:scope=Cluster
+type ReplicatedVolumeOperationList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata"`
+	Items           []ReplicatedVolumeOperation `json:"items"`
+}
+
+// GetStatusConditions is an adapter method to satisfy objutilv1.StatusConditionObject.
+// It returns the root object's `.status.conditions`.
+func (o *ReplicatedVolumeOperation) GetStatusConditions() []metav1.Condition {
+	return o.Status.Conditions
+}
+
+// SetStatusConditions is an adapter method to satisfy objutilv1.StatusConditionObject.
+// It sets the root object's `.status.conditions`.
+func (o *ReplicatedVolumeOperation) SetStatusConditions(conditions []metav1.Condition) {
+	o.Status.Conditions = conditions
+}
+
+// ReplicatedVolumeOperationSpec defines the desired state of a ReplicatedVolumeOperation.
+// All fields are immutable after creation.
+//
+// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="spec is immutable"
+// +kubebuilder:object:generate=true
+type ReplicatedVolumeOperationSpec struct {
+	// ReplicatedVolumeName is the name of the ReplicatedVolume this operation targets.
+	// +kubebuilder:validation:Required
+	// +kubebuilder:validation:MinLength=1
+	// +kubebuilder:validation:MaxLength=120
+	ReplicatedVolumeName string `json:"replicatedVolumeName"`
+
+	// Type specifies the operation type.
+	// +kubebuilder:validation:Required
+	// +kubebuilder:validation:Enum=UpdateConfiguration;ResolveEligibleNodesConflict
+	Type ReplicatedVolumeOperationType `json:"type"`
+
+	// ResolveEligibleNodesConflict indicates whether this operation should also resolve
+	// eligible nodes conflicts when updating configuration. Only meaningful when Type is
+	// UpdateConfiguration. Determined by EligibleNodesConflictResolutionStrategy.
+	// +kubebuilder:default=false
+	// +optional
+	ResolveEligibleNodesConflict bool `json:"resolveEligibleNodesConflict,omitempty"`
+}
+
+// ReplicatedVolumeOperationType enumerates possible operation types.
+type ReplicatedVolumeOperationType string
+
+const (
+	// ReplicatedVolumeOperationTypeUpdateConfiguration updates the volume configuration
+	// to match the current storage class configuration.
+	ReplicatedVolumeOperationTypeUpdateConfiguration ReplicatedVolumeOperationType = "UpdateConfiguration"
+	// ReplicatedVolumeOperationTypeResolveEligibleNodesConflict moves replicas
+	// from non-eligible nodes to eligible nodes.
+	ReplicatedVolumeOperationTypeResolveEligibleNodesConflict ReplicatedVolumeOperationType = "ResolveEligibleNodesConflict"
+)
+
+func (t ReplicatedVolumeOperationType) String() string { return string(t) }
+
+// Short name suffixes for operation resource naming.
+// Format: <rv-name>-<suffix>-<cursor>
+const (
+	// ReplicatedVolumeOperationNameSuffixUpdateConfig is the short suffix for UpdateConfiguration operations.
+	ReplicatedVolumeOperationNameSuffixUpdateConfig = "updateConfig"
+	// ReplicatedVolumeOperationNameSuffixResolveNodes is the short suffix for ResolveEligibleNodesConflict operations.
+	ReplicatedVolumeOperationNameSuffixResolveNodes = "resolveNodes"
+)
+
+// NameSuffix returns the short suffix for generating operation resource names.
+func (t ReplicatedVolumeOperationType) NameSuffix() string {
+	switch t {
+	case ReplicatedVolumeOperationTypeUpdateConfiguration:
+		return ReplicatedVolumeOperationNameSuffixUpdateConfig
+	case ReplicatedVolumeOperationTypeResolveEligibleNodesConflict:
+		return ReplicatedVolumeOperationNameSuffixResolveNodes
+	default:
+		return string(t)
+	}
+}
+
+// ReplicatedVolumeOperationStatus represents the current state of a ReplicatedVolumeOperation.
+// +kubebuilder:object:generate=true
+type ReplicatedVolumeOperationStatus struct {
+	// +patchMergeKey=type
+	// +patchStrategy=merge
+	// +listType=map
+	// +listMapKey=type
+	// +optional
+	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
+}