apimachinery: k8s.io/apimachinery/pkg/util/proxy Index | Files

package proxy

import "k8s.io/apimachinery/pkg/util/proxy"

Package proxy provides transport and upgrade support for proxies.

Index

Package Files

dial.go doc.go transport.go upgradeaware.go

Variables

var MirrorRequest http.RoundTripper = onewayRoundTripper{}

MirrorRequest is a round tripper that can be called to get back the calling request as the core round tripper in a chain.

func DialURL Uses

func DialURL(ctx context.Context, url *url.URL, transport http.RoundTripper) (net.Conn, error)

type ErrorResponder Uses

type ErrorResponder interface {
    Error(w http.ResponseWriter, req *http.Request, err error)
}

ErrorResponder abstracts error reporting to the proxy handler to remove the need to hardcode a particular error format.

func NewErrorResponder Uses

func NewErrorResponder(r SimpleErrorResponder) ErrorResponder

type SimpleErrorResponder Uses

type SimpleErrorResponder interface {
    Error(err error)
}

SimpleErrorResponder is the legacy implementation of ErrorResponder for callers that only service a single request/response per proxy.

type Transport Uses

type Transport struct {
    Scheme      string
    Host        string
    PathPrepend string

    http.RoundTripper
}

Transport is a transport for text/html content that replaces URLs in html content with the prefix of the proxy server

func (*Transport) RoundTrip Uses

func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error)

RoundTrip implements the http.RoundTripper interface

func (*Transport) WrappedRoundTripper Uses

func (rt *Transport) WrappedRoundTripper() http.RoundTripper

type UpgradeAwareHandler Uses

type UpgradeAwareHandler struct {
    // UpgradeRequired will reject non-upgrade connections if true.
    UpgradeRequired bool
    // Location is the location of the upstream proxy. It is used as the location to Dial on the upstream server
    // for upgrade requests unless UseRequestLocationOnUpgrade is true.
    Location *url.URL
    // Transport provides an optional round tripper to use to proxy. If nil, the default proxy transport is used
    Transport http.RoundTripper
    // UpgradeTransport, if specified, will be used as the backend transport when upgrade requests are provided.
    // This allows clients to disable HTTP/2.
    UpgradeTransport UpgradeRequestRoundTripper
    // WrapTransport indicates whether the provided Transport should be wrapped with default proxy transport behavior (URL rewriting, X-Forwarded-* header setting)
    WrapTransport bool
    // InterceptRedirects determines whether the proxy should sniff backend responses for redirects,
    // following them as necessary.
    InterceptRedirects bool
    // RequireSameHostRedirects only allows redirects to the same host. It is only used if InterceptRedirects=true.
    RequireSameHostRedirects bool
    // UseRequestLocation will use the incoming request URL when talking to the backend server.
    UseRequestLocation bool
    // FlushInterval controls how often the standard HTTP proxy will flush content from the upstream.
    FlushInterval time.Duration
    // MaxBytesPerSec controls the maximum rate for an upstream connection. No rate is imposed if the value is zero.
    MaxBytesPerSec int64
    // Responder is passed errors that occur while setting up proxying.
    Responder ErrorResponder
}

UpgradeAwareHandler is a handler for proxy requests that may require an upgrade

func NewUpgradeAwareHandler Uses

func NewUpgradeAwareHandler(location *url.URL, transport http.RoundTripper, wrapTransport, upgradeRequired bool, responder ErrorResponder) *UpgradeAwareHandler

NewUpgradeAwareHandler creates a new proxy handler with a default flush interval. Responder is required for returning errors to the caller.

func (*UpgradeAwareHandler) Dial Uses

func (h *UpgradeAwareHandler) Dial(req *http.Request) (net.Conn, error)

func (*UpgradeAwareHandler) DialForUpgrade Uses

func (h *UpgradeAwareHandler) DialForUpgrade(req *http.Request) (net.Conn, error)

func (*UpgradeAwareHandler) ServeHTTP Uses

func (h *UpgradeAwareHandler) ServeHTTP(w http.ResponseWriter, req *http.Request)

ServeHTTP handles the proxy request

type UpgradeRequestRoundTripper Uses

type UpgradeRequestRoundTripper interface {
    http.RoundTripper
    // WrapRequest takes a valid HTTP request and returns a suitably altered version
    // of request with any HTTP level values required to complete the request half of
    // an upgrade on the server. It does not get a chance to see the response and
    // should bypass any request side logic that expects to see the response.
    WrapRequest(*http.Request) (*http.Request, error)
}

UpgradeRequestRoundTripper provides an additional method to decorate a request with any authentication or other protocol level information prior to performing an upgrade on the server. Any response will be handled by the intercepting proxy.

func NewUpgradeRequestRoundTripper Uses

func NewUpgradeRequestRoundTripper(connection, request http.RoundTripper) UpgradeRequestRoundTripper

NewUpgradeRequestRoundTripper takes two round trippers - one for the underlying TCP connection, and one that is able to write headers to an HTTP request. The request rt is used to set the request headers and that is written to the underlying connection rt.

Package proxy imports 26 packages (graph) and is imported by 15 packages. Updated 2019-06-05. Refresh now. Tools for package owners.