forward

package

v2.0.0 Latest Latest Go to latest Published: Sep 27, 2023 License: Apache-2.0 Imports: 7 Imported by: 7

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/vulcand/oxy

Links

Open Source Insights

Documentation ¶

Overview ¶

Package forward creates a pre-configured httputil.ReverseProxy.

Index ¶

Constants
Variables
func New(passHostHeader bool) *httputil.ReverseProxy
type HeaderRewriter
- func NewHeaderRewriter() *HeaderRewriter
- func (rw *HeaderRewriter) Rewrite(req *http.Request)
type StateListener
- func NewStateListener(next http.Handler, stateListener URLForwardingStateListener) *StateListener
- func (s *StateListener) ServeHTTP(rw http.ResponseWriter, req *http.Request)
type URLForwardingStateListener

Constants ¶

View Source

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"
)

X-* Header names.

View Source

const (
	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"
)

Headers names.

View Source

const (
	SecWebsocketKey        = "Sec-Websocket-Key"
	SecWebsocketVersion    = "Sec-Websocket-Version"
	SecWebsocketExtensions = "Sec-Websocket-Extensions"
	SecWebsocketAccept     = "Sec-Websocket-Accept"
)

WebSocket Header names.

View Source

const (
	StateConnected = iota
	StateDisconnected
)

Connection states.

Variables ¶

View Source

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.

View Source

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

WebsocketDialHeaders Websocket dial headers.

View Source

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

WebsocketUpgradeHeaders Websocket upgrade headers.

View Source

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

XHeaders X-* headers.

Functions ¶

func New ¶

func New(passHostHeader bool) *httputil.ReverseProxy

New creates a new ReverseProxy.

Example (CustomErrHandler) ¶

f := New(true)
f.ErrorHandler = func(w http.ResponseWriter, req *http.Request, err error) {
	w.WriteHeader(http.StatusTeapot)
	_, _ = w.Write([]byte(http.StatusText(http.StatusTeapot)))
}

proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	req.URL, _ = url.ParseRequestURI("http://localhost:63450")
	f.ServeHTTP(w, req)
}))
defer proxy.Close()

resp, err := http.Get(proxy.URL)
if err != nil {
	fmt.Println(err)
	return
}

body, err := io.ReadAll(resp.Body)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println(resp.StatusCode)
fmt.Println(string(body))

Output:

418
I'm a teapot

Example (CustomTransport) ¶

srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	_, _ = w.Write([]byte("hello"))
}))
defer srv.Close()

f := New(true)

f.Transport = &http.Transport{
	TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}

proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	req.URL, _ = url.ParseRequestURI(srv.URL)
	f.ServeHTTP(w, req)
}))
defer proxy.Close()

resp, err := http.Get(proxy.URL)
if err != nil {
	fmt.Println(err)
	return
}

body, err := io.ReadAll(resp.Body)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println(resp.StatusCode)
fmt.Println(string(body))

Output:

200
hello

Example (ResponseModifier) ¶

srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	_, _ = w.Write([]byte("hello"))
}))
defer srv.Close()

f := New(true)
f.ModifyResponse = func(resp *http.Response) error {
	resp.Header.Add("X-Test", "CUSTOM")
	return nil
}

proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	req.URL, _ = url.ParseRequestURI(srv.URL)
	f.ServeHTTP(w, req)
}))
defer proxy.Close()

resp, err := http.Get(proxy.URL)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println(resp.StatusCode)
fmt.Println(resp.Header.Get("X-Test"))

Output:

200
CUSTOM

Types ¶

type HeaderRewriter ¶

type HeaderRewriter struct {
	TrustForwardHeader bool
	Hostname           string
}

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

func NewHeaderRewriter ¶

func NewHeaderRewriter() *HeaderRewriter

NewHeaderRewriter creates a new HeaderRewriter middleware.

func (*HeaderRewriter) Rewrite ¶

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

Rewrite request headers.

type StateListener ¶

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

StateListener listens on state change for urls.

func NewStateListener ¶

func NewStateListener(next http.Handler, stateListener URLForwardingStateListener) *StateListener

NewStateListener creates a new StateListener middleware.

Example ¶

srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	_, _ = w.Write([]byte("hello"))
}))
defer srv.Close()

f := New(true)
f.ModifyResponse = func(resp *http.Response) error {
	resp.Header.Add("X-Test", "CUSTOM")
	return nil
}

stateLn := NewStateListener(f, func(u *url.URL, i int) {
	fmt.Println(u.Hostname(), i)
})

proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	req.URL, _ = url.ParseRequestURI(srv.URL)
	stateLn.ServeHTTP(w, req)
}))
defer proxy.Close()

resp, err := http.Get(proxy.URL)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println(resp.StatusCode)

Output:

127.0.0.1 0
127.0.0.1 1
200

func (*StateListener) ServeHTTP ¶

func (s *StateListener) ServeHTTP(rw http.ResponseWriter, req *http.Request)

type URLForwardingStateListener ¶

type URLForwardingStateListener func(*url.URL, int)

URLForwardingStateListener URL forwarding state listener.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL