/** * Close connection */ func (server *server) Close(ws *websocket.Conn) { err := ws.Close() if err != nil { server.Error(err) } }
// handle implements a WebSocket handler. func (r *Reader) handle(ws *websocket.Conn) { encode := len(ws.Config().Protocol) > 0 && ws.Config().Protocol[0] == base64BinaryWebSocketProtocol defer close(r.err) defer ws.Close() go IgnoreReceives(ws, r.timeout) r.err <- messageCopy(ws, r.r, encode, r.ping, r.timeout) }
func (this *socketManager) wsOnConnect(ws *websocket.Conn) { var err error var p payload defer func() { if err = ws.Close(); err != nil { logger.Info.Println("Websocket could not be closed", err.Error()) } }() //Client connected to websocket connection := connection{ws} //Keep a reference to the connection this.connections[&connection] = true logger.Info.Println("WebSocket Connection event ...") logger.Info.Println("Number of clients connected ...", len(this.connections)) //Get the last messages from the zmqDealer TCP pipe this.getLastMessages(connection) //Wait a bit for the last messages to send... time.Sleep(3 * time.Second) // Loop to keep websocket open for { if err = websocket.JSON.Receive(ws, &p); err != nil { //Socket is closed if logger.Info.Println("Websocket Disconnected...", err.Error()) //Remove connection from active connections delete(this.connections, &connection) logger.Info.Println("Number of clients connected ...", len(this.connections)) return } } }
func (c *Client) Stream(path string, headers map[string]string, in io.Reader, out io.WriteCloser) error { origin := fmt.Sprintf("https://%s", c.Host) endpoint := fmt.Sprintf("wss://%s%s", c.Host, path) config, err := websocket.NewConfig(endpoint, origin) if err != nil { return err } config.TlsConfig = &tls.Config{ InsecureSkipVerify: true, } config.Header.Set("Version", c.Version) userpass := fmt.Sprintf("convox:%s", c.Password) userpass_encoded := base64.StdEncoding.EncodeToString([]byte(userpass)) config.Header.Add("Authorization", fmt.Sprintf("Basic %s", userpass_encoded)) for k, v := range headers { config.Header.Add(k, v) } config.TlsConfig = &tls.Config{ InsecureSkipVerify: true, } var ws *websocket.Conn if proxy := os.Getenv("HTTPS_PROXY"); proxy != "" { ws, err = c.proxyWebsocket(config, proxy) } else { ws, err = websocket.DialConfig(config) } if err != nil { return err } defer ws.Close() var wg sync.WaitGroup if in != nil { go io.Copy(ws, in) } if out != nil { wg.Add(1) go copyAsync(out, ws, &wg) } wg.Wait() out.Close() return nil }
func (self *Server) webSocketHandler(conn *websocket.Conn) { dispatcher := NewDispatcher(self) for { data := map[string]interface{}{} err := websocket.JSON.Receive(conn, &data) if err != nil { if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() { fmt.Println(err) continue } if err == io.EOF { fmt.Println(fmt.Sprintf("Client Dissconected :%s", conn.RemoteAddr())) break } else { fmt.Println(fmt.Sprintf("Receive Data Failed %s", err)) break } } fmt.Println("Dispatch", data) err = dispatcher.Dispatch(conn, data) if err != nil { fmt.Println(fmt.Sprintf("Dispatch Failed %s", err)) } } defer func() { conn.Close() }() }
func scoreboardHandler(ws *websocket.Conn) { defer ws.Close() fmt.Fprint(ws, currentResult) sendedResult := currentResult lastUpdate := time.Now() for { if sendedResult != currentResult || time.Now().After(lastUpdate.Add(time.Minute)) { sendedResult = currentResult lastUpdate = time.Now() _, err := fmt.Fprint(ws, currentResult) if err != nil { log.Println("Socket closed:", err) return } } time.Sleep(time.Second) } }
func (g *game) Start(ws *websocket.Conn) { defer ws.Close() var player user.User for { if err := websocket.JSON.Receive(ws, &player); err != nil { panic(err) return } player.Socket = ws g.Players[player.Name] = player for k, v := range g.Players { if k == player.Name { continue } if err := websocket.JSON.Send(v.Socket, player); err != nil { delete(g.Players, k) go g.SendMessageAll(&Message{ Method: "destroy", UserName: k, }) } } } }
func split(data []byte, atEOF bool, conn *websocket.Conn, callback ReadCallBack) (adv int, token []byte, err error) { l := len(data) if l < 6 { return 0, nil, nil } if l > 100000 { conn.Close() log.Println("invalid query!") return 0, nil, errors.New("to large data!") } var len1, len2 int len1 = int(binary.LittleEndian.Uint16(data[:2])) len2 = int(binary.LittleEndian.Uint32(data[2:6])) offset := 0 if len1+len2+6 > l { conn.Close() log.Println("invalid data", len1, len2, l) return 0, nil, errors.New("invalid data") } offset += len1 + len2 + 6 head := string(data[6 : 6+len1]) tail := data[6+len1 : 6+len1+len2] callback(conn, head, tail) return offset, []byte{}, nil }
// HandleConn handles on an individual socket connection func (s *SocketHandler) HandleConn(ws *websocket.Conn) { defer ws.Close() doneChan := make(chan bool, 1) s.connLock.Lock() s.connections = append(s.connections, &WebSocketConn{ Conn: ws, DoneChan: doneChan, }) s.connLock.Unlock() s.newConnectionChan <- struct{}{} // read commands forloop: for { select { case <-doneChan: break forloop default: var msg Command if err := websocket.JSON.Receive(ws, &msg); err != nil { if err == io.EOF { break forloop } fmt.Printf("\n[ERROR] %v", err) } else { s.commandChan <- msg } } } fmt.Printf("Done listening on socket") }
func Chat(ws *websocket.Conn) { var message Message defer ws.Close() for { if err := websocket.JSON.Receive(ws, &message); err != nil { Log(err) return } active[message.Name] = ws if message.Text == "Register" { if err := websocket.JSON.Send(ws, online()); err != nil { Log(err) delete(active, message.Name) return } continue } go sendAll(&message) } }
func SockServer(ws *websocket.Conn) { var err error var clientMessage string // use []byte if websocket binary type is blob or arraybuffer // var clientMessage []byte defer func() { if err = ws.Close(); err != nil { log.Println("Websocket could not be closed", err.Error()) } }() client := ws.Request().RemoteAddr log.Println("Client connected:", client) sockCli := ClientConn{ws, client} ActiveClients[sockCli] = 0 log.Println("Number of clients connected ...", len(ActiveClients)) for { if err = Message.Receive(ws, &clientMessage); err != nil { log.Println("Websocket Disconnected waiting", err.Error()) delete(ActiveClients, sockCli) log.Println("Number of clients still connected ...", len(ActiveClients)) return } if len(clientMessage) > 0 { clientMessage = sockCli.clientIP + " Said: " + clientMessage for cs, _ := range ActiveClients { if err = Message.Send(cs.websocket, clientMessage); err != nil { log.Println("Could not send message to ", cs.clientIP, err.Error()) } } } } }
// handle implements a WebSocket handler. func (r *Reader) handle(ws *websocket.Conn) { // Close the connection when the client requests it, or when we finish streaming, whichever happens first closeConnOnce := &sync.Once{} closeConn := func() { closeConnOnce.Do(func() { ws.Close() }) } negotiated := ws.Config().Protocol r.selectedProtocol = negotiated[0] defer close(r.err) defer closeConn() go func() { defer runtime.HandleCrash() // This blocks until the connection is closed. // Client should not send anything. IgnoreReceives(ws, r.timeout) // Once the client closes, we should also close closeConn() }() r.err <- messageCopy(ws, r.r, !r.protocols[r.selectedProtocol].Binary, r.ping, r.timeout) }
func (s *Server) Accept(ws *websocket.Conn) { ws.PayloadType = websocket.BinaryFrame if _, err := NewConnection(s, ws); err != nil { ws.SetDeadline(time.Now().Add(2 * time.Millisecond)) ws.Close() } }
func wsserver(ws *websocket.Conn) { // read msg var ( msg msgproto.Msg err error id int32 // topic string ) for { err = msgCodec.Receive(ws, &msg) checkErr("Receive", err) if err != nil { break } // add client and topic client id = msg.GetId() if _, ok := clients[id]; !ok { clients[id] = ws } handleMsg(msg, ws) } defer func() { delete(clients, id) ws.Close() }() }
// HandleWS implements a websocket handler. func (w *WatchServer) HandleWS(ws *websocket.Conn) { defer ws.Close() done := make(chan struct{}) go func() { var unused interface{} // Expect this to block until the connection is closed. Client should not // send anything. websocket.JSON.Receive(ws, &unused) close(done) }() for { select { case <-done: w.watching.Stop() return case event, ok := <-w.watching.ResultChan(): if !ok { // End of results. return } w.fixup(event.Object) obj, err := watchjson.Object(w.codec, &event) if err != nil { // Client disconnect. w.watching.Stop() return } if err := websocket.JSON.Send(ws, obj); err != nil { // Client disconnect. w.watching.Stop() return } } } }
func addLogs(ws *websocket.Conn) { var err error defer func() { data := map[string]interface{}{} if err != nil { data["error"] = err.Error() log.Error(err.Error()) } else { data["error"] = nil } msg, _ := json.Marshal(data) ws.Write(msg) ws.Close() }() req := ws.Request() t := context.GetAuthToken(req) if t == nil { err = fmt.Errorf("wslogs: no token") return } if t.GetAppName() != app.InternalAppName { err = fmt.Errorf("wslogs: invalid token app name: %q", t.GetAppName()) return } err = scanLogs(ws) if err != nil { return } }
func addLogs(ws *websocket.Conn) { var err error defer func() { msg := &errMsg{} if err != nil { msg.Error = err.Error() log.Errorf("failure in logs webservice: %s", err) } websocket.JSON.Send(ws, msg) ws.Close() }() req := ws.Request() t := context.GetAuthToken(req) if t == nil { err = errors.Errorf("wslogs: no token") return } if t.GetAppName() != app.InternalAppName { err = errors.Errorf("wslogs: invalid token app name: %q", t.GetAppName()) return } err = scanLogs(ws) if err != nil { return } }
// wsHandler is a WebSocket server that handles requests from the WebSocket client in the form of: // 1. { 'cmd': 'register', 'roomid': $ROOM, 'clientid': $CLIENT' }, // which binds the WebSocket client to a client ID and room ID. // A client should send this message only once right after the connection is open. // or // 2. { 'cmd': 'send', 'msg': $MSG }, which sends the message to the other client of the room. // It should be sent to the server only after 'regiser' has been sent. // The message may be cached by the server if the other client has not joined. // // Unexpected messages will cause the WebSocket connection to be closed. func (c *Collider) wsHandler(ws *websocket.Conn) { var rid, cid string registered := false var msg wsClientMsg loop: for { err := ws.SetReadDeadline(time.Now().Add(time.Duration(wsReadTimeoutSec) * time.Second)) if err != nil { c.wsError("ws.SetReadDeadline error: "+err.Error(), ws) break } err = websocket.JSON.Receive(ws, &msg) if err != nil { if err.Error() != "EOF" { c.wsError("websocket.JSON.Receive error: "+err.Error(), ws) } break } switch msg.Cmd { case "register": if registered { c.wsError("Duplicated register request", ws) break loop } if msg.RoomID == "" || msg.ClientID == "" { c.wsError("Invalid register request: missing 'clientid' or 'roomid'", ws) break loop } if err = c.roomTable.register(msg.RoomID, msg.ClientID, ws); err != nil { c.wsError(err.Error(), ws) break loop } registered, rid, cid = true, msg.RoomID, msg.ClientID c.dash.incrWs() defer c.roomTable.deregister(rid, cid) break case "send": if !registered { c.wsError("Client not registered", ws) break loop } if msg.Msg == "" { c.wsError("Invalid send request: missing 'msg'", ws) break loop } c.roomTable.send(rid, cid, msg.Msg) break default: c.wsError("Invalid message: unexpected 'cmd'", ws) break } } // This should be unnecessary but just be safe. ws.Close() }
func (ws *WebSocketServer) wslogsHandler(w *websocket.Conn) { source := w.Request().FormValue("source") host := fmt.Sprintf("%s/%d", w.RemoteAddr().String(), time.Now().UnixNano()) defer func() { log.Printf("[%s - %s] closing websocket conn", ws.name, w.RemoteAddr().String()) ws.b.DelSubscriber(host) w.Close() }() log.Printf("[%s - %s] accepting websocket conn", ws.name, w.RemoteAddr().String()) r := make(chan *buffer.Event, recvBuffer) ws.b.AddSubscriber(host, r) for { select { case ev := <-r: if len(source) > 0 { if ev.Source != source { continue } } err := websocket.Message.Send(w, *ev.Text) if err != nil { log.Printf("[%s] error sending ws message: %v", w.RemoteAddr().String(), err.Error()) return } } } }
func (l *listener) handler(ws *websocket.Conn) { l.lock.Lock() if !l.running { ws.Close() l.lock.Unlock() return } w := &wsPipe{ws: ws, addr: l.addr, proto: l.proto, open: true} w.iswss = l.iswss req := ws.Request() w.props = make(map[string]interface{}) w.props[mangos.PropLocalAddr] = ws.LocalAddr() w.props[mangos.PropRemoteAddr], _ = net.ResolveTCPAddr("tcp", req.RemoteAddr) if l.iswss { w.props[mangos.PropTlsConnState] = *req.TLS } w.wg.Add(1) l.pending = append(l.pending, w) l.cv.Broadcast() l.lock.Unlock() // We must not return before the socket is closed, because // our caller will close the websocket on our return. w.wg.Wait() }
func AppLogs(ws *websocket.Conn) error { defer ws.Close() app := mux.Vars(ws.Request())["app"] a, err := models.GetApp(app) if awsError(err) == "ValidationError" { return fmt.Errorf("no such app: %s", app) } if err != nil { return err } logs := make(chan []byte) done := make(chan bool) a.SubscribeLogs(logs, done) for data := range logs { ws.Write(data) } return nil }
func handleWss(wsconn *websocket.Conn) { p := Responder{nil, wsconn.Request(), time.Now()} serverIP := wsconn.Request().Header.Get("X-Server-IP") conn, err := net.Dial("tcp", serverIP) if err != nil { p.errorLog(http.StatusInternalServerError, "Error connecting to '%s': %s", serverIP, err.Error()) wsconn.Close() return } defer conn.Close() defer wsconn.Close() wsconn.PayloadType = websocket.BinaryFrame t := ©Syncer{alive: true} go p.CopyR2W(t, conn, wsconn, serverIP+" ws2vnc") go p.CopyR2W(t, wsconn, conn, serverIP+" vnc2ws") p.errorLog(http.StatusOK, "websocket started: '%s'", serverIP) for t.IsAlive() { time.Sleep(100 * time.Millisecond) } p.errorLog(http.StatusOK, "websocket closed: '%s'", serverIP) }
func (c WebSockApp) AxisMovementWidgetWebSocket(user string, ws *websocket.Conn) revel.Result { revel.INFO.Printf("%s", "WS_AXIS_MOV request recieved") defer ws.Close() newmessages := make(chan string) //quit := make(chan struct{}) go func() { var msg string err := websocket.Message.Receive(ws, &msg) if err != nil { close(newmessages) return } newmessages <- msg }() for { select { case msg := <-newmessages: //TODO:Change printf on cmds to virtual keyboard if strings.HasPrefix(msg, "X") { revel.INFO.Printf("%s", "X_AXIS cmd recieved") } if strings.HasPrefix(msg, "Y") { revel.INFO.Printf("%s", "Y_AXIS cmd recieved") } if strings.HasPrefix(msg, "Z") { revel.INFO.Printf("%s", "Z_AXIS cmd recieved") } } } }
func wsServer(ws *websocket.Conn) { var buf string defer func() { if err := ws.Close(); err != nil { log.Println("Websocket could not be closed", err.Error()) } else { log.Println("Websocket closed") } }() //q := ws.Request().URL.Query() //name := q.Get("name") stopped := false ticker := time.Tick(time.Duration(1) * time.Second) for !stopped { select { case <-ticker: val := expvar.Get(metricsVar) if val == nil { buf = "" } else { buf = val.String() } _, err := ws.Write([]byte(buf)) if err != nil { log.Printf("Websocket error: %s\n", err.Error()) stopped = true } } } }
// HandleWS implements a websocket handler. func (s *WatchServer) HandleWS(ws *websocket.Conn) { defer ws.Close() done := make(chan struct{}) go wsstream.IgnoreReceives(ws, 0) var unknown runtime.Unknown internalEvent := &versioned.InternalEvent{} buf := &bytes.Buffer{} streamBuf := &bytes.Buffer{} ch := s.watching.ResultChan() for { select { case <-done: s.watching.Stop() return case event, ok := <-ch: if !ok { // End of results. return } obj := event.Object s.fixup(obj) if err := s.embeddedEncoder.Encode(obj, buf); err != nil { // unexpected error utilruntime.HandleError(fmt.Errorf("unable to encode watch object: %v", err)) return } // ContentType is not required here because we are defaulting to the serializer // type unknown.Raw = buf.Bytes() event.Object = &unknown // the internal event will be versioned by the encoder *internalEvent = versioned.InternalEvent(event) if err := s.encoder.Encode(internalEvent, streamBuf); err != nil { // encoding error utilruntime.HandleError(fmt.Errorf("unable to encode event: %v", err)) s.watching.Stop() return } if s.useTextFraming { if err := websocket.Message.Send(ws, streamBuf.String()); err != nil { // Client disconnect. s.watching.Stop() return } } else { if err := websocket.Message.Send(ws, streamBuf.Bytes()); err != nil { // Client disconnect. s.watching.Stop() return } } buf.Reset() streamBuf.Reset() } } }
func (this *DevWS) freeWS(ws *websocket.Conn) { this.lock.Lock() defer this.lock.Unlock() ws.Close() if this.ws == ws { this.isNeeded = false } }
func (a *Api) execContainer(ws *websocket.Conn) { qry := ws.Request().URL.Query() containerId := qry.Get("id") command := qry.Get("cmd") ttyWidth := qry.Get("w") ttyHeight := qry.Get("h") token := qry.Get("token") cmd := strings.Split(command, ",") if !a.manager.ValidateConsoleSessionToken(containerId, token) { ws.Write([]byte("unauthorized")) ws.Close() return } log.Debugf("starting exec session: container=%s cmd=%s", containerId, command) clientUrl := a.manager.DockerClient().URL execConfig := &dockerclient.ExecConfig{ AttachStdin: true, AttachStdout: true, AttachStderr: true, Tty: true, Cmd: cmd, Container: containerId, Detach: true, } execId, err := a.manager.DockerClient().ExecCreate(execConfig) if err != nil { log.Errorf("error calling exec: %s", err) return } if err := a.hijack(clientUrl.Host, "POST", "/exec/"+execId+"/start", true, ws, ws, ws, nil, nil); err != nil { log.Errorf("error during hijack: %s", err) return } // resize w, err := strconv.Atoi(ttyWidth) if err != nil { log.Error(err) return } h, err := strconv.Atoi(ttyHeight) if err != nil { log.Error(err) return } if err := a.manager.DockerClient().ExecResize(execId, w, h); err != nil { log.Errorf("error resizing exec tty: %s", err) return } }
func addLogs(ws *websocket.Conn) { var err error defer func() { data := map[string]interface{}{} if err != nil { data["error"] = err.Error() log.Error(err.Error()) } else { data["error"] = nil } msg, _ := json.Marshal(data) ws.Write(msg) ws.Close() }() req := ws.Request() t := context.GetAuthToken(req) if t == nil { err = fmt.Errorf("wslogs: no token") return } if t.GetAppName() != app.InternalAppName { err = fmt.Errorf("wslogs: invalid token app name: %q", t.GetAppName()) return } dispatcher := app.NewlogDispatcher() scanner := bufio.NewScanner(ws) for scanner.Scan() { var entry app.Applog data := bytes.TrimSpace(scanner.Bytes()) if len(data) == 0 { continue } err = json.Unmarshal(data, &entry) if err != nil { dispatcher.Stop() err = fmt.Errorf("wslogs: parsing log line %q: %s", string(data), err) return } err = dispatcher.Send(&entry) if err != nil { // Do not disconnect by returning here, dispatcher will already // retry db connection and we gain nothing by ending the WS // connection. log.Errorf("wslogs: error storing log: %s", err) } } err = dispatcher.Stop() if err != nil { err = fmt.Errorf("wslogs: error storing log: %s", err) return } err = scanner.Err() if err != nil { err = fmt.Errorf("wslogs: waiting for log data: %s", err) return } }
func addLogs(ws *websocket.Conn) { var err error defer func() { data := map[string]interface{}{} if err != nil { data["error"] = err.Error() log.Error(err.Error()) } else { data["error"] = nil } msg, _ := json.Marshal(data) ws.Write(msg) ws.Close() }() req := ws.Request() t := context.GetAuthToken(req) if t == nil { err = fmt.Errorf("wslogs: no token") return } if t.GetAppName() != app.InternalAppName { err = fmt.Errorf("wslogs: invalid token app name: %q", t.GetAppName()) return } logCh, errCh := app.LogReceiver() scanner := bufio.NewScanner(ws) for scanner.Scan() { var entry app.Applog data := bytes.TrimSpace(scanner.Bytes()) if len(data) == 0 { continue } err = json.Unmarshal(data, &entry) if err != nil { close(logCh) err = fmt.Errorf("wslogs: parsing log line %q: %s", string(data), err) return } select { case logCh <- &entry: case err := <-errCh: close(logCh) err = fmt.Errorf("wslogs: storing log: %s", err) return } } close(logCh) err = scanner.Err() if err != nil { err = fmt.Errorf("wslogs: waiting for log data: %s", err) return } err = <-errCh if err != nil { err = fmt.Errorf("wslogs: storing log: %s", err) } }
// EchoServer contains the main server loop func WsHandler(ws *websocket.Conn) { log.Printf("%v connected to server", ws.Request().RemoteAddr) addr := ws.Request().RemoteAddr // Cleanup defer func() { // TODO: remove conn from channel if err := ws.Close(); err != nil { log.Panicf("%v cleanup could not close connecteion: %v", addr, err.Error()) } }() var data Request for { err := websocket.JSON.Receive(ws, &data) switch { case err == io.EOF: log.Printf("%v disconnected", addr) return default: panic(err.Error()) case err == nil: } switch data.Command { case "": fmt.Printf("empty message\n") case "requestChannelId": log.Printf("%v requestChannelId", addr) channelId, err := generateChannelId() if err { log.Panicf("%v could not generate channel id", addr) return } connections[channelId] = []*websocket.Conn{} response := RequestChannelIdResponse{ ChannelId: channelId, } websocket.JSON.Send(ws, response) case "connectChannel": log.Printf("%v connectChannel", addr) // TODO: disconnect from previous channel connections[data.Channel] = append(connections[data.Channel], ws) case "send": log.Printf("%v send", addr) /* Iterate all connections */ for _, conn := range connections[data.Channel] { if conn != ws { websocket.JSON.Send(conn, data) } } default: log.Panicf("%v Unhandled message\n%v", addr, data) } } }