func DumpRequest(req *http.Request, bodybool) ([]byte,error)

func DumpRequestOut(req *http.Request, bodybool) ([]byte,error)

func DumpResponse(resp *http.Response, bodybool) ([]byte,error)

func NewChunkedReader(rio.Reader)io.Reader

func NewChunkedWriter(wio.Writer)io.WriteCloser

type BufferPool interface {Get() []bytePut([]byte)}

type ProxyRequest struct {// In is the request received by the proxy.// The Rewrite function must not modify In.In *http.Request// Out is the request which will be sent by the proxy.// The Rewrite function may modify or replace this request.// Hop-by-hop headers are removed from this request// before Rewrite is called.Out *http.Request}

func (*ProxyRequest)SetURL¶added ingo1.20

func (r *ProxyRequest) SetURL(target *url.URL)

SetURL routes the outbound request to the scheme, host, and base pathprovided in target. If the target's path is "/base" and the incomingrequest was for "/dir", the target request will be for "/base/dir".To route requests without joining the incoming path,set r.Out.URL directly.

SetURL rewrites the outbound Host header to match the target's host.To preserve the inbound request's Host header (the default behaviorofNewSingleHostReverseProxy):

rewriteFunc := func(r *httputil.ProxyRequest) {r.SetURL(url)r.Out.Host = r.In.Host}

func (*ProxyRequest)SetXForwarded¶added ingo1.20

func (r *ProxyRequest) SetXForwarded()

SetXForwarded sets the X-Forwarded-For, X-Forwarded-Host, andX-Forwarded-Proto headers of the outbound request.

• The X-Forwarded-For header is set to the client IP address.
• The X-Forwarded-Host header is set to the host name requestedby the client.
• The X-Forwarded-Proto header is set to "http" or "https", dependingon whether the inbound request was made on a TLS-enabled connection.

If the outbound request contains an existing X-Forwarded-For header,SetXForwarded appends the client IP address to it. To append to theinbound request's X-Forwarded-For header (the default behavior ofReverseProxy when using a Director function), copy the headerfrom the inbound request before calling SetXForwarded:

rewriteFunc := func(r *httputil.ProxyRequest) {r.Out.Header["X-Forwarded-For"] = r.In.Header["X-Forwarded-For"]r.SetXForwarded()}

type ReverseProxy struct {// Rewrite must be a function which modifies// the request into a new request to be sent// using Transport. Its response is then copied// back to the original client unmodified.// Rewrite must not access the provided ProxyRequest// or its contents after returning.//// The Forwarded, X-Forwarded, X-Forwarded-Host,// and X-Forwarded-Proto headers are removed from the// outbound request before Rewrite is called. See also// the ProxyRequest.SetXForwarded method.//// Unparsable query parameters are removed from the// outbound request before Rewrite is called.// The Rewrite function may copy the inbound URL's// RawQuery to the outbound URL to preserve the original// parameter string. Note that this can lead to security// issues if the proxy's interpretation of query parameters// does not match that of the downstream server.//// At most one of Rewrite or Director may be set.Rewrite func(*ProxyRequest)// Director is a function which modifies// the request into a new request to be sent// using Transport. Its response is then copied// back to the original client unmodified.// Director must not access the provided Request// after returning.//// By default, the X-Forwarded-For header is set to the// value of the client IP address. If an X-Forwarded-For// header already exists, the client IP is appended to the// existing values. As a special case, if the header// exists in the Request.Header map but has a nil value// (such as when set by the Director func), the X-Forwarded-For// header is not modified.//// To prevent IP spoofing, be sure to delete any pre-existing// X-Forwarded-For header coming from the client or// an untrusted proxy.//// Hop-by-hop headers are removed from the request after// Director returns, which can remove headers added by// Director. Use a Rewrite function instead to ensure// modifications to the request are preserved.//// Unparsable query parameters are removed from the outbound// request if Request.Form is set after Director returns.//// At most one of Rewrite or Director may be set.Director func(*http.Request)// The transport used to perform proxy requests.// If nil, http.DefaultTransport is used.Transporthttp.RoundTripper// FlushInterval specifies the flush interval// to flush to the client while copying the// response body.// If zero, no periodic flushing is done.// A negative value means to flush immediately// after each write to the client.// The FlushInterval is ignored when ReverseProxy// recognizes a response as a streaming response, or// if its ContentLength is -1; for such responses, writes// are flushed to the client immediately.FlushIntervaltime.Duration// ErrorLog specifies an optional logger for errors// that occur when attempting to proxy the request.// If nil, logging is done via the log package's standard logger.ErrorLog *log.Logger// BufferPool optionally specifies a buffer pool to// get byte slices for use by io.CopyBuffer when// copying HTTP response bodies.BufferPoolBufferPool// ModifyResponse is an optional function that modifies the// Response from the backend. It is called if the backend// returns a response at all, with any HTTP status code.// If the backend is unreachable, the optional ErrorHandler is// called without any call to ModifyResponse.//// Hop-by-hop headers are removed from the response before// calling ModifyResponse. ModifyResponse may need to remove// additional headers to fit its deployment model, such as Alt-Svc.//// If ModifyResponse returns an error, ErrorHandler is called// with its error value. If ErrorHandler is nil, its default// implementation is used.ModifyResponse func(*http.Response)error// ErrorHandler is an optional function that handles errors// reaching the backend or errors from ModifyResponse.//// If nil, the default is to log the provided error and return// a 502 Status Bad Gateway response.ErrorHandler func(http.ResponseWriter, *http.Request,error)}

funcNewSingleHostReverseProxy¶

func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy

NewSingleHostReverseProxy returns a newReverseProxy that routesURLs to the scheme, host, and base path provided in target. If thetarget's path is "/base" and the incoming request was for "/dir",the target request will be for /base/dir.

NewSingleHostReverseProxy does not rewrite the Host header.

To customize the ReverseProxy behavior beyond whatNewSingleHostReverseProxy provides, use ReverseProxy directlywith a Rewrite function. The ProxyRequest SetURL methodmay be used to route the outbound request. (Note that SetURL,unlike NewSingleHostReverseProxy, rewrites the Host headerof the outbound request by default.)

proxy := &ReverseProxy{Rewrite: func(r *ProxyRequest) {r.SetURL(target)r.Out.Host = r.In.Host // if desired},}

func (*ReverseProxy)ServeHTTP¶

func (p *ReverseProxy) ServeHTTP(rwhttp.ResponseWriter, req *http.Request)