server

type Backend interface {
	Transport() http.RoundTripper // Returns a transport for the backend
	ID() string                   // A string identifier of this specific backend
	Name() string                 // A name for this backend
	Host() string                 // Returns the hostname of the backend
	Healthy() bool                // Is the backend healthy?
	Statistics() *Stats           // Returns a copy of the latest statistics. Updated every second.
	Connections() int             // Return the current number of connections
	Close()                       // Close the backend (before shutdown/reload).
}

type BackendConfig struct {
	DialTimeout   Duration `toml:"dial-timeout"`            // Timeout for connecting to a backend.
	LatencyAvg    int      `toml:"latency-average-seconds"` // Measure latency over this many seconds
	HealthTimeout Duration `toml:"health-check-timeout"`    // Timeout for a health check. Should be less than 1 second.
	HostPort      int      `toml:"new-host-port"`           // Host port the proxy should connect to.
	HealthPath    string   `toml:"new-host-health-path"`    // Health path to use.
	HealthHTTPS   bool     `toml:"new-host-health-https"`   // Set to true if the health check on new backs is https.
	DisableHealth bool     `toml:"disable-health-check"`    // Disable health checks.
}

type Config struct {
	Bind          string          `toml:"bind"`
	Https         bool            `toml:"https"`
	CertFile      string          `toml:"tls-cert-file"`
	KeyFile       string          `toml:"tls-key-file"`
	AddForwarded  bool            `toml:"add-x-forwarded-for"`
	WatchConfig   bool            `toml:"watch-config"` // Watch the configuration file for changes
	LoadBalancing LBConfig        `toml:"loadbalancing"`
	InventoryFile string          `toml:"inventory-file"`
	Backend       BackendConfig   `toml:"backend"`
	Provision     ProvisionConfig `toml:"provisioning"`
	DO            DOConfig        `toml:"do-provisioner"`
}

type DOConfig struct {
	Enable     bool   `toml:"enable"`
	HostPrefix string `toml:"hostname-prefix"`
	Region     string `toml:"region"`
	Size       string `toml:"size"`
	Image      string `toml:"image"`
	UserData   string `toml:"user-data"`
	Backups    bool   `toml:"backups"`
	Token      string `toml:"token"`
	SSHKeyID   []int  `toml:"ssh-key-ids"`
}

type Droplet struct {
	ID         int       `toml:"id"`
	Name       string    `toml:"name"`
	PublicIP   string    `toml:"public-ip"`
	PrivateIP  string    `toml:"private-ip"`
	ServerHost string    `toml:"server-host"`
	HealthURL  string    `toml:"health-url"`
	Started    time.Time `toml:"started-time"`
}

type DropletBackend struct {
	Droplet Droplet
	// contains filtered or unexported fields
}

type Droplets struct {
	Droplets []Droplet `toml:"droplet"`
}

type Duration time.Duration

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

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

type LBConfig struct {
	Type string `toml:"type"`
}

type LBStats struct {
	HealtyBackends   int
	UnhealtyBackends int
	AvgLatency       time.Duration
	Connections      int
}

type LoadBalancer interface {
	// Return a single backend instance.
	// If none can be found nil will be returned.
	Backend() Backend

	// Close all backends and stop monitoring them
	Close()
}

type ProvisionConfig struct {
	Enable bool `toml:"enable"`

	// The minimum number of running backends.
	MinBackends int `toml:"min-backends"`
	// The maximum number of running backends.
	MaxBackends int `toml:"max-backends"`

	// If latency is below this, deprovision one server.
	DownscaleLatency Duration `toml:"downscale-latency"`
	// How long should the latency be below threshold before a server is deprovisioned.
	// This is an Exponentially Weighted Moving Average.
	DownscaleTime Duration `toml:"downscale-time"`
	// How long between a server can be deprovisioned.
	DownscaleEvery Duration `toml:"downscale-every"`

	// If the latency is above this, provision a new server.
	UpscaleLatency Duration `toml:"upscale-latency"`
	// How long should the latency be below threshold before a server is provisioned.
	// This is an Exponentially Weighted Moving Average.
	UpscaleTime Duration `toml:"upscale-time"`
	// How long between a new server can be provisioned.
	UpscaleEvery Duration `toml:"upscale-every"`

	// If a server fails this many health consequtive health checks, it will be deprovisioned.
	// Health checks is performed every second.
	MaxHealthFailures int `toml:"max-health-failures"`
}

type Provisioner interface {
	Add() error
	Remove() error
}

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

type Server struct {
	Config Config
	// contains filtered or unexported fields
}

type Stats struct {
	Healthy     bool
	Latency     ewma.MovingAverage
	FailureRate ewma.MovingAverage
	// contains filtered or unexported fields
}