Debug Spread Get Peer

daemons/node/pubsub/handler.go

@@ -23,14 +23,13 @@ func (ps *PubSubService) handleEventSearch( // only : on partner followings. 3 c
 	if !(action == tools.PB_SEARCH_RESPONSE || action == tools.PB_SEARCH) {
 		return nil
 	}
-	// TODO VERIFY: FROM SHOULD BE A PEER ID OR A  DID
-	if p, err := ps.Node.GetPeerRecord(ctx, evt.From); err == nil {
-		if err := evt.Verify(p); err != nil {
+	if p, err := ps.Node.GetPeerRecord(ctx, evt.From); err == nil && len(p) > 0 { // peerFrom is Unique
+		if err := evt.Verify(p[0]); err != nil {
 			return err
 		}
 		switch action {
 		case tools.PB_SEARCH: // when someone ask for search.
-			if err := ps.StreamService.SendResponse(p, evt); err != nil {
+			if err := ps.StreamService.SendResponse(p[0], evt); err != nil {
 				return err
 			}
 

daemons/node/pubsub/service.go

@@ -14,6 +14,7 @@ import (
 )
 
 type PubSubService struct {
+	*common.LongLivedPubSubService
 	Node          common.DiscoveryPeer
 	Host          host.Host
 	PS            *pubsub.PubSub
@@ -24,10 +25,10 @@ type PubSubService struct {
 
 func InitPubSub(ctx context.Context, h host.Host, ps *pubsub.PubSub, node common.DiscoveryPeer, streamService *stream.StreamService) (*PubSubService, error) {
 	service := &PubSubService{
-		Node:          node,
-		Host:          h,
-		StreamService: streamService,
-		PS:            ps,
+		LongLivedPubSubService: common.NewLongLivedPubSubService(h),
+		Node:                   node,
+		StreamService:          streamService,
+		PS:                     ps,
 	}
 	logger := oclib.GetLogger()
 	logger.Info().Msg("subscribe to events...")

daemons/node/pubsub/subscribe.go

@@ -2,16 +2,11 @@ package pubsub
 
 import (
 	"context"
-	"encoding/json"
-	"errors"
 	"oc-discovery/daemons/node/common"
-	"slices"
-	"time"
 
 	oclib "cloud.o-forge.io/core/oc-lib"
 	"cloud.o-forge.io/core/oc-lib/models/peer"
 	"cloud.o-forge.io/core/oc-lib/tools"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
 )
 
 func (ps *PubSubService) initSubscribeEvents(ctx context.Context) error {
@@ -25,72 +20,20 @@ func (ps *PubSubService) initSubscribeEvents(ctx context.Context) error {
 func (ps *PubSubService) subscribeEvents(
 	ctx context.Context, dt *tools.DataType, action tools.PubSubAction, peerID string, timeout int,
 ) error {
+	logger := oclib.GetLogger()
 	// define a name app.action#peerID
 	name := action.String() + "#" + peerID
 	if dt != nil { // if a datatype is precised then : app.action.datatype#peerID
 		name = action.String() + "." + (*dt).String() + "#" + peerID
 	}
-	topic, err := ps.PS.Join(name) // find out the topic
-	if err != nil {
-		return err
-	}
-
-	sub, err := topic.Subscribe() // then subscribe to it
-	if err != nil {
-		return err
-	}
-	ps.mutex.Lock() // add safely in cache your subscription.
-	ps.Subscription = append(ps.Subscription, name)
-	ps.mutex.Unlock()
-
-	// launch loop waiting for results.
-	go ps.waitResults(ctx, sub, name, timeout)
-
-	return nil
-}
-
-func (ps *PubSubService) waitResults(ctx context.Context, sub *pubsub.Subscription, topicName string, timeout int) {
-	logger := oclib.GetLogger()
-	defer ctx.Done()
-	for {
-		ps.mutex.Lock()                                   // check safely if cache is actually notified subscribed to topic
-		if !slices.Contains(ps.Subscription, topicName) { // if not kill the loop.
-			break
-		}
-		ps.mutex.Unlock()
-		// if still subscribed -> wait for new message
-		var cancel context.CancelFunc
-		if timeout != -1 {
-			ctx, cancel = context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-			defer cancel()
-		}
-		msg, err := sub.Next(ctx)
-		if err != nil {
-			if errors.Is(err, context.DeadlineExceeded) {
-				// timeout hit, no message before deadline kill subsciption.
-				ps.mutex.Lock()
-				subs := []string{}
-				for _, ss := range ps.Subscription {
-					if ss != topicName {
-						subs = append(subs, ss)
-					}
-				}
-				ps.Subscription = subs
-				ps.mutex.Unlock()
-				return
-			}
-			continue
-		}
-		var evt common.Event
-		if err := json.Unmarshal(msg.Data, &evt); err != nil { // map to event
-			continue
-		}
-		if p, err := ps.Node.GetPeerRecord(ctx, evt.From); err == nil {
-			if err := ps.processEvent(ctx, p, &evt, topicName); err != nil {
+	f := func(ctx context.Context, evt common.Event, topicName string) {
+		if p, err := ps.Node.GetPeerRecord(ctx, evt.From); err == nil && len(p) > 0 {
+			if err := ps.processEvent(ctx, p[0], &evt, topicName); err != nil {
 				logger.Err(err)
 			}
 		}
 	}
+	return common.SubscribeEvents(ps.LongLivedPubSubService, ctx, name, -1, f)
 }
 
 func (ps *PubSubService) processEvent(