func (w *WebsocketController) listenForIncomingData(connection *websocket.Conn, client *WebsocketClient, disconnect chan bool) { for { mt, message, err := connection.ReadMessage() if mt == websocket.CloseMessage { disconnect <- true } if _, ok := err.(*websocket.CloseError); ok { disconnect <- true } if err != nil { w.logger.Println("warning: read message error:", err) continue } if mt != websocket.TextMessage && mt != websocket.CloseMessage { w.logger.Println("warning: recieved unsupported message: ", mt, message) continue } if mt == websocket.TextMessage { w.Received() <- ReceivedData{client, message} } } }
func (self *remoteService) run(ws *websocket.Conn) error { for { mt, msg, err := ws.ReadMessage() if err != nil { fmt.Printf("remoteService.run: %#v\n", err) break } if mt != websocket.BinaryMessage { continue } cmd := cmdResult{} if err := json.NewDecoder(bytes.NewReader(msg)).Decode(&cmd); err != nil { return err } if cmd.Id == nil { if err := self.handleEvent(cmd.Back, cmd.Sid, stream.Event([]byte(cmd.Data))); err != nil { return err } } else { if err := self.handleCmdRes(*cmd.Id, cmd.Data); err != nil { return err } } } return nil }
func (r *RancherService) pipeLogs(container *rancherClient.Container, conn *websocket.Conn) { defer conn.Close() log_name := strings.TrimPrefix(container.Name, r.context.ProjectName+"_") logger := r.context.LoggerFactory.Create(log_name) for { messageType, bytes, err := conn.ReadMessage() if messageType != websocket.TextMessage { continue } if err == io.EOF { return } else if err != nil { logrus.Errorf("Failed to read log: %v", err) return } if len(bytes) <= 3 { continue } if bytes[len(bytes)-1] != '\n' { bytes = append(bytes, '\n') } message := bytes[3:] if "01" == string(bytes[:2]) { logger.Out(message) } else { logger.Err(message) } } }
func (w *WebsocketServer) streamWebsocket(websocketSink *websocket.WebsocketSink, websocketConnection *gorilla.Conn, register func(sinks.Sink) bool, unregister func(sinks.Sink)) { register(websocketSink) defer unregister(websocketSink) go websocketConnection.ReadMessage() server.NewKeepAlive(websocketConnection, w.keepAliveInterval).Run() }
func (np *NatsProxy) activateWSProxySubject(conn *websocket.Conn, wsID string) { np.addToWSMapper(conn, wsID) np.conn.Subscribe("WS_OUT"+wsID, func(m *nats.Msg) { err := conn.WriteMessage(websocket.TextMessage, m.Data) if err != nil { log.Println("Error writing a message", err) } }) go func() { for { if _, p, err := conn.ReadMessage(); err == nil { np.conn.Publish("WS_IN"+wsID, p) } else { np.removeFromWSMapper(conn, wsID) conn.Close() // If websocket is closed normally RFC6455 // code 1000, then no error logged if !websocket.IsCloseError(err, websocket.CloseNormalClosure) { logWebsocketError(wsID, err) } break } } }() }
func jionToChatRoom(uname string, ws *websocket.Conn) { // Join chat room. Join(uname, ws) defer Leave(uname) // Message receive loop. for { _, p, err := ws.ReadMessage() if err != nil { return } //=======deal with chat==== // js, err := simplejson.NewJson(p) // if err != nil { // panic(err.Error()) // } chat := new(models.ChatBean) json.Unmarshal(p, chat) //===================== if chat.Type == 1 || len(chat.To) > 0 { publish <- newEvent(models.EVENT_CHAT, uname, string(p)) } else { publish <- newEvent(models.EVENT_MESSAGE, uname, string(p)) } } }
func primeRequestMainLoop(ws *websocket.Conn) { msgType, msg, err := ws.ReadMessage() for ; err == nil && msgType == websocket.TextMessage; msgType, msg, err = ws.ReadMessage() { req := string(msg) fields := strings.Fields(req) if len(fields) == 0 { err = ws.WriteMessage(websocket.TextMessage, []byte(warnArgCount)) } else { method := strings.ToUpper(fields[0]) switch method { case "?": err = ws.WriteMessage(msgType, []byte(helpMsg)) case "TEST": if len(fields) > 1 { err = OnTest(ws, fields[1:]) } else { err = ws.WriteMessage(msgType, []byte("ERROR: nothing to test")) } case "LIST": err = OnList(ws, fields[1:]) case "EXIT": fallthrough case "QUIT": fallthrough case "CLOSE": fmt.Fprintln(os.Stderr, "INFO: Closing Websocket...") break default: err = ws.WriteMessage(msgType, []byte(errorUnknownCmd)) } } err = ws.WriteMessage(websocket.TextMessage, []byte(eotMsg)) } }
func pipe_to_net(netConn net.Conn, wsConn *websocket.Conn, protocolType int, stopChan chan int) { for { select { case <-stopChan: return default: { _, p, err := wsConn.ReadMessage() if err != nil { stopChan <- 1 return } if protocolType == websocket.BinaryMessage { _, err = netConn.Write(p) if err != nil { stopChan <- 1 return } } else if protocolType == websocket.TextMessage { data := make([]byte, base64.StdEncoding.DecodedLen(len(p))) n, err := base64.StdEncoding.Decode(data, p) if err != nil { stopChan <- 1 return } _, err = netConn.Write(data[:n]) if err != nil { stopChan <- 1 return } } } } } }
func readMessages(ws *websocket.Conn, rc chan<- error, handler Handler) (e error) { defer func() { rc <- e }() for { _, msg, err := ws.ReadMessage() if err != nil { return fmt.Errorf("Error reading from websocket: %s", err) } var event model.WatchEvent err = json.Unmarshal(msg, &event) if err != nil { return fmt.Errorf("Error parsing event: %s", err) } log.Infof("Received event: [%s]", msg) err = handler.Handle(event) if err != nil { return fmt.Errorf("Error handling event: %s", err) } } }
func checkResponse(checkFor map[string]string, ws *websocket.Conn, c *check.C) string { for count := 0; count < 20; count++ { _, m, err := ws.ReadMessage() if err != nil { // ws closed if len(checkFor) != 0 { c.Fatal("Didn't find all keys before ws was closed: ", checkFor) } return "" } dst := make([]byte, base64.StdEncoding.EncodedLen(len(m))) _, err = base64.StdEncoding.Decode(dst, m) if err != nil { c.Fatal(err) } msg := string(dst) for k, _ := range checkFor { if strings.Contains(msg, k) { delete(checkFor, k) } } if len(checkFor) == 0 { return msg } } if len(checkFor) != 0 { c.Fatal("Didn't find: ", checkFor) } return "" }
func datawsHandler(w http.ResponseWriter, r *http.Request) { var websocket *ws.Conn var upgradeerr error websocket, upgradeerr = upgrader.Upgrade(w, r, nil) if upgradeerr != nil { w.Write([]byte(fmt.Sprintf("Could not upgrade HTTP connection to WebSocket: %v\n", upgradeerr))) return } cw := ConnWrapper{ Writing: &sync.Mutex{}, Conn: websocket, } websocket.SetReadLimit(MAX_REQSIZE) for { _, payload, err := websocket.ReadMessage() if err != nil { return // Most likely the connection was closed or the message was too big } uuidBytes, startTime, endTime, pw, token, echoTag, success := parseDataRequest(string(payload), &cw) if success { var loginsession *LoginSession if token != "" { loginsession = validateToken(token) if loginsession == nil { w.Write([]byte(ERROR_INVALID_TOKEN)) return } } if hasPermission(loginsession, uuidBytes) { dr.MakeDataRequest(uuidBytes, startTime, endTime, uint8(pw), &cw) } else { cw.GetWriter().Write([]byte("[]")) } } if cw.CurrWriter != nil { cw.CurrWriter.Close() } writer, err := websocket.NextWriter(ws.TextMessage) if err != nil { fmt.Println("Could not echo tag to client") } if cw.CurrWriter != nil { _, err = writer.Write([]byte(echoTag)) if err != nil { fmt.Println("Could not echo tag to client") } writer.Close() } cw.Writing.Unlock() } }
func (handler *handler) proxyConnectionTo(server *websocket.Conn) { handler.logger.Debugf("Output Proxy: Starting to listen to server %v", server.RemoteAddr().String()) var logMessage []byte defer server.Close() count := 0 for { _, data, err := server.ReadMessage() if err != nil { handler.logger.Errorf("Output Proxy: Error reading from the server - %v - %v", err, server.RemoteAddr().String()) handler.Done() return } handler.logger.Debugf("Output Proxy: Got message from server %v bytes", len(logMessage)) count++ err = handler.writeMessage(data) if err != nil { handler.logger.Errorf("Output Proxy: Error writing to client websocket - %v", err) return } } }
func socketRead(c *websocket.Conn) { for { _, r, err := c.ReadMessage() internal.Check(err) fmt.Print(color(string(r))) } }
func (bot *Bot) loop(conn *websocket.Conn) bool { defer conn.Close() for { messageType, bytes, err := conn.ReadMessage() if err != nil { // ReadMessage returns an error if the connection is closed return false } if messageType == websocket.BinaryMessage { continue // ignore binary messages } event, err := unpackJSON(bytes) if err != nil { log.WithFields(log.Fields{ "raw bytes": bytes, "error": err, }).Warn("message could not be unpacked") continue } log.WithFields(log.Fields{ "event": event, }).Info("received event") eventType, ok := event["type"] if ok && eventType.(string) == "team_migration_started" { return true } wrappers := bot.handle(event) closeConnection := sendResponses(wrappers, conn) if closeConnection { return false } } }
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)) } }
func handleWs(s Service, ws *websocket.Conn, subs map[uint32]*wsSub, slock *sync.Mutex) error { ch := make(chan []byte) defer close(ch) go func() { for { v, ok := <-ch if !ok { break } if err := ws.WriteMessage(websocket.BinaryMessage, v); err != nil { fmt.Printf("ws.WriteMessage: %#v\n", err) break } } }() for { mt, msg, err := ws.ReadMessage() if err != nil { fmt.Printf("ws.ReadMessage: %#v\n", err) break } if mt != websocket.BinaryMessage { continue } if err := iter(ch, msg, s, subs, slock); err != nil { return err } } return nil }
func (app *App) registerSocket(ws *websocket.Conn, hub *Hub, toHub *Hub) { defer hub.RemoveMember(ws) hub.AddMember(ws) app.KeepAlive() from := toHub.FromLabel to := toHub.ToLabel appname := app.Name for { mtype, p, err := ws.ReadMessage() if err != nil { log.Printf("%s: Connection (%s): %s", app.Name, from, err) break } msg := &AppMessage{Data: p, Mtype: mtype, Id: int(atomic.AddInt32(&msgcnt, 1)), To: toHub} log.Printf("%s: QUEUE [%d] %s -> %s (of %d) [%s]", appname, msg.Id, from, to, len(hub.Members), string(msg.Data)) app.Channel <- msg } }
func (wss *WSTraffickers) SaveConnection(accessToken string, conn *websocket.Conn) (*WSTrafficker, error) { _, payloadJson, err := conn.ReadMessage() if err != nil { return nil, err } var payload map[string]interface{} err = json.Unmarshal(payloadJson, &payload) if err != nil { return nil, err } hostnameInterface, hostnameExists := payload["Hostname"] if !hostnameExists { return nil, errors.New("Unable to establish websocket connection without Hostname payload") } wsTrafficker := NewWSTrafficker(conn) wsTrafficker.Hostname = hostnameInterface.(string) wss.ByAccessTokenHostname[accessToken+"-"+wsTrafficker.Hostname] = NewWSTrafficker(conn) logrus.WithFields(logrus.Fields{ "AccessToken": accessToken, "Hostname": wsTrafficker.Hostname, }).Info("Saved websocket connection in memory") return wsTrafficker, nil }
func AddWSSink(receivedChan chan []byte, port string, path string) (*websocket.Conn, <-chan struct{}) { connectionDroppedChannel := make(chan struct{}, 1) var ws *websocket.Conn ip, _ := localip.LocalIP() fullURL := "ws://" + ip + ":" + port + path Eventually(func() error { var err error ws, _, err = websocket.DefaultDialer.Dial(fullURL, http.Header{}) return err }, 5, 1).ShouldNot(HaveOccurred(), fmt.Sprintf("Unable to connect to server at %s.", fullURL)) ws.SetPingHandler(func(message string) error { ws.WriteControl(websocket.PongMessage, []byte(message), time.Time{}) return nil }) go func() { for { _, data, err := ws.ReadMessage() if err != nil { close(connectionDroppedChannel) close(receivedChan) return } receivedChan <- data } }() return ws, connectionDroppedChannel }
func wait(conn *websocket.Conn) { defer conn.Close() for { if _, _, err := conn.ReadMessage(); err != nil { break } } }
// START READER OMIT func reader(ws *websocket.Conn) { defer ws.Close() for { if _, _, err := ws.ReadMessage(); err != nil { // HL break } } }
func reader(ws *websocket.Conn) { defer ws.Close() for { _, _, err := ws.ReadMessage() if err != nil { log.Println(err) } } }
/* 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(id uint64, conn *websocket.Conn, readerResultChan chan readerResult) { for { messageType, data, err := conn.ReadMessage() readerResultChan <- readerResult{id, messageType, data, err} if err != nil { return } } }
// wait for an event; do things that might trigger events, and check them when they are received func waitForEvent(t *testing.T, con *websocket.Conn, eventid string, dieOnTimeout bool, f func(), check func(string, []byte) error) { // go routine to wait for webscoket msg gch := make(chan []byte) // good channel ech := make(chan error) // error channel go func() { for { _, p, err := con.ReadMessage() if err != nil { ech <- err break } else { // if the event id isnt what we're waiting on // ignore it var response struct { Event string `json:"event"` } if err := json.Unmarshal(p, &response); err != nil { ech <- err break } if response.Event == eventid { gch <- p break } } } }() // do stuff (transactions) f() // wait for an event or 10 seconds ticker := time.Tick(10 * time.Second) select { case <-ticker: if dieOnTimeout { con.Close() t.Fatalf("%s event was not received in time", eventid) } // else that's great, we didn't hear the event // and we shouldn't have case p := <-gch: if dieOnTimeout { // message was received and expected // run the check err := check(eventid, p) if err != nil { t.Fatal(err) } } else { con.Close() t.Fatalf("%s event was not expected", eventid) } case err := <-ech: t.Fatal(err) } }
func (c *connection) reader(wg *sync.WaitGroup, wsConn *websocket.Conn) { defer wg.Done() for { _, message, err := wsConn.ReadMessage() if err != nil { break } c.cs.broadcast <- message } }
func WsReader(c *websocket.Conn) { for { _, msg, err := c.ReadMessage() if err != nil { Display <- NewConsoleMsg(ERROR, err.Error()) } else { Display <- NewConsoleMsg(RECEIVING, string(msg)) } } }
func getTextMessage(ws *websocket.Conn) (string, error) { typ, msg, err := ws.ReadMessage() if err != nil { return "", fmt.Errorf("Error reading websocket message: %v", err) } if typ != websocket.TextMessage { return "", fmt.Errorf("Unexpected websocket message type: %v", typ) } return string(msg), nil }
func getTextMessage(t *testing.T, ws *websocket.Conn) string { typ, msg, err := ws.ReadMessage() if err != nil { t.Fatal("Error reading websocket message:", err) } if typ != websocket.TextMessage { t.Errorf("Unexpected websocket message type: %v", typ) } return string(msg) }
func (m *multiplexer) routeMessages(ws *websocket.Conn) { stopSignal := make(chan bool, 1) // Read messages from backend go func(stop chan<- bool) { for { msgType, msg, err := ws.ReadMessage() if err != nil { m.shutdown(stop) return } if msgType != websocket.TextMessage { continue } message := common.ParseMessage(string(msg)) m.frontendMu.RLock() frontendChan, ok := m.frontendChans[message.Key] if ok { frontendChan <- message } m.frontendMu.RUnlock() if !ok && message.Type != common.Close { m.sendClose(message.Key) } } }(stopSignal) // Write messages to backend go func(stop <-chan bool) { ticker := time.NewTicker(time.Second * 5) defer ticker.Stop() for { select { case message, ok := <-m.messagesToBackend: if !ok { return } err := ws.WriteMessage(websocket.TextMessage, []byte(message)) if err != nil { log.WithFields(log.Fields{"error": err, "msg": message}).Error("Could not write message.") } case <-ticker.C: ws.WriteControl(websocket.PingMessage, []byte(""), time.Now().Add(time.Second)) case <-stop: return } } }(stopSignal) }
// CopyToWebsocket copies pipe data to/from a websocket. It blocks. func (p *pipe) CopyToWebsocket(end io.ReadWriter, conn *websocket.Conn) error { p.mtx.Lock() if p.closed { p.mtx.Unlock() return nil } p.wg.Add(1) p.mtx.Unlock() defer p.wg.Done() errors := make(chan error, 1) // Read-from-UI loop go func() { for { _, buf, err := conn.ReadMessage() // TODO type should be binary message if err != nil { errors <- err return } if _, err := end.Write(buf); err != nil { errors <- err return } } }() // Write-to-UI loop go func() { buf := make([]byte, 1024) for { n, err := end.Read(buf) if err != nil { errors <- err return } if err := conn.WriteMessage(websocket.BinaryMessage, buf[:n]); err != nil { errors <- err return } } }() // block until one of the goroutines exits // this convoluted mechanism is to ensure we only close the websocket once. select { case err := <-errors: return err case <-p.quit: return nil } }