Debug Spread Get Peer

daemons/node/common/common_pubsub.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"sync"
 	"time"
 
@@ -87,9 +88,11 @@ func (event *Event) Verify(p *peer.Peer) error {
 }
 
 type TopicNodeActivityPub struct {
-	DID          string
-	PeerID       string
 	NodeActivity peer.PeerState
+	Disposer     pp.AddrInfo `json:"disposer_address"`
+	Name         string      `json:"name"`
+	DID          string      `json:"did"` // real PEER ID
+	PeerID       string      `json:"peer_id"`
 }
 
 type LongLivedPubSubService struct {
@@ -119,7 +122,7 @@ func (s *LongLivedPubSubService) processEvent(
 const TopicPubSubNodeActivity = "oc-node-activity"
 const TopicPubSubSearch = "oc-node-search"
 
-func (s *LongLivedPubSubService) SubscribeToNodeActivity(ps *pubsub.PubSub) error {
+func (s *LongLivedPubSubService) SubscribeToNodeActivity(ps *pubsub.PubSub, f *func(context.Context, TopicNodeActivityPub, string)) error {
 	ps.RegisterTopicValidator(TopicPubSubNodeActivity, func(ctx context.Context, p pp.ID, m *pubsub.Message) bool {
 		return true
 	})
@@ -130,10 +133,13 @@ func (s *LongLivedPubSubService) SubscribeToNodeActivity(ps *pubsub.PubSub) erro
 		defer s.PubsubMu.Unlock()
 		s.LongLivedPubSubs[TopicPubSubNodeActivity] = topic
 	}
+	if f != nil {
+		return SubscribeEvents(s, context.Background(), TopicPubSubNodeActivity, -1, *f)
+	}
 	return nil
 }
 
-func (s *LongLivedPubSubService) SubscribeToSearch(ps *pubsub.PubSub) error {
+func (s *LongLivedPubSubService) SubscribeToSearch(ps *pubsub.PubSub, f *func(context.Context, Event, string)) error {
 	ps.RegisterTopicValidator(TopicPubSubSearch, func(ctx context.Context, p pp.ID, m *pubsub.Message) bool {
 		return true
 	})
@@ -144,5 +150,67 @@ func (s *LongLivedPubSubService) SubscribeToSearch(ps *pubsub.PubSub) error {
 		defer s.PubsubMu.Unlock()
 		s.LongLivedPubSubs[TopicPubSubSearch] = topic
 	}
+	if f != nil {
+		return SubscribeEvents(s, context.Background(), TopicPubSubSearch, -1, *f)
+	}
 	return nil
 }
+
+func SubscribeEvents[T interface{}](s *LongLivedPubSubService,
+	ctx context.Context, proto string, timeout int, f func(context.Context, T, string),
+) error {
+	s.PubsubMu.Lock()
+	if s.LongLivedPubSubs[proto] == nil {
+		s.PubsubMu.Unlock()
+		return errors.New("no protocol subscribed in pubsub")
+	}
+	topic := s.LongLivedPubSubs[proto]
+	s.PubsubMu.Unlock()
+
+	sub, err := topic.Subscribe() // then subscribe to it
+	if err != nil {
+		return err
+	}
+	// launch loop waiting for results.
+	go waitResults[T](s, ctx, sub, proto, timeout, f)
+
+	return nil
+}
+
+func waitResults[T interface{}](s *LongLivedPubSubService, ctx context.Context, sub *pubsub.Subscription, proto string, timeout int, f func(context.Context, T, string)) {
+	defer ctx.Done()
+	for {
+		s.PubsubMu.Lock()                     // check safely if cache is actually notified subscribed to topic
+		if s.LongLivedPubSubs[proto] == nil { // if not kill the loop.
+			break
+		}
+		s.PubsubMu.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.
+				s.PubsubMu.Lock()
+				delete(s.LongLivedPubSubs, proto)
+				s.PubsubMu.Unlock()
+				return
+			}
+			continue
+		}
+		var evt T
+		if err := json.Unmarshal(msg.Data, &evt); err != nil { // map to event
+			continue
+		}
+		f(ctx, evt, fmt.Sprintf("%v", proto))
+		/*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)
+			}
+		}*/
+	}
+}