Adam French
9dc9a3a063
All checks were successful
Deploy with Docker Compose / deploy (push) Successful in 3m30s
107 lines
1.9 KiB
Go
107 lines
1.9 KiB
Go
package services
|
|
|
|
import (
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
|
|
"adam-french.co.uk/backend/models"
|
|
|
|
"github.com/gorilla/websocket"
|
|
)
|
|
|
|
const maxMessages = 50
|
|
|
|
type MessageRing struct {
|
|
buf []models.Message
|
|
next int // index to write next
|
|
full bool // have we wrapped at least once
|
|
}
|
|
|
|
func NewMessageRing(size int) *MessageRing {
|
|
return &MessageRing{
|
|
buf: make([]models.Message, size),
|
|
}
|
|
}
|
|
|
|
func (r *MessageRing) Add(m models.Message) {
|
|
r.buf[r.next] = m
|
|
r.next = (r.next + 1) % len(r.buf)
|
|
if r.next == 0 {
|
|
r.full = true
|
|
}
|
|
}
|
|
|
|
// Messages returns messages in chronological order (oldest -> newest).
|
|
func (r *MessageRing) Messages() []models.Message {
|
|
if !r.full {
|
|
// buffer not wrapped yet; only use [0:next)
|
|
return r.buf[:r.next]
|
|
}
|
|
|
|
// wrapped: start at next, then to end, then from 0 to next
|
|
out := make([]models.Message, len(r.buf))
|
|
copy(out, r.buf[r.next:])
|
|
copy(out[len(r.buf)-r.next:], r.buf[:r.next])
|
|
return out
|
|
}
|
|
|
|
var Upgrader = websocket.Upgrader{
|
|
ReadBufferSize: 1024,
|
|
WriteBufferSize: 1024,
|
|
CheckOrigin: func(r *http.Request) bool {
|
|
return true
|
|
},
|
|
}
|
|
|
|
var (
|
|
clients = make(map[*websocket.Conn]bool)
|
|
messages = NewMessageRing(maxMessages)
|
|
mu sync.Mutex
|
|
)
|
|
|
|
func HandleWebSocket(conn *websocket.Conn) {
|
|
defer conn.Close()
|
|
|
|
mu.Lock()
|
|
clients[conn] = true
|
|
|
|
history := messages.Messages()
|
|
|
|
// Send existing message history to new client
|
|
for _, msg := range history {
|
|
if err := conn.WriteJSON(msg); err != nil {
|
|
mu.Unlock()
|
|
return
|
|
}
|
|
}
|
|
|
|
mu.Unlock()
|
|
|
|
for {
|
|
var incoming models.Message
|
|
if err := conn.ReadJSON(&incoming); err != nil {
|
|
break
|
|
}
|
|
|
|
incoming.CreatedAt = time.Now()
|
|
|
|
// Store and broadcast
|
|
mu.Lock()
|
|
messages.Add(incoming)
|
|
|
|
for client := range clients {
|
|
if err := client.WriteJSON(incoming); err != nil {
|
|
client.Close()
|
|
delete(clients, client)
|
|
}
|
|
}
|
|
mu.Unlock()
|
|
}
|
|
|
|
// Cleanup on disconnect
|
|
mu.Lock()
|
|
delete(clients, conn)
|
|
mu.Unlock()
|
|
}
|