Skip to content

websocket

Directory actions

More options

Directory actions

More options

Latest commit

 

History

History

websocket

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
README.md
README.md
 
 
main.go
main.go
 
 

README.md

WebSocket Example

This example demonstrates WebSocket support in DotWeb.

Features

  • WebSocket echo server
  • Chat room with broadcast
  • Connection management
  • HTTP status endpoint

Running

cd example/websocket
go run main.go

Testing

Using wscat (recommended)

Install wscat:

npm install -g wscat

Echo Server

wscat -c ws://localhost:8080/ws

# Send message
> Hello, DotWeb!
< Echo: Hello, DotWeb!

Chat Room

Open multiple terminals:

# Terminal 1
wscat -c 'ws://localhost:8080/chat?name=Alice'
> Hi everyone!
< 🔔 Alice joined the chat
< 💬 Alice: Hi everyone!

# Terminal 2
wscat -c 'ws://localhost:8080/chat?name=Bob'
< 🔔 Alice joined the chat
< 🔔 Bob joined the chat
< 💬 Alice: Hi everyone!

Check Status

curl http://localhost:8080/status
# Output:
# WebSocket Server Status
# Connected clients: 2
# Endpoints:
#   - ws://localhost:8080/ws (Echo)
#   - ws://localhost:8080/chat?name=YourName (Chat)

Using Browser

<script>
const ws = new WebSocket('ws://localhost:8080/ws');

ws.onopen = () => {
    console.log('Connected');
    ws.send('Hello from browser!');
};

ws.onmessage = (event) => {
    console.log('Received:', event.data);
};

ws.onerror = (error) => {
    console.error('Error:', error);
};
</script>

WebSocket API

Check WebSocket Request

func handler(ctx dotweb.Context) error {
    if !ctx.IsWebSocket() {
        return ctx.WriteString("Requires WebSocket")
    }
    
    ws := ctx.WebSocket()
    // ...
}

Send Message

ws := ctx.WebSocket()
err := ws.SendMessage("Hello, client!")

Read Message

ws := ctx.WebSocket()
msg, err := ws.ReadMessage()
if err != nil {
    // Client disconnected
    return err
}

Get Underlying Connection

ws := ctx.WebSocket()
conn := ws.Conn  // *websocket.Conn
req := ws.Request()  // *http.Request

Common Patterns

Echo Server

app.HttpServer.GET("/ws", func(ctx dotweb.Context) error {
    ws := ctx.WebSocket()
    
    for {
        msg, err := ws.ReadMessage()
        if err != nil {
            break
        }
        ws.SendMessage("Echo: " + msg)
    }
    
    return nil
})

Chat Room with Broadcast

var clients = make(map[*websocket.Conn]bool)
var broadcast = make(chan string)

func handler(ctx dotweb.Context) error {
    ws := ctx.WebSocket()
    clients[ws.Conn] = true
    
    for {
        msg, err := ws.ReadMessage()
        if err != nil {
            delete(clients, ws.Conn)
            break
        }
        broadcast <- msg
    }
    
    return nil
}

func broadcaster() {
    for msg := range broadcast {
        for conn := range clients {
            websocket.Message.Send(conn, msg)
        }
    }
}

Heartbeat/Ping

func heartbeat(ws *dotweb.WebSocket) {
    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()
    
    for range ticker.C {
        if err := ws.SendMessage("ping"); err != nil {
            return
        }
    }
}

// Start in handler
go heartbeat(ctx.WebSocket())

Notes

  • WebSocket uses golang.org/x/net/websocket package
  • Always check ctx.IsWebSocket() before using ctx.WebSocket()
  • Handle connection errors (client disconnect)
  • Use goroutines for concurrent message handling
  • Consider adding heartbeat/ping for long connections