feat(satellite): Reconciler routes DesiredResource volumes to providers

First slice of the apply loop: maps a DesiredResource batch onto the
configured storage providers, returns a per-resource ResourceApplyResult
so the controller can react to individual replica failures.

DISKLESS-flagged resources skip the storage path entirely. The DRBD
.res / drbdadm half follows in the next slice.

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

Author: kvaps

.golangci.yml

@@ -89,6 +89,7 @@ linters:
         - rw
         - ev
         - ch
+        - dr
   exclusions:
     generated: lax
     presets:

pkg/satellite/reconciler.go

@@ -0,0 +1,115 @@
+/*
+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 satellite
+
+import (
+	"context"
+	"fmt"
+	"slices"
+
+	"github.com/cockroachdb/errors"
+
+	satellitepb "github.com/cozystack/blockstor/pkg/satellite/proto"
+	"github.com/cozystack/blockstor/pkg/storage"
+)
+
+// ReconcilerConfig parametrises a Reconciler. Providers maps the
+// satellite's local storage-pool names to provisioned `storage.Provider`
+// instances; an unknown pool fails the per-resource Apply with a
+// surfaced error message.
+type ReconcilerConfig struct {
+	Providers map[string]storage.Provider
+}
+
+// Reconciler turns a controller-pushed DesiredResource set into local
+// state. Phase-3 cut: storage provisioning only — Build/.res / drbdadm
+// follow in the next slice.
+type Reconciler struct {
+	cfg ReconcilerConfig
+}
+
+// NewReconciler constructs a Reconciler from cfg.
+func NewReconciler(cfg ReconcilerConfig) *Reconciler {
+	return &Reconciler{cfg: cfg}
+}
+
+// Apply walks res and brings local storage in line with each item.
+// Each input gets a ResourceApplyResult — partial success is the norm
+// (one missing pool shouldn't sink the rest of a batch).
+//
+// The signature returns an error too, but reserves it for context
+// cancellation — per-resource failures land in the Result entries.
+func (r *Reconciler) Apply(ctx context.Context, res []*satellitepb.DesiredResource) ([]*satellitepb.ResourceApplyResult, error) {
+	results := make([]*satellitepb.ResourceApplyResult, 0, len(res))
+
+	for _, dr := range res {
+		err := ctx.Err()
+		if err != nil {
+			return results, errors.Wrap(err, "apply: context cancelled")
+		}
+
+		results = append(results, r.applyOne(ctx, dr))
+	}
+
+	return results, nil
+}
+
+// applyOne reconciles a single DesiredResource. Diskless replicas skip
+// storage entirely (they're memory-backed by the DRBD stack); everything
+// else routes one CreateVolume per DesiredVolume.
+func (r *Reconciler) applyOne(ctx context.Context, dr *satellitepb.DesiredResource) *satellitepb.ResourceApplyResult {
+	res := &satellitepb.ResourceApplyResult{
+		Name:     dr.GetName(),
+		NodeName: dr.GetNodeName(),
+		Ok:       true,
+	}
+
+	if isDiskless(dr.GetFlags()) {
+		return res
+	}
+
+	for _, vol := range dr.GetVolumes() {
+		provider, ok := r.cfg.Providers[vol.GetStoragePool()]
+		if !ok {
+			res.Ok = false
+			res.Message = fmt.Sprintf("unknown storage pool %q", vol.GetStoragePool())
+
+			return res
+		}
+
+		err := provider.CreateVolume(ctx, storage.Volume{
+			ResourceName: dr.GetName(),
+			VolumeNumber: vol.GetVolumeNumber(),
+			SizeKib:      vol.GetSizeKib(),
+		})
+		if err != nil {
+			res.Ok = false
+			res.Message = err.Error()
+
+			return res
+		}
+	}
+
+	return res
+}
+
+// isDiskless returns true when the DRBD-layer "DISKLESS" flag is set.
+// Diskless replicas live entirely in DRBD memory and have no backing
+// storage, so the reconciler must skip the storage path for them.
+func isDiskless(flags []string) bool {
+	return slices.Contains(flags, "DISKLESS")
+}

pkg/satellite/reconciler_test.go

@@ -0,0 +1,170 @@
+/*
+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 satellite_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/cozystack/blockstor/pkg/satellite"
+	satellitepb "github.com/cozystack/blockstor/pkg/satellite/proto"
+	"github.com/cozystack/blockstor/pkg/storage"
+	"github.com/cozystack/blockstor/pkg/storage/lvm"
+)
+
+// TestApplyCreatesVolumeViaProvider: a single DesiredResource with one
+// volume on the registered LVM-thin pool ends up calling lvcreate.
+func TestApplyCreatesVolumeViaProvider(t *testing.T) {
+	fx := storage.NewFakeExec()
+	fx.Expect("lvs --noheadings -o lv_name vg/pvc-1_00000",
+		storage.FakeResponse{Stdout: []byte("")})
+
+	thin := lvm.NewThin(lvm.ThinConfig{VolumeGroup: "vg", ThinPool: "tp"}, fx)
+	rec := satellite.NewReconciler(satellite.ReconcilerConfig{
+		Providers: map[string]storage.Provider{"thin1": thin},
+	})
+
+	results, err := rec.Apply(t.Context(), []*satellitepb.DesiredResource{
+		{
+			Name:     "pvc-1",
+			NodeName: "n1",
+			Volumes: []*satellitepb.DesiredVolume{
+				{VolumeNumber: 0, SizeKib: 1024 * 1024, StoragePool: "thin1"},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Apply: %v", err)
+	}
+
+	if len(results) != 1 || !results[0].GetOk() {
+		t.Fatalf("results: %+v", results)
+	}
+
+	if !slices.Contains(fx.CommandLines(),
+		"lvcreate --thin --virtualsize 1024MiB --name pvc-1_00000 vg/tp") {
+		t.Errorf("expected lvcreate; got %v", fx.CommandLines())
+	}
+}
+
+// TestApplyUnknownPoolFails: requesting a pool the satellite doesn't
+// know about → per-resource OK=false; the batch keeps going.
+func TestApplyUnknownPoolFails(t *testing.T) {
+	fx := storage.NewFakeExec()
+	thin := lvm.NewThin(lvm.ThinConfig{VolumeGroup: "vg", ThinPool: "tp"}, fx)
+	rec := satellite.NewReconciler(satellite.ReconcilerConfig{
+		Providers: map[string]storage.Provider{"thin1": thin},
+	})
+
+	results, err := rec.Apply(t.Context(), []*satellitepb.DesiredResource{
+		{
+			Name:     "pvc-1",
+			NodeName: "n1",
+			Volumes: []*satellitepb.DesiredVolume{
+				{VolumeNumber: 0, SizeKib: 1024, StoragePool: "missing"},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Apply: %v", err)
+	}
+
+	if len(results) != 1 || results[0].GetOk() {
+		t.Fatalf("expected !ok; got %+v", results[0])
+	}
+
+	if results[0].GetMessage() == "" {
+		t.Errorf("expected non-empty message")
+	}
+}
+
+// TestApplyDisklessSkipsStorage: a resource flagged DISKLESS has no
+// local backing storage; the reconciler must not call CreateVolume.
+func TestApplyDisklessSkipsStorage(t *testing.T) {
+	fx := storage.NewFakeExec()
+	thin := lvm.NewThin(lvm.ThinConfig{VolumeGroup: "vg", ThinPool: "tp"}, fx)
+	rec := satellite.NewReconciler(satellite.ReconcilerConfig{
+		Providers: map[string]storage.Provider{"thin1": thin},
+	})
+
+	results, err := rec.Apply(t.Context(), []*satellitepb.DesiredResource{
+		{
+			Name:     "pvc-1",
+			NodeName: "n1",
+			Flags:    []string{"DISKLESS"},
+			Volumes: []*satellitepb.DesiredVolume{
+				{VolumeNumber: 0, SizeKib: 1024 * 1024, StoragePool: "thin1"},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Apply: %v", err)
+	}
+
+	if len(results) != 1 || !results[0].GetOk() {
+		t.Fatalf("results: %+v", results)
+	}
+
+	for _, line := range fx.CommandLines() {
+		if len(line) >= 8 && line[:8] == "lvcreate" {
+			t.Errorf("DISKLESS resource issued lvcreate: %s", line)
+		}
+	}
+}
+
+// TestApplyHandlesMultipleResources: all-or-nothing batch processing —
+// every input gets a result, regardless of individual outcome.
+func TestApplyHandlesMultipleResources(t *testing.T) {
+	fx := storage.NewFakeExec()
+	fx.Expect("lvs --noheadings -o lv_name vg/pvc-1_00000",
+		storage.FakeResponse{Stdout: []byte("")})
+	fx.Expect("lvs --noheadings -o lv_name vg/pvc-2_00000",
+		storage.FakeResponse{Stdout: []byte("")})
+
+	thin := lvm.NewThin(lvm.ThinConfig{VolumeGroup: "vg", ThinPool: "tp"}, fx)
+	rec := satellite.NewReconciler(satellite.ReconcilerConfig{
+		Providers: map[string]storage.Provider{"thin1": thin},
+	})
+
+	results, err := rec.Apply(t.Context(), []*satellitepb.DesiredResource{
+		{
+			Name: "pvc-1", NodeName: "n1",
+			Volumes: []*satellitepb.DesiredVolume{
+				{VolumeNumber: 0, SizeKib: 1024 * 1024, StoragePool: "thin1"},
+			},
+		},
+		{
+			Name: "pvc-2", NodeName: "n1",
+			Volumes: []*satellitepb.DesiredVolume{
+				{VolumeNumber: 0, SizeKib: 2048 * 1024, StoragePool: "thin1"},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Apply: %v", err)
+	}
+
+	if len(results) != 2 {
+		t.Fatalf("len(results): got %d, want 2", len(results))
+	}
+
+	for _, r := range results {
+		if !r.GetOk() {
+			t.Errorf("expected ok for %s; got %s", r.GetName(), r.GetMessage())
+		}
+	}
+}