Simple Architecture

daemons/node/stream/handler.go

@@ -94,27 +94,21 @@ func (abs *StreamService) sendPlanner(event *common.Event) error { //
 				return err
 			}
 		} else {
-			m := map[string]interface{}{}
-			if err := json.Unmarshal(event.Payload, &m); err == nil {
-				m["peer_id"] = event.From
-				if pl, err := json.Marshal(m); err == nil {
-					if b, err := json.Marshal(tools.PropalgationMessage{
-						DataType: -1,
-						Action:   tools.PB_PLANNER,
-						Payload:  pl,
-					}); err == nil {
-						go tools.NewNATSCaller().SetNATSPub(tools.PROPALGATION_EVENT, tools.NATSResponse{
-							FromApp:  "oc-discovery",
-							Datatype: tools.DataType(oclib.BOOKING),
-							Method:   int(tools.PROPALGATION_EVENT),
-							Payload:  b,
-						})
-					}
-				}
+			return err
+		}
+	} else { // if not empty so it's
+		m := map[string]interface{}{}
+		if err := json.Unmarshal(event.Payload, &m); err == nil {
+			m["peer_id"] = event.From
+			if pl, err := json.Marshal(m); err == nil {
+				go tools.NewNATSCaller().SetNATSPub(tools.PLANNER_EXECUTION, tools.NATSResponse{
+					FromApp:  "oc-discovery",
+					Datatype: tools.DataType(oclib.BOOKING),
+					Method:   int(tools.PLANNER_EXECUTION),
+					Payload:  pl,
+				})
 			}
 		}
-	} else {
-
 	}
 	return nil
 }

daemons/node/stream/publish.go

@@ -70,8 +70,7 @@ func (ps *StreamService) ToPartnerPublishEvent(
 		if err := json.Unmarshal(payload, &p); err != nil {
 			return err
 		}
-		pid, err := pp.Decode(p.PeerID)
-		if err != nil {
+		if _, err := pp.Decode(p.PeerID); err != nil {
 			return err
 		}
 
@@ -86,19 +85,7 @@ func (ps *StreamService) ToPartnerPublishEvent(
 				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

daemons/node/stream/service.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"oc-discovery/conf"
 	"oc-discovery/daemons/node/common"
@@ -21,7 +20,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	pp "github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/protocol"
-	ma "github.com/multiformats/go-multiaddr"
 )
 
 const ProtocolConsidersResource = "/opencloud/resource/considers/1.0"
@@ -56,10 +54,9 @@ type StreamService struct {
 	Key          pp.ID
 	Host         host.Host
 	Node         common.DiscoveryPeer
-	Streams      common.ProtocolStream
+	Streams       common.ProtocolStream
 	maxNodesConn int
 	Mu           sync.RWMutex
-	// Stream       map[protocol.ID]map[pp.ID]*daemons.Stream
 }
 
 func InitStream(ctx context.Context, h host.Host, key pp.ID, maxNode int, node common.DiscoveryPeer) (*StreamService, error) {
@@ -68,11 +65,9 @@ func InitStream(ctx context.Context, h host.Host, key pp.ID, maxNode int, node c
 		Key:          key,
 		Node:         node,
 		Host:         h,
-		Streams:      common.ProtocolStream{},
+		Streams:       common.ProtocolStream{},
 		maxNodesConn: maxNode,
 	}
-	logger.Info().Msg("handle to partner heartbeat protocol...")
-	service.Host.SetStreamHandler(ProtocolHeartbeatPartner, service.HandlePartnerHeartbeat)
 	for proto := range protocols {
 		service.Host.SetStreamHandler(proto, service.HandleResponse)
 	}
@@ -106,39 +101,11 @@ func (s *StreamService) HandleResponse(stream network.Stream) {
 		stream.Protocol(), protocols[stream.Protocol()])
 }
 
-func (s *StreamService) HandlePartnerHeartbeat(stream network.Stream) {
-	s.Mu.Lock()
-	if s.Streams[ProtocolHeartbeatPartner] == nil {
-		s.Streams[ProtocolHeartbeatPartner] = map[pp.ID]*common.Stream{}
-	}
-	streams := s.Streams[ProtocolHeartbeatPartner]
-	streamsAnonym := map[pp.ID]common.HeartBeatStreamed{}
-	for k, v := range streams {
-		streamsAnonym[k] = v
-	}
-	s.Mu.Unlock()
-	pid, hb, err := common.CheckHeartbeat(s.Host, stream, json.NewDecoder(stream), streamsAnonym, &s.Mu, s.maxNodesConn)
-	if err != nil {
-		return
-	}
-	s.Mu.Lock()
-	defer s.Mu.Unlock()
-	// if record already seen update last seen
-	if rec, ok := streams[*pid]; ok {
-		rec.DID = hb.DID
-		rec.Expiry = time.Now().UTC().Add(10 * time.Second)
-	} else { // if not in stream ?
-		val, err := stream.Conn().RemoteMultiaddr().ValueForProtocol(ma.P_IP4)
-		if err == nil {
-			s.ConnectToPartner(val)
-		}
-	}
-	// 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()
+	// Register handlers for partner resource protocols (create/update/delete).
+	// Connections to partners happen on-demand via TempStream when needed.
 	for proto, info := range protocolsPartners {
 		f := func(ss network.Stream) {
 			if s.Streams[proto] == nil {
@@ -153,25 +120,9 @@ func (s *StreamService) connectToPartners() error {
 		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 {
-		s.ConnectToPartner(p.StreamAddress)
-	}
 	return nil
 }
 
-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}, nil, 20*time.Second)
-	}
-}
 
 func (s *StreamService) searchPeer(search string) ([]*peer.Peer, error) {
 	ps := []*peer.Peer{}
@@ -220,11 +171,7 @@ func (s *StreamService) gc() {
 	defer s.Mu.Unlock()
 	now := time.Now().UTC()
 
-	if s.Streams[ProtocolHeartbeatPartner] == nil {
-		s.Streams[ProtocolHeartbeatPartner] = map[pp.ID]*common.Stream{}
-	}
-	streams := s.Streams[ProtocolHeartbeatPartner]
-	for pid, rec := range streams {
+	for pid, rec := range s.Streams[ProtocolHeartbeatPartner] {
 		if now.After(rec.Expiry) {
 			for _, sstreams := range s.Streams {
 				if sstreams[pid] != nil {