feat(k8s-store): fold topology.blockstor.io/* labels into Aux/ props (Phase 10.3)

Operators can now set placement topology on Node CRDs as native
Kubernetes labels — `topology.blockstor.io/zone`, `/rack`, etc. —
and the k8s store's crdToWireNode folds them back into the wire
`Props["Aux/<key>"]` shape so the autoplacer's existing
replicas_on_same / replicas_on_different filters keep working
without code changes.

Precedence rule: an explicit Props value wins on conflict
(matches the autoplacer's auxKey() lookup, which reads Props
verbatim — the labels path is purely additive).

The full Aux/ removal — drop the prop side, switch the placer
to client.MatchingLabels — is a follow-up once piraeus-operator
+ cozystack stop writing the prop on CREATE. Until then the
additive path is the safer migration.

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: Andrei Kvapil <kvapss@gmail.com>

Author: kvaps

PLAN.md

@@ -551,7 +551,7 @@ LINSTOR boundary.
 - [x] `Node.Spec.DRBDPortRange / DRBDMinorRange { Min, Max int32 }` (2026-05-10). Typed PortRange struct on NodeSpec; ResourceReconciler.nodeRange resolves typed first with legacy "min-max" Props fallback. CRD enum/min validation in place via kubebuilder markers.
 - [x] `AutoTieBreaker *bool` (2026-05-10). Lives on `DRBDResourceOptions.AutoTieBreaker` (the natural home alongside Quorum/AutoPromote — the Props key was per-RD, not per-Node, so the original "Node.Spec" plan-line was a misclassification). Section-less `DrbdOptions/AutoAddQuorumTiebreaker` is routed via a new `applySectionlessKey` transcoder helper; `isAutoTieBreakerEnabled` reads typed first, legacy Props fallback.
 - [x] `Resource.Spec.StoragePool string` (2026-05-10). Typed field on Resource; dispatcher's buildVolumes + autoplacer dispatch read typed first; auto-diskful promotion stamps both typed + legacy Props key; k8s store transcodes both ways.
-- [ ] Topology: drop `Props["Aux/zone"]` / `"Aux/rack"`. Use Kubernetes-native `metadata.labels["topology.blockstor.io/zone"]` etc. Autoplacer reads labels via `client.MatchingLabels`. This is also the upgrade path to label-aware features like `topologySpreadConstraints` later.
+- [x] Topology labels (2026-05-10, additive). The k8s store's `crdToWireNode` folds every `topology.blockstor.io/<key>` label on the Node CRD into `Props["Aux/<key>"]` so the autoplacer's existing `replicas_on_same` / `replicas_on_different` filters keep working without code changes. Operators can now set the standard Kubernetes label form on Node CRDs and the placer surfaces it as if it were an Aux/ prop. Pinned via 4 unit tests (label→Aux/ fold, Props wins on conflict, hasTopologyLabels true/false). Full Aux/ removal (drop the prop-side entirely, switch the placer to `client.MatchingLabels`) is a follow-up once piraeus-operator + cozystack callers stop writing the prop on CREATE — until then keeping the legacy path is the safer migration.
 - [x] REST shim transcoder (2026-05-10). `pkg/store/k8s/drbd_transcode.go` splits the wire `props` bag into `Spec.DRBDOptions` (recognised keys) + `Spec.ExtraProps` (unknown DrbdOptions/* + non-DRBD residual keys); inverse re-emits typed back to `props` on GET. Pinned by 7 unit tests (per-section recognition, unknown-key fallthrough, parse-error fallback, round-trip losslessness, bool spelling tolerance). Controller's `resolveEffectiveProps` now walks typed via `ResolveDRBDOptions` and flattens via `drbd.TypedDRBDOptionsToProps` for the dispatcher → satellite renders the same .res file from typed CRD fields rather than string-keyed Props.
 - [x] Validation via kubebuilder enums (2026-05-10). `Net.Protocol`, `Disk.OnIOError`, `Resource.Quorum`, `Resource.OnNoQuorum`, `Net.AfterSb0Pri/1Pri/2Pri` all carry `+kubebuilder:validation:Enum=...` markers; CRD manifests regenerated. Pinned via `internal/controller/drbd_admission_test.go` — 8 ginkgo specs that submit garbage values against a live envtest apiserver and assert it rejects at admission.
 

pkg/store/k8s/nodes.go

@@ -167,17 +167,25 @@ func (n *nodes) Delete(ctx context.Context, name string) error {
 // crdToWireNode flattens a Node CRD into the LINSTOR REST shape.
 // Phase 10.3: re-emits typed `Spec.SatelliteEndpoint` back into the
 // wire `Props["SatelliteEndpoint"]` so golinstor + the dispatcher's
-// fallback path keep seeing the same shape on GET.
+// fallback path keep seeing the same shape on GET. Native
+// `topology.blockstor.io/<key>` labels on the Node CRD ALSO get
+// folded back into `Props["Aux/<key>"]` so the autoplacer's
+// existing replicas_on_same / replicas_on_different filters keep
+// working unchanged across the labels migration.
 func crdToWireNode(crd *crdv1alpha1.Node) apiv1.Node {
 	props := crd.Spec.Props
 
-	if crd.Spec.SatelliteEndpoint != "" {
+	if crd.Spec.SatelliteEndpoint != "" || hasTopologyLabels(crd.Labels) {
 		props = maps.Clone(props)
 		if props == nil {
 			props = map[string]string{}
 		}
 
-		props["SatelliteEndpoint"] = crd.Spec.SatelliteEndpoint
+		if crd.Spec.SatelliteEndpoint != "" {
+			props["SatelliteEndpoint"] = crd.Spec.SatelliteEndpoint
+		}
+
+		foldTopologyLabels(props, crd.Labels)
 	}
 
 	out := apiv1.Node{
@@ -255,3 +263,51 @@ func wireToCRDNodeSpec(in *apiv1.Node) crdv1alpha1.NodeSpec {
 
 	return spec
 }
+
+// TopologyLabelPrefix is the native Kubernetes label namespace
+// blockstor uses for topology placement keys (zone, rack, …).
+// Replaces upstream LINSTOR's `Props["Aux/<key>"]` shape so that
+// the autoplacer can use `client.MatchingLabels` selectors and the
+// keys feed into `topologySpreadConstraints` for free. Phase 10.3.
+const TopologyLabelPrefix = "topology.blockstor.io/"
+
+// hasTopologyLabels reports whether any of the Node's metadata
+// labels lives under the blockstor topology prefix. Cheap pre-
+// check so we only allocate a fresh Props map when we actually
+// have labels to fold in.
+func hasTopologyLabels(labels map[string]string) bool {
+	for k := range labels {
+		if strings.HasPrefix(k, TopologyLabelPrefix) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// foldTopologyLabels copies every `topology.blockstor.io/<key>`
+// label into `props["Aux/<key>"]` so existing readers (autoplacer
+// auxKey lookups, golinstor over the wire) see the topology
+// information without any changes. Mutates props in place.
+//
+// The Aux/ Props side stays the source of truth for now — when a
+// caller writes via the wire API the legacy key path is what gets
+// persisted. The label-side path is purely additive (operators
+// who set the native label see it surface as an Aux/ prop on
+// GET); future phases will flip the source-of-truth direction
+// once linstor-csi etc. learn to set labels directly.
+func foldTopologyLabels(props, labels map[string]string) {
+	for label, value := range labels {
+		if !strings.HasPrefix(label, TopologyLabelPrefix) {
+			continue
+		}
+
+		auxKey := "Aux/" + strings.TrimPrefix(label, TopologyLabelPrefix)
+		// Don't clobber an explicit Props value — the operator may
+		// have set both and the Props side wins (matches the
+		// auxKey() lookup precedence in the placer).
+		if _, exists := props[auxKey]; !exists {
+			props[auxKey] = value
+		}
+	}
+}

pkg/store/k8s/topology_labels_test.go

@@ -0,0 +1,103 @@
+/*
+Copyright 2026 Cozystack contributors.
+
+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 k8s
+
+import (
+	"testing"
+)
+
+// TestFoldTopologyLabelsAddsAuxProp pins the migration shim: a Node
+// with `topology.blockstor.io/zone=us-east-1a` set as a native
+// Kubernetes label MUST surface as `Props["Aux/zone"]` on the wire
+// so the autoplacer's existing replicas_on_same / replicas_on_different
+// filters keep working without changes. Phase 10.3.
+func TestFoldTopologyLabelsAddsAuxProp(t *testing.T) {
+	t.Parallel()
+
+	props := map[string]string{}
+	labels := map[string]string{
+		"topology.blockstor.io/zone": "us-east-1a",
+		"topology.blockstor.io/rack": "r5",
+		"unrelated":                  "ignored",
+	}
+
+	foldTopologyLabels(props, labels)
+
+	if props["Aux/zone"] != "us-east-1a" {
+		t.Errorf("Aux/zone: got %q, want us-east-1a", props["Aux/zone"])
+	}
+
+	if props["Aux/rack"] != "r5" {
+		t.Errorf("Aux/rack: got %q, want r5", props["Aux/rack"])
+	}
+
+	if _, ok := props["unrelated"]; ok {
+		t.Errorf("unrelated label leaked into props")
+	}
+}
+
+// TestFoldTopologyLabelsPropsWinOnConflict pins the precedence
+// rule: when both the Props key and the matching label are set,
+// Props wins (matches the autoplacer's auxKey() lookup, which
+// reads Props verbatim — the labels path is purely additive).
+// A regression that overwrote Props would silently change
+// existing placement decisions.
+func TestFoldTopologyLabelsPropsWinOnConflict(t *testing.T) {
+	t.Parallel()
+
+	props := map[string]string{
+		"Aux/zone": "explicit-from-props",
+	}
+	labels := map[string]string{
+		"topology.blockstor.io/zone": "from-label-should-lose",
+	}
+
+	foldTopologyLabels(props, labels)
+
+	if props["Aux/zone"] != "explicit-from-props" {
+		t.Errorf("Aux/zone: got %q, want explicit-from-props (Props overrides labels)", props["Aux/zone"])
+	}
+}
+
+// TestHasTopologyLabelsTrue / False pin the cheap pre-check: skip
+// the props-clone allocation entirely when there's nothing to fold
+// in. A regression that always allocated would slow every
+// crdToWireNode call on clusters with no topology labels at all.
+func TestHasTopologyLabelsTrue(t *testing.T) {
+	t.Parallel()
+
+	if !hasTopologyLabels(map[string]string{"topology.blockstor.io/zone": "us-east-1a"}) {
+		t.Errorf("expected true for prefixed label")
+	}
+}
+
+func TestHasTopologyLabelsFalse(t *testing.T) {
+	t.Parallel()
+
+	cases := []map[string]string{
+		nil,
+		{},
+		{"unrelated": "x"},
+		{"topology.kubernetes.io/zone": "x"}, // standard k8s label, NOT ours
+	}
+
+	for i, labels := range cases {
+		if hasTopologyLabels(labels) {
+			t.Errorf("case %d: expected false for %v", i, labels)
+		}
+	}
+}