engine

type Address struct {
	Network string
	Address string
}

type AlreadyExistsError struct {
	Message string
}

type Anomaly struct {
	Code    int
	Message string
}

type Backend struct {
	Id       string
	Type     string
	Stats    *RoundTripStats `json:",omitempty"`
	Settings interface{}
}

type BackendDeleted struct {
	BackendKey BackendKey
}

type BackendKey struct {
	Id string
}

type BackendUpserted struct {
	Backend Backend
}

type Bracket struct {
	Quantile float64
	Value    time.Duration
}

type Counters struct {
	Period      time.Duration
	NetErrors   int64
	Total       int64
	StatusCodes []StatusCode
}

type Engine interface {
	GetHosts() ([]Host, error)
	GetHost(HostKey) (*Host, error)
	UpsertHost(Host) error
	DeleteHost(HostKey) error

	GetListeners() ([]Listener, error)
	GetListener(ListenerKey) (*Listener, error)
	UpsertListener(Listener) error
	DeleteListener(ListenerKey) error

	GetFrontends() ([]Frontend, error)
	GetFrontend(FrontendKey) (*Frontend, error)
	UpsertFrontend(Frontend, time.Duration) error
	DeleteFrontend(FrontendKey) error

	GetMiddlewares(FrontendKey) ([]Middleware, error)
	GetMiddleware(MiddlewareKey) (*Middleware, error)
	UpsertMiddleware(FrontendKey, Middleware, time.Duration) error
	DeleteMiddleware(MiddlewareKey) error

	GetBackends() ([]Backend, error)
	GetBackend(BackendKey) (*Backend, error)
	UpsertBackend(Backend) error
	DeleteBackend(BackendKey) error

	GetServers(BackendKey) ([]Server, error)
	GetServer(ServerKey) (*Server, error)
	UpsertServer(BackendKey, Server, time.Duration) error
	DeleteServer(ServerKey) error

	// Subscribe is an entry point for getting the configuration changes as well as the initial configuration.
	// It should be a blocking function generating events from change.go to the changes channel.
	Subscribe(events chan interface{}, cancel chan bool) error

	// GetRegistry returns registry with the supported plugins.
	GetRegistry() *plugin.Registry

	// Close
	Close()
}

type Frontend struct {
	Id        string
	Route     string
	Type      string
	BackendId string

	Stats    *RoundTripStats `json:",omitempty"`
	Settings interface{}     `json:",omitempty"`
}

type FrontendDeleted struct {
	FrontendKey FrontendKey
}

type FrontendKey struct {
	Id string
}

type FrontendUpserted struct {
	Frontend Frontend
}

type HTTPBackendKeepAlive struct {
	// Keepalive period
	Period string
	// How many idle connections will be kept per host
	MaxIdleConnsPerHost int
}

type HTTPBackendSettings struct {
	Timeouts HTTPBackendTimeouts
	// Controls KeepAlive settins for backend servers
	KeepAlive HTTPBackendKeepAlive
}

type HTTPBackendTimeouts struct {
	// Socket read timeout (before we receive the first reply header)
	Read string
	// Socket connect timeout
	Dial string
	// TLS handshake timeout
	TLSHandshake string
}

type HTTPFrontendLimits struct {
	MaxMemBodyBytes int64 // Maximum size to keep in memory before buffering to disk
	MaxBodyBytes    int64 // Maximum size of a request body in bytes
}

type HTTPFrontendSettings struct {
	// Limits contains various limits one can supply for a location.
	Limits HTTPFrontendLimits
	// Predicate that defines when requests are allowed to failover
	FailoverPredicate string
	// Used in forwarding headers
	Hostname string
	// In this case appends new forward info to the existing header
	TrustForwardHeader bool
}

type Host struct {
	Name     string
	Settings HostSettings
}

type HostDeleted struct {
	HostKey HostKey
}

type HostKey struct {
	Name string
}

type HostSettings struct {
	KeyPair *KeyPair
	Default bool
}

type HostUpserted struct {
	Host Host
}

type KeyPair struct {
	Key  []byte
	Cert []byte
}

type LatencyBrackets []Bracket

type Listener struct {
	Id string
	// HTTP or HTTPS
	Protocol string
	// Adddress specifies network (tcp or unix) and address (ip:port or path to unix socket)
	Address Address
}

type ListenerDeleted struct {
	ListenerKey ListenerKey
}

type ListenerKey struct {
	Id string
}

type ListenerUpserted struct {
	HostKey  HostKey
	Listener Listener
}

type Middleware struct {
	Id         string
	Priority   int
	Type       string
	Middleware plugin.Middleware
}

type MiddlewareDeleted struct {
	MiddlewareKey MiddlewareKey
}

type MiddlewareKey struct {
	FrontendKey FrontendKey
	Id          string
}

type MiddlewareUpserted struct {
	FrontendKey FrontendKey
	Middleware  Middleware
}

type NewEngineFn func() (Engine, error)

type NotFoundError struct {
	Message string
}

type RawMiddleware struct {
	Id         string
	Type       string
	Priority   int
	Middleware json.RawMessage
}

type RoundTripStats struct {
	Verdict         Verdict
	Counters        Counters
	LatencyBrackets LatencyBrackets
}

type Server struct {
	Id    string
	URL   string
	Stats *RoundTripStats `json:",omitempty"`
}

type ServerDeleted struct {
	ServerKey ServerKey
}

type ServerKey struct {
	BackendKey BackendKey
	Id         string
}

type ServerUpserted struct {
	BackendKey BackendKey
	Server     Server
}

type StatsProvider interface {
	FrontendStats(FrontendKey) (*RoundTripStats, error)
	ServerStats(ServerKey) (*RoundTripStats, error)
	BackendStats(BackendKey) (*RoundTripStats, error)

	// TopFrontends returns locations sorted by criteria (faulty, slow, most used)
	// if hostname or backendId is present, will filter out locations for that host or backendId
	TopFrontends(*BackendKey) ([]Frontend, error)

	// TopServers returns endpoints sorted by criteria (faulty, slow, mos used)
	// if backendId is not empty, will filter out endpoints for that backendId
	TopServers(*BackendKey) ([]Server, error)
}

type StatusCode struct {
	Code  int
	Count int64
}

type TransportKeepAlive struct {
	// Keepalive period
	Period time.Duration
	// How many idle connections will be kept per host
	MaxIdleConnsPerHost int
}

type TransportSettings struct {
	Timeouts  TransportTimeouts
	KeepAlive TransportKeepAlive
}

type TransportTimeouts struct {
	// Socket read timeout (before we receive the first reply header)
	Read time.Duration
	// Socket connect timeout
	Dial time.Duration
	// TLS handshake timeout
	TLSHandshake time.Duration
}

type Verdict struct {
	IsBad     bool
	Anomalies []Anomaly
}