feat(delete): finalizer-driven Resource teardown via DeleteResource RPC

New satellite RPC: DeleteResource(name, storage_pool, volume_numbers)
runs `drbdadm down` (best-effort) → DeleteVolume on every numbered
volume through the matching Provider → rm /etc/drbd.d/<name>.res.
Idempotent on missing.

ResourceReconciler now installs a finalizer
"blockstor.io.blockstor.io/resource" on every live Resource. When
DeletionTimestamp arrives, runDelete dials the satellite, asks it to
tear the resource down, and only then strips the finalizer so
kube-apiserver completes the delete. Without this the satellite
never sees the delete and the .res / LV / loopfile orphan.

Reconcile loop split for funlen budget: runApply (gRPC dispatch)
and runDelete (teardown). Boilerplate envtest stays a no-op when
Dispatcher is nil.

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

Author: kvaps

internal/controller/resource_controller.go

@@ -18,6 +18,7 @@ package controller
 
 import (
 	"context"
+	"slices"
 	"time"
 
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -30,6 +31,11 @@ import (
 	"github.com/cozystack/blockstor/pkg/dispatcher"
 )
 
+// resourceFinalizer guards on-disk + DRBD-side teardown when the
+// Resource CRD is deleted. Without it the satellite would never see
+// the delete, leaving an orphan .res file + LV / loopfile.
+const resourceFinalizer = "blockstor.io.blockstor.io/resource"
+
 // ResourceReconciler dispatches Resource CRD changes to the right
 // satellite via the Dispatcher. It collects same-RD peers and the
 // full Node list (for endpoint resolution) on every reconcile —
@@ -51,8 +57,6 @@ type ResourceReconciler struct {
 // to the satellite that hosts it. Per-replica errors land in the
 // log; transport faults trigger a 10s requeue.
 func (r *ResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
-	log := logf.FromContext(ctx)
-
 	if r.Dispatcher == nil {
 		// envtest scaffolding (suite_test.go) constructs the reconciler
 		// without a Dispatcher — keep the original no-op behaviour for
@@ -71,9 +75,37 @@ func (r *ResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 		return ctrl.Result{}, err
 	}
 
+	// Deletion path: tell the satellite to drop the resource, then
+	// remove the finalizer so kube-apiserver finishes the delete.
+	if !target.DeletionTimestamp.IsZero() {
+		return r.runDelete(ctx, &target)
+	}
+
+	// Ensure finalizer is present on every live Resource so the
+	// delete path above can run.
+	if !slices.Contains(target.Finalizers, resourceFinalizer) {
+		target.Finalizers = append(target.Finalizers, resourceFinalizer)
+
+		err = r.Update(ctx, &target)
+		if err != nil {
+			return ctrl.Result{}, err
+		}
+
+		return ctrl.Result{Requeue: true}, nil
+	}
+
+	return r.runApply(ctx, &target)
+}
+
+// runApply is the apply branch of Reconcile. Pulled out to keep
+// Reconcile under the funlen budget — the body deals with the
+// finalizer dance, this with the actual gRPC dispatch.
+func (r *ResourceReconciler) runApply(ctx context.Context, target *blockstoriov1alpha1.Resource) (ctrl.Result, error) {
+	log := logf.FromContext(ctx)
+
 	var resList blockstoriov1alpha1.ResourceList
 
-	err = r.List(ctx, &resList)
+	err := r.List(ctx, &resList)
 	if err != nil {
 		return ctrl.Result{}, err
 	}
@@ -98,7 +130,7 @@ func (r *ResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 		return ctrl.Result{}, err
 	}
 
-	result, err := r.Dispatcher.Apply(ctx, &target, peers, nodeList.Items, rdPtr)
+	result, err := r.Dispatcher.Apply(ctx, target, peers, nodeList.Items, rdPtr)
 	if err != nil {
 		log.Error(err, "Apply RPC failed", "resource", target.Name, "node", target.Spec.NodeName)
 
@@ -116,6 +148,53 @@ func (r *ResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 	return ctrl.Result{}, nil
 }
 
+// runDelete is the finalizer-driven teardown. We dial the satellite
+// to drop the resource (drbdadm down → DeleteVolume → rm .res), then
+// strip the finalizer so kube-apiserver completes the delete.
+// Failures requeue with a 10 s back-off so the resource isn't stuck
+// half-gone if a satellite is briefly unreachable.
+func (r *ResourceReconciler) runDelete(ctx context.Context, target *blockstoriov1alpha1.Resource) (ctrl.Result, error) {
+	log := logf.FromContext(ctx)
+
+	if !slices.Contains(target.Finalizers, resourceFinalizer) {
+		return ctrl.Result{}, nil
+	}
+
+	rdPtr, _ := r.lookupRD(ctx, target.Spec.ResourceDefinitionName)
+
+	var nodeList blockstoriov1alpha1.NodeList
+
+	err := r.List(ctx, &nodeList)
+	if err != nil {
+		return ctrl.Result{}, err
+	}
+
+	resp, err := r.Dispatcher.DeleteResource(ctx, target, rdPtr, nodeList.Items)
+	if err != nil {
+		log.Error(err, "DeleteResource RPC failed",
+			"resource", target.Name, "node", target.Spec.NodeName)
+
+		return ctrl.Result{RequeueAfter: 10 * time.Second}, nil
+	}
+
+	if !resp.GetOk() {
+		log.Info("satellite rejected delete", "msg", resp.GetMessage(),
+			"resource", target.Name, "node", target.Spec.NodeName)
+
+		return ctrl.Result{RequeueAfter: 10 * time.Second}, nil
+	}
+
+	target.Finalizers = slices.DeleteFunc(target.Finalizers,
+		func(s string) bool { return s == resourceFinalizer })
+
+	err = r.Update(ctx, target)
+	if err != nil {
+		return ctrl.Result{}, err
+	}
+
+	return ctrl.Result{}, nil
+}
+
 // lookupRD fetches the parent ResourceDefinition. A NotFound is
 // converted to (nil, nil) so the dispatcher can still push the
 // .res for connection setup; any other error bubbles.

pkg/dispatcher/dispatcher.go

@@ -230,6 +230,48 @@ func buildVolumes(rd *blockstoriov1alpha1.ResourceDefinition, target *blockstori
 	return out
 }
 
+// DeleteResource dials the target satellite's endpoint and asks it
+// to drop the resource (drbdadm down → DeleteVolume → rm .res).
+// Returns the per-satellite result. Missing endpoint surfaces as a
+// nil response with an error — callers retry once the Node CRD
+// catches up.
+func (d *Dispatcher) DeleteResource(ctx context.Context, target *blockstoriov1alpha1.Resource, rd *blockstoriov1alpha1.ResourceDefinition, nodes []blockstoriov1alpha1.Node) (*satellitepb.DeleteResourceResponse, error) {
+	endpoint := lookupEndpoint(target.Spec.NodeName, nodes)
+	if endpoint == "" {
+		return nil, errors.Errorf("no SatelliteEndpoint for node %q", target.Spec.NodeName)
+	}
+
+	client, closer, err := d.dialer.Dial(ctx, endpoint)
+	if err != nil {
+		return nil, errors.Wrapf(err, "dial %s", endpoint)
+	}
+	defer func() { _ = closer() }()
+
+	pool := target.Spec.Props["StorPoolName"]
+	if pool == "" && rd != nil {
+		pool = rd.Spec.Props["StorPoolName"]
+	}
+
+	volNumbers := make([]int32, 0)
+
+	if rd != nil {
+		for _, vd := range rd.Spec.VolumeDefinitions {
+			volNumbers = append(volNumbers, vd.VolumeNumber)
+		}
+	}
+
+	resp, err := client.DeleteResource(ctx, &satellitepb.DeleteResourceRequest{
+		Name:          target.Spec.ResourceDefinitionName,
+		StoragePool:   pool,
+		VolumeNumbers: volNumbers,
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "DeleteResource RPC")
+	}
+
+	return resp, nil
+}
+
 // CreateSnapshot dials every satellite that hosts a non-DISKLESS
 // replica of `rdName` and asks it to take a snapshot. Returns the
 // list of per-node results so the controller can surface granular

pkg/satellite/grpc_server.go

@@ -69,6 +69,12 @@ func (g *GRPCServer) ApplyStoragePools(_ context.Context, req *satellitepb.Apply
 	return &satellitepb.ApplyStoragePoolsResponse{Results: results}, nil
 }
 
+// DeleteResource tears down a resource (drbdadm down → DeleteVolume
+// → remove .res). Per-step errors land in the response Ok=false.
+func (g *GRPCServer) DeleteResource(ctx context.Context, req *satellitepb.DeleteResourceRequest) (*satellitepb.DeleteResourceResponse, error) {
+	return g.rec.DeleteResource(ctx, req)
+}
+
 // CreateSnapshot routes through the Reconciler's existing snapshot
 // path. Per-snapshot errors land in the response body (Ok=false), the
 // gRPC error path is reserved for context cancellation / transport