Go: ResponseController deadline not respected

I have some code where I'm trying to cancel writing back to the client if writing takes too long. I thought I could use http.ResponseController for this, since it has a SetWriteDeadline method.

Unfortunately, in the code below, rw.Write doesn't return an error after the deadline has passed.

Is there another way I can cancel the write?

package main

import (
	"log"
	"net/http"
	"time"
)

func main() {
	http.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
		log.Println(r.Method, r.URL.Path)

		rc := http.NewResponseController(rw)
		dl := time.Now().Add(3 * time.Second)
		if err := rc.SetWriteDeadline(dl); err != nil {
			log.Println(err)
			return
		}
		log.Println("write deadline:", dl)

		var total int
		for _, b := range []byte("What!\n") {
			time.Sleep(time.Second)

			n, err := rw.Write([]byte{b})
			if err != nil {
				log.Println(err)
				return
			}

			total += n
			log.Println("bytes written", n)
		}

		log.Println(r.Method, r.URL.Path, "write total", total)
	})

	http.ListenAndServe(":8080", nil)
}

$ go run main.go 
2023/04/26 12:24:40 GET /
2023/04/26 12:24:40 write deadline: 2023-04-26 12:24:43.303884739 -0700 PDT m=+11.5891
16304
2023/04/26 12:24:41 bytes written 1
2023/04/26 12:24:42 bytes written 1
2023/04/26 12:24:43 bytes written 1
2023/04/26 12:24:44 bytes written 1
2023/04/26 12:24:45 bytes written 1
2023/04/26 12:24:46 bytes written 1
2023/04/26 12:24:46 GET / write total 6

$ curl http://localhost:8080/
curl: (52) Empty reply from server

The documentation for SetWriteDeadline says:

> SetWriteDeadline sets the deadline for writing the response. Writes to the response body after the deadline has been exceeded will not block, but may succeed if the data has been buffered.

The writes to the response writer succeed in the question because the small amount of data written by the application is buffered.

The "Empty reply from server" error from curl shows that the deadline is honored when the server flushes the response to the underlying network connection on return from the handler.

Use SetWriteDeadline to protect against a slow client.

Use a context with deadline to limit the time used by the server to generate the response:

⋮
dl := time.Now().Add(3 * time.Second)
if err := rc.SetWriteDeadline(dl); err != nil {
    log.Println(err)
    return
}

// This context is canceled when the deadline has
// passed or the server detects that the client is gone.
ctx, cancel := context.WithDeadline(r.Context(), dl)
defer cancel()

var total int
for _, b := range []byte("What!\n") {

    // Check context cancelation. Use Err() if in a loop
    // as in this example or <-ctx.Done() when in a select.
	if err := ctx.Err(); err != nil {
		log.Println(err)
		return
	}
    ⋮