The Message object

HTTP is a stream protocol. Web sockets are frame-based. You prepare a block of data (of any size) and send it as a set of frames. Frames can contain either strings in UTF-8 encoding or a sequence of bytes.

The simplest way of using web sockets is just to prepare a block of data and ask the Go websocket library to package it as a set of frame data, send them across the wire and receive it as the same block. The websocket package contains a convenience object Message to do just that. The Message object has two methods, Send and Receive which take a websocket as first parameter. The second parameter is either the address of a variable to store data in, or the data to be sent. Code to send string data would look like

  1. msgToSend := "Hello"
  2. err := websocket.Message.Send(ws, msgToSend)
  4. var msgToReceive string
  5. err := websocket.Message.Receive(conn, &msgToReceive)

Code to send byte data would look like

  1. dataToSend := []byte{0, 1, 2}
  2. err := websocket.Message.Send(ws, dataToSend)
  4. var dataToReceive []byte
  5. err := websocket.Message.Receive(conn, &dataToReceive)

An echo server to send and receive string data is given below. Note that in web sockets either side can initiate sending of messages, and in this server we send messages from the server to a client when it connects (send/receive) instead of the more normal receive/send server. The server is

  1. /* EchoServer
  2.  */
  3. package main
  5. import (
  6.     "fmt"
  7.     "net/http"
  8.     "os"
  9.     // "io"
  10.     "golang.org/x/net/websocket"
  11. )
  13. func Echo(ws *websocket.Conn) {
  14.     fmt.Println("Echoing")
  16.     for n := 0; n < 10; n++ {
  17.         msg := "Hello  " + string(n+48)
  18.         fmt.Println("Sending to client: " + msg)
  19.         err := websocket.Message.Send(ws, msg)
  20.         if err != nil {
  21.             fmt.Println("Can't send")
  22.             break
  23.         }
  25.         var reply string
  26.         err = websocket.Message.Receive(ws, &reply)
  27.         if err != nil {
  28.             fmt.Println("Can't receive")
  29.             break
  30.         }
  31.         fmt.Println("Received back from client: " + reply)
  32.     }
  33. }
  35. func main() {
  37.     http.Handle("/", websocket.Handler(Echo))
  38.     err := http.ListenAndServe(":12345", nil)
  39.     checkError(err)
  40. }
  42. func checkError(err error) {
  43.     if err != nil {
  44.         fmt.Println("Fatal error ", err.Error())
  45.         os.Exit(1)
  46.     }
  47. }

A client that talks to this server is

  1. /* EchoClient
  2.  */
  3. package main
  5. import (
  6.     "golang.org/x/net/websocket"
  7.     "fmt"
  8.     "io"
  9.     "os"
  10. )
  12. func main() {
  13.     if len(os.Args) != 2 {
  14.         fmt.Println("Usage: ", os.Args[0], "ws://host:port")
  15.         os.Exit(1)
  16.     }
  17.     service := os.Args[1]
  19.     conn, err := websocket.Dial(service, "", "http://localhost")
  20.     checkError(err)
  21.     var msg string
  22.     for {
  23.         err := websocket.Message.Receive(conn, &msg)
  24.         if err != nil {
  25.             if err == io.EOF {
  26.                 // graceful shutdown by server
  27.                 break
  28.             }
  29.             fmt.Println("Couldn't receive msg " + err.Error())
  30.             break
  31.         }
  32.         fmt.Println("Received from server: " + msg)
  33.         // return the msg
  34.         err = websocket.Message.Send(conn, msg)
  35.         if err != nil {
  36.             fmt.Println("Coduln't return msg")
  37.             break
  38.         }
  39.     }
  40.     os.Exit(0)
  41. }
  43. func checkError(err error) {
  44.     if err != nil {
  45.         fmt.Println("Fatal error ", err.Error())
  46.         os.Exit(1)
  47.     }
  48. }

The url for the client running on the same machine as the server should be ws://localhost:12345/