oc-discovery -> conf

daemons/node/common/common_stream.go

@@ -14,11 +14,110 @@ import (
 	"github.com/libp2p/go-libp2p/core/protocol"
 )
 
+// InitialEventHops is the starting hop count for SWIM membership events.
+// floor(log2(typical max-pool)) + 1 gives O(log n) propagation rounds.
+const InitialEventHops = 4
+
+const maxMemberEventQueue = 50
+
+// MembershipEventQueue holds SWIM membership events to be piggybacked on
+// outgoing heartbeats (infection-style dissemination). Bounded at
+// maxMemberEventQueue entries; events are deduplicated by PeerID.
+type MembershipEventQueue struct {
+	mu     sync.Mutex
+	events []MemberEvent
+}
+
+// memberEventPriority maps event types to an integer so higher-severity
+// events override lower-severity ones for the same PeerID.
+func memberEventPriority(t MemberEventType) int {
+	switch t {
+	case MemberDead:
+		return 3
+	case MemberSuspect:
+		return 2
+	case MemberAlive:
+		return 1
+	}
+	return 0
+}
+
+// Add inserts or updates a membership event.
+// An incoming event replaces the existing entry for the same PeerID when:
+//   - its Incarnation is higher, OR
+//   - the Incarnation is equal but the event type is higher-severity.
+func (q *MembershipEventQueue) Add(e MemberEvent) {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	for i, ex := range q.events {
+		if ex.PeerID == e.PeerID {
+			if e.Incarnation > ex.Incarnation ||
+				(e.Incarnation == ex.Incarnation && memberEventPriority(e.Type) > memberEventPriority(ex.Type)) {
+				q.events[i] = e
+			}
+			return
+		}
+	}
+	if len(q.events) >= maxMemberEventQueue {
+		q.events = q.events[1:] // drop oldest
+	}
+	q.events = append(q.events, e)
+}
+
+// Drain returns up to max events ready for transmission.
+// HopsLeft is decremented on each call; events that reach 0 are removed from
+// the queue (they have already propagated enough rounds).
+func (q *MembershipEventQueue) Drain(max int) []MemberEvent {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	if len(q.events) == 0 {
+		return nil
+	}
+	out := make([]MemberEvent, 0, max)
+	kept := q.events[:0]
+	for _, e := range q.events {
+		if len(out) < max {
+			e.HopsLeft--
+			out = append(out, e)
+			if e.HopsLeft > 0 {
+				kept = append(kept, e)
+			}
+			// HopsLeft reached 0: event has propagated enough, drop from queue.
+		} else {
+			kept = append(kept, e)
+		}
+	}
+	q.events = kept
+	return out
+}
+
+// NodeEventQueue is the global SWIM event queue for the node side.
+// Events are added on suspect/dead detection and drained into outgoing heartbeats.
+var NodeEventQueue = &MembershipEventQueue{}
+
 const (
 	ProtocolPublish = "/opencloud/record/publish/1.0"
 	ProtocolGet     = "/opencloud/record/get/1.0"
+	ProtocolDelete  = "/opencloud/record/delete/1.0"
+	// ProtocolIndirectProbe is opened by a node toward a live indexer to ask it
+	// to actively probe a suspected indexer on the node's behalf (SWIM indirect ping).
+	// It is the only inter-indexer protocol — indexers do not maintain persistent
+	// connections to each other; this stream is one-shot and short-lived.
+	ProtocolIndirectProbe = "/opencloud/indexer/probe/1.0"
 )
 
+// IndirectProbeRequest is sent by a node over ProtocolIndirectProbe.
+// The receiving indexer must attempt to reach Target and report back.
+type IndirectProbeRequest struct {
+	Target pp.AddrInfo `json:"target"`
+}
+
+// IndirectProbeResponse is the reply from the probing indexer.
+type IndirectProbeResponse struct {
+	Reachable bool  `json:"reachable"`
+	LatencyMs int64 `json:"latency_ms,omitempty"`
+}
+
 const ProtocolHeartbeat = "/opencloud/heartbeat/1.0"
 
 // ProtocolWitnessQuery is opened by a node to ask a peer what it thinks of a given indexer.