clipper/backend/server/websocket.go

144 lines
2.7 KiB
Go

package server
import (
"bytes"
"log"
"net/http"
"sync"
"time"
"github.com/gorilla/websocket"
"github.com/labstack/echo/v4"
)
const (
maxmsgSizeBytes = 1_024
pongWait = 60 * time.Second
pingPeriod = (pongWait * 9) / 10
writeWait = 10 * time.Second
)
var (
space = []byte{' '}
newline = []byte{'\n'}
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1_024,
WriteBufferSize: 1_024,
// TODO: configure CORS
CheckOrigin: func(_ *http.Request) bool { return true },
}
// lient represents a client in a single browser session.
type Client struct {
conn *websocket.Conn
send chan []byte
}
func newSink(conn *websocket.Conn) *Client {
return &Client{
conn: conn,
send: make(chan []byte, 1),
}
}
func (s *Client) wait() error {
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
s.readPump()
}()
go func() {
defer wg.Done()
s.writePump()
}()
wg.Wait()
return nil
}
func (s *Client) readPump() {
defer s.conn.Close()
s.conn.SetReadLimit(maxmsgSizeBytes)
s.conn.SetReadDeadline(time.Now().Add(pongWait))
s.conn.SetPongHandler(func(string) error { s.conn.SetReadDeadline(time.Now().Add(pongWait)); return nil })
for {
_, msg, err := s.conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
log.Printf("websocket read error: %v", err)
}
break
}
msg = bytes.TrimSpace(bytes.ReplaceAll(msg, newline, space))
log.Printf("websocket message rcvd: %s", msg)
}
}
func (s *Client) writePump() {
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
s.conn.Close()
}()
for {
select {
case message, ok := <-s.send:
s.conn.SetWriteDeadline(time.Now().Add(writeWait))
if !ok {
s.conn.WriteMessage(websocket.CloseMessage, nil)
return
}
w, err := s.conn.NextWriter(websocket.TextMessage)
if err != nil {
log.Printf("error getting writer: %v", err)
return
}
w.Write(message)
// Add queued chat messages to the current websocket message.
n := len(s.send)
for i := 0; i < n; i++ {
w.Write(newline)
w.Write(<-s.send)
}
if err := w.Close(); err != nil {
log.Println("error closing writer")
return
}
case <-ticker.C:
s.conn.SetWriteDeadline(time.Now().Add(writeWait))
if err := s.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
log.Println("websocket pong timeout")
return
}
}
}
}
func (h *handler) upgradeWebsocket(c echo.Context) error {
conn, err := upgrader.Upgrade(c.Response(), c.Request(), nil)
if err != nil {
return err
}
sink := newSink(conn)
// blocks until the connection has closed:
sink.wait()
return nil
}