feat(nbhttp): Implement http.Flusher for streaming support

The existing `nbhttp.Response` did not implement the `http.Flusher`
interface, preventing its use with `http.NewResponseController` for
streaming data to the client. This was particularly problematic for
long-running requests or server-sent events (SSE). This change
introduces full support for `http.Flusher` and ensures true streaming is
possible by automatically enabling chunked encoding when a
`Content-Length` is not explicitly set. Key changes: - Added a `Flush()`
method to `Response` to implement `http.Flusher`. - Modified
`checkChunked()` to default to `Transfer-Encoding: chunked` for
responses without a `Content-Length`, which is crucial for streaming. -
Added a no-op `Push()` method to satisfy the `http.Pusher` interface,
returning an error as HTTP/2 Push is not supported.

Author: DevNewbie1826

nbhttp/response.go

@@ -345,31 +345,87 @@ func (res *Response) ReadFrom(r io.Reader) (n int64, err error) {
 	return io.Copy(c, r)
 }
 
+// Push implements the http.Pusher interface.
+// It is not supported by nbhttp, so it always returns an error.
+//
+//go:norace
+func (res *Response) Push(target string, opts *http.PushOptions) error {
+	return errors.New("http: server push not supported")
+}
+
+// Flush implements http.Flusher. It sends any buffered data to the client.
+//
+//go:norace
+func (res *Response) Flush() {
+	if res.hijacked {
+		return
+	}
+	if res.Parser == nil || res.Parser.Conn == nil {
+		return
+	}
+
+	res.WriteHeader(http.StatusOK)
+	res.checkChunked()
+	res.eoncodeHead()
+
+	conn := res.Parser.Conn
+
+	if res.buffer != nil && len(*res.buffer) > 0 {
+		_, err := conn.Write(*res.buffer)
+		if err != nil {
+			logging.Error("Response.Flush: buffer write failed: %v", err)
+			mempool.Free(res.buffer)
+			res.buffer = nil
+		} else {
+			*res.buffer = (*res.buffer)[:0]
+		}
+	}
+
+	if res.bodyBuffer != nil && len(*res.bodyBuffer) > 0 {
+		_, err := conn.Write(*res.bodyBuffer)
+		if err != nil {
+			logging.Error("Response.Flush: bodyBuffer write failed: %v", err)
+			mempool.Free(res.bodyBuffer)
+			res.bodyBuffer = nil
+		} else {
+			*res.bodyBuffer = (*res.bodyBuffer)[:0]
+		}
+	}
+}
+
 // checkChunked .
 //
 //go:norace
 func (res *Response) checkChunked() {
 	if res.chunkChecked {
 		return
 	}
-
 	res.chunkChecked = true
 
-	if res.request.ProtoAtLeast(1, 1) {
-		for _, v := range res.header[transferEncodingHeader] {
-			if v == "chunked" {
-				res.chunked = true
-			}
+	// 1. See if chunking is already set
+	for _, v := range res.header[transferEncodingHeader] {
+		if v == "chunked" {
+			res.chunked = true
+			delete(res.header, contentLengthHeader)
+			return
 		}
-		if !res.chunked {
-			if len(res.header[trailerHeader]) > 0 {
-				res.chunked = true
-				hs := res.header[transferEncodingHeader]
-				res.header[transferEncodingHeader] = append(hs, "chunked")
-			}
+	}
+
+	// 2. See if we should fall back to chunking
+	if res.request.ProtoAtLeast(1, 1) && res.header.Get(contentLengthHeader) == "" {
+		// Don't chunk for responses that are forbidden from having a body
+		if res.statusCode != http.StatusNoContent && res.statusCode != http.StatusNotModified {
+			res.chunked = true
 		}
 	}
+
+	// 3. See if we need to chunk for trailers
+	if !res.chunked && len(res.header[trailerHeader]) > 0 {
+		res.chunked = true
+	}
+
 	if res.chunked {
+		res.header.Set(transferEncodingHeader, "chunked")
 		delete(res.header, contentLengthHeader)
 	}
 }