types

type AgentCheck struct {
	Addr     string
	Interval string
	Port     int
	Send     string
}

type Backend struct {
	//
	// core config
	//
	ID        string
	Namespace string
	Name      string
	Port      string
	Endpoints []*Endpoint
	EpNaming  EndpointNaming
	Paths     []*BackendPath
	PathsMap  *HostsMap
	//
	// per backend config
	//
	AgentCheck       AgentCheck
	BalanceAlgorithm string
	Cookie           Cookie
	CustomConfig     []string
	Dynamic          DynBackendConfig
	HealthCheck      HealthCheck
	Limit            BackendLimit
	ModeTCP          bool
	OAuth            OAuthConfig
	Resolver         string
	Server           ServerConfig
	Timeout          BackendTimeoutConfig
	TLS              BackendTLSConfig
	WhitelistTCP     []string
	//
	// per path config
	//
	// TODO refactor
	//
	// The current implementation is tricky. A small refactor is welcome
	// but can wait a little more. Multipath unit tests need to do a
	// better job as well.
	//
	// Following some tips in order to multipath work properly:
	//
	//   1. On backend annotation parsing, do not filter
	//      mapper.GetBackendConfig/Str() slice, instead populate
	//      haproxy type even with empty data. Backend.NeedACL() need
	//      to know all paths in order to work properly. Filter out
	//      empty/disabled items in the template.
	//
	//   2. Every config array added here, need also to be added
	//      in Backend.NeedACL() - haproxy/types/backend.go.
	//      Template uses this func in order to know if a config
	//      has two or more paths, and so need to be configured with ACL.
	//
	AuthHTTP      []*BackendConfigAuth
	Cors          []*BackendConfigCors
	HSTS          []*BackendConfigHSTS
	MaxBodySize   []*BackendConfigInt
	RewriteURL    []*BackendConfigStr
	SSLRedirect   []*BackendConfigBool
	WAF           []*BackendConfigStr
	WhitelistHTTP []*BackendConfigWhitelist
}

type BackendConfigAuth struct {
	Paths        BackendPaths
	UserlistName string
	Realm        string
}

type BackendConfigBool struct {
	Paths  BackendPaths
	Config bool
}

type BackendConfigCors struct {
	Paths  BackendPaths
	Config Cors
}

type BackendConfigHSTS struct {
	Paths  BackendPaths
	Config HSTS
}

type BackendConfigInt struct {
	Paths  BackendPaths
	Config int64
}

type BackendConfigStr struct {
	Paths  BackendPaths
	Config string
}

type BackendConfigWhitelist struct {
	Paths  BackendPaths
	Config []string
}

type BackendLimit struct {
	Connections int
	RPS         int
	Whitelist   []string
}

type BackendPath struct {
	ID       string
	Hostname string
	Hostpath string
	Path     string
}

type BackendPaths struct {
	Items []*BackendPath
}

type BackendTLSConfig struct {
	AddCertHeader bool
	HasTLSAuth    bool
}

type BackendTimeoutConfig struct {
	Connect     string
	HTTPRequest string
	KeepAlive   string
	Queue       string
	Server      string
	ServerFin   string
	Tunnel      string
}

type BindConfig struct {
	Name   string
	Socket string
	ID     int
	Hosts  []*Host
	//
	AcceptProxy bool
	TLS         BindTLSConfig
	//
	Maps          *HostsMaps
	UseServerList *HostsMap
}

type BindTLSConfig struct {
	ALPN       string
	CAFilename string
	CAHash     string
	TLSCert    string
	TLSCertDir string
}

type BindUtils interface {
	CreateX509CertsDir(bindName string, certs []string) (string, error)
}

type Cookie struct {
	Name     string
	Dynamic  bool
	Shared   bool
	Strategy string
}

type CookieConfig struct {
	Key string
}

type Cors struct {
	Enabled bool
	//
	AllowCredentials bool
	AllowHeaders     string
	AllowMethods     string
	AllowOrigin      string
	ExposeHeaders    string
	MaxAge           int
}

type DHParamConfig struct {
	Filename       string
	DefaultMaxSize int
}

type DNSConfig struct {
	ClusterDomain string
	Resolvers     []*DNSResolver
}

type DNSNameserver struct {
	Name     string
	Endpoint string
}

type DNSResolver struct {
	Name                string
	Nameservers         []*DNSNameserver
	AcceptedPayloadSize int
	HoldObsolete        string
	HoldValid           string
	TimeoutRetry        string
}

type DrainConfig struct {
	Drain      bool
	Redispatch bool
}

type DynBackendConfig struct {
	BlockSize    int
	DynUpdate    bool
	MinFreeSlots int
}

type Endpoint struct {
	Enabled   bool
	IP        string
	Name      string
	Port      int
	Target    string
	TargetRef string
	Weight    int
}

type EndpointNaming int

type Frontend struct {
	Name  string
	Binds []*BindConfig
	Hosts []*Host
	//
	Timeout HostTimeoutConfig
	//
	Maps                       *HostsMaps
	HostBackendsMap            *HostsMap
	MaxBodySizeMap             *HostsMap
	RootRedirMap               *HostsMap
	SNIBackendsMap             *HostsMap
	TLSInvalidCrtErrorList     *HostsMap
	TLSInvalidCrtErrorPagesMap *HostsMap
	TLSNoCrtErrorList          *HostsMap
	TLSNoCrtErrorPagesMap      *HostsMap
}

type FrontendGroup struct {
	Frontends []*Frontend
	//
	DefaultBind       *BindConfig
	HasSSLPassthrough bool
	ToHTTPBind        BindConfig
	//
	Maps              *HostsMaps
	HTTPFrontsMap     *HostsMap
	HTTPRootRedirMap  *HostsMap
	HTTPSRedirMap     *HostsMap
	SSLPassthroughMap *HostsMap
	VarNamespaceMap   *HostsMap
}

type Global struct {
	Bind            GlobalBindConfig
	Procs           ProcsConfig
	Syslog          SyslogConfig
	MaxConn         int
	Timeout         TimeoutConfig
	SSL             SSLConfig
	DNS             DNSConfig
	ModSecurity     ModSecurityConfig
	Cookie          CookieConfig
	DrainSupport    DrainConfig
	ForwardFor      string
	LoadServerState bool
	AdminSocket     string
	Healthz         HealthzConfig
	Stats           StatsConfig
	StrictHost      bool
	CustomConfig    []string
	CustomDefaults  []string
	CustomFrontend  []string
}

type GlobalBindConfig struct {
	AcceptProxy    bool
	HTTPBind       string
	HTTPSBind      string
	TCPBindIP      string
	FrontingBind   string
	FrontingSockID int
}

type HSTS struct {
	Enabled    bool
	MaxAge     int
	Subdomains bool
	Preload    bool
}

type HealthCheck struct {
	Addr      string
	FallCount int
	Interval  string
	Port      int
	RiseCount int
	URI       string
}

type HealthzConfig struct {
	BindIP string
	Port   int
}

type Host struct {
	Hostname string
	Paths    []*HostPath
	//
	Alias                  HostAliasConfig
	HTTPPassthroughBackend string
	RootRedirect           string
	SSLPassthrough         bool
	Timeout                HostTimeoutConfig
	TLS                    HostTLSConfig
	VarNamespace           bool
}

type HostAliasConfig struct {
	AliasName  string
	AliasRegex string
}

type HostBackend struct {
	ID        string
	Namespace string
	Name      string
	Port      string
}

type HostPath struct {
	Path    string
	Backend HostBackend
}

type HostTLSConfig struct {
	CAErrorPage      string
	CAFilename       string
	CAHash           string
	CAVerifyOptional bool
	TLSFilename      string
	TLSHash          string
}

type HostTimeoutConfig struct {
	Client    string
	ClientFin string
}

type HostsMap struct {
	Match     []*HostsMapEntry
	MatchFile string
	Regex     []*HostsMapEntry
	RegexFile string
}

type HostsMapEntry struct {
	Key   string
	Value string
}

type HostsMaps struct {
	Items []*HostsMap
}

type ModSecurityConfig struct {
	Endpoints []string
	Timeout   ModSecurityTimeoutConfig
}

type ModSecurityTimeoutConfig struct {
	Hello      string
	Idle       string
	Processing string
}

type OAuthConfig struct {
	Impl        string
	BackendName string
	URIPrefix   string
	Headers     map[string]string
}

type ProcsConfig struct {
	Nbproc          int
	Nbthread        int
	NbprocBalance   int
	NbprocSSL       int
	BindprocBalance string
	BindprocSSL     string
	CPUMap          string
}

type SSLConfig struct {
	ALPN          string
	DHParam       DHParamConfig
	Ciphers       string
	Options       string
	Engine        string
	ModeAsync     bool
	HeadersPrefix string
}

type ServerConfig struct {
	CAFilename    string
	CAHash        string
	Ciphers       string // TLS up to 1.2
	CipherSuites  string // TLS 1.3
	CRLFilename   string
	CRLHash       string
	CrtFilename   string
	CrtHash       string
	InitialWeight int
	MaxConn       int
	MaxQueue      int
	Options       string
	Protocol      string
	Secure        bool
	SendProxy     string
}

type StatsConfig struct {
	AcceptProxy bool
	Auth        string
	BindIP      string
	Port        int
	TLSFilename string
	TLSHash     string
}

type SyslogConfig struct {
	Endpoint       string
	Format         string
	HTTPLogFormat  string
	HTTPSLogFormat string
	Tag            string
	TCPLogFormat   string
}

type TCPBackend struct {
	Name          string
	Port          int
	Endpoints     []*TCPEndpoint
	CheckInterval string
	SSL           TCPSSL
	ProxyProt     TCPProxyProt
}

type TCPEndpoint struct {
	Name   string
	IP     string
	Port   int
	Target string
}

type TCPProxyProt struct {
	Decode        bool
	EncodeVersion string
}

type TCPSSL struct {
	Filename string
}

type TimeoutConfig struct {
	HostTimeoutConfig
	BackendTimeoutConfig
	Stop string
}

type User struct {
	Name      string
	Passwd    string
	Encrypted bool
}

type Userlist struct {
	Name  string
	Users []User
}

type UserlistConfig struct {
	Name  string
	Realm string
}