publish leader state before signaling

A newly elected leader could still look like a follower when
`GainedLeadership` was observed. The elector did not publish
`isLeader = true` until `keepLeadershipLoop`, so a `request_resign`
notification arriving in that transition window could be dropped as if
no leader existed.

Move leadership publication to the point immediately after election
succeeds and before the gained-leadership signal is emitted. That makes
the signal truthful: once observers see it, subscriber state and
`isLeader` already reflect leadership.

Add a DB-backed regression that keeps the initial subscriber
notification buffered and verifies `GainedLeadership` waits for leader
state publication. The immediate-resign regression comments now document
the intended ordering.

Author: bgentry

internal/leadership/elector.go

@@ -196,6 +196,8 @@ func (e *Elector) Start(ctx context.Context) error {
 				return
 			}
 
+			e.notifySubscribers(true)
+
 			e.Logger.DebugContext(ctx, e.Name+": Gained leadership", "client_id", e.config.ClientID)
 			e.testSignals.GainedLeadership.Signal(struct{}{})
 
@@ -312,9 +314,6 @@ func (e *Elector) handleLeadershipNotification(ctx context.Context, topic notifi
 var errLostLeadershipReelection = errors.New("lost leadership with no error")
 
 func (e *Elector) keepLeadershipLoop(ctx context.Context) error {
-	// notify all subscribers that we're the leader
-	e.notifySubscribers(true)
-
 	// On the way out clear any another item that may have been added to
 	// requestResignChan. Having isLeader set to false will prevent additional
 	// items from being queued after this one.

internal/leadership/elector_test.go

@@ -260,6 +260,37 @@ func testElector[TElectorBundle any](
 		require.False(t, notification.IsLeader)
 	})
 
+	t.Run("GainedLeadershipWaitsForLeadershipStatePublication", func(t *testing.T) {
+		t.Parallel()
+
+		elector, _ := setup(t, nil)
+
+		sub := elector.Listen()
+		t.Cleanup(sub.Unlisten)
+
+		startElector(ctx, t, elector)
+
+		var gainedLeadershipTooEarly bool
+
+		select {
+		case <-elector.testSignals.GainedLeadership.WaitC():
+			gainedLeadershipTooEarly = true
+		case <-time.After(250 * time.Millisecond):
+		}
+
+		notification := riversharedtest.WaitOrTimeout(t, sub.ch)
+		require.False(t, notification.IsLeader)
+
+		notification = riversharedtest.WaitOrTimeout(t, sub.ch)
+		require.True(t, notification.IsLeader)
+
+		if gainedLeadershipTooEarly {
+			require.FailNow(t, "expected gained leadership signal to wait for leadership state publication")
+		}
+
+		elector.testSignals.GainedLeadership.WaitOrTimeout()
+	})
+
 	t.Run("SustainsLeadership", func(t *testing.T) {
 		t.Parallel()
 
@@ -472,11 +503,10 @@ func testElector[TElectorBundle any](
 		elector.testSignals.GainedLeadership.WaitOrTimeout()
 
 		// Send a resign request immediately after gaining leadership.
-		// GainedLeadership is signaled _before_ keepLeadershipLoop is
-		// entered, so the resign request arrives before the loop's
-		// select. This only works if requestResignChan is buffered;
-		// with an unbuffered channel the send would be dropped by the
-		// default case since nobody is receiving yet.
+		// This only works if the elector has already published its
+		// leader state before signaling GainedLeadership, and if
+		// requestResignChan is buffered while keepLeadershipLoop is
+		// still entering its select.
 		payload, err := json.Marshal(DBNotification{
 			Action: DBNotificationKindRequestResign,
 		})