filter

type CompressionFilter ¶

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

A ResponseFilter that performs compression when compression is available and the content isn't already compressed

func NewCompressionFilter(types []string) *CompressionFilter

func (c *CompressionFilter) FilterResponse(request *falcore.Request, res *http.Response)

type DateFilter ¶

type DateFilter struct {
}

If Date header is non-existent in the response, this filter will automatically set it to the current date

func (f *DateFilter) FilterResponse(request *falcore.Request, res *http.Response)

type EtagFilter ¶

type EtagFilter struct {
}

EtagFilter is a falcore.ResponseFilter that matches the response's Etag header against the request's If-None-Match header. If they match, the filter will return a '304 Not Modifed' status and no body.

Ideally, Etag filtering is performed as soon as possible as you may be able to skip generating the response body at all. Even as a last step, you will see a significant benefit if clients are well behaved.

func (f *EtagFilter) FilterResponse(request *falcore.Request, res *http.Response)

type FileFilter ¶

type FileFilter struct {
	// File system base path for serving files
	BasePath string
	// Prefix in URL path
	PathPrefix string
	// File to look for if path is a directory
	DirectoryIndex string
}

A falcore RequestFilter for serving static files from the filesystem. This filter returns nil if the file is not found or is outside of scope.

func (f *FileFilter) FilterRequest(req *falcore.Request) (res *http.Response)

type HandlerFilter ¶

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

Wraps an http.Handler in a falcore.RequestFilter. This allows for compatibility with existing handlers built for the standard library's http server. This will always return a response due to the requirements of the http.Handler interface so it should be placed at the end of the Upstream pipeline.

func NewHandlerFilter(handler http.Handler) *HandlerFilter

func (h *HandlerFilter) FilterRequest(req *falcore.Request) *http.Response

type StringBody ¶

type StringBody struct {
	BodyBuffer *bytes.Reader
	// contains filtered or unexported fields
}

Keeps the body of a request in a string so it can be re-read at each stage of the pipeline implements io.ReadCloser to match http.Request.Body

func (sb *StringBody) Close() error

func (sb *StringBody) Read(b []byte) (n int, err error)

type StringBodyFilter ¶

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

Injests the body of the request into a buffer so it can be read more than once.

func NewStringBodyFilter() *StringBodyFilter

func (sbf *StringBodyFilter) FilterRequest(request *falcore.Request) *http.Response

func (sbf *StringBodyFilter) FilterResponse(request *falcore.Request, res *http.Response)

func (sbf *StringBodyFilter) ReturnBuffer(request *falcore.Request)

type Throttler ¶

type Throttler struct {
	Condition func(req *falcore.Request) bool // If this is set, and returns false, the request will not be throttled
	// contains filtered or unexported fields
}

Throttles incomming requests at a maximum number of requests per second. Pending requests will just wait in a queue.

func NewThrottler(RPS int) *Throttler

func (t *Throttler) FilterRequest(req *falcore.Request) *http.Response

func (t *Throttler) Pending() int64

func (t *Throttler) SetRPS(RPS int)

func (t *Throttler) StartReporter(name string, interval time.Duration)

type Upstream ¶

type Upstream struct {
	// Name, if set, is used in logging and request stats
	Name      string
	Transport *UpstreamTransport
	// Will ignore https on the incoming request and always upstream http
	ForceHttp bool
	// Ping URL Path-only for checking upness
	PingPath string
	// contains filtered or unexported fields
}

Proxies the request through another server. Can be used in conjunction with the UpstreamPool to load balance traffic across several servers.

func NewUpstream(transport *UpstreamTransport) *Upstream

func (u *Upstream) FilterRequest(request *falcore.Request) (res *http.Response)

func (u *Upstream) MaxConcurrent() int64

func (u *Upstream) QueueLength() int64

func (u *Upstream) SetMaxConcurrent(max int64)

type UpstreamEntry ¶

type UpstreamEntry struct {
	Upstream *Upstream
	Weight   int
}

type UpstreamPool ¶

type UpstreamPool struct {
	Name string
	// contains filtered or unexported fields
}

An UpstreamPool is a list of upstream servers which are considered functionally equivalent. The pool will round-robin the requests to the servers.

func NewUpstreamPool(name string, upstreams []*UpstreamEntry) *UpstreamPool

func (up UpstreamPool) FilterRequest(req *falcore.Request) (res *http.Response)

func (up UpstreamPool) LogStatus()

func (up UpstreamPool) Next() *UpstreamEntry

func (up UpstreamPool) Shutdown()

type UpstreamTransport ¶

type UpstreamTransport struct {
	DNSCacheDuration time.Duration
	// contains filtered or unexported fields
}

Holds all the information about how to lookup and connect to an upstream.

func NewUpstreamTransport(host string, port int, timeout time.Duration, transport *http.Transport) *UpstreamTransport