creating sse broker

broker.go

@@ -0,0 +1,166 @@
+package goblocks
+
+import (
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type Message struct {
+	Event string
+	Data  any
+}
+
+type Client struct {
+	ID       string
+	Send     chan Message
+	Close    chan struct{}
+	IsActive bool
+}
+
+type SSEBroker struct {
+	clients map[string]*Client
+	mu      sync.RWMutex
+	ticker  *time.Ticker
+	done    chan struct{}
+}
+
+func newSSEBroker() *SSEBroker {
+	s := &SSEBroker{
+		clients: make(map[string]*Client),
+		ticker:  time.NewTicker(time.Minute),
+		done:    make(chan struct{}),
+	}
+	go s.run()
+	return s
+}
+
+func (s *SSEBroker) run() {
+	for {
+		select {
+		case <-s.ticker.C:
+			s.Broadcast("ticker")
+		case <-s.done:
+			s.ticker.Stop()
+			return
+		}
+	}
+}
+
+func (s *SSEBroker) registerClient(id string) *Client {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	client := &Client{
+		ID:       id,
+		Send:     make(chan Message, 100),
+		Close:    make(chan struct{}),
+		IsActive: true,
+	}
+	s.clients[id] = client
+	return client
+}
+
+func (s *SSEBroker) unregisterClient(id string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if client, exists := s.clients[id]; exists {
+		close(client.Close)
+		delete(s.clients, id)
+	}
+}
+
+func (s *SSEBroker) Broadcast(event string, data ...any) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	var dataValue any
+	if len(data) > 0 {
+		dataValue = data[0]
+	}
+
+	message := Message{
+		Event: event,
+		Data:  dataValue,
+	}
+
+	for _, client := range s.clients {
+		if client.IsActive {
+			select {
+			case client.Send <- message:
+			default:
+				slog.Warn("client channel full, skipping message", "client_id", client.ID)
+			}
+		}
+	}
+}
+
+func (s *SSEBroker) HandleSSE(w http.ResponseWriter, r *http.Request) {
+	slog.Debug("SSE called")
+
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+	w.Header().Set("Transfer-Encoding", "chunked")
+
+	clientID := uuid.New().String()
+	client := s.registerClient(clientID)
+	defer s.unregisterClient(clientID)
+
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
+		return
+	}
+
+	slog.Info("SSE connection established", "client_id", clientID)
+
+	fmt.Fprintf(w, "event: connection\ndata: %s\n\n", clientID)
+	flusher.Flush()
+
+	clientGone := r.Context().Done()
+
+	for {
+		select {
+		case message := <-client.Send:
+			var data string
+			switch v := message.Data.(type) {
+			case string:
+				data = v
+			case map[string]any, []any:
+				jsonData, err := json.Marshal(v)
+				if err != nil {
+					slog.Error("error marshaling message", "error", err)
+					continue
+				}
+				data = string(jsonData)
+			default:
+				jsonData, err := json.Marshal(v)
+				if err != nil {
+					slog.Error("error marshaling message", "error", err)
+					continue
+				}
+				data = string(jsonData)
+			}
+			fmt.Fprintf(w, "event: %s\ndata: %s\n\n", message.Event, data)
+		case <-client.Close:
+			slog.Info("client closed", "client_id", clientID)
+			return
+		case <-clientGone:
+			slog.Info("client gone", "client_id", clientID)
+			return
+		}
+
+		flusher.Flush()
+	}
+}
+
+func (s *SSEBroker) Shutdown() {
+	close(s.done)
+}