proxy

type CacheControl ¶ added in v0.5.0

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

CacheControl sets Cache-Control response header with different ages for different mimes

func MakeCacheControl(cacheOpts []string) (*CacheControl, error)

func NewCacheControl(defaultAge time.Duration) *CacheControl

func (c *CacheControl) AddMime(m string, d time.Duration)

func (c *CacheControl) Middleware(next http.Handler) http.Handler

type ErrorReporter ¶ added in v0.5.0

type ErrorReporter struct {
	Template string
	Nice     bool
	// contains filtered or unexported fields
}

ErrorReporter formats error with a given template Supports go-style template with {{.ErrMessage}} and {{.ErrCode}}

func (em *ErrorReporter) Report(w http.ResponseWriter, code int)

type FailoverSelector ¶ added in v1.1.0

type FailoverSelector struct{}

FailoverSelector is a selector with failover, thread-safe

func (r *FailoverSelector) Select(_ int) int

type Http ¶

type Http struct {
	Matcher
	Address          string
	AssetsLocation   string
	AssetsWebRoot    string
	Assets404        string
	AssetsSPA        bool
	MaxBodySize      int64
	GzEnabled        bool
	ProxyHeaders     []string
	DropHeader       []string
	SSLConfig        SSLConfig
	Insecure         bool
	Version          string
	AccessLog        io.Writer
	StdOutEnabled    bool
	Signature        bool
	Timeouts         Timeouts
	CacheControl     MiddlewareProvider
	Metrics          MiddlewareProvider
	PluginConductor  MiddlewareProvider
	Reporter         Reporter
	LBSelector       LBSelector
	OnlyFrom         *OnlyFrom
	BasicAuthEnabled bool
	BasicAuthAllowed []string

	ThrottleSystem int
	ThrottleUser   int

	KeepHost bool
}

Http is a proxy server for both http and https

func (h *Http) Run(ctx context.Context) error

type LBSelector ¶ added in v1.1.0

type LBSelector interface {
	Select(len int) int // return index of picked server
}

LBSelector defines load balancer strategy

type LBSelectorFunc ¶ added in v1.1.0

type LBSelectorFunc func(n int) int

LBSelectorFunc is a functional adapted for LBSelector to select backend from the list

func (f LBSelectorFunc) Select(n int) int

type Matcher ¶

type Matcher interface {
	Match(srv, src string) (res discovery.Matches)
	Servers() (servers []string)
	Mappers() (mappers []discovery.URLMapper)
	CheckHealth() (pingResult map[string]error)
}

Matcher source info (server and route) to the destination url If no match found return ok=false

type MatcherMock ¶ added in v0.8.0

type MatcherMock struct {
	// CheckHealthFunc mocks the CheckHealth method.
	CheckHealthFunc func() map[string]error

	// MappersFunc mocks the Mappers method.
	MappersFunc func() []discovery.URLMapper

	// MatchFunc mocks the Match method.
	MatchFunc func(srv string, src string) discovery.Matches

	// ServersFunc mocks the Servers method.
	ServersFunc func() []string
	// contains filtered or unexported fields
}

MatcherMock is a mock implementation of Matcher.

func TestSomethingThatUsesMatcher(t *testing.T) {

	// make and configure a mocked Matcher
	mockedMatcher := &MatcherMock{
		CheckHealthFunc: func() map[string]error {
			panic("mock out the CheckHealth method")
		},
		MappersFunc: func() []discovery.URLMapper {
			panic("mock out the Mappers method")
		},
		MatchFunc: func(srv string, src string) discovery.Matches {
			panic("mock out the Match method")
		},
		ServersFunc: func() []string {
			panic("mock out the Servers method")
		},
	}

	// use mockedMatcher in code that requires Matcher
	// and then make assertions.

}

func (mock *MatcherMock) CheckHealth() map[string]error

func (mock *MatcherMock) CheckHealthCalls() []struct {
}

len(mockedMatcher.CheckHealthCalls())

func (mock *MatcherMock) Mappers() []discovery.URLMapper

func (mock *MatcherMock) MappersCalls() []struct {
}

len(mockedMatcher.MappersCalls())

func (mock *MatcherMock) Match(srv string, src string) discovery.Matches

func (mock *MatcherMock) MatchCalls() []struct {
	Srv string
	Src string
}

len(mockedMatcher.MatchCalls())

func (mock *MatcherMock) Servers() []string

func (mock *MatcherMock) ServersCalls() []struct {
}

len(mockedMatcher.ServersCalls())

type MiddlewareProvider ¶ added in v0.5.0

type MiddlewareProvider interface {
	Middleware(next http.Handler) http.Handler
}

MiddlewareProvider interface defines http middleware handler

type OFLookup ¶ added in v1.1.0

type OFLookup string

OFLookup defines lookup method for source IP.

const (
	OFRemoteAddr OFLookup = "remote-addr"
	OFRealIP     OFLookup = "real-ip"
	OFForwarded  OFLookup = "forwarded"
)

type OnlyFrom ¶ added in v1.1.0

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

OnlyFrom implements middleware to allow access for a limited list of source IPs.

func NewOnlyFrom(lookups ...OFLookup) *OnlyFrom

func (o *OnlyFrom) Handler(next http.Handler) http.Handler

type RandomSelector ¶ added in v1.1.0

type RandomSelector struct{}

RandomSelector is a random selector, thread-safe

func (r *RandomSelector) Select(n int) int

type Reporter ¶ added in v0.5.0

type Reporter interface {
	Report(w http.ResponseWriter, code int)
}

Reporter defines error reporting service

type RoundRobinSelector ¶ added in v1.1.0

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

RoundRobinSelector is a simple round-robin selector, thread-safe

func (r *RoundRobinSelector) Select(n int) int

type SSLConfig ¶

type SSLConfig struct {
	SSLMode       sslMode
	Cert          string
	Key           string
	ACMELocation  string
	ACMEEmail     string
	FQDNs         []string
	RedirHTTPPort int
}

SSLConfig holds all ssl params for rest server

type Timeouts ¶ added in v0.2.0

type Timeouts struct {
	// server timeouts
	ReadHeader time.Duration
	Write      time.Duration
	Idle       time.Duration
	// transport timeouts
	Dial           time.Duration
	KeepAlive      time.Duration
	IdleConn       time.Duration
	TLSHandshake   time.Duration
	ExpectContinue time.Duration
	ResponseHeader time.Duration
}

Timeouts consolidate timeouts for both server and transport