Comment 1:

A CookieJar's methods should return error, and maybe be renamed from http.CookieJar to
cookiejar.Interface.

Comment 2 by robryk:

In http.Client, there should be a uniform way of specifying request headers on the
initial request and subsequent requests when following a redirect. Current the
Request.Header field is useless if the request might get redirected. See issue #5782.
Maybe something like a func(*Request) field in the request, that gets called on this
request and each redirected one before it gets sent?

Comment 3 by jeff.allen:

The fact that headers are parsed into a map is a mega bummer for garbage reduction. If
the main way headers were exposed was more opaque, the headers map could be made up of
offsets into the buffer that came straight from Read.

Comment 4:

Labels changed: added repo-main.

Comment 5:

Related to comment #1, net/http/cookiejar.PublicSuffixList's PublicSuffix method should
perhaps return (string, error) instead of (string), in case the PSL implementation is
passed non-canonicalized input such as upper-cased "EXAMPLE.COM.AU". Returning an
explicit error is probably safer than silently returning a "" that would mean a liberal
cookie policy.

Comment 6:

It would be nice to have a handle on when all the goroutines that handle requests have
terminated after closing the listener (thereby breaking out of the accept loop) for
cases where they are using a shared resource that needs to be cleaned up (e.g. an
in-process database that needs to be closed). And maybe a way to force-close all their
connections. Especially useful for tests and SIGTERM situations.

Comment 7 by robryk:

You can do that by counting open connections returned by Listener's
Accept: http://play.golang.org/p/sPmvXaR-2M
(Disclaimer: I didn't test that code.)
Robert

Comment 8:

@Robert thanks, I did something similar in the end.

Comment 9:

@Robert For what it's worth, I think your listener breaks in the more general case where
you hand off the socket to both a reader and a writer goroutine. There a "done" channel
might be better.

Comment 10 by robryk:

Summarizing a discussion with fullung@: That version didn't handle multiple calls to
Close and had a (likely irrelevant) ReadWrite/Close race condition. The corrected
version is here: http://play.golang.org/p/WTKa021ipJ

Comment 11 by robryk:

Summarizing a discussion with fullung@: That version didn't handle multiple calls to
Close and had a (likely irrelevant) ReadWrite/Close race condition. The corrected
version is here: http://play.golang.org/p/WTKa021ipJ

Comment 12:

Labels changed: added release-none.

Comment 13 by robryk:

We have http.StripPrefix which modifies Request.URL.Path and passes the modified request
to a handler. We also have http.Redirect, which assumes that Request.URL.Path is
absolute.
Thus, if one tries to use http.Redirect within a handler that is wrapped in
http.StripPrefix the redirect will point to a wrong URL. In fact, we don't use
http.Redirect in http.FileServer for this very reason:
https://code.google.com/p/go/source/browse/src/pkg/net/http/fs.go#339
We could abandon StripPrefix and have another way of passing the prefix to handlers. We
could also keep the original path and the possibly-shortened path in request, so that
redirect could use the original path.

Comment 14 by nigel.tao.gnome:

Make http.Server recovering from panics opt-in instead of opt-out.
https://groups.google.com/forum/#!msg/golang-dev/rXs4TG1gdXw/7BQ29S4NPrgJ

I wish there was a way to delegate URL path subtrees to another handler in a way where recipient doesn't have to specifically understand the whole path, but can still easily do redirects and such. A convention for "this is the unprocessed part of the path".

For example, try using the same handler for /foo/ and /bar/quux/, having the handler extract the immediate child segment as a numeric ID, doing a database lookup, and creating a redirect to a canonical non-numerically named child (e.g. http://macworld.com/article/2367748 )

Right now, mutating Request.URL.Path (like StripPrefix) destroys knowledge of the requested URL (and re-parsing Request.RequestURI seems wrong).

Only partially related (it belongs more in the scheduler/netpoller) but since net/http has ListenAndServe* I'll add it here: integrate support for REUSEPORT in the netpoller (i.e. open multiple listening sockets on the same port -one for proc?- and accept() on multiple procs)

It'd be neat if we could just use *httputil.ReverseProxy and support WebSocket connection upgrades transparently.

@nhooyr, there's no reason that needs to wait for Go 2. I'll do it for Go 1.12. I filed #26937.

Awesome! I figured we'd need an API change to do this correctly as we have to hijack the client connection. Curious to see how you managed to do it.

Nvm, I see now. We just don't use the transport.

The http/Server.ErrorLog is *log.Logger.

If you want to log server errors in a custom way you have to create a custom io.Writer that assumes each call to Write() is a single, complete log message or you have to buffer, parse, and restructure a stream of calls to Write().

It would be much more flexible to have ErrorLog be an interface such as:

type ErrorLog interface {
    Printf(string, ...interface{})
}

@AgentZombie, there's another bug open about rethinking log/log interfaces. Whatever we did across std would also be done in net/http.

How about explicit context support?

ServeHTTP(context.Context, ResponseWriter, *Request)

and then get rid of (*Request).Context(). That way, middleware can also more easily augment the context without suffering #28737.

Would be nice to rename http.Header to http.Headers as it is a map of headers and not a single header.

Hi @nhooyr, but Header["foo"] gives the single Foo header so it reads okay. I agree another style is to use a plural for an array or map so it really depends on the normal style within http and stdlib as a whole.

It’s not the worst thing but most usages of maps and array are plural in the stdlib.

The auto recovering of http.Server didn't generate core dump even if GOTRACEBACK=crash, which make it hard to debug. All the information I get is the call stack which is not enough as I need to examine the value of various variable.

Consider http client DO NOT following redirects by default. FYI: encode/httpx#1785

One more thought via #52727. Especially now that we have errors.Is, a new net/http client should produce errors with more structure.

For example, on a Content-Length mismatch the current client returns a bare io.ErrUnexpectedEOF, rather than (say) a more structured error in the style produced by the os package: perhaps one that includes the URL and/or the expected Content-Length.

One thought I have: it seems like it's somewhat common to forget to implement http.Flusher when wrapping an http.ResponseWriter, which can cause some really nasty issues. Would it perhaps be better if the Flush method was simply on http.ResponseWriter, and canonically a no-op if the underlying implementation is unbuffered?