gslb

type Backend struct {
	Fqdn            string               // Fully qualified domain name
	Description     string               // Description of the backend
	Address         string               // IP address or hostname
	Port            int                  // Port number of the backend
	Priority        int                  // Priority for load balancing
	Weight          int                  // Weight for weighted load balancing
	Enable          bool                 // Enable or disable the backend
	Tags            []string             // List of tags for filtering or grouping
	HealthChecks    []GenericHealthCheck `yaml:"healthchecks"` // Health check configurations
	Timeout         string               // Timeout for requests
	Alive           bool                 // Indicates if the backend is alive
	Continent       string               // Continent code for GeoIP (e.g. EU)
	Country         string               // Country code for GeoIP
	Subdivision     string               // Subdivision/state code for GeoIP (e.g. CA, NY)
	City            string               // City name for GeoIP
	ASN             string               // ASN for GeoIP
	Location        string               // location
	Longitude       float64              // Longitude for distance-based GeoIP routing
	Latitude        float64              // Latitude for distance-based GeoIP routing
	LongitudeRad    float64              // Precomputed longitude in radians for distance calculations
	LatitudeRad     float64              // Precomputed latitude in radians for distance calculations
	HasCoordinates  bool                 // Indicates whether both coordinates were explicitly configured
	LastHealthcheck time.Time            // Last time a healthcheck was launched
	AssumeHealthy   bool                 `yaml:"assume_healthy"` // Bypass healthchecks and assume UP
	Passive         bool                 `yaml:"passive"`        // Passive health checking, read from Redis only
	Rise            int                  `yaml:"rise" default:"2"`
	Fall            int                  `yaml:"fall" default:"3"`
	// contains filtered or unexported fields
}

type BackendInterface interface {
	GetFqdn() string
	SetFqdn(fqdn string)
	GetDescription() string
	GetAddress() string
	GetPort() int
	GetPriority() int
	GetWeight() int
	IsEnabled() bool
	GetAssumeHealthy() bool
	IsPassive() bool
	GetRise() int
	GetFall() int
	GetTags() []string
	GetHealthChecks() []GenericHealthCheck
	GetTimeout() string
	GetContinent() string
	GetCountry() string
	GetSubdivision() string
	GetCity() string
	GetASN() string
	GetLocation() string
	GetLongitude() float64
	GetLatitude() float64
	GetLongitudeRad() float64
	GetLatitudeRad() float64
	HasGeoCoordinates() bool
	IsHealthy() bool
	IsAlive() bool
	SetAlive(alive bool)
	GetLastHealthcheck() time.Time
	SetLastHealthcheck(t time.Time)

	ApplyHealthCheckResult(alive bool)

	Lock()
	Unlock()
	// contains filtered or unexported methods
}

type BackendState struct {
	Status         string    `json:"status"` // "healthy" or "unhealthy"
	LastCheck      time.Time `json:"last_check"`
	LastResolution time.Time `json:"last_resolution"`
}

type ClientInfo struct {
	IP        net.IP
	PrefixLen uint8
}

type CustomSubnet struct {
	Subnet   string
	IPNet    *net.IPNet
	Location string
}

type DiscoveredEndpoint struct {
	Address string
	Port    int
}

type DiscoveryConfig struct {
	Type     string `yaml:"type"`
	Endpoint string `yaml:"endpoint"`
	Service  string `yaml:"service"`
	Interval string `yaml:"interval"`
	Tag      string `yaml:"tag"`
}

type FallbackPolicy struct {
	Mode          string   `yaml:"mode"`
	FallbackIPs   []string `yaml:"fallback_ips"`
	FallbackCNAME string   `yaml:"fallback_cname"`
	Rcode         string   `yaml:"rcode"`
}

type GRPCHealthCheck struct {
	Host          string        `yaml:"host"`
	Port          int           `yaml:"port"`
	Service       string        `yaml:"service"`
	Timeout       time.Duration `yaml:"timeout"`
	EnableTLS     bool          `yaml:"enable_tls"`
	Cert          string        `yaml:"cert_path"`
	Key           string        `yaml:"key_path"`
	CA            string        `yaml:"ca_path"`
	SkipTLSVerify bool          `yaml:"skip_tls_verify"`
}

type GSLB struct {
	Next                plugin.Handler
	Zones               map[string]string             // List of authoritative domains
	Records             map[string]map[string]*Record // zone -> fqdn -> record
	HealthcheckProfiles map[string]*HealthCheck       `yaml:"healthcheck_profiles"`

	Zone                      string   // Zone attendue pour la vérification des records
	LastResolution            sync.Map // key: domain (string), value: time.Time
	RoundRobinIndex           sync.Map
	MaxStaggerStart           string
	BatchSizeStart            int
	ResolutionIdleTimeout     string
	ResolutionIdleMultiplier  int // Multiplier for slow healthcheck interval
	HealthcheckIdleMultiplier int // Multiplier for slow healthcheck interval
	Mutex                     sync.RWMutex
	LocationMapMutex          sync.Mutex
	UseEDNSCSubnet            bool
	LocationMap               map[string]string
	LocationMapIPNet          []CustomSubnet
	GeoIPCountryDB            *geoip2.Reader // Loaded MaxMind DB (country)
	GeoIPCityDB               *geoip2.Reader // Loaded MaxMind DB (city)
	GeoIPASNDB                *geoip2.Reader // Loaded MaxMind DB (ASN)
	APIEnable                 bool           // Enable/disable API HTTP server
	APICertPath               string         // TLS certificate path for API
	APIKeyPath                string         // TLS key path for API
	APIListenAddr             string         // API listen address (default 0.0.0.0)
	APIListenPort             string         // API listen port (default 8080)
	APIBasicUser              string         // HTTP Basic Auth username (optional)
	APIBasicPass              string         // HTTP Basic Auth password (optional)
	// DisableTXT disables TXT record resolution if set to true
	DisableTXT bool

	RedisEnable    bool
	RedisAddr      string
	RedisPassword  string
	RedisDB        int
	RedisKeyPrefix string
	RedisSyncMode  string

	StatePersistEnable   bool
	StatePersistPath     string
	StatePersistInterval string
	StateMaxAge          string
	// contains filtered or unexported fields
}

type GenericHealthCheck interface {
	// PerformCheck executes the health check for a backend.
	PerformCheck(backend *Backend, fdqn string, maxRetries int) bool

	// GetType returns the type of the health check (e.g., "http/80").
	GetType() string

	// Equals compares the current health check with another instance for equality.
	Equals(other GenericHealthCheck) bool
}

type HTTPHealthCheck struct {
	Port          int               `yaml:"port" default:"443"`
	EnableTLS     bool              `yaml:"enable_tls" default:"true"`
	Cert          string            `yaml:"cert_path" default:""`
	Key           string            `yaml:"key_path" default:""`
	CA            string            `yaml:"ca_path" default:""`
	URI           string            `yaml:"uri" default:"/"`
	Method        string            `yaml:"method" default:"GET"`
	Host          string            `yaml:"host" default:"localhost"`
	Headers       map[string]string `yaml:"headers"`
	Timeout       string            `yaml:"timeout" default:"5s"`
	ExpectedCode  int               `yaml:"expected_code" default:"200"`
	ExpectedBody  string            `yaml:"expected_body" default:""`
	SkipTLSVerify bool              `yaml:"skip_tls_verify" default:"false"`
}

type HealthCheck struct {
	Type   string                 `yaml:"type"`
	Params map[string]interface{} `yaml:"params"`
	Rise   int                    `yaml:"rise"`
	Fall   int                    `yaml:"fall"`
}

type ICMPHealthCheck struct {
	Count   int    `yaml:"count" default:"3"`    // Number of ICMP packets to send
	Timeout string `yaml:"timeout" default:"5s"` // Maximum duration for pings
}

type LuaHealthCheck struct {
	Script  string                                  `yaml:"script"`
	Timeout time.Duration                           `yaml:"timeout"`
	Proto   atomic.Pointer[gopherlua.FunctionProto] `yaml:"-"`
}

type MockHealthCheck struct{}

type MySQLHealthCheck struct {
	Host     string `yaml:"host"`
	Port     int    `yaml:"port" default:"3306"`
	User     string `yaml:"user"`
	Password string `yaml:"password"`
	Database string `yaml:"database"`
	Timeout  string `yaml:"timeout" default:"3s"`
	Query    string `yaml:"query" default:"SELECT 1"`
}

type Pinger interface {
	Run() error
	Statistics() *probing.Statistics
	SetPrivileged(privileged bool)
}

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

type Record struct {
	Fqdn           string
	Zone           string
	Mode           string
	Backends       []BackendInterface
	Owner          string
	Description    string
	RecordTTL      int
	ScrapeInterval string
	ScrapeRetries  int
	ScrapeTimeout  string
	FallbackPolicy FallbackPolicy
	Discovery      *DiscoveryConfig
	ALPN           []string
	// contains filtered or unexported fields
}

type RedisHealthUpdate struct {
	Zone    string `json:"zone"`
	Fqdn    string `json:"fqdn"`
	Address string `json:"address"`
	Alive   bool   `json:"alive"`
}

type TCPHealthCheck struct {
	Port    int    `yaml:"port" default:"80"`    // TCP port to connect to
	Timeout string `yaml:"timeout" default:"5s"` // Timeout for the TCP connection
}