Websocket friert bei abnormaler Verbindung ein

Question

Ich habe einen einfachen Websocket erstellt, der einen JSON-Stream veröffentlicht. Ich arbeite die meiste Zeit gut, außer in einigen Fällen, in denen ich denke, dass beim Durchschleifen der Clients, um ihnen eine Nachricht zu senden, sie auf einem Client hängen bleibt, der abnormal getrennt wird. Welche Maßnahme kann ich diesem Code hinzufügen, um ihn zu verringern?

Client.go

import (
    "github.com/gorilla/websocket" 
) 

type client struct { 
    socket *websocket.Conn 

    send chan *Message 
} 

func (c *client) read() { 
    defer c.socket.Close() 
    for { 
     _, _, err := c.socket.ReadMessage() 
     if err != nil { 
      log.Info("Websocket: %s", err) 
      break 
     } 
    } 
} 

func (c *client) write() { 
    defer c.socket.Close() 
    for msg := range c.send { 
     err := c.socket.WriteJSON(msg) 
     if err != nil { 
      break 
     } 
    } 
} 

Stream.go

import (
    "net/http" 

    "github.com/gorilla/websocket" 
) 

const (
    socketBufferSize = 1024 
    messageBufferSize = 256 
) 

var upgrader = &websocket.Upgrader{ 
    ReadBufferSize: socketBufferSize, 
    WriteBufferSize: socketBufferSize, 
} 

type Stream struct { 
    Send chan *Message 

    join chan *client 

    leave chan *client 

    clients map[*client]bool 
} 

func (s *Stream) Run() { 
    for { 
     select { 
     case client := <-s.join: // joining 
      s.clients[client] = true 
     case client := <-s.leave: // leaving 
      delete(s.clients, client) 
      close(client.send) 
     case msg := <-s.Send: // send message to all clients 
      for client := range s.clients { 
       client.send <- msg 
      } 
     } 
    } 
} 

func (s *Stream) ServeHTTP(w http.ResponseWriter, res *http.Request) { 
    socket, err := upgrader.Upgrade(w, res, nil) 
    if err != nil { 
     log.Error(err) 
     return 
    } 

    defer func() { 
     socket.Close() 
    }() 

    client := &client{ 
     socket: socket, 
     send: make(chan *Message, messageBufferSize), 
    } 

    s.join <- client 
    defer func() { s.leave <- client }() 

    go client.write() 
    client.read() 
}   

Answer 1

Siehe Gorilla Chat Application für ein Beispiel, wie auf einem Client zu vermeiden, blockiert.

Die wichtigsten Teile sind:

• Use a buffered channel for sending to the client. Ihre Anwendung tut dies bereits.

• Send to the client using select/default Blockierung zu vermeiden. Angenommen, der Client ist beim Schreiben blockiert, wenn der Client nicht sofort eine Nachricht empfangen kann. Schließen Sie den Client-Kanal in dieser Situation, damit die Schreibschleife des Clients beendet wird.

• Write with a deadline.