144 lines
2.7 KiB
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
|
|
}
|