// New takes a websocket and creates a ShellClient object implementing the // engines.Shell interface. func New(ws *websocket.Conn) *ShellClient { stdinReader, stdin := ioext.BlockedPipe() tellOut := make(chan int, 10) tellErr := make(chan int, 10) stdout, stdoutWriter := ioext.AsyncPipe(shellconsts.ShellMaxPendingBytes, tellOut) stderr, stderrWriter := ioext.AsyncPipe(shellconsts.ShellMaxPendingBytes, tellErr) stdinReader.Unblock(shellconsts.ShellMaxPendingBytes) s := &ShellClient{ ws: ws, stdin: stdin, stdout: stdout, stderr: stderr, stdinReader: stdinReader, stdoutWriter: stdoutWriter, stderrWriter: stderrWriter, done: make(chan struct{}), } ws.SetReadLimit(shellconsts.ShellMaxMessageSize) ws.SetReadDeadline(time.Now().Add(shellconsts.ShellPongTimeout)) ws.SetPongHandler(s.pongHandler) go s.writeMessages() go s.readMessages() go s.sendPings() go s.sendAck(shellconsts.StreamStdout, tellOut) go s.sendAck(shellconsts.StreamStderr, tellErr) return s }
func (this *subServer) wsReadPump(clientGone chan struct{}, ws *websocket.Conn) { ws.SetReadLimit(this.wsReadLimit) ws.SetReadDeadline(time.Now().Add(this.wsPongWait)) ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(this.wsPongWait)) return nil }) // if kateway shutdown while there are open ws conns, the shutdown will // wait 1m: this.subServer.wsPongWait for { _, message, err := ws.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Warn("%s: %v", ws.RemoteAddr(), err) } else { log.Debug("%s: %v", ws.RemoteAddr(), err) } close(clientGone) break } log.Debug("ws[%s] read: %s", ws.RemoteAddr(), string(message)) } }
// New returns a new display client implementing the ioext.ReadWriteCloser // interface using a websocket. // // The DisplayClient essentially takes care of sending and receiving ping/pongs // to keep the websocket alive. However, the DisplayClient does read/write // directly on websocket without any buffering, hence, you must keep calling // Read() with a non-empty buffer to keep the connection alive. func New(ws *websocket.Conn) *DisplayClient { c := &DisplayClient{ ws: ws, } ws.SetReadLimit(displayconsts.DisplayMaxMessageSize) ws.SetReadDeadline(time.Now().Add(displayconsts.DisplayPongTimeout)) ws.SetPongHandler(c.pongHandler) go c.sendPings() return c }
func reader(ws *websocket.Conn) { defer ws.Close() ws.SetReadLimit(512) ws.SetReadDeadline(time.Now().Add(pongWait)) ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, _, err := ws.ReadMessage() if err != nil { break } } }
func (ws *WebSocker) reader(conn *websocket.Conn) { defer conn.Close() conn.SetReadLimit(512) conn.SetReadDeadline(time.Now().Add(pongWait)) conn.SetPongHandler(func(string) error { conn.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, _, err := conn.ReadMessage() if err != nil { break } } }
func imwork(wsConn *websocket.Conn) { wsConn.SetReadLimit(maxMessageSize) wsConn.SetReadDeadline(time.Now().Add(pongWait)) wsConn.SetPongHandler(func(string) error { wsConn.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, msgBytes, err := wsConn.ReadMessage() if err != nil { fmt.Println(err) break } // fmt.Println("receive:", msgBytes) go procMsg(msgBytes) } }
func pumpStdin(ws *websocket.Conn, w io.Writer) { defer ws.Close() ws.SetReadLimit(maxMessageSize) ws.SetReadDeadline(time.Now().Add(pongWait)) ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, message, err := ws.ReadMessage() if err != nil { break } message = append(message, '\n') if _, err := w.Write(message); err != nil { break } } }
func NewWs(ws *websocket.Conn, bufSize int, pingPeriod time.Duration) *Ws { ws.SetPongHandler(func(msg string) error { sent, err := strconv.ParseInt(msg, 36, 64) if err != nil { log.Warningln("Wrong pong time:", msg) return nil } log.Infof("Ping time: %dns\n", time.Now().UnixNano()-sent) return nil }) return &Ws{ Conn: ws, pingPeriod: pingPeriod, copyBuf: make([]byte, bufSize), } }
// pumpStdin handles reading data from the websocket connection and writing // it to stdin of the process. func pumpStdin(conn *websocket.Conn, stdin io.WriteCloser) { // Setup our connection's websocket ping/pong handlers from our const values. defer conn.Close() conn.SetReadLimit(maxMessageSize) conn.SetReadDeadline(time.Now().Add(pongWait)) conn.SetPongHandler(func(string) error { conn.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, message, err := conn.ReadMessage() if err != nil { break } message = append(message, '\n') if _, err := stdin.Write(message); err != nil { break } } }
func wsReader(ws *websocket.Conn, mc chan string) { defer ws.Close() ws.SetReadLimit(512) ws.SetReadDeadline(time.Now().Add(pongWait)) ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, msg, err := ws.ReadMessage() if err != nil { log.Println("Error when reading websocket message") log.Println(err) break } log.Println("Recieved message: " + string(msg)) mc <- string(msg) } }
func messagesHandler(ws *websocket.Conn, ticker *time.Ticker, msg Event, c chan Event, e chan error) { ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(PONG_WAIT)) return nil }) for { err := ws.ReadJSON(&msg) if err != nil { log.Println("READ ERR") ticker.Stop() e <- err } if reflect.TypeOf(msg).String() == "tutum.Event" { c <- msg } } }
// reader is the guts of this package. It takes the stdin and stdout pipes // of the cmd we created in ServeWS and pipes them between the client and server // over websockets. func reader(conn *websocket.Conn, stdout io.ReadCloser, stdin io.WriteCloser) { // Setup our connection's websocket ping/pong handlers from our const values. conn.SetReadLimit(maxMessageSize) conn.SetReadDeadline(time.Now().Add(pongWait)) conn.SetPongHandler(func(string) error { conn.SetReadDeadline(time.Now().Add(pongWait)); return nil }) tickerChan := make(chan bool) defer close(tickerChan) // make sure to close the ticker when we are done. go ticker(conn, tickerChan) for { msgType, r, err := conn.NextReader() if err != nil { if msgType == -1 { return // we got a disconnect from the client. We are good to close. } conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseGoingAway, ""), time.Time{}) return } w, err := conn.NextWriter(msgType) if err != nil { conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseGoingAway, ""), time.Time{}) return } if _, err := io.Copy(stdin, r); err != nil { conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseGoingAway, ""), time.Time{}) return } go func() { if _, err := io.Copy(w, stdout); err != nil { conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseGoingAway, ""), time.Time{}) return } if err := w.Close(); err != nil { conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseGoingAway, ""), time.Time{}) return } }() } }
// readPump pumps messages from the websocket connection to the hub. func responseAndAnswer(ws *websocket.Conn, client string, r *http.Request, w http.ResponseWriter) { defer func() { ws.Close() }() ws.SetReadLimit(maxMessageSize) ws.SetReadDeadline(time.Now().Add(pongWait)) ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(pongWait)); return nil }) //enemyFromCookie:="" for { _, message, err := ws.ReadMessage() if err != nil { break } //enemyNameCookie, _ := r.Cookie("enemyName") //if (enemyNameCookie!=nil){ // enemyFromCookie =enemyNameCookie.Value //} //fmt.Println(string(message)) names := string(message[:bytes.Index(message, []byte(":"))]) colons := bytes.Index(message, []byte(":")) identifier := string(message[colons+1 : colons+9]) //fmt.Println("IDDDDDDDDDDD "+identifier) switch identifier { case "clientTo": askInvitation(names) break case "Accepted": acceptInvitation(names, colons, client, w) break case "CheckVal": getSideValue(client) break case "MadeStep": madeStep(client, names) case "QuitGame": quitGame(w, r, names) } } }
/* reader reads input from the web socket connection and sends it to the master. * reader runs in its own goroutine. * If the connection closes, the reader goroutine terminates. */ func reader(conn *websocket.Conn, ch chan readerResult) { conn.SetPongHandler(func(appData string) error { ch <- readerResult{conn, 10, nil, nil} return nil }) conn.SetPingHandler(func(appData string) error { ch <- readerResult{conn, 9, nil, nil} return nil }) for { messageType, data, err := conn.ReadMessage() readerResult := readerResult{conn, messageType, data, err} ch <- readerResult if err != nil { return } } }
func (h *Hub) Add(c *websocket.Conn) { h.chAdd <- c c.SetPongHandler(func(string) error { c.SetReadDeadline(time.Now().Add(5 * time.Second)) return nil }) go func() { defer func() { h.chDel <- c c.Close() }() for { _, _, err := c.ReadMessage() if err != nil { return } } }() go func() { defer func() { c.Close() }() for { <-time.After(3 * time.Second) err := c.WriteMessage(websocket.PingMessage, nil) if err != nil { return } } }() }
func (user *User) Receiver(location *Location, ws *websocket.Conn) { // receives and decodes messages from users go func() { ws.SetReadLimit(MAX_MESSAGE_SIZE) ws.SetReadDeadline(time.Now().Add(PONG_WAIT)) ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(PONG_WAIT)) return nil }) for { op, r, err := ws.NextReader() if err != nil { user.Kick(err.Error()) return } switch op { case websocket.BinaryMessage: data, err := ioutil.ReadAll(r) if err != nil { user.Kick(err.Error()) return } var event []interface{} err = codec.NewDecoderBytes(data, &msgpackHandle).Decode(&event) if err != nil { user.Kick(err.Error()) return } location.Message <- &UserAndEvent{user, &event} default: user.Kick(fmt.Sprintf("bad message type: %v", op)) return } } }() }
func messagesHandler(ws *websocket.Conn, ticker *time.Ticker, msg Event, c chan Event, e chan error, e2 chan error) { ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(PONG_WAIT)) return nil }) for { err := ws.ReadJSON(&msg) if err != nil { e <- err e2 <- err time.Sleep(4 * time.Second) } else { if reflect.TypeOf(msg).String() == "tutum.Event" { c <- msg } } } }