server

type AIConfig struct {
	// NewProvider builds a provider client (tests inject fakes). The
	// default is provider.New.
	NewProvider func(provider.Config) (provider.Provider, error)
	// Workers bounds concurrently running jobs (default 2).
	Workers int
	// MaxQueued bounds jobs waiting for a worker (default 20).
	MaxQueued int
	// DefaultMonthlyTokenCap applies to providers saved without a cap
	// (default 2,000,000 tokens).
	DefaultMonthlyTokenCap int64
	// JobTimeout bounds one job (default 30 minutes).
	JobTimeout time.Duration
	// Transport overrides the dry run's HTTP transport (tests).
	Transport http.RoundTripper
}

type AutoExecutor struct {
	Local       Executor
	Distributed *DistributedExecutor
}

type Config struct {
	Store   *store.Store
	Keyring *keyring.Keyring
	Logger  *slog.Logger
	// Executor runs load. The default runs it inside the server process.
	Executor Executor
	// Workers lists connected workers for GET /workers (optional).
	Workers func() []WorkerInfo
	// UI is the built web app; nil serves only the API.
	UI fs.FS
	// SecureCookies sets the Secure flag (enable behind HTTPS).
	SecureCookies bool
	// DBRetryFor is how long writes at the end of a run (its report and
	// final status) are retried while the database is unreachable
	// (default two minutes).
	DBRetryFor time.Duration
	// TLS, when set, serves the API and web UI over HTTPS.
	TLS *tls.Config
	// RedirectAddr, with TLS, also listens for plain HTTP there and
	// redirects to HTTPS; RedirectHandler (for ACME HTTP-01 challenges)
	// wraps the redirect when set.
	RedirectAddr    string
	RedirectHandler func(fallback http.Handler) http.Handler
	// SessionTTL is how long a login lasts (default 7 days).
	SessionTTL time.Duration
	// HardCaps bound every run regardless of target settings.
	HardCaps safety.Caps
	// AbortFloor stops any run whose target is clearly failing, even when
	// its scenario sets no abort limits. Nil disables it.
	AbortFloor *scenario.Abort
	// DataDir is where CSV and JSON feeder files for server runs live.
	// Empty disables file feeders on the server.
	DataDir string
	// TrustedProxies are the reverse proxies whose X-Forwarded-For header
	// is believed. Empty means the connection's address is the client.
	TrustedProxies []netip.Prefix
	// Clock is replaceable in tests.
	Now func() time.Time
	// AI configures optional AI journey generation (see handlers_ai.go).
	AI AIConfig
	// Notify configures run notifications (see notifications.go).
	Notify NotifyConfig
	// OIDC turns on single sign-on (see oidc.go).
	OIDC *OIDCConfig
	// ReplicaAddr is this replica's address, recorded for operators.
	ReplicaAddr string
	// ReplicaHeartbeat and ReplicaStale tune how often a replica refreshes
	// its row and how old a row may get before its runs are settled
	// (defaults 5s and 30s).
	ReplicaHeartbeat, ReplicaStale time.Duration
	// SchedulerInterval is how often StartScheduler looks for due
	// schedules (default 15s).
	SchedulerInterval time.Duration
}

type DistributedExecutor struct {
	Coordinator *coordinator.Coordinator
}

type ExecEvent struct {
	Type    string
	Message string
	Worker  string
	Details map[string]any
}

type ExecResult struct {
	T0         time.Time
	End        time.Time
	StopReason string
	Phases     map[int]*[metrics.NumPhases]*metrics.Histogram
	PeakVUs    int
	Workers    int
	Notes      []string
	// Snapshots, when set, replaces the live snapshots for the report.
	Snapshots []*metrics.Snapshot
	// Annotate, when set, adds executor-specific detail to the report.
	Annotate func(*report.Report)
}

type ExecSpec struct {
	RunID    string
	Scenario *scenario.Scenario
	// YAML is the final scenario (overrides applied, base URL set) for
	// executors that ship it to workers.
	YAML    []byte
	Env     map[string]string
	Secrets map[string]string
	// AllowHosts are public hosts besides the target that requests may reach.
	AllowHosts []string
	TargetHost string
	// Workers is how many workers to use (0 = all available).
	Workers int
	// Regions splits load by worker region (fractions); nil does not.
	Regions map[string]float64
}

type Execution interface {
	// Snapshots delivers one merged snapshot per interval, in order, and
	// is closed when the run ends.
	Snapshots() <-chan *metrics.Snapshot
	// Events is closed when the run ends.
	Events() <-chan ExecEvent
	Stop(reason string)
	Kill()
	Wait(ctx context.Context) (*ExecResult, error)
}

type Executor interface {
	Start(ctx context.Context, spec ExecSpec) (Execution, error)
}

type LocalExecutor struct {
	Logger *slog.Logger
}

type NotifyConfig struct {
	// Sender delivers events; tests replace its backoff. The default
	// retries after 2s, 10s and 30s.
	Sender *notify.Sender
	// PublicURL is the server's external base URL, used for links to runs
	// in notifications. Empty leaves the links out.
	PublicURL string
	// KeepDeliveries is how many attempts are kept per channel (default 50).
	KeepDeliveries int
	// Concurrency bounds deliveries in flight (default 8).
	Concurrency int
}

type OIDCConfig struct {
	Issuer       string
	ClientID     string
	ClientSecret string
	// RedirectURL is where the provider sends users back; default the
	// server's public URL + /api/v1/auth/oidc/callback.
	RedirectURL string
	// Name labels the sign-in button (default "SSO").
	Name string
	// AllowedDomains limits sign-in to these email domains (empty: any).
	AllowedDomains []string
	// DefaultRole is given to people who sign in for the first time; empty
	// means only people who already have an account may sign in.
	DefaultRole auth.Role
	// Scopes besides openid (default email and profile).
	Scopes []string
}

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

type WorkerHealth struct {
	ID, Name, Region string
	// Connected is false once the worker stopped sending heartbeats.
	Connected   bool
	Saturated   bool
	Reasons     []string
	CPUPercent  float64
	SchedLagP99 time.Duration
	GCPauseP99  time.Duration
	Dropped     uint64
	// LastHeartbeat is zero before the first sample.
	LastHeartbeat time.Time
}

type WorkerInfo struct {
	ID          string
	Name        string
	Region      string
	Version     string
	Labels      map[string]string
	CPUs        int
	MemoryBytes int64
	// Protocols are the worker's drivers; Plugins its installed plugins.
	Protocols, Plugins []string
	Status             string
	RunID              string
	ConnectedAt        time.Time
	LastSeenAt         time.Time
}