feat(satellite/controllers): wire StoragePoolReconciler.Reconcile body (Phase 10.1)

StoragePool reconciler now actually registers providers — the
same dynamic path Phase 10.5's `ApplyStoragePools` opened, but
driven by CRD watches instead of gRPC pushes.

Reconcile body:
  - DeletionTimestamp set → RegisterProvider(name, nil) which
    deregisters. The destructive teardown (vgremove --force /
    zpool destroy) lives behind the Phase 10.8 finalizer.
  - Otherwise → `satellite.NewProviderFromKind(kind, props, exec)`
    builds the matching Provider; `RegisterProvider(name, p)`
    adds it to the in-memory pool map. Idempotent re-runs
    replace the entry, which is the desired behaviour after a
    pool config edit.

Config gains an `Exec storage.Exec` field — handed to
NewProviderFromKind so the same fake/real switch the rest of
the satellite uses applies here. Per-pool failures log without
failing the reconcile so controller-runtime's back-off handles
retries.

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

Author: kvaps

pkg/satellite/controllers/config.go

@@ -18,6 +18,7 @@ package controllers
 
 import (
 	"github.com/cozystack/blockstor/pkg/satellite"
+	"github.com/cozystack/blockstor/pkg/storage"
 )
 
 // Config carries the bits the four reconcilers need beyond what
@@ -38,4 +39,10 @@ type Config struct {
 	// the storage + DRBD + LUKS chain. Phase 10.1 reuses it so
 	// the controller-runtime path doesn't duplicate logic.
 	Apply *satellite.Reconciler
+
+	// Exec is the shell-out interface the StoragePool reconciler
+	// hands to `satellite.NewProviderFromKind` when materialising
+	// a Provider instance from a StoragePool CRD. Production
+	// wires `storage.RealExec{}`; tests inject `storage.FakeExec`.
+	Exec storage.Exec
 }

pkg/satellite/controllers/storagepool.go

@@ -27,6 +27,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/log"
 
 	blockstoriov1alpha1 "github.com/cozystack/blockstor/api/v1alpha1"
+	"github.com/cozystack/blockstor/pkg/satellite"
 )
 
 // StoragePoolReconciler watches StoragePool CRDs filtered to
@@ -68,13 +69,33 @@ func (r *StoragePoolReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		"kind", pool.Spec.ProviderKind,
 		"deletionTimestamp", pool.DeletionTimestamp)
 
-	// Phase 10.1 follow-up: instantiate via
-	// `satellite.NewProviderFromKind(pool.Spec.ProviderKind,
-	// pool.Spec.Props, exec)` and call
-	// `Config.Apply.RegisterProvider(poolName, provider)`. The
-	// per-pool capacity reporting (Status writes) flips to a
-	// periodic loop here too — Phase 10.5's stub gets replaced
-	// with the c-r-driven real path.
+	// On delete: deregister the provider (its in-memory
+	// instance goes away). The actual on-disk teardown
+	// (`vgremove --force` / `zpool destroy`) is a Phase 10.8
+	// finalizer that runs separately when
+	// `Spec.DestroyOnDelete=true`.
+	if !pool.DeletionTimestamp.IsZero() {
+		r.Config.Apply.RegisterProvider(pool.Spec.PoolName, nil)
+
+		return ctrl.Result{}, nil
+	}
+
+	provider, err := satellite.NewProviderFromKind(pool.Spec.ProviderKind, pool.Spec.Props, r.Config.Exec)
+	if err != nil {
+		// Per-pool failure: log and let the next reconcile
+		// retry (controller-runtime back-off handles the
+		// retry cadence). The pool stays unavailable until
+		// the operator fixes the config — same semantic the
+		// gRPC `ApplyStoragePools` path had via Ok=false.
+		logger.Info("NewProviderFromKind failed", "kind", pool.Spec.ProviderKind, "err", err)
+
+		return ctrl.Result{}, nil
+	}
+
+	// nil provider = DISKLESS kind; RegisterProvider's nil path
+	// deregisters, which is the right semantic.
+	r.Config.Apply.RegisterProvider(pool.Spec.PoolName, provider)
+
 	return ctrl.Result{}, nil
 }