Debug

daemons/node/indexer/handler.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	oclib "cloud.o-forge.io/core/oc-lib"
+	"cloud.o-forge.io/core/oc-lib/dbs"
 	pp "cloud.o-forge.io/core/oc-lib/models/peer"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
@@ -108,6 +109,49 @@ func (ix *IndexerService) genPIDKey(peerID string) string {
 	return "/pid/" + peerID
 }
 
+// isPeerKnown is the stream-level gate: returns true if pid is allowed.
+// Check order (fast → slow):
+//  1. In-memory stream records — currently heartbeating to this indexer.
+//  2. Local DB by peer_id — known peer, blacklist enforced here.
+//  3. DHT /pid/{peerID} → /node/{DID} — registered on any indexer.
+//
+// ProtocolHeartbeat and ProtocolPublish handlers do NOT call this — they are
+// the streams through which a node first makes itself known.
+func (ix *IndexerService) isPeerKnown(pid lpp.ID) bool {
+	// 1. Fast path: active heartbeat session.
+	ix.StreamMU.RLock()
+	_, active := ix.StreamRecords[common.ProtocolHeartbeat][pid]
+	ix.StreamMU.RUnlock()
+	if active {
+		return true
+	}
+	// 2. Local DB: known peer (handles blacklist).
+	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
+	results := access.Search(&dbs.Filters{
+		And: map[string][]dbs.Filter{
+			"peer_id": {{Operator: dbs.EQUAL.String(), Value: pid.String()}},
+		},
+	}, pid.String(), false)
+	for _, item := range results.Data {
+		p, ok := item.(*pp.Peer)
+		if !ok || p.PeerID != pid.String() {
+			continue
+		}
+		return p.Relation != pp.BLACKLIST
+	}
+	// 3. DHT lookup by peer_id.
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	did, err := ix.DHT.GetValue(ctx, ix.genPIDKey(pid.String()))
+	cancel()
+	if err != nil || len(did) == 0 {
+		return false
+	}
+	ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
+	_, err = ix.DHT.GetValue(ctx2, ix.genKey(string(did)))
+	cancel2()
+	return err == nil
+}
+
 func (ix *IndexerService) initNodeHandler() {
 	logger := oclib.GetLogger()
 	logger.Info().Msg("Init Node Handler")
@@ -144,21 +188,32 @@ func (ix *IndexerService) initNodeHandler() {
 			logger.Warn().Err(err).Str("did", rec.DID).Msg("indexer: heartbeat record signature invalid")
 			return
 		}
+		// Keep StreamRecord.Record in sync so BuildHeartbeatResponse always
+		// sees a populated PeerRecord (Name, DID, etc.) regardless of whether
+		// handleNodePublish ran before or after the heartbeat stream was opened.
+		if pid, err := lpp.Decode(rec.PeerID); err == nil {
+			ix.StreamMU.Lock()
+			if srec, ok := ix.StreamRecords[common.ProtocolHeartbeat][pid]; ok {
+				srec.Record = rec
+			}
+			ix.StreamMU.Unlock()
+		}
 		data, err := json.Marshal(rec)
 		if err != nil {
 			return
 		}
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		logger.Info().Msg("REFRESH PutValue " + ix.genKey(rec.DID))
 		if err := ix.DHT.PutValue(ctx, ix.genKey(rec.DID), data); err != nil {
-			logger.Warn().Err(err).Str("did", rec.DID).Msg("indexer: DHT refresh failed")
-			cancel()
-			return
+			logger.Warn().Err(err).Str("did", rec.DID).Msg("indexer: DHT refresh /node/ failed")
 		}
 		cancel()
+		// /pid/ is written unconditionally — the gater queries by PeerID and this
+		// index must stay fresh regardless of whether the /node/ write succeeded.
 		if rec.PeerID != "" {
 			ctx2, cancel2 := context.WithTimeout(context.Background(), 10*time.Second)
-			ix.DHT.PutValue(ctx2, ix.genPIDKey(rec.PeerID), []byte(rec.DID))
+			if err := ix.DHT.PutValue(ctx2, ix.genPIDKey(rec.PeerID), []byte(rec.DID)); err != nil {
+				logger.Warn().Err(err).Str("pid", rec.PeerID).Msg("indexer: DHT refresh /pid/ failed")
+			}
 			cancel2()
 		}
 	}
@@ -173,6 +228,12 @@ func (ix *IndexerService) initNodeHandler() {
 // Returns a random sample of indexers from the local DHT cache.
 func (ix *IndexerService) handleCandidateRequest(s network.Stream) {
 	defer s.Close()
+	if !ix.isPeerKnown(s.Conn().RemotePeer()) {
+		logger := oclib.GetLogger()
+		logger.Warn().Str("peer", s.Conn().RemotePeer().String()).Msg("[candidates] unknown peer, rejecting stream")
+		s.Reset()
+		return
+	}
 	s.SetDeadline(time.Now().Add(5 * time.Second))
 	var req common.IndexerCandidatesRequest
 	if err := json.NewDecoder(s).Decode(&req); err != nil {
@@ -280,6 +341,11 @@ func (ix *IndexerService) handleNodeGet(s network.Stream) {
 	defer s.Close()
 	logger := oclib.GetLogger()
 	remotePeer := s.Conn().RemotePeer()
+	if !ix.isPeerKnown(remotePeer) {
+		logger.Warn().Str("peer", remotePeer.String()).Msg("[get] unknown peer, rejecting stream")
+		s.Reset()
+		return
+	}
 	if err := ix.behavior.RecordGet(remotePeer); err != nil {
 		logger.Warn().Err(err).Str("peer", remotePeer.String()).Msg("get refused")
 		s.Reset()

daemons/node/indexer/search.go

@@ -74,6 +74,11 @@ func (ix *IndexerService) handleSearchPeer(s network.Stream) {
 	logger := oclib.GetLogger()
 	defer s.Reset()
 
+	if !ix.isPeerKnown(s.Conn().RemotePeer()) {
+		logger.Warn().Str("peer", s.Conn().RemotePeer().String()).Msg("[search] unknown peer, rejecting stream")
+		return
+	}
+
 	var req common.SearchPeerRequest
 	if err := json.NewDecoder(s).Decode(&req); err != nil || req.QueryID == "" {
 		return

daemons/node/indexer/service.go

@@ -162,7 +162,7 @@ func NewIndexerService(h host.Host, ps *pubsub.PubSub, maxNode int) *IndexerServ
 
 	// Build and send a HeartbeatResponse after each received node heartbeat.
 	// Raw metrics only — no pre-cooked score. Node computes the score itself.
-	ix.BuildHeartbeatResponse = func(remotePeer pp.ID, need int, challenges []string, challengeDID string, referent bool) *common.HeartbeatResponse {
+	ix.BuildHeartbeatResponse = func(remotePeer pp.ID, need int, challenges []string, challengeDID string, referent bool, rawRecord json.RawMessage) *common.HeartbeatResponse {
 		ix.StreamMU.RLock()
 		peerCount := len(ix.StreamRecords[common.ProtocolHeartbeat])
 		// Collect lastSeen per active peer for challenge responses.
@@ -184,6 +184,16 @@ func NewIndexerService(h host.Host, ps *pubsub.PubSub, maxNode int) *IndexerServ
 		}
 		ix.StreamMU.RUnlock()
 
+		// AfterHeartbeat updates srec.Record asynchronously — it may not have run yet.
+		// Use rawRecord (the fresh signed PeerRecord embedded in the heartbeat) directly
+		// so referencedNodes always gets the current Name/DID regardless of timing.
+		if remotePeerRecord.Name == "" && len(rawRecord) > 0 {
+			var fresh PeerRecord
+			if json.Unmarshal(rawRecord, &fresh) == nil {
+				remotePeerRecord = fresh
+			}
+		}
+
 		// Update referent designation: node marks its best-scored indexer with Referent=true.
 		ix.updateReferent(remotePeer, remotePeerRecord, referent)