Wijayanto | Fullstack Developer

Introduction to WebSockets and Timeouts

WebSockets provide a powerful way to establish persistent, bidirectional communication channels between a client and a server. However, like any network connection, they are susceptible to issues like network partitions, unresponsive clients, or hung servers. Without proper handling, these issues can lead to resource leaks (e.g., idle connections consuming memory and file descriptors) and unresponsive applications.

One crucial mechanism for managing WebSocket connections in Go is setting deadlines for read and write operations. This ensures that your application doesn't wait indefinitely for data that may never arrive or for an acknowledgment that may never be sent.

Understanding `SetDeadline`, `SetReadDeadline`, and `SetWriteDeadline`

The standard Go net.Conn interface (which WebSocket connections often build upon or wrap) provides three key methods for managing timeouts:

SetDeadline(t time.Time): Sets both the read and write deadlines associated with the connection. A zero value for t means no deadline.
SetReadDeadline(t time.Time): Sets the deadline for future Read calls. If a read operation does not complete before the deadline, it will return a timeout error.
SetWriteDeadline(t time.Time): Sets the deadline for future Write calls. If a write operation does not complete before the deadline, it will return a timeout error.

These deadlines are absolute points in time. It's common practice to reset the deadline after each successful read or write operation, effectively creating an idle timeout.

Why Use Deadlines with WebSockets?

Preventing Resource Leaks: Automatically close connections that have been idle for too long, freeing up server resources.
Detecting Unresponsive Peers: Identify clients or servers that have stopped responding without properly closing the connection.
Improving Application Robustness: Ensure that read/write operations don't block indefinitely, making your application more resilient to network issues.

Practical Example: WebSocket Ping/Pong with Deadlines

Let's look at a common scenario: a server that expects clients to respond to ping messages within a certain time frame. We can use SetReadDeadline to enforce this.

package main

import (
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
	CheckOrigin: func(r *http.Request) bool { // Allow all origins for simplicity
		return true
	},
}

const (
	// Time allowed to write a message to the peer.
	writeWait = 10 * time.Second
	// Time allowed to read the next pong message from the peer.
	pongWait = 60 * time.Second
	// Send pings to peer with this period. Must be less than pongWait.
	pingPeriod = (pongWait * 9) / 10
	// Maximum message size allowed from peer.
	maxMessageSize = 512
)

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("Upgrade error:", err)
		return
	}
	defer conn.Close()

	// Set initial read deadline
	conn.SetReadLimit(maxMessageSize)
	conn.SetReadDeadline(time.Now().Add(pongWait)) // Expect a pong within pongWait

	// Set pong handler to update read deadline
	conn.SetPongHandler(func(string) error {
		fmt.Println("Pong received, extending deadline")
		conn.SetReadDeadline(time.Now().Add(pongWait))
		return nil
	})

	// Goroutine to send pings periodically
	go func() {
		ticker := time.NewTicker(pingPeriod)
		defer ticker.Stop()
		for {
			select {
			case <-ticker.C:
				// Set write deadline before sending ping
				conn.SetWriteDeadline(time.Now().Add(writeWait))
				fmt.Println("Sending Ping")
				if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
					log.Println("Write ping error:", err)
					return // Exit goroutine on error
				}
			// Add a way to stop this goroutine when the connection closes
			// (e.g., using a done channel signaled by the read loop)
			}
		}
	}()

	// Read loop (main connection handler)
	for {
		// ReadMessage respects the read deadline set by SetReadDeadline
		_, message, err := conn.ReadMessage()
		if err != nil {
			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
				log.Printf("Read error: %v", err)
			} else {
				log.Printf("Connection closed or timeout: %v", err) // This will catch deadline exceeded errors
			}
			break // Exit loop on error
		}
		log.Printf("Received message: %s", message)
		// Process message...

		// Optionally reset read deadline after processing a regular message too
		// conn.SetReadDeadline(time.Now().Add(pongWait))
	}
	log.Println("Client disconnected")
}

func main() {
	http.HandleFunc("/ws", handleWebSocket)
	log.Println("WebSocket server starting on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

(Note: This example uses the popular github.com/gorilla/websocket library, which provides helpers but the underlying SetReadDeadline concept applies to the net.Conn it uses.)

In this example:

We set an initial ReadDeadline when the connection is established.
The PongHandler resets the ReadDeadline every time a pong message is received from the client.
A separate goroutine sends periodic pings. Before writing, it sets a WriteDeadline.
If the client doesn't send a pong message (or any message) within the pongWait duration, the conn.ReadMessage() call will return a timeout error, causing the connection handler to exit and close the connection.

Important Considerations

Resetting Deadlines: Remember that deadlines are absolute. You usually need to reset them after successful operations (e.g., conn.SetReadDeadline(time.Now().Add(idleTimeout))).
Goroutine Safety: Accessing the connection (e.g., calling SetDeadline and WriteMessage) concurrently from multiple goroutines requires careful synchronization if the underlying library doesn't handle it internally. Libraries like gorilla/websocket often provide concurrent write safety, but read operations and deadline setting might still need care.
Read vs. Write vs. Combined: Choose the appropriate deadline method (SetReadDeadline, SetWriteDeadline, SetDeadline) based on whether you want to time out reads, writes, or both. Using separate read/write deadlines offers more granular control.
Zero Time: Setting a deadline to time.Time{} (the zero value) disables the deadline.

Conclusion

Using SetDeadline, SetReadDeadline, and SetWriteDeadline is essential for building robust and resource-efficient WebSocket applications in Go. By setting appropriate timeouts, you can gracefully handle idle or unresponsive connections, prevent resource exhaustion, and create more resilient systems. Remember to reset deadlines appropriately to implement idle timeouts and consider concurrency implications when accessing the connection from multiple goroutines.