feat(reconcile): auto-primary seed + observed-state writeback

Two halves of the same UpToDate-without-human-intervention story:

1. Dispatcher tags one diskful replica per RD (lex-lowest node name)
   with drbd_options[auto-primary]=true. On firstActivation the
   satellite Reconciler.applyDRBD runs `drbdadm primary --force`
   then `drbdadm secondary`, which seeds the resource into UpToDate
   without an operator running drbdadm by hand. Subsequent reconciles
   see firstActivation=false and skip.

2. Server.applyObserved (events2 → ReportObserved) now actually
   writes the observed DRBD state back to the Resource: DrbdState
   prop + Resource.State.InUse. Lets REST clients (linstor-csi,
   kubectl-linstor) see live runtime status without schema changes.

drbdadm wrapper gains PrimaryForce so the seed step uses --force
explicitly rather than the bare Primary which refuses to promote
when local disk is Inconsistent and no peer is UpToDate.

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

Author: kvaps

pkg/dispatcher/dispatcher.go

@@ -177,6 +177,17 @@ func buildDesired(target *blockstoriov1alpha1.Resource, peers []blockstoriov1alp
 		"minor":   strconv.Itoa(minor),
 	}
 
+	// Pick a single replica (lexically lowest node name) to seed
+	// initial Primary. Without this every diskful brand-new RD comes
+	// up Inconsistent and stays there until something opens for
+	// write. The seed flag is harmless on subsequent reconciles —
+	// satellite Reconciler runs primary --force only on
+	// firstActivation.
+	if !slices.Contains(target.Spec.Flags, "DISKLESS") &&
+		target.Spec.NodeName == sortedAll[0] {
+		drbdOpts["auto-primary"] = "true"
+	}
+
 	// Per-peer entries — used by ConfFileBuilder on the satellite to
 	// compose the connection mesh. We resolve each peer's
 	// SatelliteEndpoint prop into a real IP so drbd-9 has somewhere

pkg/drbd/drbdadm.go

@@ -69,6 +69,14 @@ func (a *Adm) Primary(ctx context.Context, resource string) error {
 	return a.run(ctx, "primary", resource)
 }
 
+// PrimaryForce promotes a resource to Primary even when local disk is
+// Inconsistent and no peer is UpToDate. Used as the initial-sync seed
+// on a brand-new diskful replica — without --force, drbd refuses to
+// promote, leaving the resource permanently "Inconsistent".
+func (a *Adm) PrimaryForce(ctx context.Context, resource string) error {
+	return a.run(ctx, "primary", "--force", resource)
+}
+
 // Secondary flips the resource back to Secondary role. Used after the
 // consumer unmounts and before another peer takes Primary.
 func (a *Adm) Secondary(ctx context.Context, resource string) error {

pkg/satellite/reconciler.go

@@ -344,6 +344,24 @@ func (r *Reconciler) applyDRBD(ctx context.Context, dr *satellitepb.DesiredResou
 		return errors.Wrapf(err, "adjust %s", dr.GetName())
 	}
 
+	// On first activation of a diskful replica the controller may
+	// flag it as the auto-primary seed. We promote once (force-
+	// primary then back to secondary) so the metadata moves out of
+	// "Inconsistent" into "UpToDate" without a human running
+	// drbdadm. Subsequent reconciles see firstActivation=false and
+	// skip the seed.
+	if firstActivation && !diskless && dr.GetDrbdOptions()["auto-primary"] == "true" {
+		err = r.cfg.Adm.PrimaryForce(ctx, dr.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "auto-primary %s", dr.GetName())
+		}
+
+		err = r.cfg.Adm.Secondary(ctx, dr.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "auto-secondary %s", dr.GetName())
+		}
+	}
+
 	return nil
 }
 

pkg/satellitecontroller/server.go

@@ -132,12 +132,39 @@ func (s *Server) ReportObserved(stream satellitepb.Controller_ReportObservedServ
 	}
 }
 
-// applyObserved is the per-event Status update — currently a no-op
-// placeholder while the Resource CRD's Status fields settle (we'll
-// land conditions + per-volume disk state in the next slice). Keeping
-// the call site means the wire path is exercised end-to-end on the
-// stand and any future implementation slots in without re-touching
-// the gRPC frame loop.
-func (s *Server) applyObserved(_ context.Context, _ *satellitepb.ResourceObservedEvent) error {
+// applyObserved lands one parsed events2 frame on the matching
+// Resource. We store the DRBD state as a `DrbdState` prop and the
+// "in use" hint via Resource.State.InUse so existing REST callers
+// (linstor-csi, kubectl-linstor) see the live runtime info without
+// the schema needing to change. Granular per-volume disk state lands
+// once the CRD's volume-level status fields settle.
+func (s *Server) applyObserved(ctx context.Context, ev *satellitepb.ResourceObservedEvent) error {
+	if ev.GetResourceName() == "" || ev.GetNodeName() == "" {
+		return nil
+	}
+
+	res, err := s.st.Resources().Get(ctx, ev.GetResourceName(), ev.GetNodeName())
+	if err != nil {
+		// NotFound is normal during convergence — the satellite may
+		// observe state for a resource the controller hasn't yet
+		// created. Bubble nothing.
+		return nil //nolint:nilerr // best-effort: missing resource isn't a stream-fatal event
+	}
+
+	if res.Props == nil {
+		res.Props = map[string]string{}
+	}
+
+	if disk := ev.GetDrbdState(); disk != "" {
+		res.Props["DrbdState"] = disk
+	}
+
+	res.State.InUse = ev.GetInUse()
+
+	err = s.st.Resources().Update(ctx, &res)
+	if err != nil {
+		return errors.Wrap(err, "update resource state")
+	}
+
 	return nil
 }