bd05edfb9c
- Frontend: index.html, style.css, app.js - Dunkles Kontrast-Design mit Team-Farben (Rot/Grün) - Vollbild-Toggle, Responsive Design - Echtzeit-Updates über WebSocket + Polling-Fallback - Tastatur-Shortcuts (R/G für Punkte, N für nächste Runde) - Rundenverlauf mit Farbcodierung - Go-Integration: - frontend.go: embed.FS für statische Dateien - websocket.go: WebSocket-Handler (/ws) für State-Broadcast - httpapi.go: broadcastState() nach jeder Mutation, /ws-Route - main.go: api.SetupFrontend() für Frontend-Einbettung - Frontend unter '/' verfügbar, API unter '/api/' - Tests: 17 End-to-End-Tests bestanden - Alle HTTP-Endpunkte funktionsfähig - Frontend-Assets korrekt eingebettet - Persistenz (state.json) funktioniert
195 lines
3.9 KiB
Go
195 lines
3.9 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"bufio"
|
|
"crypto/sha1"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"sync"
|
|
)
|
|
|
|
const websocketGUID = "258EAFA5-E914-47DA-95CA-5AB5D10B5E23"
|
|
|
|
// websocketConn represents a websocket connection with send channel and mutex.
|
|
type websocketConn struct {
|
|
conn net.Conn
|
|
send chan []byte
|
|
mu sync.Mutex
|
|
}
|
|
|
|
// Hub manages websocket connections and broadcasts state updates.
|
|
type Hub struct {
|
|
clients map[*websocketConn]bool
|
|
broadcast chan []byte
|
|
register chan *websocketConn
|
|
unregister chan *websocketConn
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
var hub *Hub
|
|
var hubOnce sync.Once
|
|
|
|
func getHub() *Hub {
|
|
hubOnce.Do(func() {
|
|
hub = &Hub{
|
|
clients: make(map[*websocketConn]bool),
|
|
broadcast: make(chan []byte, 256),
|
|
register: make(chan *websocketConn),
|
|
unregister: make(chan *websocketConn),
|
|
}
|
|
go hub.run()
|
|
})
|
|
return hub
|
|
}
|
|
|
|
func (h *Hub) run() {
|
|
for {
|
|
select {
|
|
case client := <-h.register:
|
|
h.mu.Lock()
|
|
h.clients[client] = true
|
|
h.mu.Unlock()
|
|
case client := <-h.unregister:
|
|
h.mu.Lock()
|
|
if _, ok := h.clients[client]; ok {
|
|
delete(h.clients, client)
|
|
close(client.send)
|
|
}
|
|
h.mu.Unlock()
|
|
case message := <-h.broadcast:
|
|
h.mu.RLock()
|
|
for client := range h.clients {
|
|
select {
|
|
case client.send <- message:
|
|
default:
|
|
close(client.send)
|
|
delete(h.clients, client)
|
|
}
|
|
}
|
|
h.mu.RUnlock()
|
|
}
|
|
}
|
|
}
|
|
|
|
// upgradeWebSocket performs a WebSocket handshake using raw net.Conn.
|
|
func upgradeWebSocket(w http.ResponseWriter, r *http.Request) (*websocketConn, error) {
|
|
key := r.Header.Get("Sec-WebSocket-Key")
|
|
if key == "" {
|
|
return nil, fmt.Errorf("missing Sec-WebSocket-Key")
|
|
}
|
|
|
|
// Calculate accept key
|
|
h := sha1.New()
|
|
h.Write([]byte(key + websocketGUID))
|
|
acceptKey := base64.StdEncoding.EncodeToString(h.Sum(nil))
|
|
|
|
// Hijack the connection
|
|
hj, ok := w.(http.Hijacker)
|
|
if !ok {
|
|
return nil, fmt.Errorf("server does not support hijacking")
|
|
}
|
|
|
|
conn, bufrw, err := hj.Hijack()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("hijack failed: %v", err)
|
|
}
|
|
|
|
// Write handshake response
|
|
response := "HTTP/1.1 101 Switching Protocols\r\n" +
|
|
"Upgrade: websocket\r\n" +
|
|
"Connection: Upgrade\r\n" +
|
|
"Sec-WebSocket-Accept: " + acceptKey + "\r\n\r\n"
|
|
|
|
bufrw.WriteString(response)
|
|
bufrw.Flush()
|
|
|
|
return &websocketConn{
|
|
conn: conn,
|
|
send: make(chan []byte, 256),
|
|
}, nil
|
|
}
|
|
|
|
// wsHandler handles websocket upgrades and client communication.
|
|
func (s *Server) wsHandler(w http.ResponseWriter, r *http.Request) {
|
|
conn, err := upgradeWebSocket(w, r)
|
|
if err != nil {
|
|
fmt.Fprintf(nil, "[ws] upgrade failed: %v\n", err)
|
|
return
|
|
}
|
|
|
|
h := getHub()
|
|
h.register <- conn
|
|
|
|
go s.wsWriteHandler(conn)
|
|
s.wsReadHandler(conn)
|
|
}
|
|
|
|
func (s *Server) wsWriteHandler(c *websocketConn) {
|
|
for {
|
|
message, ok := <-c.send
|
|
if !ok {
|
|
c.conn.Close()
|
|
return
|
|
}
|
|
c.mu.Lock()
|
|
_, err := c.conn.Write(message)
|
|
c.mu.Unlock()
|
|
if err != nil {
|
|
c.conn.Close()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Server) wsReadHandler(c *websocketConn) {
|
|
br := bufio.NewReader(c.conn)
|
|
for {
|
|
line, err := br.ReadString('\n')
|
|
if err != nil {
|
|
if err != io.EOF {
|
|
fmt.Fprintf(nil, "[ws] read error: %v\n", err)
|
|
}
|
|
h := getHub()
|
|
h.unregister <- c
|
|
return
|
|
}
|
|
_ = line // consume header lines
|
|
if line == "\r\n" {
|
|
break
|
|
}
|
|
}
|
|
// Connection established, start reading frames
|
|
// For simplicity, just keep reading until close
|
|
for {
|
|
data, err := br.ReadBytes(0xFF)
|
|
if err != nil {
|
|
h := getHub()
|
|
h.unregister <- c
|
|
return
|
|
}
|
|
_ = data
|
|
}
|
|
}
|
|
|
|
// broadcastState broadcasts the current scoreboard state to all websocket clients.
|
|
func (s *Server) broadcastState() {
|
|
state := map[string]interface{}{
|
|
"current_round": s.sb.CurrentRound,
|
|
"red_score": s.sb.RedScore,
|
|
"green_score": s.sb.GreenScore,
|
|
"rounds": s.sb.Rounds,
|
|
}
|
|
|
|
data, err := json.Marshal(state)
|
|
if err != nil {
|
|
fmt.Fprintf(nil, "[ws] JSON error: %v\n", err)
|
|
return
|
|
}
|
|
|
|
h := getHub()
|
|
h.broadcast <- data
|
|
} |