Skip to content

Take control over your live stream video by running it yourself. Streaming + chat out of the box.

fix(sse): stream small responses immediately (#5173)

Gabe Kangas5322b8ea3fd9
diff --git a/services/plugins/server.go b/services/plugins/server.go
index 76a5638b41..cbae884485 100644
--- a/services/plugins/server.go
+++ b/services/plugins/server.go
@@ -328,6 +328,9 @@ func (s *Server) serveSSE(w http.ResponseWriter, r *http.Request, p *Loaded, cha
h.Set("Cache-Control", "no-cache")
h.Set("Connection", "keep-alive")
w.WriteHeader(http.StatusOK)
+ if _, err := io.WriteString(w, ": connected\n\n"); err != nil {
+ return
+ }
flusher.Flush()
keepAlive := time.NewTicker(SSEKeepAliveInterval)
diff --git a/services/plugins/server_sse_test.go b/services/plugins/server_sse_test.go
index a85548ec9c..924198a6c8 100644
--- a/services/plugins/server_sse_test.go
+++ b/services/plugins/server_sse_test.go
@@ -93,7 +93,7 @@ func TestServer_SSE_StreamsPublishedFrames(t *testing.T) {
srv := httptest.NewServer(sseServer(t, []string{"http.sse"}, hub))
defer srv.Close()
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, "GET", srv.URL+"/plugins/demo"+tc.path, nil)
if err != nil {
@@ -111,6 +111,14 @@ func TestServer_SSE_StreamsPublishedFrames(t *testing.T) {
if ct := resp.Header.Get("Content-Type"); ct != "text/event-stream" {
t.Errorf("Content-Type = %q want text/event-stream", ct)
}
+ reader := bufio.NewReader(resp.Body)
+ line, err := reader.ReadString('\n')
+ if err != nil {
+ t.Fatal(err)
+ }
+ if line != ": connected\n" {
+ t.Fatalf("initial SSE line = %q, want %q", line, ": connected\n")
+ }
// The handler subscribes on its own goroutine; wait for it before
// publishing so the frame isn't dropped before anyone's listening.
@@ -120,7 +128,7 @@ func TestServer_SSE_StreamsPublishedFrames(t *testing.T) {
t.Fatalf("expected delivery to the connected client, got %d", n)
}
- frame := readSSEFrame(t, resp.Body)
+ frame := readSSEFrame(t, reader)
if !strings.Contains(frame, "event: emoji\n") || !strings.Contains(frame, "data: 🦉\n") {
t.Errorf("unexpected SSE frame: %q", frame)
}
diff --git a/webserver/router/compression_test.go b/webserver/router/compression_test.go
new file mode 100644
index 0000000000..838617d518
--- /dev/null
+++ b/webserver/router/compression_test.go
@@ -0,0 +1,108 @@
+package router
+
+import (
+ "bufio"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+ "time"
+)
+
+func TestHTTPCompressionAdapterStreamsSSEWithoutCompression(t *testing.T) {
+ compress, err := newHTTPCompressionAdapter()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ flushed := make(chan struct{})
+ release := make(chan struct{})
+
+ handler := compress(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ w.Header().Set("Content-Type", "text/event-stream")
+ w.WriteHeader(http.StatusOK)
+ if _, err := io.WriteString(w, ": connected\n\n"); err != nil {
+ t.Error(err)
+ return
+ }
+ w.(http.Flusher).Flush()
+ close(flushed)
+ <-release
+ }))
+ server := httptest.NewServer(handler)
+ defer server.Close()
+ defer close(release)
+
+ client := &http.Client{Transport: &http.Transport{DisableCompression: true}}
+ req, err := http.NewRequest(http.MethodGet, server.URL, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Accept-Encoding", "gzip")
+
+ response := make(chan *http.Response, 1)
+ go func() {
+ resp, requestErr := client.Do(req)
+ if requestErr != nil {
+ t.Errorf("request: %v", requestErr)
+ return
+ }
+ response <- resp
+ }()
+
+ select {
+ case <-flushed:
+ case <-time.After(time.Second):
+ t.Fatal("SSE handler did not flush the initial comment")
+ }
+
+ var resp *http.Response
+ select {
+ case resp = <-response:
+ case <-time.After(time.Second):
+ t.Fatal("SSE response headers were not delivered")
+ }
+ defer resp.Body.Close()
+
+ if got := resp.Header.Get("Content-Encoding"); got != "" {
+ t.Fatalf("Content-Encoding = %q, want empty", got)
+ }
+ line, err := bufio.NewReader(resp.Body).ReadString('\n')
+ if err != nil {
+ t.Fatal(err)
+ }
+ if line != ": connected\n" {
+ t.Fatalf("first SSE line = %q", line)
+ }
+}
+
+func TestHTTPCompressionAdapterStillCompressesJSON(t *testing.T) {
+ compress, err := newHTTPCompressionAdapter()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ handler := compress(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = io.WriteString(w, strings.Repeat("x", 1024))
+ }))
+ server := httptest.NewServer(handler)
+ defer server.Close()
+
+ client := &http.Client{Transport: &http.Transport{DisableCompression: true}}
+ req, err := http.NewRequest(http.MethodGet, server.URL, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Accept-Encoding", "gzip")
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer resp.Body.Close()
+
+ if got := resp.Header.Get("Content-Encoding"); got != "gzip" {
+ t.Fatalf("Content-Encoding = %q, want gzip", got)
+ }
+}
diff --git a/webserver/router/router.go b/webserver/router/router.go
index 51ab38e8ae..d44c3bbe71 100644
--- a/webserver/router/router.go
+++ b/webserver/router/router.go
@@ -125,7 +125,7 @@ func Start(cfg *config.Config, enableVerboseLogging bool, h *handlers.Handlers,
protocols.SetHTTP1(true)
protocols.SetUnencryptedHTTP2(true)
- compress, _ := httpcompression.DefaultAdapter() // Use the default configuration
+ compress, _ := newHTTPCompressionAdapter()
server := &http.Server{
Addr: fmt.Sprintf("%s:%d", ip, port),
ReadHeaderTimeout: 4 * time.Second,
@@ -143,6 +143,12 @@ func Start(cfg *config.Config, enableVerboseLogging bool, h *handlers.Handlers,
return server.ListenAndServe()
}
+func newHTTPCompressionAdapter() (func(http.Handler) http.Handler, error) {
+ return httpcompression.DefaultAdapter(
+ httpcompression.ContentTypes([]string{"text/event-stream"}, true),
+ )
+}
+
func addStaticFileEndpoints(r chi.Router, h *handlers.Handlers, apc *apcontrollers.Controllers) {
// Images
r.HandleFunc("/thumbnail.jpg", h.GetThumbnail)