demo test + Peer

2026-03-03 16:38:24 +01:00
parent 79aa3cc2b3
commit ef3d998ead
41 changed files with 2360 additions and 578 deletions
--- a/daemons/node/stream/handler.go
+++ b/daemons/node/stream/handler.go
@@ -5,6 +5,7 @@ import (
 	"crypto/subtle"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"oc-discovery/daemons/node/common"

 	oclib "cloud.o-forge.io/core/oc-lib"
@@ -19,6 +20,7 @@ type Verify struct {
 }

 func (ps *StreamService) handleEvent(protocol string, evt *common.Event) error {
+	fmt.Println("handleEvent")
 	ps.handleEventFromPartner(evt, protocol)
 	/*if protocol == ProtocolVerifyResource {
 		if evt.DataType == -1 {
@@ -148,14 +150,6 @@ func (abs *StreamService) pass(event *common.Event, action tools.PubSubAction) e
 }

 func (ps *StreamService) handleEventFromPartner(evt *common.Event, protocol string) error {
-	resource, err := resources.ToResource(int(evt.DataType), evt.Payload)
-	if err != nil {
-		return err
-	}
-	b, err := json.Marshal(resource)
-	if err != nil {
-		return err
-	}
 	switch protocol {
 	case ProtocolSearchResource:
 		if evt.DataType < 0 {
@@ -169,20 +163,20 @@ func (ps *StreamService) handleEventFromPartner(evt *common.Event, protocol stri
 				ps.SendResponse(p[0], evt)
 			}
 		}
-	case ProtocolCreateResource:
-	case ProtocolUpdateResource:
+	case ProtocolCreateResource, ProtocolUpdateResource:
+		fmt.Println("RECEIVED Protocol.Update")
 		go tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
 			FromApp:  "oc-discovery",
 			Datatype: tools.DataType(evt.DataType),
 			Method:   int(tools.CREATE_RESOURCE),
-			Payload:  b,
+			Payload:  evt.Payload,
 		})
 	case ProtocolDeleteResource:
 		go tools.NewNATSCaller().SetNATSPub(tools.REMOVE_RESOURCE, tools.NATSResponse{
 			FromApp:  "oc-discovery",
 			Datatype: tools.DataType(evt.DataType),
 			Method:   int(tools.REMOVE_RESOURCE),
-			Payload:  b,
+			Payload:  evt.Payload,
 		})
 	default:
 		return errors.New("no action authorized available : " + protocol)
@@ -213,9 +207,9 @@ func (abs *StreamService) SendResponse(p *peer.Peer, event *common.Event) error
 			if j, err := json.Marshal(ss); err == nil {
 				if event.DataType != -1 {
 					ndt := tools.DataType(dt.EnumIndex())
-					abs.PublishResources(&ndt, event.User, peerID, j)
+					abs.PublishCommon(&ndt, event.User, peerID, ProtocolSearchResource, j)
 				} else {
-					abs.PublishResources(nil, event.User, peerID, j)
+					abs.PublishCommon(nil, event.User, peerID, ProtocolSearchResource, j)
 				}
 			}
 		}
--- a/daemons/node/stream/publish.go
+++ b/daemons/node/stream/publish.go
@@ -15,81 +15,45 @@ import (
 	"github.com/libp2p/go-libp2p/core/protocol"
 )

-func (ps *StreamService) PublishCommon(dt *tools.DataType, user string, toPeerID string, proto protocol.ID, resource []byte) (*common.Stream, error) {
+func (ps *StreamService) PublishesCommon(dt *tools.DataType, user string, filter *dbs.Filters, resource []byte, protos ...protocol.ID) error {
 	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
-	p := access.LoadOne(toPeerID)
-	if p.Err != "" {
-		return nil, errors.New(p.Err)
-	} else {
-		ad, err := pp.AddrInfoFromString(p.Data.(*peer.Peer).StreamAddress)
+	p := access.Search(filter, "", false)
+	for _, pes := range p.Data {
+		for _, proto := range protos {
+			if _, err := ps.PublishCommon(dt, user, pes.(*peer.Peer).PeerID, proto, resource); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (ps *StreamService) PublishCommon(dt *tools.DataType, user string, toPeerID string, proto protocol.ID, resource []byte) (*common.Stream, error) {
+	fmt.Println("PublishCommon")
+	if toPeerID == ps.Key.String() {
+		return nil, errors.New("Can't send to ourself !")
+	}
+
+	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
+	p := access.Search(&dbs.Filters{
+		And: map[string][]dbs.Filter{ // search by name if no filters are provided
+			"peer_id": {{Operator: dbs.EQUAL.String(), Value: toPeerID}},
+		},
+	}, toPeerID, false)
+	var pe *peer.Peer
+	if len(p.Data) > 0 && p.Data[0].(*peer.Peer).Relation != peer.BLACKLIST {
+		pe = p.Data[0].(*peer.Peer)
+	} else if pps, err := ps.Node.GetPeerRecord(context.Background(), toPeerID); err == nil && len(pps) > 0 {
+		pe = pps[0]
+	}
+	if pe != nil {
+		ad, err := pp.AddrInfoFromString(p.Data[0].(*peer.Peer).StreamAddress)
 		if err != nil {
 			return nil, err
 		}
 		return ps.write(toPeerID, ad, dt, user, resource, proto)
 	}
-}
-
-func (ps *StreamService) PublishResources(dt *tools.DataType, user string, toPeerID string, resource []byte) error {
-	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
-	p := access.LoadOne(toPeerID)
-	if p.Err != "" {
-		return errors.New(p.Err)
-	} else {
-		ad, err := pp.AddrInfoFromString(p.Data.(*peer.Peer).StreamAddress)
-		if err != nil {
-			return err
-		}
-		ps.write(toPeerID, ad, dt, user, resource, ProtocolSearchResource)
-	}
-	return nil
-}
-
-func (ps *StreamService) SearchKnownPublishEvent(dt *tools.DataType, user string, search string) error {
-	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
-	peers := access.Search(&dbs.Filters{ // filter by like name, short_description, description, owner, url if no filters are provided
-		And: map[string][]dbs.Filter{
-			"": {{Operator: dbs.NOT.String(), Value: dbs.Filters{ // filter by like name, short_description, description, owner, url if no filters are provided
-				And: map[string][]dbs.Filter{
-					"relation": {{Operator: dbs.EQUAL.String(), Value: peer.BLACKLIST}},
-				},
-			}}},
-		},
-	}, search, false)
-	if peers.Err != "" {
-		return errors.New(peers.Err)
-	} else {
-		b, err := json.Marshal(map[string]string{"search": search})
-		if err != nil {
-			return err
-		}
-		for _, p := range peers.Data {
-			ad, err := pp.AddrInfoFromString(p.(*peer.Peer).StreamAddress)
-			if err != nil {
-				continue
-			}
-			ps.write(p.GetID(), ad, dt, user, b, ProtocolSearchResource)
-		}
-	}
-	return nil
-}
-
-func (ps *StreamService) SearchPartnersPublishEvent(dt *tools.DataType, user string, search string) error {
-	if peers, err := ps.searchPeer(fmt.Sprintf("%v", peer.PARTNER.EnumIndex())); err != nil {
-		return err
-	} else {
-		b, err := json.Marshal(map[string]string{"search": search})
-		if err != nil {
-			return err
-		}
-		for _, p := range peers {
-			ad, err := pp.AddrInfoFromString(p.StreamAddress)
-			if err != nil {
-				continue
-			}
-			ps.write(p.GetID(), ad, dt, user, b, ProtocolSearchResource)
-		}
-	}
-	return nil
+	return nil, errors.New("peer unvalid " + toPeerID)
 }

 func (ps *StreamService) ToPartnerPublishEvent(
@@ -103,35 +67,44 @@ func (ps *StreamService) ToPartnerPublishEvent(
 		if err != nil {
 			return err
 		}
-		ps.Mu.Lock()
-		defer ps.Mu.Unlock()
-		if p.Relation == peer.PARTNER {
-			if ps.Streams[ProtocolHeartbeatPartner] == nil {
-				ps.Streams[ProtocolHeartbeatPartner] = map[pp.ID]*common.Stream{}
-			}
-			ps.ConnectToPartner(p.StreamAddress)
-		} else if ps.Streams[ProtocolHeartbeatPartner] != nil && ps.Streams[ProtocolHeartbeatPartner][pid] != nil {
-			for _, pids := range ps.Streams {
-				if pids[pid] != nil {
-					delete(pids, pid)
+
+		if pe, err := oclib.GetMySelf(); err != nil {
+			return err
+		} else if pe.GetID() == p.GetID() {
+			return fmt.Errorf("can't send to ourself")
+		} else {
+			pe.Relation = p.Relation
+			pe.Verify = false
+			if b2, err := json.Marshal(pe); err == nil {
+				if _, err := ps.PublishCommon(dt, user, p.PeerID, ProtocolUpdateResource, b2); err != nil {
+					return err
+				}
+				if p.Relation == peer.PARTNER {
+					if ps.Streams[ProtocolHeartbeatPartner] == nil {
+						ps.Streams[ProtocolHeartbeatPartner] = map[pp.ID]*common.Stream{}
+					}
+					fmt.Println("SHOULD CONNECT")
+					ps.ConnectToPartner(p.StreamAddress)
+				} else if ps.Streams[ProtocolHeartbeatPartner] != nil && ps.Streams[ProtocolHeartbeatPartner][pid] != nil {
+					for _, pids := range ps.Streams {
+						if pids[pid] != nil {
+							delete(pids, pid)
+						}
+					}
 				}
 			}
 		}
 		return nil
 	}
-	if peers, err := ps.searchPeer(fmt.Sprintf("%v", peer.PARTNER.EnumIndex())); err != nil {
-		return err
-	} else {
-		for _, p := range peers {
-			for protocol := range protocolsPartners {
-				ad, err := pp.AddrInfoFromString(p.StreamAddress)
-				if err != nil {
-					continue
-				}
-				ps.write(p.GetID(), ad, dt, user, payload, protocol)
-			}
-		}
+	ks := []protocol.ID{}
+	for k := range protocolsPartners {
+		ks = append(ks, k)
 	}
+	ps.PublishesCommon(dt, user, &dbs.Filters{ // filter by like name, short_description, description, owner, url if no filters are provided
+		And: map[string][]dbs.Filter{
+			"relation": {{Operator: dbs.EQUAL.String(), Value: peer.PARTNER}},
+		},
+	}, payload, ks...)
 	return nil
 }

@@ -158,6 +131,7 @@ func (s *StreamService) write(
 	}
 	stream := s.Streams[proto][peerID.ID]
 	evt := common.NewEvent(string(proto), peerID.ID.String(), dt, user, payload)
+	fmt.Println("SEND EVENT ", evt.From, evt.DataType, evt.Timestamp)
 	if err := json.NewEncoder(stream.Stream).Encode(evt); err != nil {
 		stream.Stream.Close()
 		logger.Err(err)
--- a/daemons/node/stream/service.go
+++ b/daemons/node/stream/service.go
@@ -116,7 +116,7 @@ func (s *StreamService) HandlePartnerHeartbeat(stream network.Stream) {
 		streamsAnonym[k] = v
 	}
 	s.Mu.Unlock()
-	pid, hb, err := common.CheckHeartbeat(s.Host, stream, streamsAnonym, &s.Mu, s.maxNodesConn)
+	pid, hb, err := common.CheckHeartbeat(s.Host, stream, json.NewDecoder(stream), streamsAnonym, &s.Mu, s.maxNodesConn)
 	if err != nil {
 		return
 	}
@@ -132,10 +132,12 @@ func (s *StreamService) HandlePartnerHeartbeat(stream network.Stream) {
 			s.ConnectToPartner(val)
 		}
 	}
-	go s.StartGC(30 * time.Second)
+	// GC is already running via InitStream — starting a new ticker goroutine on
+	// every heartbeat would leak an unbounded number of goroutines.
 }

 func (s *StreamService) connectToPartners() error {
+	logger := oclib.GetLogger()
 	for proto, info := range protocolsPartners {
 		f := func(ss network.Stream) {
 			if s.Streams[proto] == nil {
@@ -147,11 +149,12 @@ func (s *StreamService) connectToPartners() error {
 			}
 			go s.readLoop(s.Streams[proto][ss.Conn().RemotePeer()], ss.Conn().RemotePeer(), proto, info)
 		}
-		fmt.Println("SetStreamHandler", proto)
+		logger.Info().Msg("SetStreamHandler " + string(proto))
 		s.Host.SetStreamHandler(proto, f)
 	}
 	peers, err := s.searchPeer(fmt.Sprintf("%v", peer.PARTNER.EnumIndex()))
 	if err != nil {
+		logger.Err(err)
 		return err
 	}
 	for _, p := range peers {
@@ -161,19 +164,19 @@ func (s *StreamService) connectToPartners() error {
 }

 func (s *StreamService) ConnectToPartner(address string) {
+	logger := oclib.GetLogger()
 	if ad, err := pp.AddrInfoFromString(address); err == nil {
+		logger.Info().Msg("Connect to Partner " + ProtocolHeartbeatPartner + " " + address)
 		common.SendHeartbeat(context.Background(), ProtocolHeartbeatPartner, conf.GetConfig().Name,
-			s.Host, s.Streams, map[string]*pp.AddrInfo{address: ad}, 20*time.Second)
+			s.Host, s.Streams, map[string]*pp.AddrInfo{address: ad}, nil, 20*time.Second)
 	}
 }

 func (s *StreamService) searchPeer(search string) ([]*peer.Peer, error) {
-	/* TODO FOR TEST ONLY A VARS THAT DEFINE ADDRESS... deserialize */
 	ps := []*peer.Peer{}
 	if conf.GetConfig().PeerIDS != "" {
 		for _, peerID := range strings.Split(conf.GetConfig().PeerIDS, ",") {
 			ppID := strings.Split(peerID, "/")
-			fmt.Println(ppID, peerID)
 			ps = append(ps, &peer.Peer{
 				AbstractObject: utils.AbstractObject{
 					UUID: uuid.New().String(),
@@ -185,7 +188,6 @@ func (s *StreamService) searchPeer(search string) ([]*peer.Peer, error) {
 			})
 		}
 	}
-
 	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
 	peers := access.Search(nil, search, false)
 	for _, p := range peers.Data {
@@ -252,8 +254,9 @@ func (ps *StreamService) readLoop(s *common.Stream, id pp.ID, proto protocol.ID,
 		}
 		var evt common.Event
 		if err := json.NewDecoder(s.Stream).Decode(&evt); err != nil {
-			s.Stream.Close()
-			continue
+			// Any decode error (EOF, reset, malformed JSON) terminates the loop;
+			// continuing on a dead/closed stream creates an infinite spin.
+			return
 		}
 		ps.handleEvent(evt.Type, &evt)
 		if protocolInfo.WaitResponse && !protocolInfo.PersistantStream {