Rework websockets and add timeouts

downloader/ws-client.go

@@ -2,22 +2,30 @@ package main
 
 import (
 	"log"
+	"sync"
 	"time"
 
 	"github.com/gorilla/websocket"
 )
 
+const TIMEOUT = 6
+const IDLE_TIMEOUT = TIMEOUT * time.Second
+const PING_INTERVAL = (TIMEOUT - 1) * time.Second
+
 type WSConnection struct {
-	url      string
+	url       string
-	conn     *websocket.Conn
+	conn      *websocket.Conn
-	errChan  chan error
+	errChan   chan error
-	ReadChan chan string
+	writeLock sync.Mutex
+	ReadChan  chan string
+	WriteChan chan string
 }
 
-func (ws *WSConnection) readMessage() {
+func (ws *WSConnection) messageReader() {
 	log.Printf("Reading messages")
 	for {
 		_, message, err := ws.conn.ReadMessage()
+		ws.conn.SetReadDeadline(time.Now().Add(IDLE_TIMEOUT))
 		if err != nil {
 			ws.errChan <- err
 			return
@@ -27,12 +35,38 @@ func (ws *WSConnection) readMessage() {
 	}
 }
 
-func (ws *WSConnection) writeMessage(message string) {
+func (ws *WSConnection) messageSender() {
-	err := ws.conn.WriteMessage(websocket.TextMessage, []byte(message))
+	log.Printf("Sending messages")
-	if err != nil {
+	for {
-		log.Printf("Error during message writing: %v", err)
+		msg := <-ws.WriteChan
-		ws.errChan <- err
+		ws.writeLock.Lock()
-		return
+		
+		ws.conn.SetWriteDeadline(time.Now().Add(IDLE_TIMEOUT))
+		log.Printf("Sending: %s", msg)
+		err := ws.conn.WriteMessage(websocket.TextMessage, []byte(msg))
+		if err != nil {
+			log.Printf("Error during message writing: %v", err)
+			ws.errChan <- err
+			return
+		}
+		ws.writeLock.Unlock()
+	}
+}
+
+func (ws *WSConnection) pinger() {
+	log.Printf("Starting pinger, sleeping for %v", PING_INTERVAL)
+	for {
+		time.Sleep(PING_INTERVAL)
+
+		// log.Printf("Ping")
+		ws.writeLock.Lock()
+		err := ws.conn.WriteMessage(websocket.PingMessage, nil)
+		if err != nil {
+			log.Println("Error during ping:", err)
+			ws.errChan <- err
+			return
+		}
+		ws.writeLock.Unlock()
 	}
 }
 
@@ -58,6 +92,20 @@ func (ws *WSConnection) Open() {
 	ws.conn = conn
 	ws.errChan = make(chan error)
 	ws.ReadChan = make(chan string, 1024)
-	go ws.readMessage()
+	ws.WriteChan = make(chan string, 1024)
+
+	ws.conn.SetReadLimit(1024)
+	ws.conn.SetReadDeadline(time.Now().Add(IDLE_TIMEOUT))
+	ws.conn.SetWriteDeadline(time.Now().Add(IDLE_TIMEOUT))
+	ws.conn.SetPongHandler(func(string) error {
+		// log.Println("Pong")
+		ws.conn.SetReadDeadline(time.Now().Add(IDLE_TIMEOUT))
+		ws.conn.SetWriteDeadline(time.Now().Add(IDLE_TIMEOUT))
+		return nil
+	})
+
+	go ws.messageReader()
+	go ws.messageSender()
 	go ws.handleError()
+	go ws.pinger()
 }

ws-server/main.go

@@ -6,6 +6,8 @@ import (
 	"io"
 	"log"
 	"net/http"
+	"sync"
+	"time"
 
 	"github.com/gorilla/websocket"
 )
@@ -13,6 +15,83 @@ import (
 var upgrader = websocket.Upgrader{}
 var wsBroadcast = make(chan []byte, 100)
 
+const TIMEOUT = 6
+const IDLE_TIMEOUT = TIMEOUT * time.Second
+const PING_INTERVAL = (TIMEOUT - 1) * time.Second
+
+type WSConnection struct {
+	conn      *websocket.Conn
+	writeLock sync.Mutex
+	ReadChan  chan string
+	WriteChan chan string
+}
+
+func (ws *WSConnection) messageReader() {
+	log.Printf("Reading messages")
+	for {
+		_, message, err := ws.conn.ReadMessage()
+		ws.conn.SetReadDeadline(time.Now().Add(IDLE_TIMEOUT))
+		if err != nil {
+			return
+		}
+		log.Printf("Received: %s", message)
+		ws.ReadChan <- string(message)
+	}
+}
+
+func (ws *WSConnection) messageSender() {
+	log.Printf("Sending messages")
+	for {
+		msg := <-ws.WriteChan
+		ws.writeLock.Lock()
+
+		ws.conn.SetWriteDeadline(time.Now().Add(IDLE_TIMEOUT))
+		log.Printf("Sending: %s", msg)
+		err := ws.conn.WriteMessage(websocket.TextMessage, []byte(msg))
+		if err != nil {
+			log.Printf("Error during message writing: %v", err)
+			return
+		}
+		ws.writeLock.Unlock()
+	}
+}
+
+func (ws *WSConnection) pinger() {
+	log.Printf("Starting pinger, sleeping for %v", PING_INTERVAL)
+	for {
+		time.Sleep(PING_INTERVAL)
+
+		// log.Printf("Ping")
+		ws.writeLock.Lock()
+		err := ws.conn.WriteMessage(websocket.PingMessage, nil)
+		if err != nil {
+			log.Println("Error during ping:", err)
+			return
+		}
+		ws.writeLock.Unlock()
+	}
+}
+
+func (ws *WSConnection) Open() {
+	log.Printf("Client connected")
+	ws.ReadChan = make(chan string, 1024)
+	ws.WriteChan = make(chan string, 1024)
+
+	ws.conn.SetReadLimit(1024)
+	ws.conn.SetReadDeadline(time.Now().Add(IDLE_TIMEOUT))
+	ws.conn.SetWriteDeadline(time.Now().Add(IDLE_TIMEOUT))
+	ws.conn.SetPongHandler(func(string) error {
+		// log.Println("Pong")
+		ws.conn.SetReadDeadline(time.Now().Add(IDLE_TIMEOUT))
+		ws.conn.SetWriteDeadline(time.Now().Add(IDLE_TIMEOUT))
+		return nil
+	})
+
+	go ws.messageReader()
+	go ws.messageSender()
+	go ws.pinger()
+}
+
 func wsHandler(responseWriter http.ResponseWriter, request *http.Request) {
 	conn, err := upgrader.Upgrade(responseWriter, request, nil)
 	if err != nil {
@@ -20,33 +99,9 @@ func wsHandler(responseWriter http.ResponseWriter, request *http.Request) {
 		return
 	}
 
-	go wsHandleRead(conn)
+	ws := new(WSConnection)
-	wsHandleWrite(conn)
+	ws.conn = conn
-}
+	ws.Open()
-
-func wsHandleRead(conn *websocket.Conn) {
-	log.Printf("Starting read handler")
-	for {
-		messageType, packet, err := conn.ReadMessage()
-		if err != nil {
-			fmt.Println("Error during message reading:", err)
-			return
-		}
-		log.Printf("Received: %v %s", messageType, packet)
-	}
-}
-
-func wsHandleWrite(conn *websocket.Conn) {
-	log.Println("Starting write handler")
-	for {
-		packet := <-wsBroadcast
-		log.Printf("Broadcasting: %s", packet)
-		err := conn.WriteMessage(websocket.TextMessage, packet)
-		if err != nil {
-			fmt.Println("Error during message writing:", err)
-			return
-		}
-	}
 }
 
 type DownloadReq struct {