chore: import upstream snapshot with attribution

web/sse.go

@@ -0,0 +1,294 @@
+// Package web provides a web service for go-micro
+package web
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+
+	"go-micro.dev/v6/events"
+	log "go-micro.dev/v6/logger"
+)
+
+// SSEClient represents a connected SSE client
+type SSEClient struct {
+	id   string
+	send chan []byte
+	done chan struct{}
+}
+
+// SSEBroadcaster manages SSE connections and broadcasts events to connected clients
+type SSEBroadcaster struct {
+	clients    map[*SSEClient]struct{}
+	register   chan *SSEClient
+	unregister chan *SSEClient
+	broadcast  chan []byte
+	stream     events.Stream
+	topics     []string
+	logger     log.Logger
+	mu         sync.RWMutex
+	running    bool
+	stopCh     chan struct{}
+}
+
+// SSEEvent represents an event to be sent to clients
+type SSEEvent struct {
+	ID    string      `json:"id,omitempty"`
+	Event string      `json:"event,omitempty"`
+	Data  interface{} `json:"data"`
+}
+
+// SSEOption is a function that configures the SSEBroadcaster
+type SSEOption func(*SSEBroadcaster)
+
+// WithStream sets the events stream for the broadcaster
+func WithStream(stream events.Stream) SSEOption {
+	return func(b *SSEBroadcaster) {
+		b.stream = stream
+	}
+}
+
+// WithTopics sets the topics to subscribe to
+func WithTopics(topics ...string) SSEOption {
+	return func(b *SSEBroadcaster) {
+		b.topics = topics
+	}
+}
+
+// WithSSELogger sets the logger for the broadcaster
+func WithSSELogger(logger log.Logger) SSEOption {
+	return func(b *SSEBroadcaster) {
+		b.logger = logger
+	}
+}
+
+// NewSSEBroadcaster creates a new SSE broadcaster
+func NewSSEBroadcaster(opts ...SSEOption) *SSEBroadcaster {
+	b := &SSEBroadcaster{
+		clients:    make(map[*SSEClient]struct{}),
+		register:   make(chan *SSEClient),
+		unregister: make(chan *SSEClient),
+		broadcast:  make(chan []byte, 256),
+		logger:     log.DefaultLogger,
+		stopCh:     make(chan struct{}),
+	}
+
+	for _, opt := range opts {
+		opt(b)
+	}
+
+	return b
+}
+
+// Start begins the broadcaster's event loop and subscribes to configured topics
+func (b *SSEBroadcaster) Start() error {
+	b.mu.Lock()
+	if b.running {
+		b.mu.Unlock()
+		return nil
+	}
+	b.running = true
+	b.mu.Unlock()
+
+	// Start the main event loop
+	go b.run()
+
+	// Subscribe to topics if stream is configured
+	if b.stream != nil && len(b.topics) > 0 {
+		for _, topic := range b.topics {
+			if err := b.subscribeToTopic(topic); err != nil {
+				b.logger.Logf(log.ErrorLevel, "Failed to subscribe to topic %s: %v", topic, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+// Stop gracefully shuts down the broadcaster
+func (b *SSEBroadcaster) Stop() {
+	b.mu.Lock()
+	if !b.running {
+		b.mu.Unlock()
+		return
+	}
+	b.running = false
+	b.mu.Unlock()
+
+	close(b.stopCh)
+}
+
+func (b *SSEBroadcaster) run() {
+	for {
+		select {
+		case client := <-b.register:
+			b.mu.Lock()
+			b.clients[client] = struct{}{}
+			b.mu.Unlock()
+			b.logger.Logf(log.DebugLevel, "SSE client connected: %s", client.id)
+
+		case client := <-b.unregister:
+			b.mu.Lock()
+			if _, ok := b.clients[client]; ok {
+				delete(b.clients, client)
+				close(client.send)
+			}
+			b.mu.Unlock()
+			b.logger.Logf(log.DebugLevel, "SSE client disconnected: %s", client.id)
+
+		case message := <-b.broadcast:
+			b.mu.RLock()
+			for client := range b.clients {
+				select {
+				case client.send <- message:
+				default:
+					// Client buffer full, skip
+				}
+			}
+			b.mu.RUnlock()
+
+		case <-b.stopCh:
+			b.mu.Lock()
+			for client := range b.clients {
+				close(client.send)
+				delete(b.clients, client)
+			}
+			b.mu.Unlock()
+			return
+		}
+	}
+}
+
+func (b *SSEBroadcaster) subscribeToTopic(topic string) error {
+	eventChan, err := b.stream.Consume(topic)
+	if err != nil {
+		return err
+	}
+
+	go func() {
+		for {
+			select {
+			case event := <-eventChan:
+				b.Broadcast(event.Payload)
+			case <-b.stopCh:
+				return
+			}
+		}
+	}()
+
+	b.logger.Logf(log.InfoLevel, "SSE broadcaster subscribed to topic: %s", topic)
+	return nil
+}
+
+// Broadcast sends a message to all connected clients
+func (b *SSEBroadcaster) Broadcast(data []byte) {
+	select {
+	case b.broadcast <- data:
+	default:
+		b.logger.Log(log.WarnLevel, "SSE broadcast channel full, dropping message")
+	}
+}
+
+// BroadcastEvent sends a structured event to all connected clients
+func (b *SSEBroadcaster) BroadcastEvent(eventType string, data interface{}) error {
+	event := SSEEvent{
+		ID:    fmt.Sprintf("%d", time.Now().UnixNano()),
+		Event: eventType,
+		Data:  data,
+	}
+
+	jsonData, err := json.Marshal(event)
+	if err != nil {
+		return err
+	}
+
+	b.Broadcast(jsonData)
+	return nil
+}
+
+// BroadcastHTML sends raw HTML to clients (for htmx/datastar integration)
+func (b *SSEBroadcaster) BroadcastHTML(eventType string, html string) {
+	// Format as SSE with event type for htmx sse-swap
+	message := fmt.Sprintf("event: %s\ndata: %s\n\n", eventType, html)
+	b.Broadcast([]byte(message))
+}
+
+// ClientCount returns the number of connected clients
+func (b *SSEBroadcaster) ClientCount() int {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return len(b.clients)
+}
+
+// Handler returns an http.HandlerFunc for SSE connections
+func (b *SSEBroadcaster) Handler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Check if the client supports SSE
+		flusher, ok := w.(http.Flusher)
+		if !ok {
+			http.Error(w, "SSE not supported", http.StatusInternalServerError)
+			return
+		}
+
+		// Set SSE headers
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Header().Set("Cache-Control", "no-cache")
+		w.Header().Set("Connection", "keep-alive")
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("X-Accel-Buffering", "no") // Disable nginx buffering
+
+		// Create client
+		client := &SSEClient{
+			id:   fmt.Sprintf("%d", time.Now().UnixNano()),
+			send: make(chan []byte, 64),
+			done: make(chan struct{}),
+		}
+
+		// Register client
+		b.register <- client
+
+		// Ensure cleanup on disconnect
+		defer func() {
+			b.unregister <- client
+		}()
+
+		// Send initial connection event
+		fmt.Fprintf(w, "event: connected\ndata: {\"id\":\"%s\"}\n\n", client.id)
+		flusher.Flush()
+
+		// Keep-alive ticker
+		ticker := time.NewTicker(30 * time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case message, ok := <-client.send:
+				if !ok {
+					return
+				}
+				// Check if message is already SSE formatted (contains "event:" or "data:")
+				if len(message) > 0 && (message[0] == 'e' || message[0] == 'd') {
+					w.Write(message)
+				} else {
+					fmt.Fprintf(w, "data: %s\n\n", message)
+				}
+				flusher.Flush()
+
+			case <-ticker.C:
+				// Send keep-alive comment
+				fmt.Fprintf(w, ": keepalive\n\n")
+				flusher.Flush()
+
+			case <-r.Context().Done():
+				return
+			}
+		}
+	}
+}
+
+// GinHandler returns a handler compatible with Gin framework
+func (b *SSEBroadcaster) GinHandler() interface{} {
+	return b.Handler()
+}