client/daemon: route liveness / bfd / clearer event/type var names

Author: snormore

client/doublezerod/internal/liveness/scheduler.go

@@ -10,20 +10,20 @@ import (
 )
 
 // evType distinguishes between scheduled transmit (TX) and detect-timeout (Detect) events.
-type evType uint8
+type eventType uint8
 
 const (
-	evTX     evType = 1 // transmit control packet
-	evDetect evType = 2 // detect timeout check
+	eventTypeTX     eventType = 1 // transmit control packet
+	eventTypeDetect eventType = 2 // detect timeout check
 )
 
 // event represents a single scheduled action tied to a session.
 // Each event is timestamped and sequence-numbered to ensure stable ordering in the heap.
 type event struct {
-	when time.Time // time when the event should fire
-	typ  evType    // type of event (TX or Detect)
-	s    *Session  // owning session
-	seq  uint64    // sequence number for deterministic ordering
+	when      time.Time // time when the event should fire
+	eventType eventType // type of event (TX or Detect)
+	session   *Session  // owning session
+	seq       uint64    // sequence number for deterministic ordering
 }
 
 // EventQueue is a thread-safe priority queue of scheduled events.
@@ -173,22 +173,22 @@ func (s *Scheduler) Run(ctx context.Context) error {
 			}
 		}
 
-		switch ev.typ {
-		case evTX:
-			s.doTX(ev.s)
-			s.scheduleTx(time.Now(), ev.s)
-		case evDetect:
-			if s.tryExpire(ev.s) {
+		switch ev.eventType {
+		case eventTypeTX:
+			s.doTX(ev.session)
+			s.scheduleTx(time.Now(), ev.session)
+		case eventTypeDetect:
+			if s.tryExpire(ev.session) {
 				// Expiration triggers asynchronous session-down handling.
-				go s.onSessionDown(ev.s)
+				go s.onSessionDown(ev.session)
 				continue
 			}
 			// Still active; re-arm detect timer for next interval.
-			ev.s.mu.Lock()
-			st := ev.s.state
-			ev.s.mu.Unlock()
+			ev.session.mu.Lock()
+			st := ev.session.state
+			ev.session.mu.Unlock()
 			if st == StateUp || st == StateInit {
-				s.scheduleDetect(time.Now(), ev.s)
+				s.scheduleDetect(time.Now(), ev.session)
 			}
 		}
 	}
@@ -204,7 +204,7 @@ func (s *Scheduler) scheduleTx(now time.Time, sess *Session) {
 		return
 	}
 	next := sess.ComputeNextTx(now, nil)
-	s.eq.Push(&event{when: next, typ: evTX, s: sess})
+	s.eq.Push(&event{when: next, eventType: eventTypeTX, session: sess})
 }
 
 // scheduleDetect arms or re-arms a session’s detection timer and enqueues a detect event.
@@ -214,7 +214,7 @@ func (s *Scheduler) scheduleDetect(now time.Time, sess *Session) {
 	if !ok {
 		return
 	}
-	s.eq.Push(&event{when: ddl, typ: evDetect, s: sess})
+	s.eq.Push(&event{when: ddl, eventType: eventTypeDetect, session: sess})
 }
 
 // doTX builds and transmits a ControlPacket representing the session’s current state.
@@ -262,7 +262,7 @@ func (s *Scheduler) doTX(sess *Session) {
 func (s *Scheduler) tryExpire(sess *Session) bool {
 	now := time.Now()
 	if sess.ExpireIfDue(now) {
-		s.eq.Push(&event{when: now, typ: evTX, s: sess})
+		s.eq.Push(&event{when: now, eventType: eventTypeTX, session: sess})
 		return true
 	}
 	return false

client/doublezerod/internal/liveness/scheduler_test.go

@@ -57,7 +57,7 @@ func TestClient_Liveness_Scheduler_TryExpireEnqueuesImmediateTX(t *testing.T) {
 	// first event should be immediate TX
 	ev := s.eq.Pop()
 	require.NotNil(t, ev)
-	require.Equal(t, evTX, ev.typ)
+	require.Equal(t, eventTypeTX, ev.eventType)
 
 	// and state flipped to Down, detect cleared
 	require.Equal(t, StateDown, sess.state)
@@ -86,7 +86,7 @@ func TestClient_Liveness_Scheduler_ScheduleDetect_EnqueuesDeadline(t *testing.T)
 	s.scheduleDetect(time.Now(), sess)
 	ev := s.eq.Pop()
 	require.NotNil(t, ev)
-	require.Equal(t, evDetect, ev.typ)
+	require.Equal(t, eventTypeDetect, ev.eventType)
 }
 
 func TestClient_Liveness_Scheduler_TryExpire_Idempotent(t *testing.T) {
@@ -134,14 +134,14 @@ func TestClient_Liveness_Scheduler_ScheduleTx_AdaptiveBackoffWhenDown(t *testing
 	s.scheduleTx(now, sess)
 	ev1 := s.eq.Pop()
 	require.NotNil(t, ev1)
-	require.Equal(t, evTX, ev1.typ)
+	require.Equal(t, eventTypeTX, ev1.eventType)
 	require.Greater(t, sess.backoffFactor, uint32(1)) // doubled to 2
 
 	// next schedule should further increase backoff factor (up to ceil)
 	s.scheduleTx(now.Add(time.Millisecond), sess)
 	ev2 := s.eq.Pop()
 	require.NotNil(t, ev2)
-	require.Equal(t, evTX, ev2.typ)
+	require.Equal(t, eventTypeTX, ev2.eventType)
 	require.GreaterOrEqual(t, sess.backoffFactor, uint32(4))
 	// both events should be scheduled in the future
 	require.True(t, ev1.when.After(now))