forward

Documentation

Overview

Package forward implements http handler that forwards requests to remote server and serves back the response websocket proxying support based on https://github.com/yhat/wsutil

Index

• Constants
• Variables
• func BufferPool(pool httputil.BufferPool) optSetter
• func ErrorHandler(h utils.ErrorHandler) optSetter
• func IsWebsocketRequest(req *http.Request) bool
• func Logger(l utils.Logger) optSetter
• func PassHostHeader(b bool) optSetter
• func ResponseModifier(responseModifier func(*http.Response) error) optSetter
• func Rewriter(r ReqRewriter) optSetter
• func RoundTripper(r http.RoundTripper) optSetter
• func StateListener(stateListener UrlForwardingStateListener) optSetter
• func Stream(stream bool) optSetter
• func StreamingFlushInterval(flushInterval time.Duration) optSetter
• func WebsocketConnectionClosedHook(hook func(req *http.Request, conn net.Conn)) optSetter
• func WebsocketTLSClientConfig(tcc *tls.Config) optSetter
• type ErrorHandlingRoundTripper
  • func (rt ErrorHandlingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error)
• type Forwarder
  • func New(setters ...optSetter) (*Forwarder, error)
  • func (f *Forwarder) ServeHTTP(w http.ResponseWriter, req *http.Request)
• type HeaderRewriter
  • func (rw *HeaderRewriter) Rewrite(req *http.Request)
• type ReqRewriter
• type UrlForwardingStateListener

Constants

const (
	StateConnected = iota
	StateDisconnected
)

Connection states

const (
	XForwardedProto        = "X-Forwarded-Proto"
	XForwardedFor          = "X-Forwarded-For"
	XForwardedHost         = "X-Forwarded-Host"
	XForwardedPort         = "X-Forwarded-Port"
	XForwardedServer       = "X-Forwarded-Server"
	XRealIp                = "X-Real-Ip"
	Connection             = "Connection"
	KeepAlive              = "Keep-Alive"
	ProxyAuthenticate      = "Proxy-Authenticate"
	ProxyAuthorization     = "Proxy-Authorization"
	Te                     = "Te" // canonicalized version of "TE"
	Trailers               = "Trailers"
	TransferEncoding       = "Transfer-Encoding"
	Upgrade                = "Upgrade"
	ContentLength          = "Content-Length"
	SecWebsocketKey        = "Sec-Websocket-Key"
	SecWebsocketVersion    = "Sec-Websocket-Version"
	SecWebsocketExtensions = "Sec-Websocket-Extensions"
	SecWebsocketAccept     = "Sec-Websocket-Accept"
)

Headers

Variables

var HopHeaders = []string{
	Connection,
	KeepAlive,
	ProxyAuthenticate,
	ProxyAuthorization,
	Te,
	Trailers,
	TransferEncoding,
	Upgrade,
}

HopHeaders Hop-by-hop headers. These are removed when sent to the backend. http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html Copied from reverseproxy.go, too bad

var WebsocketDialHeaders = []string{
	Upgrade,
	Connection,
	SecWebsocketKey,
	SecWebsocketVersion,
	SecWebsocketExtensions,
	SecWebsocketAccept,
}

WebsocketDialHeaders Websocket dial headers

var WebsocketUpgradeHeaders = []string{
	Upgrade,
	Connection,
	SecWebsocketAccept,
	SecWebsocketExtensions,
}

WebsocketUpgradeHeaders Websocket upgrade headers

var XHeaders = []string{
	XForwardedProto,
	XForwardedFor,
	XForwardedHost,
	XForwardedPort,
	XForwardedServer,
	XRealIp,
}

XHeaders X-* headers

Functions

func BufferPool

func BufferPool(pool httputil.BufferPool) optSetter

BufferPool specifies a buffer pool for httputil.ReverseProxy.

func ErrorHandler

func ErrorHandler(h utils.ErrorHandler) optSetter

ErrorHandler is a functional argument that sets error handler of the server

func IsWebsocketRequest

func IsWebsocketRequest(req *http.Request) bool

IsWebsocketRequest determines if the specified HTTP request is a websocket handshake request

func Logger

func Logger(l utils.Logger) optSetter

Logger defines the logger the forwarder will use.

func PassHostHeader

func PassHostHeader(b bool) optSetter

PassHostHeader specifies if a client's Host header field should be delegated

func ResponseModifier

func ResponseModifier(responseModifier func(*http.Response) error) optSetter

ResponseModifier defines a response modifier for the HTTP forwarder

func Rewriter

func Rewriter(r ReqRewriter) optSetter

Rewriter defines a request rewriter for the HTTP forwarder

func RoundTripper

func RoundTripper(r http.RoundTripper) optSetter

RoundTripper sets a new http.RoundTripper Forwarder will use http.DefaultTransport as a default round tripper

func StateListener

func StateListener(stateListener UrlForwardingStateListener) optSetter

StateListener defines a state listener for the HTTP forwarder

func Stream

func Stream(stream bool) optSetter

Stream specifies if HTTP responses should be streamed.

func StreamingFlushInterval

func StreamingFlushInterval(flushInterval time.Duration) optSetter

StreamingFlushInterval defines a streaming flush interval for the HTTP forwarder

func WebsocketConnectionClosedHook

func WebsocketConnectionClosedHook(hook func(req *http.Request, conn net.Conn)) optSetter

WebsocketConnectionClosedHook defines a hook called when websocket connection is closed

func WebsocketTLSClientConfig

func WebsocketTLSClientConfig(tcc *tls.Config) optSetter

WebsocketTLSClientConfig define the websocker client TLS configuration

Types

type ErrorHandlingRoundTripper

type ErrorHandlingRoundTripper struct {
	http.RoundTripper
	// contains filtered or unexported fields
}

ErrorHandlingRoundTripper a error handling round tripper

func (ErrorHandlingRoundTripper) RoundTrip

func (rt ErrorHandlingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error)

RoundTrip executes the round trip

type Forwarder

type Forwarder struct {
	// contains filtered or unexported fields
}

Forwarder wraps two traffic forwarding implementations: HTTP and websockets. It decides based on the specified request which implementation to use

func New

func New(setters ...optSetter) (*Forwarder, error)

New creates an instance of Forwarder based on the provided list of configuration options

func (*Forwarder) ServeHTTP

func (f *Forwarder) ServeHTTP(w http.ResponseWriter, req *http.Request)

ServeHTTP decides which forwarder to use based on the specified request and delegates to the proper implementation

type HeaderRewriter

type HeaderRewriter struct {
	TrustForwardHeader bool
	Hostname           string
}

HeaderRewriter is responsible for removing hop-by-hop headers and setting forwarding headers

func (*HeaderRewriter) Rewrite

func (rw *HeaderRewriter) Rewrite(req *http.Request)

Rewrite rewrite request headers

type ReqRewriter

type ReqRewriter interface {
	Rewrite(r *http.Request)
}

ReqRewriter can alter request headers and body

type UrlForwardingStateListener

type UrlForwardingStateListener func(*url.URL, int)

UrlForwardingStateListener URL forwarding state listener