stuff

internal/websocket/server.go

@@ -0,0 +1,154 @@
+package websocket
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"sync"
+
+	"github.com/gorilla/websocket"
+)
+
+type DataType string
+
+const (
+	DataTypeTraces  DataType = "traces"
+	DataTypeMetrics DataType = "metrics"
+	DataTypeLogs    DataType = "logs"
+)
+
+type HistoryProvider interface {
+	GetHistory() []HistoryEntry
+}
+
+type HistoryEntry struct {
+	Type      string      `json:"type"`
+	Timestamp int64       `json:"timestamp"`
+	Data      interface{} `json:"data"`
+}
+
+type Entry struct {
+	Type string      `json:"type"`
+	Data interface{} `json:"data"`
+}
+
+type Broadcaster interface {
+	Broadcast(data *Entry)
+}
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool {
+		return true
+	},
+}
+
+type Server struct {
+	clients         map[*websocket.Conn]bool
+	mutex           sync.Mutex
+	historyProvider HistoryProvider
+}
+
+func New(historyProvider HistoryProvider) *Server {
+	return &Server{
+
+		clients:         make(map[*websocket.Conn]bool),
+		historyProvider: historyProvider,
+	}
+}
+
+func (s *Server) HandleConnections(w http.ResponseWriter, r *http.Request) {
+	ws, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("failed to upgrade connection: %v", err)
+		return
+	}
+	defer ws.Close()
+
+	s.mutex.Lock()
+	s.clients[ws] = true
+	s.mutex.Unlock()
+
+	log.Printf("client connected")
+
+	// // Send history to new client
+	// if s.historyProvider != nil {
+	// 	history := s.historyProvider.GetHistory()
+	// 	for _, entry := range history {
+	// 		if data, err := json.Marshal(entry); err == nil {
+	// 			if err := ws.WriteMessage(websocket.TextMessage, data); err != nil {
+	// 				log.Printf("failed to send history to client: %v", err)
+	// 				break
+	// 			}
+	// 		}
+	// 	}
+	// }
+
+	for {
+		// Read message from browser
+		_, _, err := ws.ReadMessage()
+		if err != nil {
+			log.Printf("read error: %v", err)
+			break
+		}
+	}
+
+	s.mutex.Lock()
+	delete(s.clients, ws)
+	s.mutex.Unlock()
+	log.Printf("client disconnected")
+}
+
+func (s *Server) Broadcast(entry *Entry) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	msg, err := json.Marshal(entry)
+	if err != nil {
+		log.Printf("failed to marshal log entry: %v", err)
+	} else {
+		for client := range s.clients {
+			if err := client.WriteMessage(websocket.TextMessage, msg); err != nil {
+				log.Printf("write error: %v", err)
+			}
+		}
+	}
+}
+
+func (s *Server) SendHistory(ws *websocket.Conn) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	history := s.historyProvider.GetHistory() // Assuming GetHistory() returns the history data
+	for _, entry := range history {
+		data, err := json.Marshal(entry)
+		if err != nil {
+			log.Printf("failed to marshal history entry: %v", err)
+			continue
+		}
+		if err := ws.WriteMessage(websocket.TextMessage, data); err != nil {
+			log.Printf("write error: %v", err)
+		}
+	}
+}
+
+func (s *Server) HandleMessage(ws *websocket.Conn, msg []byte) {
+	var message map[string]interface{}
+	if err := json.Unmarshal(msg, &message); err != nil {
+		log.Printf("error unmarshaling message: %v", err)
+		return
+	}
+
+	// Handle the message (this is just an example, adjust according to your needs)
+	switch message["type"] {
+	case "ping":
+		log.Printf("received ping")
+		s.SendPong(ws)
+	default:
+		log.Printf("unknown message type : %v", message)
+	}
+}
+
+func (s *Server) SendPong(ws *websocket.Conn) {
+	if err := ws.WriteMessage(websocket.PongMessage, nil); err != nil {
+		log.Printf("error sending pong", err)
+	}
+}