func (rc *RevelController) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Dirty hacks, do NOT copy! revel.MainRouter = rc.router upgrade := r.Header.Get("Upgrade") if upgrade == "websocket" || upgrade == "Websocket" { panic("Not implemented") } else { var ( req = revel.NewRequest(r) resp = revel.NewResponse(w) c = revel.NewController(req, resp) ) req.Websocket = nil revel.Filters[0](c, revel.Filters[1:]) if c.Result != nil { c.Result.Apply(req, resp) } else if c.Response.Status != 0 { panic("Not implemented") } // Close the Writer if we can if w, ok := resp.Out.(io.Closer); ok { w.Close() } } }
// echoReadAll echoes messages from the client by reading the entire message // with ioutil.ReadAll. func echoReadAll(w http.ResponseWriter, r *http.Request, writeMessage bool) { conn, err := websocket.Upgrade(w, r.Header, nil, 4096, 4096) if err != nil { log.Println("Upgrade:", err) http.Error(w, "Bad request", 400) return } defer conn.Close() for { op, r, err := conn.NextReader() if err != nil { if err != io.EOF { log.Println("NextReader:", err) } return } if op == websocket.OpPong { continue } if op == websocket.OpText { r = &validator{r: r} } b, err := ioutil.ReadAll(r) if err != nil { if err == errInvalidUTF8 { conn.WriteControl(websocket.OpClose, websocket.FormatCloseMessage(websocket.CloseInvalidFramePayloadData, ""), time.Time{}) } log.Println("ReadAll:", err) return } if writeMessage { err = conn.WriteMessage(op, b) if err != nil { log.Println("WriteMessage:", err) } } else { w, err := conn.NextWriter(op) if err != nil { log.Println("NextWriter:", err) return } if _, err := w.Write(b); err != nil { log.Println("Writer:", err) return } if err := w.Close(); err != nil { log.Println("Close:", err) return } } } }
// echoCopy echoes messages from the client using io.Copy. func echoCopy(w http.ResponseWriter, r *http.Request, writerOnly bool) { conn, err := websocket.Upgrade(w, r.Header, nil, 4096, 4096) if err != nil { log.Println("Upgrade:", err) http.Error(w, "Bad request", 400) return } defer conn.Close() for { op, r, err := conn.NextReader() if err != nil { if err != io.EOF { log.Println("NextReader:", err) } return } if op == websocket.OpPong { continue } if op == websocket.OpText { r = &validator{r: r} } w, err := conn.NextWriter(op) if err != nil { log.Println("NextWriter:", err) return } if op == websocket.OpText { r = &validator{r: r} } if writerOnly { _, err = io.Copy(struct{ io.Writer }{w}, r) } else { _, err = io.Copy(w, r) } if err != nil { if err == errInvalidUTF8 { conn.WriteControl(websocket.OpClose, websocket.FormatCloseMessage(websocket.CloseInvalidFramePayloadData, ""), time.Time{}) } log.Println("Copy:", err) return } err = w.Close() if err != nil { log.Println("Close:", err) return } } }
func (t wsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { t.Log("HELLOOO") if r.Method != "GET" { http.Error(w, "Method not allowed", 405) t.Logf("bad method: %s", r.Method) return } if r.Header.Get("Origin") != "http://"+r.Host { http.Error(w, "Origin not allowed", 403) t.Logf("bad origin: %s", r.Header.Get("Origin")) return } ws, err := websocket.Upgrade(w, r.Header, "", 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { t.Logf("bad handshake: %v", err) http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { t.Logf("upgrade error: %v", err) return } defer ws.Close() for { op, r, err := ws.NextReader() if err != nil { if err != io.EOF { t.Logf("NextReader: %v", err) } return } if op == websocket.OpPong { continue } w, err := ws.NextWriter(op) if err != nil { t.Logf("NextWriter: %v", err) return } if _, err = io.Copy(w, r); err != nil { t.Logf("Copy: %v", err) return } if err := w.Close(); err != nil { t.Logf("Close: %v", err) return } } }
// echoCopy echoes messages from the client using io.Copy. func echoCopy(w http.ResponseWriter, r *http.Request, writerOnly bool) { conn, err := upgrader.Upgrade(w, r, nil) if err != nil { log.Println("Upgrade:", err) return } defer conn.Close() for { mt, r, err := conn.NextReader() if err != nil { if err != io.EOF { log.Println("NextReader:", err) } return } if mt == websocket.TextMessage { r = &validator{r: r} } w, err := conn.NextWriter(mt) if err != nil { log.Println("NextWriter:", err) return } if mt == websocket.TextMessage { r = &validator{r: r} } if writerOnly { _, err = io.Copy(struct{ io.Writer }{w}, r) } else { _, err = io.Copy(w, r) } if err != nil { if err == errInvalidUTF8 { conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseInvalidFramePayloadData, ""), time.Time{}) } log.Println("Copy:", err) return } err = w.Close() if err != nil { log.Println("Close:", err) return } } }
func (s *LiveServer) HandleWebSocket(w http.ResponseWriter, r *http.Request) { conn, err, closed := websocket.Upgrade(w, r, s.websocketOrigin, "") if err != nil { log.StandardError(err) if !closed { serve400(w, r) } return } logRequest(HTTP_WEBSOCKET, http.StatusOK, r) conn.SetReadMaxSize(1 << 20) reads := make(chan []byte, 1) quit := make(chan bool, 1) writes := make(chan []byte, 1) tick := time.NewTicker(pingInterval) go readWebSocket(conn, reads, quit) defer func() { tick.Stop() conn.Close() }() for { select { case <-tick.C: err = conn.WriteControl(websocket.OpPing, pingData, time.Now().Add(pingInterval)) if err != nil { log.Error("websocket: failed on ping: %s", err) return } case read := <-reads: writes <- read case write := <-writes: w, err := conn.NextWriter(websocket.OpText) if err != nil { log.Error("websocket: failed on NextWriter: %s", err) return } n, err := w.Write(write) w.Close() if n != len(write) || err != nil { log.Error("websocket: failed on write: %s", err) return } case <-quit: return } } }
func (t handshakeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { if r.Method != "GET" { http.Error(w, "Method not allowed", 405) t.Logf("method = %s, want GET", r.Method) return } subprotos := Subprotocols(r) if !reflect.DeepEqual(subprotos, handshakeDialer.Subprotocols) { http.Error(w, "bad protocol", 400) t.Logf("Subprotocols = %v, want %v", subprotos, handshakeDialer.Subprotocols) return } ws, err := handshakeUpgrader.Upgrade(w, r, http.Header{"Set-Cookie": {"sessionID=1234"}}) if err != nil { t.Logf("upgrade error: %v", err) return } defer ws.Close() if ws.Subprotocol() != "p1" { t.Logf("ws.Subprotocol() = %s, want p1", ws.Subprotocol()) return } for { op, r, err := ws.NextReader() if err != nil { if err != io.EOF { t.Logf("NextReader: %v", err) } return } w, err := ws.NextWriter(op) if err != nil { t.Logf("NextWriter: %v", err) return } if _, err = io.Copy(w, r); err != nil { t.Logf("Copy: %v", err) return } if err := w.Close(); err != nil { t.Logf("Close: %v", err) return } } }
// echoReadAll echoes messages from the client by reading the entire message // with ioutil.ReadAll. func echoReadAll(w http.ResponseWriter, r *http.Request, writeMessage bool) { conn, err := websocket.Upgrade(w, r, nil, 4096, 4096) if err != nil { log.Println("Upgrade:", err) http.Error(w, "Bad request", 400) return } defer conn.Close() for { mt, b, err := conn.ReadMessage() if err != nil { if err != io.EOF { log.Println("NextReader:", err) } return } if mt == websocket.TextMessage { if !utf8.Valid(b) { conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseInvalidFramePayloadData, ""), time.Time{}) log.Println("ReadAll: invalid utf8") } } if writeMessage { err = conn.WriteMessage(mt, b) if err != nil { log.Println("WriteMessage:", err) } } else { w, err := conn.NextWriter(mt) if err != nil { log.Println("NextWriter:", err) return } if _, err := w.Write(b); err != nil { log.Println("Writer:", err) return } if err := w.Close(); err != nil { log.Println("Close:", err) return } } } }
func handleInternal(w http.ResponseWriter, r *http.Request, ws *websocket.Conn) { var ( req = NewRequest(r) resp = NewResponse(w) c = NewController(req, resp) ) req.Websocket = ws Filters[0](c, Filters[1:]) if c.Result != nil { c.Result.Apply(req, resp) } else if c.Response.Status != 0 { c.Response.Out.WriteHeader(c.Response.Status) } // Close the Writer if we can if w, ok := resp.Out.(io.Closer); ok { w.Close() } }
func echo(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Upgrade(w, r.Header, nil, 1024, 1024) if err != nil { http.Error(w, err.Error(), 400) return } defer conn.Close() for { op, r, err := conn.NextReader() if err != nil { return } if op != websocket.OpBinary && op != websocket.OpText { continue } w, err := conn.NextWriter(op) if err != nil { return } io.Copy(w, r) w.Close() } }
func handleInternal(w http.ResponseWriter, r *http.Request, ws *websocket.Conn) { // TODO For now this okay to put logger here for all the requests // However, it's best to have logging handler at server entry level start := time.Now() var ( req = NewRequest(r) resp = NewResponse(w) c = NewController(req, resp) ) req.Websocket = ws Filters[0](c, Filters[1:]) if c.Result != nil { c.Result.Apply(req, resp) } else if c.Response.Status != 0 { c.Response.Out.WriteHeader(c.Response.Status) } // Close the Writer if we can if w, ok := resp.Out.(io.Closer); ok { w.Close() } // Revel request access log format // RequestStartTime ClientIP ResponseStatus RequestLatency HTTPMethod URLPath // Sample format: // 2016/05/25 17:46:37.112 127.0.0.1 200 270.157µs GET / requestLog.Printf("%v %v %v %10v %v %v", start.Format(requestLogTimeFormat), ClientIP(r), c.Response.Status, time.Since(start), r.Method, r.URL.Path, ) }
func (h *KagomeDemoHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { type record struct { Surface string Pos string Baseform string Reading string Pronounciation string } sen := r.FormValue("s") opt := r.FormValue("r") var records []record var tokens []kagome.Token var svg string var cmdErr string const cmdTimeout = 30 * time.Second switch opt { case "1": // normal tokens = h.tokenizer.Tokenize(sen) case "2": // search tokens = h.tokenizer.SearchModeTokenize(sen) case "3": // extended tokens = h.tokenizer.ExtendedModeTokenize(sen) case "4": // lattice if _, e := exec.LookPath("dot"); e != nil { log.Print("graphviz is not in your future\n") break } var buf bytes.Buffer cmd := exec.Command("dot", "-Tsvg") r, w := io.Pipe() cmd.Stdin = r cmd.Stdout = &buf cmd.Stderr = os.Stderr cmd.Start() h.tokenizer.Dot(sen, w) w.Close() done := make(chan error, 1) //XXX go func() { done <- cmd.Wait() }() select { case <-time.After(cmdTimeout): if err := cmd.Process.Kill(); err != nil { log.Fatal("failed to kill: ", err) } cmdErr = "Time out" <-done case err := <-done: if err != nil { cmdErr = "Error" log.Printf("process done with error = %v", err) } } svg = buf.String() if pos := strings.Index(svg, "<svg"); pos > 0 { svg = svg[pos:] } } for _, tok := range tokens { if tok.Id == kagome.BosEosId { continue } m := record{Surface: tok.Surface} fs := tok.Features() switch len(fs) { case 9: m.Pos = strings.Join(fs[0:5], ",") m.Baseform = fs[6] m.Reading = fs[7] m.Pronounciation = fs[8] case 7: m.Pos = strings.Join(fs[0:5], ",") m.Baseform = fs[6] m.Reading = "*" m.Pronounciation = "*" case 3: m.Pos = fs[0] m.Baseform = fs[1] m.Reading = fs[2] m.Pronounciation = "*" } records = append(records, m) } d := struct { Sentence string Tokens []record CmdErr string GraphSvg template.HTML RadioOpt string }{Sentence: sen, Tokens: records, CmdErr: cmdErr, GraphSvg: template.HTML(svg), RadioOpt: opt} t := template.Must(template.New("top").Parse(demo_html)) t.Execute(w, d) }
// The handlers func xhrHandlerBase(opts xhrOptions, r *Router, w http.ResponseWriter, req *http.Request) { if xhrProlog(w, req) { return } xhrJsessionid(r, w, req) w.Header().Set("Content-type", opts.contentType()) // For CORS, if the server sent Access-Control-Request-Headers, we // echo it back. acrh := req.Header.Get("Access-Control-Request-Headers") if acrh != "" { w.Header().Set("Access-Control-Allow-Headers", acrh) } sessionId := mux.Vars(req)["sessionid"] w.WriteHeader(http.StatusOK) opts.writePrelude(w) hijackAndContinue(w, func(w io.WriteCloser, done chan struct{}) { defer w.Close() var trans *xhrTransport // Find the session s, _ := r.getOrCreateSession(sessionId) s.sessionLock.Lock() // TODO: encapsulate this logic var sessionUnlocked bool defer func() { if !sessionUnlocked { s.sessionLock.Unlock() } }() if s.trans != nil { if s.closed { s.trans.writeFrame(w, closeFrame(3000, "Go away!")) return } var ok bool trans, ok = s.trans.(*xhrTransport) if !ok { s.trans.writeFrame(w, closeFrame(1001, "Another kind of connection is using this session")) return } } else { trans = new(xhrTransport) trans.opts = opts s.trans = trans trans.s = s trans.writeFrame(w, openFrame()) conn := &Conn{s} go r.handler(conn) if !opts.streaming() { w.Close() return } } s.sessionLock.Unlock() sessionUnlocked = true var leavingVoluntarily bool loopDone := make(chan bool) recvDone := make(chan bool) go func() { defer close(loopDone) defer w.Close() select { case <-recvDone: leavingVoluntarily = true return case <-done: return } }() err := trans.setReceiver(&xhrReceiver{t: trans, w: w, opts: opts, closed: recvDone}) if err != nil { return } defer trans.clearReceiver() // The session may already have closed from underneath us! // If so, die now if s.closed { return } <-loopDone // If the session isn't closed, and we're not closing voluntarily, then // assume the client closed us and close the session. if !leavingVoluntarily && !s.closed { trans.clearReceiver() s.Close() r.removeSession(sessionId, s) } }) }
func (s *MonitorServer) postContainersAttach(version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error { if err := parseForm(r); err != nil { return err } if vars == nil { return fmt.Errorf("Missing parameter") } inStream, outStream, err := hijackServer(w) if err != nil { return err } defer func() { if tcpc, ok := inStream.(*net.TCPConn); ok { tcpc.CloseWrite() } else { inStream.Close() } }() defer func() { if tcpc, ok := outStream.(*net.TCPConn); ok { tcpc.CloseWrite() } else if closer, ok := outStream.(io.Closer); ok { closer.Close() } }() var errStream io.Writer fmt.Fprintf(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n") /* !tty & api>1.6 errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr) outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout) */ errStream = outStream var ( logs = boolValue(r, "logs") stream = boolValue(r, "stream") stdin = boolValue(r, "stdin") stdout = boolValue(r, "stdout") stderr = boolValue(r, "stderr") ) container := s.monitor.Container() //logs if logs { cLog, err := container.ReadLog("json") if err != nil && os.IsNotExist(err) { // Legacy logs log.Debugf("Old logs format") if stdout { cLog, err := container.ReadLog("stdout") if err != nil { log.Errorf("Error reading logs (stdout): %s", err) } else if _, err := io.Copy(outStream, cLog); err != nil { log.Errorf("Error streaming logs (stdout): %s", err) } } if stderr { cLog, err := container.ReadLog("stderr") if err != nil { log.Errorf("Error reading logs (stderr): %s", err) } else if _, err := io.Copy(errStream, cLog); err != nil { log.Errorf("Error streaming logs (stderr): %s", err) } } } else if err != nil { log.Errorf("Error reading logs (json): %s", err) } else { dec := json.NewDecoder(cLog) for { l := &jsonlog.JSONLog{} if err := dec.Decode(l); err == io.EOF { break } else if err != nil { log.Errorf("Error streaming logs: %s", err) break } if l.Stream == "stdout" && stdout { io.WriteString(outStream, l.Log) } if l.Stream == "stderr" && stderr { io.WriteString(errStream, l.Log) } } } } //stream if stream { var ( cStdin io.ReadCloser cStdout, cStderr io.Writer cStdinCloser io.Closer ) if stdin { r, w := io.Pipe() go func() { defer w.Close() defer log.Debugf("Closing buffered stdin pipe") io.Copy(w, inStream) }() cStdin = r cStdinCloser = inStream } if stdout { cStdout = outStream } if stderr { cStderr = errStream } <-s.Attach(&container.StreamConfig, container.Config.OpenStdin, container.Config.StdinOnce, container.Config.Tty, cStdin, cStdinCloser, cStdout, cStderr) close(s.AttachSignal) // If we are in stdinonce mode, wait for the process to end // otherwise, simply return if container.Config.StdinOnce && !container.Config.Tty { container.WaitStop(-1 * time.Second) } } return nil }