scale

type Action string

type Budget struct {
	HostTotal  uint64 // total host resource
	HostFree   uint64 // measured-free right now
	Reserved   uint64 // everything NOT this service: control plane + edge + safety floor + OTHER apps' desired replicas
	FreeFloor  uint64 // keep at least this much free (applied to the measured budget)
	PerReplica uint64 // this service's per-replica reservation (required, non-zero)
	Current    int    // this service's current replica count
}

type CapacityInput struct {
	Mem Budget
	CPU Budget

	PolicyMax          int    // operator's configured max_replicas
	PerReplicaMemFloor uint64 // an implausibly small per-replica mem reservation is rejected
	NearOOMFreeBytes   uint64 // host mem free below this → effective_max collapses to 1
}

type Config struct {
	Store        *Store
	Alerts       *alertstore.Store // nil → refusals are logged only
	Snap         func() *monitor.Snapshot
	Sem          *dockerexec.Semaphore
	Scaler       Scaler
	Edge         EdgeReconciler // optional
	Reserves     Reserves
	Log          *slog.Logger
	Interval     time.Duration
	WritePlaneOK bool
	HostCPUMilli uint64                                        // total host CPU (milli); 0 disables the CPU budget
	IsCandidate  func(app, service string) (ServiceSpec, bool) // C1–C6 from compose; nil → trust the policy opt-in
	Now          func() int64
}

type Decision struct {
	Target int
	Action Action
	Reason string
	Next   State
}

type EdgeReconciler interface {
	ReconcilePool(ctx context.Context, app, service string, replicas int) error
}

type Key struct{ App, Service string }

type Metrics struct {
	CPUMeanPct float64
	MemMaxPct  float64
	AllHealthy bool
}

type Policy struct {
	Min, Max         int
	UpCPUPct         float64
	UpMemPct         float64
	DownCPUPct       float64
	DownMemPct       float64
	BreachForSecs    int64
	CooldownUpSecs   int64
	CooldownDownSecs int64
}

type PolicyRow struct {
	Policy
	Enabled       bool
	PerReplicaMem uint64
	PerReplicaCPU uint64
}

type Reserves struct {
	MemReserveBytes    uint64 // control plane + edge + safety floor (memory)
	CPUReserveMilli    uint64 // control plane + edge (cpu)
	MemFreeFloor       uint64 // keep at least this much memory free (measured budget)
	CPUFreeFloor       uint64
	NearOOMFreeBytes   uint64
	PerReplicaMemFloor uint64
}

type Scaler interface {
	Scale(ctx context.Context, app, service string, replicas int) error
}

type ServiceSpec struct {
	Name                string
	EdgeUpstream        bool // C1: an edge HTTP upstream with a known internal port
	L4Upstream          bool // C1 (alt): a managed L4 (TCP/UDP) upstream — fronted by an edge l4_route, replicas internal-only
	FixedHostPort       bool // C2 (disqualifies): publishes a fixed host port the LB does NOT own
	RWVolume            bool // C3 (disqualifies): has an exclusive read-write volume
	Stateful            bool // C4 (disqualifies): a DB/broker/coordination store
	IdentityPlaceholder bool // C5 (disqualifies): a deploy-time identity (node cookie/name/seed/host-bound port)
	StatelessContract   bool // C6: honors the stateless restart contract (operator attests)
	OptedIn             bool // C7: the operator explicitly enabled scaling for this service
}

type State struct {
	Replicas    int
	BreachSince int64 // unix sec; when the current up-breach started (0 = not breaching)
	LastChange  int64 // unix sec; last scale action (for the cooldowns)
}

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

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