caddy: github.com/mholt/caddy/caddyhttp/proxy Index | Files

package proxy

import "github.com/mholt/caddy/caddyhttp/proxy"

Package proxy is middleware that proxies HTTP requests.

Index

Package Files

body.go policy.go proxy.go reverseproxy.go setup.go upstream.go

Constants

const CustomStatusContextCancelled = 499

func RegisterPolicy Uses

func RegisterPolicy(name string, policy func(string) Policy)

RegisterPolicy adds a custom policy to the proxy.

type First Uses

type First struct{}

First is a policy that selects the first available host

func (*First) Select Uses

func (r *First) Select(pool HostPool, request *http.Request) *UpstreamHost

Select selects the first available host from the pool

type Header struct {
    // The name of the request header, the value of which will determine
    // how the request is routed
    Name string
}

Header is a policy that selects based on a hash of the given header

func (*Header) Select Uses

func (r *Header) Select(pool HostPool, request *http.Request) *UpstreamHost

Select selects the host based on hashing the header value

type HostPool Uses

type HostPool []*UpstreamHost

HostPool is a collection of UpstreamHosts.

type IPHash Uses

type IPHash struct{}

IPHash is a policy that selects hosts based on hashing the request IP

func (*IPHash) Select Uses

func (r *IPHash) Select(pool HostPool, request *http.Request) *UpstreamHost

Select selects an up host from the pool based on hashing the request IP

type LeastConn Uses

type LeastConn struct{}

LeastConn is a policy that selects the host with the least connections.

func (*LeastConn) Select Uses

func (r *LeastConn) Select(pool HostPool, request *http.Request) *UpstreamHost

Select selects the up host with the least number of connections in the pool. If more than one host has the same least number of connections, one of the hosts is chosen at random.

type Policy Uses

type Policy interface {
    Select(pool HostPool, r *http.Request) *UpstreamHost
}

Policy decides how a host will be selected from a pool.

type Proxy Uses

type Proxy struct {
    Next      httpserver.Handler
    Upstreams []Upstream
}

Proxy represents a middleware instance that can proxy requests.

func (Proxy) ServeHTTP Uses

func (p Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)

ServeHTTP satisfies the httpserver.Handler interface.

type Random Uses

type Random struct{}

Random is a policy that selects up hosts from a pool at random.

func (*Random) Select Uses

func (r *Random) Select(pool HostPool, request *http.Request) *UpstreamHost

Select selects an up host at random from the specified pool.

type ReverseProxy Uses

type ReverseProxy struct {
    // Director 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.
    Director func(*http.Request)

    // The transport used to perform proxy requests.
    Transport http.RoundTripper

    // FlushInterval specifies the flush interval
    // to flush to the client while copying the
    // response body.
    // If zero, no periodic flushing is done.
    FlushInterval time.Duration
    // contains filtered or unexported fields
}

ReverseProxy is an HTTP Handler that takes an incoming request and sends it to another server, proxying the response back to the client.

func NewSingleHostReverseProxy Uses

func NewSingleHostReverseProxy(target *url.URL, without string, keepalive int, timeout, fallbackDelay time.Duration) *ReverseProxy

NewSingleHostReverseProxy returns a new ReverseProxy that rewrites URLs to the scheme, host, and base path provided in target. If the target's path is "/base" and the incoming request was for "/dir", the target request will be for /base/dir. Without logic: target's path is "/", incoming is "/api/messages", without is "/api", then the target request will be for /messages.

func (*ReverseProxy) ServeHTTP Uses

func (rp *ReverseProxy) ServeHTTP(rw http.ResponseWriter, outreq *http.Request, respUpdateFn respUpdateFn) error

ServeHTTP serves the proxied request to the upstream by performing a roundtrip. It is designed to handle websocket connection upgrades as well.

func (*ReverseProxy) UseClientCertificates Uses

func (rp *ReverseProxy) UseClientCertificates(keyPair *tls.Certificate)

UseClientCertificates is used to facilitate HTTPS proxying with locally provided certificate.

func (*ReverseProxy) UseInsecureTransport Uses

func (rp *ReverseProxy) UseInsecureTransport()

UseInsecureTransport is used to facilitate HTTPS proxying when it is OK for upstream to be using a bad certificate, since this transport skips verification.

func (*ReverseProxy) UseOwnCACertificates Uses

func (rp *ReverseProxy) UseOwnCACertificates(CaCertPool *x509.CertPool)

UseOwnCertificate is used to facilitate HTTPS proxying with locally provided certificate.

type RoundRobin Uses

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

RoundRobin is a policy that selects hosts based on round-robin ordering.

func (*RoundRobin) Select Uses

func (r *RoundRobin) Select(pool HostPool, request *http.Request) *UpstreamHost

Select selects an up host from the pool using a round-robin ordering scheme.

type URIHash Uses

type URIHash struct{}

URIHash is a policy that selects the host based on hashing the request URI

func (*URIHash) Select Uses

func (r *URIHash) Select(pool HostPool, request *http.Request) *UpstreamHost

Select selects the host based on hashing the URI

type Upstream Uses

type Upstream interface {
    // The path this upstream host should be routed on
    From() string

    // Selects an upstream host to be routed to. It
    // should return a suitable upstream host, or nil
    // if no such hosts are available.
    Select(*http.Request) *UpstreamHost

    // Checks if subpath is not an ignored path
    AllowedPath(string) bool

    // Gets the duration of the headstart the first
    // connection is given in the Go standard library's
    // implementation of "Happy Eyeballs" when DualStack
    // is enabled in net.Dialer.
    GetFallbackDelay() time.Duration

    // Gets how long to try selecting upstream hosts
    // in the case of cascading failures.
    GetTryDuration() time.Duration

    // Gets how long to wait between selecting upstream
    // hosts in the case of cascading failures.
    GetTryInterval() time.Duration

    // Gets the number of upstream hosts.
    GetHostCount() int

    // Gets how long to wait before timing out
    // the request
    GetTimeout() time.Duration

    // Stops the upstream from proxying requests to shutdown goroutines cleanly.
    Stop() error
}

Upstream manages a pool of proxy upstream hosts.

func NewStaticUpstreams Uses

func NewStaticUpstreams(c caddyfile.Dispenser, host string) ([]Upstream, error)

NewStaticUpstreams parses the configuration input and sets up static upstreams for the proxy middleware. The host string parameter, if not empty, is used for setting the upstream Host header for the health checks if the upstream header config requires it.

type UpstreamHost Uses

type UpstreamHost struct {
    // This field is read & written to concurrently, so all access must use
    // atomic operations.
    Conns             int64 // must be first field to be 64-bit aligned on 32-bit systems
    MaxConns          int64
    Name              string // hostname of this upstream host
    UpstreamHeaders   http.Header
    DownstreamHeaders http.Header
    FailTimeout       time.Duration
    CheckDown         UpstreamHostDownFunc
    WithoutPathPrefix string
    ReverseProxy      *ReverseProxy
    Fails             int32
    // This is an int32 so that we can use atomic operations to do concurrent
    // reads & writes to this value.  The default value of 0 indicates that it
    // is healthy and any non-zero value indicates unhealthy.
    Unhealthy                    int32
    HealthCheckResult            atomic.Value
    UpstreamHeaderReplacements   headerReplacements
    DownstreamHeaderReplacements headerReplacements
}

UpstreamHost represents a single proxy upstream

func (*UpstreamHost) Available Uses

func (uh *UpstreamHost) Available() bool

Available checks whether the upstream host is available for proxying to

func (*UpstreamHost) Down Uses

func (uh *UpstreamHost) Down() bool

Down checks whether the upstream host is down or not. Down will try to use uh.CheckDown first, and will fall back to some default criteria if necessary.

func (*UpstreamHost) Full Uses

func (uh *UpstreamHost) Full() bool

Full checks whether the upstream host has reached its maximum connections

type UpstreamHostDownFunc Uses

type UpstreamHostDownFunc func(*UpstreamHost) bool

UpstreamHostDownFunc can be used to customize how Down behaves.

Package proxy imports 29 packages (graph) and is imported by 108 packages. Updated 2019-12-05. Refresh now. Tools for package owners.