handlers

package
v0.0.0-...-96ff825 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 16, 2024 License: Apache-2.0, BSD-2-Clause-Views, BSD-3-Clause, + 1 more Imports: 41 Imported by: 0

Documentation

Index

Constants

View Source
const (
	W3CTraceparentHeader = "traceparent"
	W3CTracestateHeader  = "tracestate"

	W3CVendorID = "gorouter"
)
View Source
const (
	W3CTraceparentVersion    = uint8(0)
	W3CTraceparentSampled    = uint8(1)
	W3CTraceparentNotSampled = uint8(0)
)
View Source
const CfAppInstance = "X-CF-APP-INSTANCE"
View Source
const ONE_MB = 1024 * 1024 // bytes * kb
View Source
const RequestInfoCtxKey key = "RequestInfo"
View Source
const (
	VcapCookieId = "__VCAP_ID__"
)
View Source
const (
	VcapRequestIdHeader = "X-Vcap-Request-Id"
)

Variables

This section is empty.

Functions

func AddRouterErrorHeader

func AddRouterErrorHeader(rw http.ResponseWriter, val string)

func CreateDomainAllowlist

func CreateDomainAllowlist(allowlist []string) (map[string]struct{}, error)

CreateDomainAllowlist collects the static parts of wildcard allowlist expressions and wildcards stripped of their first segment.

Each entry is checked to follow DNS wildcard notation, e.g. *.domain-123.com, subdomain.example.com

but not subdomain.*.example.com, *.*.example.com or invalid DNS names, e.g. ?!.example.com

This function is exported so it can be tested as part of the route service test

func EndpointIteratorForRequest

func EndpointIteratorForRequest(logger logger.Logger, request *http.Request, loadBalanceMethod string, stickySessionCookieNames config.StringSet, authNegotiateSticky bool, azPreference string, az string) (route.EndpointIterator, error)

func GetEndpoint

func GetEndpoint(ctx context.Context) (*route.Endpoint, error)

func GetStickySession

func GetStickySession(request *http.Request, stickySessionCookieNames config.StringSet, authNegotiateSticky bool) (string, bool)

func IsWebSocketUpgrade

func IsWebSocketUpgrade(request *http.Request) bool

func LoggerWithTraceInfo

func LoggerWithTraceInfo(l logger.Logger, r *http.Request) logger.Logger

func NewAccessLog

func NewAccessLog(
	accessLogger accesslog.AccessLogger,
	extraHeadersToLog []string,
	logAttemptsDetails bool,
	logger logger.Logger,
) negroni.Handler

NewAccessLog creates a new handler that handles logging requests to the access log

func NewClientCert

func NewClientCert(
	skipSanitization func(req *http.Request) bool,
	forceDeleteHeader func(req *http.Request) (bool, error),
	forwardingMode string,
	logger logger.Logger,
	ew errorwriter.ErrorWriter,
) negroni.Handler

func NewHTTPLatencyPrometheus

func NewHTTPLatencyPrometheus(r Registry) negroni.Handler

NewHTTPLatencyPrometheus creates a new handler that handles prometheus metrics for latency

func NewHTTPRewriteHandler

func NewHTTPRewriteHandler(cfg config.HTTPRewrite, headersToAlwaysRemove []string) negroni.Handler

func NewHTTPStartStop

func NewHTTPStartStop(emitter dropsonde.EventEmitter, logger logger.Logger) negroni.Handler

NewHTTPStartStop creates a new handler that handles emitting frontend HTTP StartStop events

func NewHealthcheck

func NewHealthcheck(health *health.Health, logger logger.Logger) http.Handler

func NewLookup

func NewLookup(
	registry registry.Registry,
	rep metrics.ProxyReporter,
	logger logger.Logger,
	ew errorwriter.ErrorWriter,
	emptyPoolResponseCode503 bool,
) negroni.Handler

NewLookup creates a handler responsible for looking up a route.

func NewPanicCheck

func NewPanicCheck(health *health.Health, logger logger.Logger) negroni.Handler

NewPanicCheck creates a handler responsible for checking for panics and setting the Healthcheck to fail.

func NewProtocolCheck

func NewProtocolCheck(logger logger.Logger, errorWriter errorwriter.ErrorWriter, enableHTTP2 bool) negroni.Handler

NewProtocolCheck creates a handler responsible for checking the protocol of the request

func NewProxyHealthcheck

func NewProxyHealthcheck(userAgent string, health *health.Health) negroni.Handler

NewHealthcheck creates a handler that responds to healthcheck requests. If userAgent is set to a non-empty string, it will use that user agent to differentiate between healthcheck requests and non-healthcheck requests. Otherwise, it will treat all requests as healthcheck requests.

func NewProxyWriter

func NewProxyWriter(logger logger.Logger) negroni.Handler

NewProxyWriter creates a handler responsible for setting a proxy responseWriter on the request and response

func NewQueryParam

func NewQueryParam(logger logger.Logger) negroni.Handler

NewQueryParam creates a new handler that emits warnings if requests came in with semicolons un-escaped

func NewReporter

func NewReporter(reporter metrics.ProxyReporter, logger logger.Logger) negroni.Handler

NewReporter creates a new handler that handles reporting backend responses to metrics and missing Content-Length header

func NewRequestInfo

func NewRequestInfo() negroni.Handler

NewRequestInfo creates a RequestInfoHandler

func NewRouteService

func NewRouteService(
	config *routeservice.RouteServiceConfig,
	routeRegistry registry.Registry,
	logger logger.Logger,
	errorWriter errorwriter.ErrorWriter,
) negroni.Handler

NewRouteService creates a handler responsible for handling route services

func NewVcapRequestIdHeader

func NewVcapRequestIdHeader(logger logger.Logger) negroni.Handler

Types

type HopByHop

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

func NewHopByHop

func NewHopByHop(cfg *config.Config, logger logger.Logger) *HopByHop

NewHopByHop creates a new handler that sanitizes hop-by-hop headers based on the HopByHopHeadersToFilter config

func (*HopByHop) SanitizeRequestConnection

func (h *HopByHop) SanitizeRequestConnection(r *http.Request)

func (*HopByHop) ServeHTTP

func (h *HopByHop) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type InvalidInstanceHeaderError

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

func (InvalidInstanceHeaderError) Error

func (err InvalidInstanceHeaderError) Error() string

type MaxRequestSize

type MaxRequestSize struct {
	MaxSize int
	// contains filtered or unexported fields
}

func NewMaxRequestSize

func NewMaxRequestSize(cfg *config.Config, logger logger.Logger) *MaxRequestSize

NewAccessLog creates a new handler that handles logging requests to the access log

func (*MaxRequestSize) ServeHTTP

func (m *MaxRequestSize) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type Registry

type Registry interface {
	NewHistogram(name, helpText string, buckets []float64, opts ...metrics.MetricOption) metrics.Histogram
}

type RequestInfo

type RequestInfo struct {
	// ReceivedAt records the time at which this request was received by
	// gorouter as recorded in the RequestInfo middleware.
	ReceivedAt time.Time
	// AppRequestStartedAt records the time at which gorouter starts sending
	// the request to the backend.
	AppRequestStartedAt time.Time
	// LastFailedAttemptFinishedAt is the end of the last failed request,
	// if any. If there was at least one failed attempt this will be set, if
	// there was no successful attempt the RequestFailed flag will be set.
	LastFailedAttemptFinishedAt time.Time

	// These times document at which timestamps the individual phases of the
	// request started / finished if there was a successful attempt.
	DnsStartedAt           time.Time
	DnsFinishedAt          time.Time
	DialStartedAt          time.Time
	DialFinishedAt         time.Time
	TlsHandshakeStartedAt  time.Time
	TlsHandshakeFinishedAt time.Time

	// AppRequestFinishedAt records the time at which either a response was
	// received or the last performed attempt failed and no further attempts
	// could be made.
	AppRequestFinishedAt time.Time

	// FinishedAt is recorded once the access log middleware is executed after
	// performing the request, in contrast to the ReceivedAt value which is
	// recorded before the access log, but we need the value to be able to
	// produce the log.
	FinishedAt time.Time

	RoutePool                         *route.EndpointPool
	RouteEndpoint                     *route.Endpoint
	ProxyResponseWriter               utils.ProxyResponseWriter
	RouteServiceURL                   *url.URL
	ShouldRouteToInternalRouteService bool
	FailedAttempts                    int

	// RoundTripSuccessful will be set once a request has successfully reached a backend instance.
	RoundTripSuccessful bool

	TraceInfo TraceInfo

	BackendReqHeaders http.Header
}

RequestInfo stores all metadata about the request and is used to pass information between handlers. The timing information is ordered by time of occurrence.

func ContextRequestInfo

func ContextRequestInfo(req *http.Request) (*RequestInfo, error)

ContextRequestInfo gets the RequestInfo from the request Context

func (*RequestInfo) ProvideTraceInfo

func (r *RequestInfo) ProvideTraceInfo() (TraceInfo, error)

func (*RequestInfo) SetTraceInfo

func (r *RequestInfo) SetTraceInfo(traceID, spanID string) error

type RequestInfoHandler

type RequestInfoHandler struct{}

RequestInfoHandler adds a RequestInfo to the context of all requests that go through this handler

func (*RequestInfoHandler) ServeHTTP

func (r *RequestInfoHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, next http.HandlerFunc)

type RouteService

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

func (*RouteService) AllowRouteServiceHairpinningRequest

func (r *RouteService) AllowRouteServiceHairpinningRequest(uri route.Uri) bool

AllowRouteServiceHairpinningRequest decides whether a route service request can be resolved internally via the route registry or should be handled as external request. If the provided route is not known to this gorouter's route registry, the request will always be external. If the route is known, the hairpinning allowlist is consulted (if defined).

Only routes with host names that match an entry on the allowlist are resolved internally. Should the allowlist be empty, it is considered disabled and will allow internal resolution of any request that can be resolved via the gorouter's route registry.

returns true to use internal resolution via this gorouter, false for external resolution via route service URL call.

func (*RouteService) ArrivedViaRouteService

func (r *RouteService) ArrivedViaRouteService(req *http.Request, logger logger.Logger) (bool, error)

func (*RouteService) IsRouteServiceTraffic

func (r *RouteService) IsRouteServiceTraffic(req *http.Request) bool

func (*RouteService) MatchAllowlistHostname

func (r *RouteService) MatchAllowlistHostname(host string) bool

MatchAllowlistHostname checks, if the provided host name matches an entry as is, or matches a wildcard when stripping the first segment.

func (*RouteService) ServeHTTP

func (r *RouteService) ServeHTTP(rw http.ResponseWriter, req *http.Request, next http.HandlerFunc)

type TraceInfo

type TraceInfo struct {
	TraceID string
	SpanID  string
	UUID    string
}

type W3C

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

W3C is a handler that sets W3C headers on requests

func NewW3C

func NewW3C(enabled bool, tenantID string, logger logger.Logger) *W3C

NewW3C creates a new handler that sets W3C headers on requests

func (*W3C) HeadersToLog

func (m *W3C) HeadersToLog() []string

HeadersToLog specifies the headers which should be logged if W3C headers are enabled

func (*W3C) ServeHTTP

func (m *W3C) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

func (*W3C) ServeNewTraceparent

func (m *W3C) ServeNewTraceparent(rw http.ResponseWriter, r *http.Request, requestInfo *RequestInfo, logger logger.Logger)

func (*W3C) ServeUpdatedTraceparent

func (m *W3C) ServeUpdatedTraceparent(
	rw http.ResponseWriter,
	r *http.Request,
	requestInfo *RequestInfo,
	prevTraceparent W3CTraceparent,
	logger logger.Logger,
)

type W3CTraceparent

type W3CTraceparent struct {
	Version  uint8
	TraceID  []byte
	ParentID []byte
	Flags    uint8
}

W3CTraceparent is a struct which represents the traceparent header See https://www.w3.org/TR/trace-context/

func NewW3CTraceparent

func NewW3CTraceparent(requestInfo *RequestInfo) (W3CTraceparent, error)

NewW3CTraceparent returns W3C traceparent header value according to https://www.w3.org/TR/trace-context/#version-format It uses trace ID and span ID provided in the request context Or generates new IDs

func ParseW3CTraceparent

func ParseW3CTraceparent(header string) *W3CTraceparent

ParseW3CTraceparent parses a W3C traceparent header value according to https://www.w3.org/TR/trace-context/#version-format If it cannot parse the input header string it returns nil

func (W3CTraceparent) Next

func (h W3CTraceparent) Next() (W3CTraceparent, error)

Next generates a new Traceparent

func (W3CTraceparent) String

func (h W3CTraceparent) String() string

String generates the W3C traceparent header value according to https://www.w3.org/TR/trace-context/#version-format

type W3CTracestate

type W3CTracestate []W3CTracestateEntry

W3CTracestate is an alias for a slice W3CTracestateEntry; has helper funcs

func NewW3CTracestate

func NewW3CTracestate(tenantID string, parentID []byte) W3CTracestate

NewW3CTracestate generates a new set of W3C tracestate pairs according to https://www.w3.org/TR/trace-context/#version-format Initially it is populated with the current tracestate determined by arguments tenantID and parentID

func ParseW3CTracestate

func ParseW3CTracestate(header string) W3CTracestate

func (W3CTracestate) Next

func (s W3CTracestate) Next(tenantID string, parentID []byte) W3CTracestate

func (W3CTracestate) String

func (s W3CTracestate) String() string

type W3CTracestateEntry

type W3CTracestateEntry struct {
	Key string
	Val string
}

W3CTracestateEntry represents a Tracestate entry: a key value pair

func NextW3CTracestate

func NextW3CTracestate(tenantID string, parentID []byte) W3CTracestateEntry

func (W3CTracestateEntry) String

func (s W3CTracestateEntry) String() string

type XForwardedProto

type XForwardedProto struct {
	SkipSanitization         func(req *http.Request) bool
	ForceForwardedProtoHttps bool
	SanitizeForwardedProto   bool
}

func (*XForwardedProto) ServeHTTP

func (h *XForwardedProto) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type Zipkin

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

Zipkin is a handler that sets Zipkin headers on requests

func NewZipkin

func NewZipkin(enabled bool, logger logger.Logger) *Zipkin

NewZipkin creates a new handler that sets Zipkin headers on requests

func (*Zipkin) HeadersToLog

func (z *Zipkin) HeadersToLog() []string

HeadersToLog specifies the headers which should be logged if Zipkin headers are enabled

func (*Zipkin) ServeHTTP

func (z *Zipkin) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

Jump to

Keyboard shortcuts

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