doukan5332 2019-03-25 08:03
浏览 287
已采纳

如何使用Golang Gorilla / mux托管并发Websocket连接?

thanks in advance for any help or advice!

I am building a chess application, the frontend is in Reactjs and backend is a server written in Golang using Gorilla mux library. The backend is a chess engine for the human user to play against. The react frontend creates a WebSocket connection with the server in the top-level constructor.

The app works well for a single connection. However, upon opening a second browser tab, the first browser tab's Websocket connection is lost.

The server reports the error,

read error: websocket: close 1001 (going away)

and then,

read error: read tcp 127.0.0.1:8081-\u003e127.0.0.1:64146: use of closed network connection

I've looked at the Gorrilla/mux documentation for websockets and am reading/writing all from the same function in order to avoid concurrent reads or writes on the same connection.

React frontend constructor is here:

class Game extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      history: [{
        position: this.props.chess.fen(),
        move: "",
      }],
      ply: 0,
      selectedSq: null,
      engineName: "",
      engineAuthor: "",
      uciOK: false,
      isReady: false,
      engineThinking: false,
      playersTurn: true,
      playerColor: WHITE,
    };
    this.ws = websocketConnect("ws://localhost:8081/uci");
    this.ws.onmessage = (event) => {
      const msg = event.data
      this.processEngineMessage(msg)
    }
  }

It is referencing websocket.js which is here:

export function websocketConnect(url) {
  const ws = new WebSocket(url);
  ws.addEventListener('open', (event) => {
    ws.send('uci');
  });
  return ws;
}

Goland Websocket package is here

package websocket

import (
    "net/http"

    "github.com/namsral/flag"
    log "github.com/sirupsen/logrus"

    "github.com/gorilla/websocket"
)

type WebsocketServer struct {
    upgrader websocket.Upgrader
    addr     *string
    conn     *websocket.Conn
}

func NewWebsocketServer() *WebsocketServer {
    w := new(WebsocketServer)
    w.addr = flag.String("addr", "localhost:8081", "http service address")
    flag.Parse()
    w.upgrader = websocket.Upgrader{} // use default options
    http.HandleFunc("/uci", w.uciHandler)
    return w
}

func (w *WebsocketServer) uciHandler(rw http.ResponseWriter, r *http.Request) {
    var err error
    log.Error("upgrading to websocket connection")
    w.upgrader.CheckOrigin = func(r *http.Request) bool { return true }
    w.conn, err = w.upgrader.Upgrade(rw, r, nil)
    if err != nil {
        log.Print("upgrade:", err)
        return
    }
    go w.UCI(rw, r)
}

func (w *WebsocketServer) Start() {
    log.Info("starting websocket server")
    http.ListenAndServe(*w.addr, nil)
}

func (w *WebsocketServer) CloseConnection() {
    w.conn.Close()
}

func (w *WebsocketServer) StartReader(channel chan string) {
    for {
        _, message, err := w.conn.ReadMessage()
        if err != nil {
            log.Println("read error:", err)
            break
        }
        log.Printf("recv: %s", message)
        channel <- string(message)
    }
}

func (w *WebsocketServer) Write(msg string) {
    err := w.conn.WriteMessage(websocket.TextMessage, []byte(msg))
    if err != nil {
        log.Println("write:", err)
    }
}

Full code here: server: https://github.com/tonyOreglia/glee frontend: https://github.com/tonyOreglia/chess-board-react

I am hoping to be able to support multiple concurrent users using the website. It is currently hosted on DigitalOcean.

  • 写回答

1条回答 默认 最新

  • dongxie3701 2019-03-25 08:19
    关注

    The design of your WebServer struct only allows for a single connection.

    What happens is that on every initial http request on /uci, the connection get upgaded, and everytime you upgrade the http request to a ws connection, you replace the previous connection on the WebServer struct by that one.

    Also, it is not thread safe, as each request is processed in a different goroutine.

    I suggest you pass the connection to your UCI method instead of attaching it to the server.

    type WebsocketServer struct {
        upgrader websocket.Upgrader
        addr     *string
    }
    
    func (w *WebsocketServer) uciHandler(rw http.ResponseWriter, r *http.Request) {
        var err error
        log.Error("upgrading to websocket connection")
        w.upgrader.CheckOrigin = func(r *http.Request) bool { return true }
        // here is the difference
        conn, err := w.upgrader.Upgrade(rw, r, nil)
        if err != nil {
            log.Print("upgrade:", err)
            return
        }
        // and here
        go w.UCI(rw, r, conn)
    }
    

    You could also keep a slice/map with a mutex where you store all your connections. Just don't forget to remove it when your connection closes.

    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论

报告相同问题?

悬赏问题

  • ¥15 c# 直接使用c++ 类库文件
  • ¥15 一个主机电脑有两个显示器,当前有两个软件主体是网页html打包的exe程序,如何通过cmd命令bat同时打开软件一个在主屏幕显示,另外一个软件在2副屏幕上显示
  • ¥15 AE SDK插件开发,获取关键帧值得问题
  • ¥15 谁知道这个咋搞的吗,有偿
  • ¥20 基于spring boot、的scorm
  • ¥15 往复密封问题的两个问题
  • ¥15 DAC函数和STM32
  • ¥15 任务是接收数据并把数据写入DAC7311,这些代码能实现此功能吗
  • ¥15 分析FP -Growth代码运行内存太大而无法运行的原因
  • ¥20 qtcreat 使用msvc编译器开发软件运行时字体锯齿感严重