为什么这个 SSE 处理程序会导致客户端连接卡在待处理状态？

Question

In this example, https://github.com/kljensen/golang-html5-sse-example/blob/d4eba81ddea2b4191f039adb6929086ca6b39c0f/server.go#L130 , you can block on a channel. But doing that in my HandleExecute results in the browser/client connection status to remain stuck in a pending state and nothing gets sent to the client.

If I remove the for loop and use a select statement with a default case writing back no data, then it works ( execute writes and flushes data) except that the handler returns and the client re-connects every 5 seconds instead of maintaining the connection. When I do it that way, the client gets streamed data only on the reconnect intervals.

So users end up seeing a delay lasting anywhere less than 5 seconds depending on when HandleExecuteRequest gets hit. HandleExecute could be ready to write but the client may not have reconnected yet. I hope that makes sense.

How can I write these handlers to maintain a constant connection instead of reconnecting?

func (s *Server) HandleExecuteRequest(w http.ResponseWriter, r *http.Request) {
    err := r.ParseForm()
    if err != nil {
        log.Printf("Error parsing request: %v", err)
        fmt.Fprintf(w, "Error parsing request: %v", err)
        return
    }

    decoder := schema.NewDecoder()
    var f Form
    err = decoder.Decode(&f, r.PostForm)
    if err != nil {
        log.Printf("Error decoding form: %v", err)
        fmt.Fprintf(w, "Error decoding form: %v", err)
        return
    }

    s.clientMap[r.RemoteAddr] <- buildCommand(&f)
}

func (s *Server) HandleExecute(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    s.addClient(r)

    for {
        cmd := <-s.clientMap[r.RemoteAddr]
        execute(w, cmd)
    }
}

Javascript

var source = new EventSource('<host>/execute');
source.onmessage = function(e) {
document.querySelector("code").innerHTML +="<span class='font-weight-bold' style='white-space: pre-wrap; padding-left: 200px;'>" + e.data + "</span>" + "<br>"
};

If I update HandleExecute to below, I get a continuous connection but then HandleExecuteRequest gets stuck in pending when that is hit. It could how I'm setting up the clients and handling the channels in this case.

func (s *Server) HandleExecute(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    s.addClient(r)

    for {
        select {
        case cmd := <-s.clientMap[r.RemoteAddr]:
            execute(w, cmd)
        default:
            fmt.Fprint(w, ": no data\n\n")
        }
    }
}

Answer 1

My issue had nothing to do with how the SSE handler was set up. My channel was not being setup correctly and was blocking connections.