timeout errors are unrecoverable

[tve]

Once websocket.nextReader returns a timeout error it will always do so. That makes it impossible to poll a websocket and periodically check whether the socket should be closing or something like that. Basically what I wanted to do is to have the sender set a flag when it sends a close message and have the reader continue reading until a one minute timeout is reached. What I tried is below, but perhaps there's a much more elegant way to do this?

closing := false
for {
  // check whether the writer has closed
  if !closing {
    select {
    case code := <-ch:
        closing = true
    default:
    }
  }
  // set a deadline on the NextReader so we periodically go around the loop
  // and check the closing channel (see code above)
  ws.SetReadDeadline(time.Now().Add(time.Minute))
  // read a message from the websocket
  t, r, err := ws.NextReader()
  if err != nil {
    // if we get a timeout and we're told to close then it's time to give up
    netErr, ok := err.(net.Error)
    if ok && netErr.Timeout() && !closing {
      continue // just a timeout, that's OK
    }
    break
  }
  // continue reading message
}

[garyburd]

It is not idiomatic to poll connections with timeouts in Go.

Close the websocket connection one minute after writing the close message. This will cause a blocked reader to return with an error.

[garyburd]

Recoverable timeouts are difficult to implement. I am not aware of other Go network protocol libraries that support recoverable timeouts.

The application can implement timeout polling in a net.Conn shim between the websocket.Conn and the underlying net.Conn. A sketch for creating the shim is:

type appResponseWriter struct {  http.ResponseWriter }

func (w appResponseWriter)  Hijack() (net.Conn, *bufio.ReadWriter, error) {
    if h, ok := w.ResponseWriter.(http.Hijacker); ok {
        c, brw, err := h.Hijack()
        c = appConn(c)
        return c, brw, err
   } else {
        return nil, nil, errors.New("not supported")
   }
}

type appConn struct {
    net.Conn
}

func (c appConn) Read(p []byte) (int, err) {
    // implement timeout polling here.
}

func handler(w http.ResponseWriter, r *http.Request) {
    ws, err := websocket.Upgrade(appResponseWriter{w}, r, nil, 1024, 1024)
    if _, ok := err.(websocket.HandshakeError); ok {
        http.Error(w, "Not a websocket handshake", 400)
        return
    } else if err != nil {
        log.Println(err)
        return
    }
    ... Use conn to send and receive messages.
}