fix(store): find replicas and snapshots in any name spelling, store layer stacks in canonical case

cmd/satellite/coldstart_owned.go

@@ -11,6 +11,7 @@ import (
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	blockstoriov1alpha1 "github.com/cozystack/blockstor/api/v1alpha1"
+	"github.com/cozystack/blockstor/pkg/naming"
 	k8sstore "github.com/cozystack/blockstor/pkg/store/k8s"
 )
 
@@ -42,7 +43,7 @@ func ownedOnNode(ctx context.Context, c ctrlclient.Client, nodeName string) (map
 
 	owned := make(map[string]struct{}, len(replicas))
 	for i := range replicas {
-		owned[replicas[i].Name] = struct{}{}
+		owned[naming.Key(replicas[i].Name)] = struct{}{}
 	}
 
 	return owned, nil
@@ -60,7 +61,7 @@ func selectOrphans(names []string, healthy, owned map[string]struct{}) ([]string
 			continue
 		}
 
-		if _, ok := owned[name]; !ok {
+		if _, ok := owned[naming.Key(name)]; !ok {
 			foreign = append(foreign, name)
 
 			continue

cmd/satellite/coldstart_owned_test.go

@@ -156,3 +156,36 @@ func TestOwnedOnNodeNamesTheReplicasOfThisNode(t *testing.T) {
 		t.Errorf("owned on srv1 = %v, want [pvc-a pvc-b]", got)
 	}
 }
+
+// A definition registered as PVC-X runs in the kernel under its key, pvc-x,
+// while the store shows its replica under the registered spelling. Cold start
+// still knows that kernel resource for blockstor's, and takes it down when it
+// is not healthy, instead of leaving it as another DRBD user's.
+func TestColdStartOwnsAResourceRegisteredInMixedCase(t *testing.T) {
+	t.Parallel()
+
+	scheme := runtime.NewScheme()
+	if err := blockstoriov1alpha1.AddToScheme(scheme); err != nil {
+		t.Fatalf("scheme: %v", err)
+	}
+
+	c := fake.NewClientBuilder().WithScheme(scheme).
+		WithObjects(&blockstoriov1alpha1.Resource{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:        "pvc-x.srv1",
+				Annotations: map[string]string{"blockstor.io/linstor-resource-definition-name": "PVC-X"},
+			},
+			Spec: blockstoriov1alpha1.ResourceSpec{ResourceDefinitionName: "pvc-x", NodeName: "srv1"},
+		}).
+		Build()
+
+	owned, err := ownedOnNode(t.Context(), c, "srv1")
+	if err != nil {
+		t.Fatalf("ownedOnNode: %v", err)
+	}
+
+	orphans, foreign := selectOrphans([]string{"pvc-x"}, map[string]struct{}{}, owned)
+	if !slices.Equal(orphans, []string{"pvc-x"}) || len(foreign) != 0 {
+		t.Errorf("orphans %v, foreign %v; want pvc-x taken down as blockstor's", orphans, foreign)
+	}
+}

docs/linstor-migration.md

@@ -48,7 +48,7 @@ Migrated: nodes, storage pools, resource groups, resource definitions (+ volume
 
 4. **Back up the ZFS/LVM pools' snapshots** (optional but recommended): a `zfs snapshot -r` of each pool gives an instant rollback point that is independent of both control planes.
 
-5. **Verify the zvol names blockstor will adopt match what is on disk.** Adoption is name-based: blockstor addresses each volume as `<zpool>/<rd-name-lowercased>_<volume-number-%05d>` (e.g. `data/pvc-abc…_00000`), and `CreateVolume` is idempotent only when that dataset already exists. A byte mismatch (ZFS names are case-sensitive) makes blockstor create a fresh EMPTY zvol next to the real one. Multi-replica DRBD would self-heal by SyncTarget, but **single-replica `["STORAGE"]` volumes have no resync fallback** — a mismatch there silently presents an empty disk. Cross-check before cutover, read-only, on each satellite:
+5. **Verify the zvol names blockstor will adopt match what is on disk.** Adoption is name-based: blockstor addresses each volume as `<zpool>/<rd-cr-name>_<volume-number-%05d>` (e.g. `data/pvc-abc…_00000`), where `<rd-cr-name>` is the RD's `metadata.name` in the converted manifests: the LINSTOR name lowercased, or, for a name that is not a valid RFC 1123 label once lowercased, a hashed slug such as `35d21682-my-res` for `my_res`. Such a definition never matches the LINSTOR volume on disk, so rename it or the volume before cutover. `CreateVolume` is idempotent only when that dataset already exists. A byte mismatch (ZFS names are case-sensitive) makes blockstor create a fresh EMPTY zvol next to the real one. Multi-replica DRBD would self-heal by SyncTarget, but **single-replica `["STORAGE"]` volumes have no resync fallback** — a mismatch there silently presents an empty disk. Cross-check before cutover, read-only, on each satellite:
 
    ```bash
    # what is on disk:
@@ -61,7 +61,7 @@ Migrated: nodes, storage pools, resource groups, resource definitions (+ volume
 
    If any single-replica volume's computed name is absent from `ondisk-zvols.txt`, STOP — do not cut over until the naming is reconciled (`zfs rename`, or fix the converter).
 
-   **Adopted snapshots are addressed the same way** — `<zpool>/<rd-name-lowercased>_00000@<snapshot-name>` — so run the same cross-check for them, otherwise a name miss only surfaces when someone tries to restore, long after cutover:
+   **Adopted snapshots are addressed the same way** — `<zpool>/<rd-cr-name>_00000@<snapshot-name>` — so run the same cross-check for them, otherwise a name miss only surfaces when someone tries to restore, long after cutover:
 
    ```bash
    zfs list -H -o name -t snapshot | sort > /tmp/ondisk-snapshots.txt

go.mod

@@ -14,6 +14,7 @@ require (
 	github.com/prometheus/client_golang v1.23.2
 	golang.org/x/sys v0.39.0
 	golang.org/x/term v0.38.0
+	golang.org/x/tools v0.39.0
 	k8s.io/api v0.35.0
 	k8s.io/apiextensions-apiserver v0.35.0
 	k8s.io/apimachinery v0.35.0
@@ -91,7 +92,6 @@ require (
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/text v0.32.0 // indirect
 	golang.org/x/time v0.14.0 // indirect
-	golang.org/x/tools v0.39.0 // indirect
 	gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20250303144028-a0af3efb3deb // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a // indirect

internal/cli/definition.go

@@ -29,6 +29,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	apiv1 "github.com/cozystack/blockstor/pkg/api/v1"
+	"github.com/cozystack/blockstor/pkg/naming"
 	"github.com/cozystack/blockstor/pkg/store"
 
 	"github.com/cozystack/blockstor/internal/cli/command"
@@ -365,11 +366,11 @@ func candidatePools(ctx context.Context, run *runContext, group *apiv1.ResourceG
 			continue
 		case !matchesAny(wanted, pool.StoragePoolName):
 			continue
-		case seen[pool.NodeName]:
+		case seen[naming.Key(pool.NodeName)]:
 			continue
 		}
 
-		seen[pool.NodeName] = true
+		seen[naming.Key(pool.NodeName)] = true
 
 		pools = append(pools, *pool)
 	}
@@ -388,7 +389,7 @@ func matchesAny(filter []string, name string) bool {
 		return true
 	}
 
-	return slices.Contains(filter, name)
+	return slices.ContainsFunc(filter, func(f string) bool { return naming.Same(f, name) })
 }
 
 // maxVolumeSizeKib is the smallest free capacity among the pools a

internal/cli/flags.go

@@ -24,6 +24,7 @@ import (
 	"strings"
 
 	"github.com/cozystack/blockstor/pkg/drbd"
+	"github.com/cozystack/blockstor/pkg/naming"
 
 	"github.com/cozystack/blockstor/internal/cli/command"
 )
@@ -367,15 +368,15 @@ func splitList(value string) []string {
 	return out
 }
 
-// matches reports whether a value passes a filter list (empty filter
-// matches everything).
+// matches reports whether a name passes a filter list, comparing as the
+// store addresses objects (naming.Same); an empty filter matches everything.
 func matches(filter []string, value string) bool {
 	if len(filter) == 0 {
 		return true
 	}
 
 	for _, want := range filter {
-		if strings.EqualFold(want, value) {
+		if naming.Same(want, value) {
 			return true
 		}
 	}

internal/cli/guards_test.go

@@ -92,6 +92,38 @@ func TestMigrateDiskRefusesSelfMigration(t *testing.T) {
 	}
 }
 
+// The two ends are compared as the store addresses nodes: Node-1 and node-1
+// are one node, so `r td node-1 pvc-x --migrate-from Node-1` is a migration
+// onto its own source and is refused with nothing written, neither a mark on
+// the source nor a second replica.
+func TestMigrateDiskRefusesSelfMigrationInAnotherSpelling(t *testing.T) {
+	t.Parallel()
+
+	app, _, errBuf := newApp(t, func(ctx context.Context, backend store.Store) {
+		_ = backend.Nodes().Create(ctx, &apiv1.Node{Name: "Node-1"})
+		_ = backend.ResourceDefinitions().Create(ctx, &apiv1.ResourceDefinition{Name: "pvc-x"})
+		_ = backend.Resources().Create(ctx, &apiv1.Resource{Name: "pvc-x", NodeName: "Node-1"})
+	})
+
+	argv := []string{"r", "td", "node-1", "pvc-x", "--migrate-from", "Node-1"}
+	if got := app.Run(t.Context(), argv); got == 0 {
+		t.Fatalf("self-migration in another spelling was accepted (stderr: %s)", errBuf.String())
+	}
+
+	replicas, err := appStore(t, app).Resources().ListByDefinition(t.Context(), "pvc-x")
+	if err != nil {
+		t.Fatalf("list replicas: %v", err)
+	}
+
+	if len(replicas) != 1 {
+		t.Fatalf("the refused migration left %d replicas, want the source alone: %+v", len(replicas), replicas)
+	}
+
+	if replicas[0].Props["BlockstorMigratingFrom"] != "" {
+		t.Errorf("the refused migration still stamped the source: %v", replicas[0].Props)
+	}
+}
+
 // A restore onto a node that does not hold the snapshot creates a replica
 // with nothing behind it and reports success.
 func TestRestoreRefusesNodesWithoutTheSnapshot(t *testing.T) {

internal/cli/handlers.go

@@ -27,6 +27,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	apiv1 "github.com/cozystack/blockstor/pkg/api/v1"
+	"github.com/cozystack/blockstor/pkg/naming"
 
 	"github.com/cozystack/blockstor/pkg/store"
 
@@ -311,14 +312,13 @@ func volumeDefinitionList(ctx context.Context, run *runContext) error {
 // colour classifier went to the trouble of stripping it.
 //
 // The replicas are read whole and filtered in process, `-n` and `-r`
-// included. The filter compares the way LINSTOR does, case-insensitively,
-// and a replica's spec keeps whatever case its writer used: an adoption
-// run or linstor-csi can store `NODE-1` for a node the operator types as
-// `node-1`. The node- and definition-scoped reads compare the stored
-// spelling verbatim (see store.FoldName), so answering a narrowed listing
-// with them returned fewer rows than this filter finds, with exit status
-// zero. Narrowing the read without that loss needs the folded selectable
-// field FoldName describes; until it exists, the listing stays whole.
+// included. The filter compares names as the store addresses them
+// (naming.Same), and a replica's spec keeps whatever case its writer used:
+// an adoption run or linstor-csi can store `NODE-1` for a node the operator
+// types as `node-1`. The node- and definition-scoped reads compare the stored
+// spelling verbatim, as a field selector does (pkg/store/k8s/spellings.go),
+// so answering a narrowed listing with them returned fewer rows than this
+// filter finds, with exit status zero; the listing stays whole.
 func resourceList(ctx context.Context, run *runContext) error {
 	resources, err := fetchResources(ctx, run.Store)
 	if err != nil {
@@ -512,7 +512,7 @@ func volumeSizesInOneRequest(
 	sizes := make(map[string]map[int32]int64, len(names))
 
 	for _, name := range names {
-		vds, ok := all[store.FoldName(name)]
+		vds, ok := all[naming.Key(name)]
 		if !ok {
 			continue
 		}

internal/cli/layer_list_case_test.go

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+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 cli
+
+import (
+	"slices"
+	"testing"
+)
+
+// The CLI writes the CRDs directly, so it stores the stack in the same
+// canonical case as the REST doors.
+func TestParseLayerListStoresCanonicalCase(t *testing.T) {
+	t.Parallel()
+
+	got, err := parseLayerList("drbd,Luks,storage")
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+
+	want := []string{"DRBD", "LUKS", "STORAGE"}
+	if !slices.Equal(got, want) {
+		t.Fatalf("got %v, want %v", got, want)
+	}
+}

internal/cli/name_filter_test.go

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+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 cli
+
+import "testing"
+
+// A list filter names objects the way the store addresses them: PVC-X finds
+// pvc-x, and my_res does not find My_Res, a definition of its own.
+func TestListFiltersMatchByKey(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		filter, value string
+		want          bool
+	}{
+		{"PVC-X", "pvc-x", true},
+		{"Node-1", "node-1", true},
+		{"my_res", "My_Res", false},
+		{"My_Res", "My_Res", true},
+		{"pvc-y", "pvc-x", false},
+	} {
+		if got := matches([]string{tc.filter}, tc.value); got != tc.want {
+			t.Errorf("matches(%q, %q) = %v, want %v", tc.filter, tc.value, got, tc.want)
+		}
+	}
+}
+
+// A group's pool filter names pools the way the store addresses them.
+func TestPoolFilterMatchesByKey(t *testing.T) {
+	t.Parallel()
+
+	if !matchesAny([]string{"ThinPool"}, "thinpool") {
+		t.Error("filter ThinPool does not admit pool thinpool")
+	}
+
+	if matchesAny([]string{"thin_pool"}, "Thin_Pool") {
+		t.Error("filter thin_pool admits Thin_Pool, another pool")
+	}
+}

internal/cli/node_spelling_pool_test.go

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+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 cli
+
+import (
+	"testing"
+
+	apiv1 "github.com/cozystack/blockstor/pkg/api/v1"
+	"github.com/cozystack/blockstor/pkg/store"
+)
+
+// The wire spells a replica's node as it was registered, Node-1, while the
+// operator names the node node-1. The pool a restore or a create infers is
+// the one of that node's own replica, or of a sibling, never the other way.
+func TestPoolInferenceReadsTheNodeInAnotherSpelling(t *testing.T) {
+	t.Parallel()
+
+	st := store.NewInMemory()
+	ctx := t.Context()
+	run := &runContext{Store: st, Flags: &flagSet{Values: map[string]string{}}}
+
+	for _, node := range []string{"Node-1", "Node-2"} {
+		if err := st.Resources().Create(ctx, &apiv1.Resource{
+			Name:     "pvc-mix",
+			NodeName: node,
+			Props:    map[string]string{storPoolNameProp: "pool-" + node},
+		}); err != nil {
+			t.Fatalf("seed replica on %s: %v", node, err)
+		}
+	}
+
+	if pool, err := sourcePoolOn(ctx, run, "pvc-mix", "node-2"); err != nil || pool != "pool-Node-2" {
+		t.Errorf("sourcePoolOn(node-2) = %q, %v; want the pool of the replica on Node-2", pool, err)
+	}
+
+	if pool, err := resolveStorPool(ctx, run, "pvc-mix", "node-1"); err != nil || pool != "pool-Node-2" {
+		t.Errorf("resolveStorPool(node-1) = %q, %v; want the sibling's pool, not node-1's own", pool, err)
+	}
+}