func writer(ws *websocket.Conn) { pingTicker := time.NewTicker(pingPeriod) nodesTicker := time.NewTicker(nodesPeriod) defer func() { pingTicker.Stop() nodesTicker.Stop() ws.Close() }() for { select { case <-nodesTicker.C: p := []byte(fmt.Sprintf("%v", nodesH)) if p != nil { ws.SetWriteDeadline(time.Now().Add(writeWait)) if err := ws.WriteMessage(websocket.TextMessage, p); err != nil { return } } case <-pingTicker.C: ws.SetWriteDeadline(time.Now().Add(writeWait)) if err := ws.WriteMessage(websocket.PingMessage, []byte{}); err != nil { return } } } }
// writer runs in a goroutine for each connected WS client. It emits all message returned by the observer. func writer(ws *websocket.Conn, a *ApiHandlers) { pingTicker := time.NewTicker(pingPeriod) s := a.getDBSubscriber() jww.INFO.Println("Opened WebSocket connection.") defer func(is *subscriber) { jww.INFO.Println("Closing WebSocket connection.") is.quitChan <- true pingTicker.Stop() ws.Close() }(s) for { select { case msg := <-s.bufChan: ws.SetWriteDeadline(time.Now().Add(writeWait)) if err := ws.WriteJSON(msg); err != nil { return } case <-pingTicker.C: ws.SetWriteDeadline(time.Now().Add(writeWait)) if err := ws.WriteMessage(websocket.PingMessage, []byte{}); err != nil { return } } } }
func write(ws *websocket.Conn, mt int, payload []byte) error { if ws == nil { return errors.New("no web socket connection: ws") } ws.SetWriteDeadline(time.Now().Add(writeWait)) return ws.WriteMessage(mt, payload) }
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 PushMsg(ws *websocket.Conn, WSWriter chan []uint8) { defer ws.Close() for { msg := <-WSWriter if msg == nil { continue } // write message to client if err := ws.WriteMessage(websocket.TextMessage, []byte(msg)); err != nil { log.Println("[ErrorInfo]", err.Error()) break } if string(msg) == "bye" { break } } endChan <- true }
func WebsocketSendStream(conn *websocket.Conn, r io.Reader) chan bool { ch := make(chan bool) go func(conn *websocket.Conn, r io.Reader) { in := ReaderToChannel(r) for { buf, ok := <-in if !ok { break } w, err := conn.NextWriter(websocket.BinaryMessage) if err != nil { Debugf("got error getting next writer %s", err) break } _, err = w.Write(buf) w.Close() if err != nil { Debugf("got err writing %s", err) break } } closeMsg := websocket.FormatCloseMessage(websocket.CloseNormalClosure, "") conn.WriteMessage(websocket.CloseMessage, closeMsg) ch <- true }(conn, r) return ch }
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 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 WebsocketSendStream(conn *websocket.Conn, r io.Reader) chan bool { ch := make(chan bool) if r == nil { close(ch) return ch } go func(conn *websocket.Conn, r io.Reader) { in := ReaderToChannel(r) for { buf, ok := <-in if !ok { break } w, err := conn.NextWriter(websocket.BinaryMessage) if err != nil { Debugf("Got error getting next writer %s", err) break } _, err = w.Write(buf) w.Close() if err != nil { Debugf("Got err writing %s", err) break } } conn.WriteMessage(websocket.TextMessage, []byte{}) ch <- true }(conn, r) return ch }
func sendCloseMessage(t *testing.T, ws *websocket.Conn) { err := ws.WriteMessage(websocket.CloseMessage, []byte{}) assert.Nil(t, err, "ws: %v", err) wait(10) }
func createPlayer(conn *websocket.Conn) { message, _ := json.Marshal(&Message{Title: "createPlayer", Data: connections.m[conn]}) if err := conn.WriteMessage(websocket.TextMessage, message); err != nil { closeConnection(conn) } }
// sendGameStateToConnection broadcasts the current gameState as JSON to all players // within a connectionPair func sendGameStateToConnection(wsConn *websocket.Conn, c *connection) { err := wsConn.WriteMessage(websocket.TextMessage, c.cp.gs.gameStateToJSON()) //removing connection if updating gameState fails if err != nil { c.cp.removeConnection(c) } }
func runInit(c *websocket.Conn) { dir, _ := filepath.Abs(filepath.Dir(os.Args[0])) initPath := path.Join(dir, "init.cmd") if _, err := os.Stat(initPath); err == nil { file, err := os.Open(initPath) if err != nil { log.Fatal(err) } defer file.Close() scanner := bufio.NewScanner(file) for scanner.Scan() { line := strings.TrimSpace(scanner.Text()) log.Println(line) if line != "" && !strings.HasPrefix(line, "#") { fmt.Println("<<", line) c.WriteMessage(websocket.TextMessage, []byte(line)) } } if err := scanner.Err(); err != nil { log.Fatal(err) } } }
func (ws *WebSocker) writer(conn *websocket.Conn, user string, tmpl *template.Template) { pingTicker := time.NewTicker(pingPeriod) chl, chq := notifier.listen(user) ws.log.Println(user, "connected") defer func() { pingTicker.Stop() conn.Close() close(chq) ws.log.Println(user, "disconnected") }() for { var buf bytes.Buffer select { case p := <-chl: conn.SetWriteDeadline(time.Now().Add(writeWait)) buf.Reset() if err := tmpl.Execute(&buf, p); err != nil { ws.log.Println(err) return } if err := conn.WriteMessage(websocket.TextMessage, buf.Bytes()); err != nil { return } ws.log.Println("notified:", user) case <-pingTicker.C: conn.SetWriteDeadline(time.Now().Add(writeWait)) if err := conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil { ws.log.Println("ping:", err) return } } } }
func pipe_to_ws(netConn net.Conn, wsConn *websocket.Conn, protocolType int, stopChan chan int) { for { select { case <-stopChan: return default: { data := make([]byte, BUFFER_SIZE) n, err := netConn.Read(data) if err != nil { stopChan <- 1 return } if protocolType == websocket.BinaryMessage { err = wsConn.WriteMessage(protocolType, data[:n]) if err != nil { stopChan <- 1 return } } else if protocolType == websocket.TextMessage { encodedData := []byte(base64.StdEncoding.EncodeToString(data[:n])) err = wsConn.WriteMessage(protocolType, encodedData) if err != nil { stopChan <- 1 return } } } } } }
func newWSConn(conn *websocket.Conn, pendingWriteNum int) *WSConn { wsConn := new(WSConn) wsConn.conn = conn wsConn.writeChan = make(chan []byte, pendingWriteNum) go func() { for b := range wsConn.writeChan { if b == nil { break } err := conn.WriteMessage(websocket.BinaryMessage, b) if err != nil { break } } conn.Close() wsConn.Lock() wsConn.closeFlag = true wsConn.Unlock() }() return wsConn }
func (b BackendController) SendToClient(msg []byte, conn *websocket.Conn) error { if err := conn.WriteMessage(websocket.TextMessage, msg); err != nil { b.CleanUpHandler(conn) return err } else { return nil } }
func (w *WebsocketController) listenForOutcomingData(connection *websocket.Conn, client *WebsocketClient) { for { received := <-client.In() connection.WriteMessage(websocket.TextMessage, []byte(received)) w.logger.Println("client", client, "recieved", received) } }
// Write sync messages to client func clientWriteSync(ws *websocket.Conn, payload []byte) { log.Println("Sending ", len(payload), "chunk.") err := ws.WriteMessage(websocket.BinaryMessage, payload) if err != nil { panic(err) } }
func addNewPlayer(conn *websocket.Conn, oldconn *websocket.Conn) { if conn != oldconn { message, _ := json.Marshal(&Message{Title: "addPlayer", Data: connections.m[conn]}) if err := oldconn.WriteMessage(websocket.TextMessage, message); err != nil { closeConnection(oldconn) } } }
func writeEventToSubscriber(ws *websocket.Conn, c chan string) { for { event := <-c err := ws.WriteMessage(websocket.TextMessage, []byte(event)) if err != nil { log.WithFields(log.Fields{"error": err, "msg": event}).Fatal("Could not write message.") } } }
func sendPublish(c *websocket.Conn) { /* fmt.Println("input your channels split by blank:") in := make([]byte, 1024) os.Stdin.Read(in) */ msg := "LHTTP/1.0 suubpub\r\npublish:camera_123" + "\r\n\r\nhello world" c.WriteMessage(websocket.TextMessage, []byte(msg)) }
func sendSubscribe(c *websocket.Conn) { /* fmt.Println("input your channels split by blank:") in := make([]byte, 1024) os.Stdin.Read(in) */ msg := "LHTTP/1.0 suubpub\r\nsubscribe:cam_123" + "\r\n\r\n" c.WriteMessage(websocket.TextMessage, []byte(msg)) }
func addOtherPlayers(conn *websocket.Conn, oldconn *websocket.Conn) { if conn != oldconn && connections.m[oldconn].inLobby { message, _ := json.Marshal(&Message{Title: "addPlayer", Player: connections.m[oldconn]}) if err := conn.WriteMessage(websocket.TextMessage, message); err != nil { closeConnection(conn) } } }
func (c *connection) writer(wg *sync.WaitGroup, wsConn *websocket.Conn) { defer wg.Done() for message := range c.send { err := wsConn.WriteMessage(websocket.TextMessage, message) if err != nil { break } } }
func updatePlayer(conn *websocket.Conn, oldconn *websocket.Conn, data PlayerMessage) { if conn != oldconn { message, _ := json.Marshal(&data) if err := oldconn.WriteMessage(websocket.TextMessage, message); err != nil { closeConnection(oldconn) } } }
func patchUserSource(t *testing.T, c *websocket.Conn, fileName, oldSource, newSource string) []interface{} { patchJson := createPatchJson(t, fileName, oldSource, newSource) err := c.WriteMessage(websocket.TextMessage, []byte(patchJson)) require.Nil(t, err) result := make(map[string]interface{}) err = c.ReadJSON(&result) require.Nil(t, err) return result["errors"].([]interface{}) }
func sendmsg(ws *websocket.Conn, msgs ...*fayeMsg) error { jmsg, err := json.Marshal(msgs) if err != nil { return err } if err = ws.WriteMessage(websocket.TextMessage, jmsg); err != nil { return err } return nil }
func WsWriter(c *websocket.Conn) { for { msg := <-SendToServer Display <- NewConsoleMsg(SENDING, msg) err := c.WriteMessage(websocket.TextMessage, []byte(msg)) if err != nil { Display <- NewConsoleMsg(ERROR, err.Error()) } } }
func sendMessagesToWebsocket(logMessages []*logmessage.Message, ws *websocket.Conn, logger *gosteno.Logger) { for _, message := range logMessages { err := ws.WriteMessage(websocket.BinaryMessage, message.GetRawMessage()) if err != nil { logger.Debugf("Dump Sink %s: Error when trying to send data to sink %s. Requesting close. Err: %v", ws.RemoteAddr(), err) } else { logger.Debugf("Dump Sink %s: Successfully sent data", ws.RemoteAddr()) } } }