// readPump pumps messages from the websocket connection to the hub. func (c *Conn) readPump() { defer func() { hub.unregister <- c c.ws.Close() }() c.ws.SetReadLimit(maxMessageSize) c.ws.SetReadDeadline(time.Now().Add(pongWait)) c.ws.SetPongHandler(func(string) error { c.ws.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, message, err := c.ws.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v", err) } break } message = bytes.TrimSpace(bytes.Replace(message, newline, space, -1)) msg := &Message{} err = json.Unmarshal(message, msg) bo := strings.Split(string(message), ",") target := hub.connections[bo[0]] if target != nil { target.send <- []byte(bo[1]) } if err != nil { // byte message continue } //service.SendMessage(msg, string(message)) // hub.broadcast <- message } }
// writePump pumps messages from the toplevel to the websocket connection. func (c *Client) writePump() { defer func() { c.conn.Close() c.top.terminate() }() buf := make([]byte, 4*1024) for { n, err := c.top.stdout.Read(buf) // log.Printf("Read %s", buf[:n]) if n > 0 { err := c.conn.WriteMessage(websocket.TextMessage, buf[:n]) if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseNoStatusReceived) { log.Printf("Writepump websocket error: %s", err) } break } } else { if err != nil { if err != io.EOF { log.Printf("Writepump Unexpected error while reading STDOUT from process: %s", err) } else { log.Printf("Writepump Process STDOUT closed: %s", err) } break } } } }
func (h *Hijacker) handleOutput(conn *websocket.Conn, pio ProcessIO) int { var exitStatus int for { var output atc.HijackOutput err := conn.ReadJSON(&output) if err != nil { if !websocket.IsCloseError(err) && !websocket.IsUnexpectedCloseError(err) { fmt.Println(err) } break } if output.ExitStatus != nil { exitStatus = *output.ExitStatus } else if len(output.Error) > 0 { fmt.Fprintf(os.Stderr, "%s\n", ansi.Color(output.Error, "red+b")) exitStatus = 255 } else if len(output.Stdout) > 0 { pio.Out.Write(output.Stdout) } else if len(output.Stderr) > 0 { pio.Err.Write(output.Stderr) } } return exitStatus }
// readPump pumps messages from the websocket connection to the hub. func (c *connection) readPump() { defer func() { h.unregister <- c c.ws.Close() }() c.ws.SetReadLimit(maxMessageSize) c.ws.SetReadDeadline(time.Now().Add(pongWait)) c.ws.SetPongHandler(func(string) error { c.ws.SetReadDeadline(time.Now().Add(pongWait)) return nil }) for { _, message, err := c.ws.ReadMessage() fmt.Println(string(message)) if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v", err) } break } } }
func handleConnectionError(connection *Connection, err error) { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseNormalClosure) { log.Printf("Unexpected error from connection: %q", err) } hub.Unregister(connection) }
//Callback function that is called for new connection. func connectionHandler(w http.ResponseWriter, r *http.Request, server *WServer) { conn, err := gorillaUpgrader.Upgrade(w, r, nil) if err != nil { log.Println("connectionHandler: gorillaUpgrader: ", err) return } defer func() { //dev log.Println("Connection close: ", conn.RemoteAddr()) conn.Close() }() //dev log.Println("New connection: ", conn.RemoteAddr()) client := Client{server.OnMessage, conn} defer server.OnClose(&client) for { messageType, r, err := conn.NextReader() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Println("Connection handler: ", err) } return } new_msg := &Message{&r, messageType} client.onmessage(new_msg, &client) } }
// readPump pumps messages from the websocket connection to the hub. func (c *Client) readPump() { defer func() { c.hub.unregister <- c c.conn.Close() }() c.conn.SetReadLimit(maxMessageSize) c.conn.SetReadDeadline(time.Now().Add(pongWait)) c.conn.SetPongHandler(func(string) error { c.conn.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, message, err := c.conn.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v", err) } else { log.Printf("Client disconnected") } break } if c.hub.read { c.hub.ReadBuffer.Lock() c.hub.ReadBuffer.Messages = append(c.hub.ReadBuffer.Messages, &message) c.hub.ReadBuffer.Unlock() } } }
// readPump pumps messages from the websocket connection to the hub. func (u *User) readPump() { defer func() { u.g.unregister <- u u.ws.Close() }() u.ws.SetReadLimit(maxMessageSize) u.ws.SetReadDeadline(time.Now().Add(pongWait)) u.ws.SetPongHandler(func(string) error { u.ws.SetReadDeadline(time.Now().Add(pongWait)) return nil }) for { _, message, err := u.ws.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { // TODO: do something?? } u.Log.Error(err.Error()) return } u.Log.WithField("content", string(message)).Debug("new message") c := NewCommand(u, string(message)) u.g.commands <- c } }
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)) } }
// The websocket.IsUnexpectedCloseError function is useful for identifying // application and protocol errors. // // This server application works with a client application running in the // browser. The client application does not explicitly close the websocket. The // only expected close message from the client has the code // websocket.CloseGoingAway. All other other close messages are likely the // result of an application or protocol error and are logged to aid debugging. func ExampleIsUnexpectedCloseError(err error, c *websocket.Conn, req *http.Request) { for { messageType, p, err := c.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v, user-agent: %v", err, req.Header.Get("User-Agent")) } return } processMesage(messageType, p) } }
// readPump pumps messages from the websocket connection to the hub. func (s *subscription) readPump() { defer func() { Hub.unregister <- s s.conn.ws.Close() }() s.conn.ws.SetReadLimit(maxMessageSize) s.conn.ws.SetReadDeadline(time.Now().Add(pongWait)) s.conn.ws.SetPongHandler(func(string) error { log.Println("[DEBUG] In pong handler", s.conn.username) s.conn.ws.SetReadDeadline(time.Now().Add(pongWait)) return nil }) for { _, message, err := s.conn.ws.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v", err) } log.Printf("error: %v", err) break } // Parse as JSON. var m Message err = json.Unmarshal(message, &m) if err != nil { log.Println("error unmarshaling: ", err) break } // Save raw data for this message for further processing, but append // username. // XXX: we'll end up unmarshalling twice. We should re-think this later. m.realm = s.realm m.From = s.conn.username // Remarshal to m.rawdata rawdata, err := json.Marshal(m) if err != nil { log.Println("Error re-marshalling: ", err) break } m.rawdata = rawdata // Pass it on to the external handler. Hub.handler.HandleMessage(m) // For right now only PrivateMT should not be broadcast. if m.Mtype != PrivateMT { Hub.broadcast <- m } } }
// readPump pumps messages from the websocket connection to the toplevel. func (c *Client) readPump() { defer func() { c.reg.unregister <- c c.conn.Close() c.top.terminate() }() for { _, message, err := c.conn.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseNoStatusReceived) { log.Printf("readPump error: %v", err) } break } c.top.stdin.Write(message) } }
// readPump pumps messages from the websocket connection to the hub. func (c *Conn) readPump() { defer func() { hub.unregister <- c c.ws.Close() }() c.ws.SetReadLimit(maxMessageSize) c.ws.SetReadDeadline(time.Now().Add(pongWait)) c.ws.SetPongHandler(func(string) error { c.ws.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, message, err := c.ws.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v", err) } break } message = bytes.TrimSpace(bytes.Replace(message, newline, space, -1)) hub.broadcast <- message } }
func (c *Client) read() { hub := GetHub() defer func() { hub.unregister <- c c.con.Close() }() c.con.SetReadLimit(maxMessageSize) c.con.SetReadDeadline(time.Now().Add(pongWait)) c.con.SetPongHandler(func(string) error { c.con.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { message := &SendMessage{} err := c.con.ReadJSON(message) if err != nil { if soc.IsUnexpectedCloseError(err, soc.CloseGoingAway) { log.Printf("error: %v", err) } break } message.Message = string(bytes.TrimSpace(bytes.Replace([]byte(message.Message), newline, space, -1))) hub.broadcast <- message } }
// readMessagesLoop reads messages from the websocket connection. func (c *wsConnection) readMessagesLoop(mode int) { // When disconnect defer func() { close(c.done) close(c.outboxMessages) close(c.inboxMessages) }() for { // Reset the read deadline. c.ws.SetReadDeadline(time.Now().Add(c.sc.pingTimeout)) messageType, message, err := c.ws.ReadMessage() if err != nil { isUnexpectedError := websocket.IsUnexpectedCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway, websocket.CloseNoStatusReceived) if err != io.EOF && isUnexpectedError { log.Error("failed to read data from websocket: %v", err) } return } switch messageType { case mode: log.Debug("received message with a payload") c.inboxMessages <- message case websocket.CloseMessage: log.Debug("got close message") return default: log.Debug("got wrong message, message dropped") } } }
// readPump pumps messages from the websocket connection to the hub. func (c *Connection) readPump() { defer func() { c.tb.disconnected(c) c.ws.Close() }() c.ws.SetReadLimit(maxMessageSize) c.ws.SetReadDeadline(time.Now().Add(pongWait)) c.ws.SetPongHandler(func(d string) error { c.ws.SetReadDeadline(time.Now().Add(pongWait)) return nil }) for { var event Event err := c.ws.ReadJSON(&event) if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v", err) } break } log.Printf("Received event %v", event) switch event.Type { case "subscribe": c.Subscribed(event.Channel) case "message": for _, ch := range c.tb.Channels(event.Channel) { ch.Received(event) } default: log.Printf("unknown event command %s", event.Type) } } }
func (c *Conn) readPump() { defer func() { c.ws.Close() }() c.ws.SetReadLimit(maxMessageSize) c.ws.SetReadDeadline(time.Now().Add(pongWait)) c.ws.SetPongHandler(func(string) error { c.ws.SetReadDeadline(time.Now().Add(pongWait)); return nil }) for { _, message, err := c.ws.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { Debug(fmt.Sprintf("ERROR: %v", err)) } break } message = bytes.TrimSpace(bytes.Replace(message, newline, space, -1)) Debug(string(message)) if c.readCallback != nil { c.readCallback(c, string(message)) } } }
func (i *Informer) watch() { const ( // Time allowed to write a message to the peer. writeWait = 10 * time.Second // Time allowed to read the next pong message from the peer. pongWait = 10 * time.Second // Send pings to peer with this period. Must be less than pongWait. pingPeriod = (pongWait * 9) / 10 ) // write writes a message with the given message type and payload. writeFn := func(ws *websocket.Conn, mt int, payload []byte) error { ws.SetWriteDeadline(time.Now().Add(writeWait)) return ws.WriteMessage(mt, payload) } for { ws, resp, err := i.wsDialer.Dial(i.wsURL, i.wsHeader) if err != nil { if err == websocket.ErrBadHandshake { err = fmt.Errorf("handshake failed with status %d", resp.StatusCode) } i.notifyError(err) continue } // TODO: Look which is the max resource limit in kubernetes (the json serialized one) //ws.SetReadLimit(maxResourceSize) ws.SetReadDeadline(time.Now().Add(pongWait)) ws.SetPongHandler(func(string) error { ws.SetReadDeadline(time.Now().Add(pongWait)) return nil }) // this routine pumps messages from the hub to the websocket connection. go func() { ticker := time.NewTicker(pingPeriod) defer func() { ticker.Stop() ws.Close() }() for { select { case <-ticker.C: if err := writeFn(ws, websocket.PingMessage, []byte{}); err != nil { return } } } }() L: for { select { case <-i.stopChan: break default: v := i.rc.item() we := &kapi.WatchEvent{Object: v} if err := ws.ReadJSON(&we); err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { i.notifyError(err) } break L } else { // notify watch event i.notify(we) } } } } }
func (connection *Connection) ReadPump() { defer func() { HubInstance.unregister <- connection connection.ws.Close() }() connection.ws.SetReadLimit(consts.MaxMessageSize) connection.ws.SetReadDeadline(time.Now().Add(consts.PongWait)) connection.ws.SetPongHandler(func(string) error { connection.ws.SetReadDeadline(time.Now().Add(consts.PongWait)) return nil }) for { _, message, err := connection.ws.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) { log.Printf("error: %v", err) } break } messageRequest := &MessageRequest{} if unmarshalErr := json.Unmarshal(message, messageRequest); unmarshalErr != nil { // request type error. HubInstance.typeerr <- connection continue } connection.request = messageRequest switch messageRequest.RequestType { case consts.CpuMetric: // cpu metric request. HubInstance.cpumetric <- connection case consts.MemoryMetric: // memory metric request. HubInstance.memorymetric <- connection case consts.DiskMetric: // disk metric request. HubInstance.diskmetric <- connection case consts.DiskReadMetric: // disk read metric request. HubInstance.diskreadmetric <- connection case consts.NetworkReceiveMetric: // network receive metric request. HubInstance.networkreceivemetric <- connection case consts.NetworkTransmitMetric: // network transmitMetric: HubInstance.networktransmitmetric <- connection case consts.CombinMetric: // combin metric request. HubInstance.combinmetric <- connection case consts.NodeBootMetric: // node boot time metric request. HubInstance.nodebootmetric <- connection case consts.ProcessRunningMetric: // node process running metric request. HubInstance.processrunningmetric <- connection case consts.ProcessBlockedMetric: // node process blocked metric request. HubInstance.processblockedmetric <- connection case consts.ContainerLastSeenMetric: // container last seen metric request. HubInstance.containerlastseenmetric <- connection case consts.ContainerMemoryUsageBytesMetric: // container memory usage bytes metric request. HubInstance.containermemoryusagebytesmetric <- connection case consts.TotalRancherServicesMetric: // total rancher services metric request. HubInstance.totalrancherservicesmetric <- connection default: // request type error. HubInstance.typeerr <- connection } } }