Observe + metrics

routers/router.go

@@ -9,10 +9,12 @@ package routers
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"oc-peer/controllers"
 	"oc-peer/infrastructure"
 	"strings"
+	"time"
 
 	oclib "cloud.o-forge.io/core/oc-lib"
 	"cloud.o-forge.io/core/oc-lib/tools"
@@ -44,8 +46,7 @@ func init() {
 	)
 	beego.AddNamespace(ns)
 
-	// WebSocket route enregistrée en dehors du pipeline Beego
-	// beego.Handler bypasse le controller pipeline (pas de WriteHeader parasite)
+	// WebSocket — peer search (returns found peers + online/offline updates for them)
 	beego.Handler("/oc/decentralized/search/:search", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		conn, err := upgrader.Upgrade(w, r, nil)
 		if err != nil {
@@ -55,13 +56,89 @@ func init() {
 		parts := strings.Split(strings.TrimSuffix(r.URL.Path, "/"), "/")
 		search := parts[len(parts)-1]
 
-		user, _, groups := oclib.ExtractTokenInfo(*r)
+		user, _, groups := oclib.ExtractTokenInfoWs(*r)
 		b, _ := json.Marshal(map[string]string{"search": search})
 		infrastructure.EmitNATS(user, groups, tools.PropalgationMessage{
 			Action:   tools.PB_SEARCH,
 			DataType: tools.PEER.EnumIndex(),
 			Payload:  b,
 		})
+		fmt.Println("SEARCH", search)
 		controllers.Websocket(r.Context(), user, conn)
 	}))
+
+	// WebSocket — dedicated online/offline feed, user-scoped.
+	//
+	// The frontend sends lists of ShallowPeer to watch; oc-peer forwards them
+	// to oc-discovery via NATS (with user identity). On any disconnect or error
+	// oc-peer emits NATS close for all peers watched in this session.
+	beego.Handler("/oc/decentralized/observe", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			return
+		}
+
+		user, _, _ := oclib.ExtractTokenInfoWs(*r)
+		connID := fmt.Sprintf("%p", conn)
+		ch := make(chan infrastructure.WSMessage, 64)
+		fmt.Println("SUBSCRIBED TO", connID)
+		infrastructure.RegisterObserveSession(connID, user, ch)
+		done := make(chan struct{})
+		defer func() {
+			infrastructure.CloseObserveSession(connID)
+			close(done)
+			conn.Close()
+		}()
+
+		const pongWait = 60 * time.Second
+		const pingPeriod = 50 * time.Second
+		const writeWait = 10 * time.Second
+
+		conn.SetReadDeadline(time.Now().Add(pongWait))
+		conn.SetPongHandler(func(string) error {
+			return conn.SetReadDeadline(time.Now().Add(pongWait))
+		})
+
+		// Write loop: forward state-change messages and send keepalive pings.
+		go func() {
+			ticker := time.NewTicker(pingPeriod)
+			defer ticker.Stop()
+			for {
+				select {
+				case msg := <-ch:
+					fmt.Println("ONLINE", msg)
+					conn.SetWriteDeadline(time.Now().Add(writeWait))
+					if conn.WriteJSON(msg) != nil {
+						conn.Close()
+						return
+					}
+				case <-ticker.C:
+					conn.SetWriteDeadline(time.Now().Add(writeWait))
+					if conn.WriteMessage(websocket.PingMessage, nil) != nil {
+						conn.Close()
+						return
+					}
+				case <-done:
+					return
+				}
+			}
+		}()
+
+		// Read loop: receive peer lists from the frontend.
+		var req struct {
+			Peers []infrastructure.ShallowPeer `json:"peers"`
+		}
+		for {
+			if err := conn.ReadJSON(&req); err != nil {
+				return
+			}
+			// AddObservedPeers deduplicates, emits NATS observe, returns snapshot.
+			for _, msg := range infrastructure.AddObservedPeers(connID, req.Peers) {
+				select {
+				case ch <- msg:
+				default:
+				}
+			}
+		}
+	}))
 }