Discovery Neo Oclib

2026-05-27 16:17:00 +02:00
parent 7f951afd41
commit 6ce6e6fe7d
20 changed files with 1436 additions and 1133 deletions
@@ -15,6 +15,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/resources"
 	"cloud.o-forge.io/core/oc-lib/tools"
 	"github.com/libp2p/go-libp2p/core/network"
+	pp "github.com/libp2p/go-libp2p/core/peer"
 )

 type Verify struct {
@@ -23,8 +24,18 @@ type Verify struct {

 func (ps *StreamService) handleEvent(protocol string, evt *common.Event, s network.Stream) error {
 	fmt.Println("handleEvent", protocol)
-	// Heartbeat received on an outgoing ProtocolObserve stream.
 	if protocol == ProtocolObserve {
+		// Distinguish between an open request and a close request by inspecting
+		// the ObserveRequest payload. The remote wraps both in a common.Event
+		// with Type=ProtocolObserve so the persistent readLoop can decode them.
+		var req ObserveRequest
+		if evt.Payload != nil {
+			json.Unmarshal(evt.Payload, &req) //nolint:errcheck — zero value means open
+		}
+		if req.Close {
+			ps.observeCache.cancel(s.Conn().RemotePeer().String())
+			return nil
+		}
 		return ps.handleIncomingObserve(s)
 	}
 	if protocol == observeHBEventType {
@@ -59,6 +70,11 @@ func (ps *StreamService) handleEvent(protocol string, evt *common.Event, s netwo
 			return err
 		}
 	}
+	if protocol == ProtocolSourcePresignResource {
+		if err := ps.pass(evt, tools.SOURCE_PRESIGN_EVENT); err != nil {
+			return err
+		}
+	}
 	if protocol == ProtocolAdmiraltyConfigResource {
 		if err := ps.pass(evt, tools.ADMIRALTY_CONFIG_EVENT); err != nil {
 			return err
@@ -125,9 +141,9 @@ func (abs *StreamService) sendPlanner(event *common.Event) error { //
 }

 func (abs *StreamService) retrieveResponse(event *common.Event) error { //
-	if !abs.ResourceSearches.IsActive(event.User) {
+	/*if !abs.ResourceSearches.IsActive(event.User) {
 		return nil // search already closed or timed out
-	}
+	}*/
 	res, err := resources.ToResource(int(event.DataType), event.Payload)
 	if err != nil || res == nil {
 		return nil
@@ -137,6 +153,7 @@ func (abs *StreamService) retrieveResponse(event *common.Event) error { //
 	b, err := json.Marshal(res.Serialize(res))
 	go tools.NewNATSCaller().SetNATSPub(tools.SEARCH_EVENT, tools.NATSResponse{
 		FromApp:  "oc-discovery",
+		User:     event.User,
 		Datatype: tools.DataType(event.DataType),
 		Method:   int(tools.SEARCH_EVENT),
 		Payload:  b,
@@ -147,6 +164,7 @@ func (abs *StreamService) retrieveResponse(event *common.Event) error { //
 func (abs *StreamService) pass(event *common.Event, method tools.NATSMethod) error { //
 	go tools.NewNATSCaller().SetNATSPub(method, tools.NATSResponse{
 		FromApp:  "oc-discovery",
+		User:     event.User,
 		Datatype: tools.DataType(event.DataType),
 		Method:   int(method),
 		Payload:  event.Payload,
@@ -154,6 +172,36 @@ func (abs *StreamService) pass(event *common.Event, method tools.NATSMethod) err
 	return nil
 }

+// resolveBookingNano does a single DB lookup and returns:
+//
+//	(nil, true)  — not a booking, dest_peer_id absent, or dest == self → process normally, no forward
+//	(nano, true) — dest is one of our NANO peers → process + forward to nano
+//	(nil, false) — dest is unknown → ignore
+func (ps *StreamService) resolveBookingNano(evt *common.Event) (*peer.Peer, bool) {
+	if tools.DataType(evt.DataType) != tools.BOOKING {
+		return nil, true
+	}
+	var b struct {
+		DestPeerID string `json:"dest_peer_id"`
+	}
+	if err := json.Unmarshal(evt.Payload, &b); err != nil || b.DestPeerID == "" {
+		return nil, true
+	}
+	if self, err := oclib.GetMySelf(); err == nil && self != nil && b.DestPeerID == self.GetID() {
+		return nil, true
+	}
+	d := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil).Search(&dbs.Filters{
+		And: map[string][]dbs.Filter{
+			"id":       {{Operator: dbs.EQUAL.String(), Value: b.DestPeerID}},
+			"relation": {{Operator: dbs.EQUAL.String(), Value: peer.NANO}},
+		},
+	}, "", false, 0, 1)
+	if len(d.Data) == 0 {
+		return nil, false
+	}
+	return d.Data[0].(*peer.Peer), true
+}
+
 func (ps *StreamService) handleEventFromPartner(evt *common.Event, protocol string) error {
 	switch protocol {
 	case ProtocolSearchResource:
@@ -176,9 +224,10 @@ func (ps *StreamService) handleEventFromPartner(evt *common.Event, protocol stri
 				ps.SendResponse(p[0], evt, fmt.Sprintf("%v", search))
 			}
 		} else {
-			fmt.Println("SEND SEARCH_EVENT SetNATSPub", m)
-			go tools.NewNATSCaller().SetNATSPub(tools.SEARCH_EVENT, tools.NATSResponse{
+			fmt.Println("SEND SEARCH_EVENT SetNATSPub", m, evt.DataType, evt.User)
+			tools.NewNATSCaller().SetNATSPub(tools.SEARCH_EVENT, tools.NATSResponse{
 				FromApp:  "oc-discovery",
+				User:     evt.User,
 				Datatype: tools.DataType(evt.DataType),
 				Method:   int(tools.SEARCH_EVENT),
 				Payload:  evt.Payload,
@@ -186,19 +235,35 @@ func (ps *StreamService) handleEventFromPartner(evt *common.Event, protocol stri
 		}
 	case ProtocolCreateResource, ProtocolUpdateResource:
 		fmt.Println("RECEIVED Protocol.Update", string(evt.Payload))
-		go tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
+		nano, ok := ps.resolveBookingNano(evt)
+		if !ok {
+			return nil
+		}
+		tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
 			FromApp:  "oc-discovery",
+			User:     evt.User,
 			Datatype: tools.DataType(evt.DataType),
 			Method:   int(tools.CREATE_RESOURCE),
 			Payload:  evt.Payload,
 		})
+		if nano != nil {
+			ps.forwardToNano(nano, evt, protocol)
+		}
 	case ProtocolDeleteResource:
-		go tools.NewNATSCaller().SetNATSPub(tools.REMOVE_RESOURCE, tools.NATSResponse{
+		nano, ok := ps.resolveBookingNano(evt)
+		if !ok {
+			return nil
+		}
+		tools.NewNATSCaller().SetNATSPub(tools.REMOVE_RESOURCE, tools.NATSResponse{
 			FromApp:  "oc-discovery",
+			User:     evt.User,
 			Datatype: tools.DataType(evt.DataType),
 			Method:   int(tools.REMOVE_RESOURCE),
 			Payload:  evt.Payload,
 		})
+		if nano != nil {
+			ps.forwardToNano(nano, evt, protocol)
+		}
 	default:
 		return errors.New("no action authorized available : " + protocol)
 	}
@@ -223,11 +288,31 @@ func (abs *StreamService) SendResponse(p *peer.Peer, event *common.Event, search
 			access := oclib.NewRequestAdmin(oclib.LibDataEnum(dt), nil)
 			searched := access.Search(abs.FilterPeer(self.GetID(), event.Groups, search), "", false, 0, 0)
 			for _, ss := range searched.Data {
+				// SendResponse uses an admin request so SetAllowedInstances
+				// never calls FilterExploitationAuthorizations.  Apply it
+				// explicitly here so we never leak private AEs to a remote peer.
+				if r, ok := ss.(resources.ResourceInterface); ok {
+					r.SetAllowedInstances(&tools.APIRequest{PeerID: p.UUID, Groups: event.Groups, Username: event.User})
+				}
 				if j, err := json.Marshal(ss); err == nil {
 					abs.PublishCommon(&dt, event.User, event.Groups, p.PeerID, ProtocolSearchResource, j)
 				}
 			}
 		}
 	}
+	// Close the ProtocolSearchResource stream to the requester immediately after
+	// sending all results. This prevents TempStream from reusing a stale (already
+	// closed by the remote) stream entry for a subsequent search from the same peer,
+	// which would cause write failure and no results for the second search.
+	if decodedID, err := pp.Decode(p.PeerID); err == nil {
+		abs.Mu.Lock()
+		if abs.Streams[ProtocolSearchResource] != nil {
+			if s, ok := abs.Streams[ProtocolSearchResource][decodedID]; ok {
+				s.Stream.Reset()
+				delete(abs.Streams[ProtocolSearchResource], decodedID)
+			}
+		}
+		abs.Mu.Unlock()
+	}
 	return nil
 }