how to return stream response?

[NeoyeElf]

func encodeXXResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
	flusher, ok := w.(http.Flusher)
	if !ok {
                // error happened here
		http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
		return nil
	}

	w.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")

       //... some code 
}

Why the w http.ResponseWriter not implement http.Flusher interface? How to return stream response? Thks!

[NeoyeElf]

I have figured it out. I have set the func ServerFinalizer(f ...ServerFinalizerFunc) ServerOption, then the "w" become "interceptingWriter", which not implement http.Flusher interface. The related code is below:

func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

         // here it is!
	if len(s.finalizer) > 0 {
		iw := &interceptingWriter{w, http.StatusOK, 0}
		defer func() {
			ctx = context.WithValue(ctx, ContextKeyResponseHeaders, iw.Header())
			ctx = context.WithValue(ctx, ContextKeyResponseSize, iw.written)
			for _, f := range s.finalizer {
				f(ctx, iw.code, r)
			}
		}()
		w = iw
	}

	for _, f := range s.before {
		ctx = f(ctx, r)
	}

	request, err := s.dec(ctx, r)
	if err != nil {
		s.errorHandler.Handle(ctx, err)
		s.errorEncoder(ctx, err, w)
		return
	}

	response, err := s.e(ctx, request)
	if err != nil {
		s.errorHandler.Handle(ctx, err)
		s.errorEncoder(ctx, err, w)
		return
	}

	for _, f := range s.after {
		ctx = f(ctx, w)
	}

	if err := s.enc(ctx, w, response); err != nil {
		s.errorHandler.Handle(ctx, err)
		s.errorEncoder(ctx, err, w)
		return
	}
}

Is it better for interceptingWriter to also implement http.Flusher interface?

[peterbourgon]

How do we know the underlying http.ResponseWriter actually implements http.Flusher?

There are tricks, of course...

[NeoyeElf]

How do we know the underlying http.ResponseWriter actually implements http.Flusher?

Actually, I don't know what do you mean...Maybe I didn't make it clear. My project is a http server which use the "github.com/go-kit/kit/transport/http" to make my "Handler" as below

import (
	kithttp "github.com/go-kit/kit/transport/http"
)

func encodeXXResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
       //some code for stream response
}

xxHandler := kithttp.NewServer(
       makeXXEndpoint(s),
       decodeXXRequest,
       encodeXXResponse,
)

The "w" that comes from func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) is the struct "response" in net/http package which indeed implements http.Flusher. As you can see, when I remove func ServerFinalizer(f ...ServerFinalizerFunc) ServerOption it works fine.

My question is, should interceptingWriter also implement http.Flusher? Then when we want return stream response, we can set func ServerFinalizer(f ...ServerFinalizerFunc) ServerOption as well

[NeoyeElf]

func (w *interceptingWriter) Flush() {
	flush, ok := w.ResponseWriter.(http.Flusher)
	if ok {
		flush.Flush()
	}
}

maybe we can add this code to solve the problem above?
If you have no other comments, I would like to make a pull request :)

[peterbourgon]

Again, ServeHTTP takes an http.ResponseWriter, but there is no guarantee that it actually implements Flusher. The problem is described in detail in this issue. Your solution is insufficient.

[NeoyeElf]

Ok. Then how can I use func ServerFinalizer(f ...ServerFinalizerFunc) ServerOption when I return the stream response? Because the http.ResponseWriter which implements Flusher in my situation is replaced by the interceptingWriter that dosen't implements Flusher

[basvanbeek]

If we want to support optional interfaces from the HTTP package we could use something like:
https://github.com/felixge/httpsnoop

[NeoyeElf]

Solved part of my problem @basvanbeek , but I can't get the values from context.Context using the package https://github.com/felixge/httpsnoop

[NeoyeElf]

Adding a new interceptingFlushWriter struct, which implement http.Flusher:

type interceptingFlushWriter struct {
	*interceptingWriter
}

func (fw *interceptingFlushWriter) Flush() {
	fw.ResponseWriter.(http.Flusher).Flush()
}

If the "w" implement the http.Flusher, then do w = &interceptingFlushWriter{iw}

func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	if len(s.finalizer) > 0 {
		iw := &interceptingWriter{w, http.StatusOK, 0}
		defer func() {
			ctx = context.WithValue(ctx, ContextKeyResponseHeaders, iw.Header())
			ctx = context.WithValue(ctx, ContextKeyResponseSize, iw.written)
			for _, f := range s.finalizer {
				f(ctx, iw.code, r)
			}
		}()

                // add new code here
		if _, ok := w.(http.Flusher); ok {
			w = &interceptingFlushWriter{iw}
		} else {
			w = iw
		}
	}

	...
}

@peterbourgon the code above seems more reasonable, and solves my problem.

[peterbourgon]

@NeoyeElf Again, you solution is insufficient. Here are some interfaces that http.ResponseWriters often implement:

• http.Flusher
• http.CloseNotifier
• http.Hijacker
• io.ReaderFrom
• http.Pusher

How shall we amend the code to accommodate these?

if _, ok := w.(http.Flusher); ok {
    w = &interceptingFlusherWriter{iw}
} else if _, ok := w.(http.CloseNotifier); ok {
    w = &interceptingCloseNotifierWriter{iw}
} else if _, ok := w.(http.Hijacker); ok {
    w = &interceptingHijackerWriter{iw}
} else if _, ok := w.(io.ReaderFrom); ok {
    w = &interceptingReaderFromWriter{iw}
} else if _, ok := w.(http.Pusher); ok {
    w = &interceptingPusherWriter{iw}
} else {
    w = iw
}

But wait, what if my http.ResponseWriter implements both http.Flusher and http.CloseNotifier, and I want to use both?

var (
    _, isFlusher       = w.(http.Flusher)
    _, isCloseNotifier = w.(http.CloseNotifier)
    _, isHijacker      = w.(http.Hijacker)
    _, isReaderFrom    = w.(io.ReaderFrom)
    _, isPusher        = w.(http.Pusher)
)
switch {
case isFlusher && !isCloseNotifier && !isHijacker && !isReaderFrom && !isPusher:
    w = &interceptingFlusherWriter{iw}
case isFlusher && isCloseNotifier && !isHijacker && !isReaderFrom && !isPusher:
    w = &interceptingFlusherCloseNotifierWriter{iw}
case ...
    ...
}

This obviously does not scale.

I'm also not sure the cost/benefit of introducing httpsnoop makes sense.

[NeoyeElf]

Oh...I was not thoughtfully considered. It seems that I can only think about other solutions. Thanks for your patience!