feat(store): CRD-backed Store implementation; default it in cmd/main.go

Phase 2 backbone. The same pkg/store.Store interface is now satisfied by
both pkg/store (in-process map) and pkg/store/k8s (controller-runtime client
against Node and StoragePool CRDs).

- api/v1alpha1: StoragePool CRD scaffolded; Spec carries (nodeName, poolName,
  providerKind, props), Status carries observed capacity/traits/conditions.
  Node spec.type validated as enum, so empty-Type Creates now fail uniformly
  on both stores (the in-memory store didn't catch this; CRDs do).
- pkg/store/k8s: Nodes / StoragePools mapping CRD <-> wire shape. The
  StoragePool composite (node, pool) key is encoded as `<node>.<pool>` in
  metadata.name and indexed via blockstor.io/{node,pool}-name labels so
  ListByNode is server-side filtered.
- pkg/store/storetest: shared test suite — every branch every Store must
  honour. pkg/store and pkg/store/k8s both call into it; behavioural drift
  between the two implementations would fail the same subtest immediately.
- pkg/store/k8s/k8s_test.go: envtest harness (TestMain spins up etcd +
  kube-apiserver, loads our CRDs, wipes between subtests). Skips cleanly
  when KUBEBUILDER_ASSETS is missing so plain `go test ./...` stays green
  without `make setup-envtest`. With assets installed, all 18 NodeStore +
  StoragePoolStore subtests pass against real CRD validation.
- cmd/main.go: --store={k8s|memory} flag; default k8s (uses mgr.GetClient()).
- .golangci.yml: extra ignore-names + per-path exclusions for storetest.

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

Author: kvaps

.golangci.yml

@@ -72,7 +72,9 @@ linters:
         - c
         - m
         - n
+        - in
         - sp
+        - st
         - rd
         - vd
         - rg
@@ -116,6 +118,23 @@ linters:
           - goconst
           - noinlineerr
         path: _test\.go
+      # storetest is a shared test suite imported by both InMemory and k8s
+      # store tests. It contains test code, just not in _test.go files, so
+      # the same exclusions apply.
+      - linters:
+          - funlen
+          - dupl
+          - gocognit
+          - gocyclo
+          - cyclop
+          - gocritic
+          - nlreturn
+          - wsl_v5
+          - varnamelen
+          - goconst
+          - noinlineerr
+          - thelper
+        path: pkg/store/storetest/
       - linters:
           - forbidigo
           - gocyclo

PROJECT

@@ -17,4 +17,12 @@ resources:
   kind: Node
   path: github.com/cozystack/blockstor/api/v1alpha1
   version: v1alpha1
+- api:
+    crdVersion: v1
+  controller: true
+  domain: blockstor.io
+  group: blockstor.io
+  kind: StoragePool
+  path: github.com/cozystack/blockstor/api/v1alpha1
+  version: v1alpha1
 version: "3"

api/v1alpha1/storagepool_types.go

@@ -0,0 +1,106 @@
+/*
+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 v1alpha1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// StoragePoolSpec is the desired state of a LINSTOR storage pool.
+//
+// LINSTOR storage pools are keyed by (node_name, pool_name); a single CRD
+// instance represents one pool on one satellite. The metadata.name is the
+// LINSTOR pool name, and spec.nodeName names the satellite hosting it.
+type StoragePoolSpec struct {
+	// nodeName is the name of the satellite hosting this pool. Same as the
+	// LINSTOR Node CRD's metadata.name.
+	// +required
+	NodeName string `json:"nodeName"`
+
+	// poolName is the LINSTOR pool name (LVM VG, ZFS dataset, etc.). When
+	// empty, defaults to metadata.name.
+	// +optional
+	PoolName string `json:"poolName,omitempty"`
+
+	// providerKind is the storage backend.
+	// +kubebuilder:validation:Enum=LVM;LVM_THIN;ZFS;ZFS_THIN;FILE;FILE_THIN;DISKLESS
+	ProviderKind string `json:"providerKind"`
+
+	// props is the LINSTOR property map for this pool.
+	// +optional
+	Props map[string]string `json:"props,omitempty"`
+}
+
+// StoragePoolStatus is the observed state of a storage pool, populated by
+// the satellite once it brings up the backing volume group.
+type StoragePoolStatus struct {
+	// freeCapacity is the free capacity in bytes reported by the satellite.
+	// +optional
+	FreeCapacity int64 `json:"freeCapacity,omitempty"`
+
+	// totalCapacity is the total capacity in bytes reported by the satellite.
+	// +optional
+	TotalCapacity int64 `json:"totalCapacity,omitempty"`
+
+	// supportsSnapshots is whether the backing provider can create snapshots.
+	// +optional
+	SupportsSnapshots bool `json:"supportsSnapshots,omitempty"`
+
+	// staticTraits exposes provider-static attributes (kind, etc.).
+	// +optional
+	StaticTraits map[string]string `json:"staticTraits,omitempty"`
+
+	// conditions represent the current state of the StoragePool resource.
+	// +listType=map
+	// +listMapKey=type
+	// +optional
+	Conditions []metav1.Condition `json:"conditions,omitempty"`
+}
+
+// +kubebuilder:object:root=true
+// +kubebuilder:subresource:status
+// +kubebuilder:resource:scope=Cluster
+
+// StoragePool is the Schema for the storagepools API
+type StoragePool struct {
+	metav1.TypeMeta `json:",inline"`
+
+	// metadata is a standard object metadata
+	// +optional
+	metav1.ObjectMeta `json:"metadata,omitzero"`
+
+	// spec defines the desired state of StoragePool
+	// +required
+	Spec StoragePoolSpec `json:"spec"`
+
+	// status defines the observed state of StoragePool
+	// +optional
+	Status StoragePoolStatus `json:"status,omitzero"`
+}
+
+// +kubebuilder:object:root=true
+
+// StoragePoolList contains a list of StoragePool
+type StoragePoolList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitzero"`
+	Items           []StoragePool `json:"items"`
+}
+
+func init() {
+	SchemeBuilder.Register(&StoragePool{}, &StoragePoolList{})
+}

api/v1alpha1/zz_generated.deepcopy.go

@@ -0,0 +1 @@
+/Users/kvaps/git/blockstor/bin/setup-envtest-release-0.23

bin/k8s/1.35.0-darwin-arm64/etcd

@@ -39,6 +39,7 @@ import (
 	"github.com/cozystack/blockstor/internal/controller"
 	"github.com/cozystack/blockstor/pkg/rest"
 	"github.com/cozystack/blockstor/pkg/store"
+	storek8s "github.com/cozystack/blockstor/pkg/store/k8s"
 	// +kubebuilder:scaffold:imports
 )
 
@@ -63,9 +64,12 @@ func main() {
 	var secureMetrics bool
 	var enableHTTP2 bool
 	var restAddr string
+	var storeKind string
 	var tlsOpts []func(*tls.Config)
 	flag.StringVar(&restAddr, "rest-bind-address", ":3370",
 		"The address the LINSTOR-compatible REST API binds to (upstream LINSTOR plain-text port is 3370).")
+	flag.StringVar(&storeKind, "store", "k8s",
+		"Persistence backend for the REST API: 'k8s' (CRD-backed, default) or 'memory' (in-process, lost on restart, useful for tests).")
 	flag.StringVar(&metricsAddr, "metrics-bind-address", "0", "The address the metrics endpoint binds to. "+
 		"Use :8443 for HTTPS or :8080 for HTTP, or leave as 0 to disable the metrics service.")
 	flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")
@@ -189,6 +193,13 @@ func main() {
 		setupLog.Error(err, "Failed to create controller", "controller", "node")
 		os.Exit(1)
 	}
+	if err := (&controller.StoragePoolReconciler{
+		Client: mgr.GetClient(),
+		Scheme: mgr.GetScheme(),
+	}).SetupWithManager(mgr); err != nil {
+		setupLog.Error(err, "Failed to create controller", "controller", "storagepool")
+		os.Exit(1)
+	}
 	// +kubebuilder:scaffold:builder
 
 	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
@@ -200,9 +211,22 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Phase 1 store: in-memory. Phase 2 swaps in a CRD-backed implementation
-	// behind the same interface.
-	st := store.NewInMemory()
+	// REST persistence: Kubernetes CRDs (default) or in-process map (tests).
+	// Both implementations satisfy pkg/store.Store; the same test suite (in
+	// pkg/store/storetest) exercises both, so behaviour cannot diverge.
+	var st store.Store
+
+	switch storeKind {
+	case "k8s":
+		st = storek8s.New(mgr.GetClient())
+	case "memory":
+		st = store.NewInMemory()
+
+		setupLog.Info("Using in-memory store; data will be lost on restart")
+	default:
+		setupLog.Error(nil, "Unknown --store value", "store", storeKind)
+		os.Exit(1)
+	}
 
 	if err := mgr.Add(&rest.Server{Addr: restAddr, Store: st}); err != nil {
 		setupLog.Error(err, "Failed to register REST API server")