func (fl *fakeLoggregator) ServeHTTP(w http.ResponseWriter, r *http.Request) { fl.receivedRequests = append(fl.receivedRequests, r) ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { Fail("Bad Handshake") return } else if err != nil { Fail("Upgrade Close") return } defer ws.Close() r.ParseForm() for _, msg := range fl.messages { ws.WriteMessage(websocket.BinaryMessage, []byte(msg)) } for { _, _, err := ws.ReadMessage() if err == nil { fl.numKeepAlives++ continue } return } }
func socket(w http.ResponseWriter, r *http.Request) { log.Print("connection established") if _case == "hang" { hang := time.Minute log.Printf("hanging for %s\n", hang.String()) time.Sleep(hang) } ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if err != nil { log.Print(err) return } defer func() { ws.Close() log.Print("connection closed") }() for { msgt, msg, err := ws.ReadMessage() if err != nil { log.Print(err) return } log.Print("rcvd: '" + string(msg) + "'") ws.WriteMessage(msgt, msg) } }
func wsHandler(w http.ResponseWriter, r *http.Request) { // Websocket handshake. ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { return } addr := ws.RemoteAddr() log.Printf("Websocket accepted: %s\n", addr) // Creating player. one := newPlayer(ws) // Adding player to sector. mainSector.addPlayer(one) // Spawing writing goroutine. go one.writer() // Sending player identification. one.ident() // Blocking this function on a reader. one.reader() // Reader has stopped, good bye! log.Printf("Websocket finalized: %s", addr) }
func serveWs(w http.ResponseWriter, r *http.Request) { if r.Method != "GET" { http.Error(w, "Method not allowed", 405) return } // Read request details. r.ParseForm() iface := r.FormValue("if") if iface == "" { iface = "eth0" } ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } c := &connection{send: make(chan []byte, 256), ws: ws, iface: iface} h.register <- c go c.writePump() c.readPump() }
func websocketHandler(w http.ResponseWriter, r *http.Request) { conn, _ := websocket.Upgrade(w, r, nil, 1024, 1024) addConnection(conn) listen(conn) }
func wsHandler(w http.ResponseWriter, r *http.Request, _ httprouter.Params) { fmt.Println(r.Method) // Taken from gorilla's website conn, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } log.Println("Succesfully upgraded connection") connections[conn] = true for { // Blocks until a message is read _, msg, err := conn.ReadMessage() if err != nil { delete(connections, conn) conn.Close() return } log.Println(string(msg)) sendAll(msg) } }
// Join method handles WebSocket requests for WebSocketController. func (this *WebSocketController) Join() { uname := this.GetString("uname") if len(uname) == 0 { this.Redirect("/", 302) return } // Upgrade from http request to WebSocket. ws, err := websocket.Upgrade(this.Ctx.ResponseWriter, this.Ctx.Request, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(this.Ctx.ResponseWriter, "Not a websocket handshake", 400) return } else if err != nil { beego.Error("Cannot setup WebSocket connection:", err) return } // Join chat room. Join(uname, ws) defer Leave(uname) // Message receive loop. for { _, p, err := ws.ReadMessage() if err != nil { return } publish <- newEvent(models.EVENT_MESSAGE, uname, string(p)) } }
func serveWs(w http.ResponseWriter, r *http.Request) { log.Print("serveWs") session, _ := store.Get(r, "session-name") if session.IsNew { log.Printf("rejecting ws without session from %v", r.RemoteAddr) return } ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { log.Printf("rejecting ws with bad handshake from %v", r.RemoteAddr) http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Printf("serveWs error: %s", err.Error()) return } log.Printf("serveWs ws connection from %v", r.RemoteAddr) c := &wsconn{send: make(chan []byte, 256), ws: ws} h.register <- c defer func() { h.unregister <- c }() go c.writer() c.reader() }
func notificationWSHandler(w http.ResponseWriter, r *http.Request) { sid := r.URL.Query()["sid"][0] cSession := coditorSessions.get(sid) if nil == cSession { return } conn, _ := websocket.Upgrade(w, r, nil, 1024, 1024) wsChan := util.WSChannel{Sid: sid, Conn: conn, Request: r, Time: time.Now()} ret := map[string]interface{}{"notification": "Notification initialized", "cmd": "init-notification"} err := wsChan.WriteJSON(&ret) if nil != err { return } notificationWS[sid] = &wsChan logger.Tracef("Open a new [Notification] with session [%s], %d", sid, len(notificationWS)) // add user event handler cSession.EventQueue.addHandler(eventHandleFunc(event2Notification)) input := map[string]interface{}{} for { if err := wsChan.ReadJSON(&input); err != nil { return } } }
func (h *hub) handleConn(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Upgrade(w, r, nil, 0, 0) ok(err) s := &stream{h: h, conn: conn} for { _, buf, err := conn.ReadMessage() if isReadFromClosedConnError(err) { log.Printf("conn closed: %v", err) break } ok(err) // TODO: Avoid decoding multiple times. var mt MsgType ok(json.Unmarshal(buf, &mt)) switch mt.Type { case "SubscribeC2S": var msg SubscribeC2S ok(json.Unmarshal(buf, &msg)) ok(s.processSubscribeC2S(&msg)) case "SubscribeI2R": var msg SubscribeI2R ok(json.Unmarshal(buf, &msg)) ok(s.processSubscribeI2R(&msg)) case "PatchC2S": var msg PatchC2S ok(json.Unmarshal(buf, &msg)) ok(s.processPatchC2S(&msg)) default: panic(fmt.Errorf("unknown message type: %s", mt.Type)) } } conn.Close() }
func (b BackendController) WsHandler(writer http.ResponseWriter, request *http.Request) { conn, err := websocket.Upgrade(writer, request, nil, 1024, 1024) log.Println("getting a connection") if _, ok := err.(websocket.HandshakeError); ok { http.Error(writer, "got a websocket handshake", 400) return } else if err != nil { log.Println(err) return } b.ConnectionHandler(conn) defer b.CleanUpHandler(conn) // if this function ever exits, clean up the data defer delete(b.connections, conn) // if this function ever exits, clean up the data b.connections[conn] = true for { _, msg, err := conn.ReadMessage() if err != nil { return } b.EventHandler(msg, conn) } }
func (w *WebsocketServer) ServeHTTP(writer http.ResponseWriter, request *http.Request) { w.logger.Debug("WebsocketServer.ServeHTTP: starting") var handler wsHandler var err error paths := strings.Split(request.URL.Path, "/") endpointName := paths[1] if endpointName == "firehose" { handler, err = w.firehoseHandler(paths, writer, request) } else { handler, err = w.appHandler(paths, writer, request) } if err != nil { w.logger.Errorf("WebsocketServer.ServeHTTP: %s", err.Error()) return } ws, err := gorilla.Upgrade(writer, request, nil, 1024, 1024) if err != nil { w.logger.Errorf("WebsocketServer.ServeHTTP: Upgrade error (returning 400): %s", err.Error()) http.Error(writer, err.Error(), 400) return } defer func() { ws.WriteControl(gorilla.CloseMessage, gorilla.FormatCloseMessage(gorilla.CloseNormalClosure, ""), time.Time{}) ws.Close() }() handler(ws) }
// Upgrade the connection to a websocket connection func upgradeRequest(resp http.ResponseWriter, req *http.Request, o *Options) (*websocket.Conn, int, error) { if req.Method != "GET" { o.log("Method %s is not allowed", LogLevelWarning, req.RemoteAddr, req.Method) return nil, http.StatusMethodNotAllowed, errors.New("Method not allowed") } allowedOrigin := replacementRegexp.ReplaceAllString(o.AllowedOrigin, req.Host) if r, err := regexp.MatchString(allowedOrigin, req.Header.Get("Origin")); !r || err != nil { o.log("Origin %s is not allowed", LogLevelWarning, req.RemoteAddr, req.Host) return nil, http.StatusForbidden, errors.New("Origin not allowed") } o.log("Request to %s has been allowed for origin %s", LogLevelDebug, req.RemoteAddr, req.Host, req.Header.Get("Origin")) ws, err := websocket.Upgrade(resp, req, nil, 1024, 1024) if handshakeErr, ok := err.(websocket.HandshakeError); ok { o.log("Handshake failed: %s", LogLevelWarning, req.RemoteAddr, handshakeErr) return nil, http.StatusBadRequest, handshakeErr } else if err != nil { o.log("Handshake failed: %s", LogLevelWarning, req.RemoteAddr, err) return nil, http.StatusBadRequest, err } o.log("Connection established", LogLevelInfo, req.RemoteAddr) return ws, http.StatusOK, nil }
func (w *WebsocketServer) ServeHTTP(rw http.ResponseWriter, r *http.Request) { var handler func(string, *gorilla.Conn) switch r.URL.Path { case TAIL_LOGS_PATH: handler = w.streamLogs case RECENT_LOGS_PATH: handler = w.recentLogs case DUMP_LOGS_PATH: handler = w.recentLogs default: http.Error(rw, "invalid path "+r.URL.Path, 400) return } appId, err := w.validate(r) if err != nil { http.Error(rw, err.Error(), 400) return } ws, err := gorilla.Upgrade(rw, r, nil, 1024, 1024) if err != nil { http.Error(rw, err.Error(), 400) return } defer ws.Close() defer ws.WriteControl(gorilla.CloseMessage, gorilla.FormatCloseMessage(gorilla.CloseNormalClosure, ""), time.Time{}) handler(appId, ws) }
func (f *fakeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { if r.Method == "HEAD" { w.WriteHeader(http.StatusOK) return } if r.Method != "GET" { http.Error(w, "Method not allowed", 405) return } ws, err := websocket.Upgrade(w, r, nil, 0, 0) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } defer ws.Close() defer ws.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""), time.Time{}) f.Lock() f.lastWSConn = ws f.Unlock() go ws.ReadMessage() for msg := range f.messages { if err := ws.WriteMessage(websocket.BinaryMessage, msg); err != nil { return } } }
func slashws(w http.ResponseWriter, req *http.Request) { if req.Method != "GET" { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } if req.Header.Get("Origin") != "http://"+req.Host { http.Error(w, "Forbidden", http.StatusForbidden) return } ws, err := websocket.Upgrade(w, req, nil, 1024, 1024) if err != nil { if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "websocket.Upgrade errd", http.StatusBadRequest) return } panic(err) } wc := &wclient{ws: ws, ping: make(chan bool, 1)} register <- wc defer func() { unregister <- wc }() go wc.waitfor_messages() // read from client wc.waitfor_updates() // write to client }
func (h *sockethub) WsHandler(w http.ResponseWriter, r *http.Request) { var authenticated bool if h.Auth != nil { authenticated = h.Auth(r) } if authenticated { ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Printf("WsHandler error: %s", err.Error()) return } c := &connection{send: make(chan *Data), ws: ws} h.register <- c defer func() { h.unregister <- c }() go c.writer() c.reader() } else { http.Error(w, "Invalid API key", 401) } }
/* HTTP handler that can be dropped into the standard http handlers list */ func FayeHandler(server faye.Server) http.Handler { // websocketHandler := websocket.Handler(transport.WebsocketServer(server)) return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Header.Get("Upgrade") == "websocket" { ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } transport.WebsocketServer(server)(ws) } else { if r.Method == "POST" { var v interface{} dec := json.NewDecoder(r.Body) if err := dec.Decode(&v); err == nil { transport.MakeLongPoll(v, server, w) } else { log.Fatal(err) } } } }) }
func (ws *WebServer) wsHandler(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Upgrade(w, r, nil, 1024*1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", http.StatusBadRequest) return } else if err != nil { log.Print(err) return } for { messageType, p, err := conn.ReadMessage() if err != nil { return } if messageType == websocket.TextMessage { msg := string(p) parts := strings.Split(msg, ",") speedStr, angleStr := parts[0], parts[1] _, err = ws.setOrientation(speedStr, angleStr) if err != nil { log.Print(err) } } } }
// serverWs handles webocket requests from the peer. func serveWs(w http.ResponseWriter, r *http.Request) { if r.Method != "GET" { http.Error(w, "Method not allowed", 405) return } /* if r.Header.Get("Origin") != "http://"+r.Host { log.Println("403") http.Error(w, "Origin not allowed", 403) return } */ ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } c := &connection{send: make(chan []byte, 256), ws: ws} h.register <- c go c.writePump() c.readPump() }
func Handler(w http.ResponseWriter, r *http.Request) { c, err := websocket.Upgrade(w, r, nil, 1024, 1024) if err != nil { log.Println(err) return } s := NewSession() go func() { for m := range s.m { if err := c.WriteJSON(m); err != nil { if err != io.EOF { log.Println(err) } return } } }() for { m := new(Message) if err := c.ReadJSON(m); err != nil { if err != io.EOF { log.Println(err) } return } if err := s.Handle(m); err != nil { log.Println(err) } } }
func serveWs(w http.ResponseWriter, r *http.Request) { if r.Method != "GET" { http.Error(w, "Method not allowed", 405) return } // TODO: Add origin check / CORS support ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } if r.URL.Path == "/ws/v1/data" { c := &connection{send: make(chan []byte, 256), ws: ws} h.register <- c go c.writePump() } else if r.URL.Path == "/ws/v1/control" { fmt.Println("Got registration") } }
func (s *Server) websocketHandler(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) blockId, ok := vars["id"] if !ok { s.apiWrap(w, r, 500, s.response("must specify block ID to connect")) return } if r.Method != "GET" { http.Error(w, "Method not allowed", 405) return } w.Header().Set("Access-Control-Allow-Origin", "*") /*if r.Header.Get("Origin") != "http://"+r.Host { http.Error(w, "Origin not allowed", 403) return }*/ ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { s.apiWrap(w, r, 500, s.response("Not a websocket handshake")) return } else if err != nil { //log.Println(err) return } c := &connection{send: make(chan []byte, 256), ws: ws} s.manager.Mu.Lock() blockChan, connId, err := s.manager.GetSocket(vars["id"]) s.manager.Mu.Unlock() if err != nil { s.apiWrap(w, r, 500, s.response(err.Error())) return } ticker := time.NewTicker((10 * time.Second * 9) / 10) go func(c *connection, bChan chan *blocks.Msg, cId string, bId string) { defer func() { s.manager.Mu.Lock() _ = s.manager.DeleteSocket(bId, cId) s.manager.Mu.Unlock() ticker.Stop() c.ws.Close() }() for { select { case msg := <-bChan: message, _ := json.Marshal(msg.Msg) if err := c.write(websocket.TextMessage, message); err != nil { return } case <-ticker.C: if err := c.write(websocket.PingMessage, []byte{}); err != nil { return } } } }(c, blockChan, connId, blockId) }
// wsHandler eleva la conexio http con el cliente a websockets func wsHandler(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } defer conn.Close() var data struct { UserName string `json:"userName"` UID int32 `json:"uid"` } if err := conn.ReadJSON(&data); err != nil { log.Fatal(err) return } if p, ok := players[data.UID]; ok { p.Conn = conn log.Println("El jugador con uid", data.UID, "inició conexión websocket") } else { log.Println("EL jugador con uid", data.UID, "no tiene sesión iniciada") return } }
func socketHandler(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "go home, you're not a socket, you're drunk", 400) return } else if err != nil { log.Println(err) return } log.Println("new client") defer log.Println("client closed") conn.WriteMessage(websocket.TextMessage, []byte("hello")) // TODO: handle timing out; don't want to have these linger for { typ, msg, err := conn.ReadMessage() log.Println(string(msg)) if err != nil { return } if err := conn.WriteMessage(typ, msg); err != nil { return } } }
func socketHandler(w http.ResponseWriter, r *http.Request) { c, err := websocket.Upgrade(w, r, nil, 1024, 1024) if err != nil { log.Println(err) return } u, err := ui.New() if err != nil { log.Println(err) return } defer u.Close() go func() { for m := range u.M { if err := c.WriteJSON(m); err != nil { log.Println(err) return } } }() for { m := new(ui.Message) if err := c.ReadJSON(m); err != nil { log.Println(err) return } if err := u.Handle(m); err != nil { log.Println(err) } } }
// WSHandler handles request of creating editor channel. // XXX: NOT used at present func WSHandler(w http.ResponseWriter, r *http.Request) { httpSession, _ := session.HTTPSession.Get(r, "wide-session") if httpSession.IsNew { http.Error(w, "Forbidden", http.StatusForbidden) return } sid := httpSession.Values["id"].(string) conn, _ := websocket.Upgrade(w, r, nil, 1024, 1024) editorChan := util.WSChannel{Sid: sid, Conn: conn, Request: r, Time: time.Now()} ret := map[string]interface{}{"output": "Editor initialized", "cmd": "init-editor"} err := editorChan.WriteJSON(&ret) if nil != err { return } session.EditorWS[sid] = &editorChan logger.Tracef("Open a new [Editor] with session [%s], %d", sid, len(session.EditorWS)) args := map[string]interface{}{} for { if err := session.EditorWS[sid].ReadJSON(&args); err != nil { return } code := args["code"].(string) line := int(args["cursorLine"].(float64)) ch := int(args["cursorCh"].(float64)) offset := getCursorOffset(code, line, ch) logger.Tracef("offset: %d", offset) gocode := util.Go.GetExecutableInGOBIN("gocode") argv := []string{"-f=json", "autocomplete", strconv.Itoa(offset)} var output bytes.Buffer cmd := exec.Command(gocode, argv...) cmd.Stdout = &output stdin, _ := cmd.StdinPipe() cmd.Start() stdin.Write([]byte(code)) stdin.Close() cmd.Wait() ret = map[string]interface{}{"output": string(output.Bytes()), "cmd": "autocomplete"} if err := session.EditorWS[sid].WriteJSON(&ret); err != nil { logger.Error("Editor WS ERROR: " + err.Error()) return } } }
func makeTestHandler(keepAliveCompleted chan struct{}) http.Handler { return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { conn, _ := websocket.Upgrade(rw, req, nil, 0, 0) go conn.ReadMessage() server.NewKeepAlive(conn, 50*time.Millisecond).Run() close(keepAliveCompleted) }) }
func upgrade(w http.ResponseWriter, r *http.Request) *websocket.Conn { ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if err != nil { http.Error(w, "Not a websocket handshake", 400) return nil } return ws }
func (this *Server) initSocketListener() { Connect := func(w http.ResponseWriter, r *http.Request) { if r.Method != "GET" { http.Error(w, "Method not allowed", 405) return } //if r.Header.Get("Origin") != "http://"+r.Host { // http.Error(w, "Origin not allowed", 403) // return // } ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { log.Println(err) return } defer func() { ws.Close() if DEBUG { log.Println("Socket Closed") } }() sock := newSocket(ws, nil, this, "") if DEBUG { log.Printf("Socket connected via %s\n", ws.RemoteAddr()) } if err := sock.Authenticate(""); err != nil { if DEBUG { log.Printf("Error: %s\n", err.Error()) } return } go sock.listenForMessages() go sock.listenForWrites() if this.timeout <= 0 { // if timeout is 0 then wait forever and return when socket is done. <-sock.done return } select { case <-time.After(this.timeout * time.Second): sock.Close() return case <-sock.done: return } } http.HandleFunc("/socket", Connect) }