appsleep

type ActiveOps interface {
	ServicesWithActiveDeploy(ctx context.Context) (map[string]bool, error)
}

type Apps interface {
	GetDesiredService(ctx context.Context, name string) (*store.DesiredService, error)
	UpdateServiceSuspended(ctx context.Context, name string, suspended bool) error
}

type Breakdowns interface {
	QueryBreakdown(ctx context.Context, resourceID string, from, to time.Time) (telemetry.Breakdown, error)
}

type Config struct {
	NetworkFloorBytesPerMin int64
	WakeCooldown            time.Duration
	PortWakeTimeout         time.Duration
	PortWakeRetry           time.Duration
	PortWakeCollect         time.Duration
	PortWakeMinPort         int
	IdleMin                 int
	IdleMax                 int
	IdleDefault             int
	HoldMin                 time.Duration
	HoldMax                 time.Duration
	HoldDefault             time.Duration
	HoldHeadroom            float64
	WakeProbeInterval       time.Duration
}

type ConnCounter interface {
	Open(ctx context.Context, app string, ports []int) int
}

type DecideInput struct {
	Now         time.Time
	IdleMinutes int
	// Since is when the app was enabled or last woke.
	Since time.Time
	// ObservedFrom is when this process started watching; earlier time is unknown.
	ObservedFrom time.Time
	Cooldown     time.Duration
	Signals      Signals
}

type Decision struct {
	Sleep  bool
	Reason string
	// LastActivity is the newest sign of use, or the baseline when there is none.
	LastActivity time.Time
	IdleFor      time.Duration
	// WillSleepAt is when the app would sleep if nothing else happens, zero when held.
	WillSleepAt time.Time
}

type Eligibility struct {
	Blockers []Item
	Warnings []Item
}

type EventStore interface {
	AddSleepEvent(ctx context.Context, e store.SleepEvent) (int64, error)
	AddAppEvent(ctx context.Context, e store.AppEvent) error
}

type Facts struct {
	App string
	// IdleMinutes is the current setting, 0 when off; fixes keep it.
	IdleMinutes int
	// PinnedPorts are the host ports the app pins; empty means none.
	PinnedPorts []int
	// PortWakeSupported says Levelrail can hold those ports while the app sleeps.
	PortWakeSupported bool
	// PortWakeUnsupportedReason explains why not, shown when it matters.
	PortWakeUnsupportedReason string
	// PortWakeEnabled is the per-app port_wake setting.
	PortWakeEnabled bool
	// PortWakeError is the last bind failure for the pinned ports, if any.
	PortWakeError string
	// IsManagedDatabase is true when the app name is a managed database.
	IsManagedDatabase bool
	// StatefulImage is true for a well known database image.
	StatefulImage bool
	// NodeUnschedulable is true when the app's node is cordoned or drained.
	NodeUnschedulable bool
	CanaryTarget      bool
	// DependedOnBy lists sibling apps that start after, and reach, this one.
	DependedOnBy []string
	HoldRequests bool
	HasDomain    bool
	HasStreams   bool
	IsTrial      bool
	Replicas     int
	// LastWakeError is the last failed wake, empty when the last wake worked.
	LastWakeError string
}

type Fix struct {
	Kind   string         `json:"kind"`
	Label  string         `json:"label"`
	Method string         `json:"method"`
	Path   string         `json:"path"`
	Body   map[string]any `json:"body,omitempty"`
}

type Fleet struct {
	Services map[string]store.DesiredService
	// contains filtered or unexported fields
}

type FleetStore interface {
	ListDesiredServices(ctx context.Context) ([]store.DesiredService, error)
	ListNodes(ctx context.Context) ([]store.Node, error)
	ListCanaryReleases(ctx context.Context) ([]store.CanaryRelease, error)
	ListDesiredDatabases(ctx context.Context) ([]store.DesiredDatabase, error)
	CountAppStreamsByService(ctx context.Context) (map[string]int, error)
}

type Item struct {
	Code   string `json:"code"`
	Title  string `json:"title"`
	Detail string `json:"detail"`
	Fix    *Fix   `json:"fix,omitempty"`
}

type Metrics interface {
	QueryMany(ctx context.Context, resourceIDs, metrics []string, from, to time.Time) ([]telemetry.Sample, error)
}

type NetSample struct {
	At    time.Time
	Bytes float64
}

type Nudger interface{ Nudge() }

type PortSyncer interface{ Sync(ctx context.Context) }

type PortWakeManager struct {
	Store  PortWakeStore
	Apps   Apps
	Nudger Nudger
	Events EventStore
	Logger *slog.Logger
	Cfg    Config
	Now    func() time.Time
	// IsLocal says whether nodeID is the node this process runs on; nil treats "" as local.
	IsLocal func(nodeID string) bool
	// Ready adds an application level readiness check on top of the port answering.
	Ready func(ctx context.Context, name string, since time.Time) bool
	// Listen and Dial are replaceable for tests.
	Listen func(network, addr string) (net.Listener, error)
	Dial   func(ctx context.Context, network, addr string) (net.Conn, error)
	// contains filtered or unexported fields
}

type PortWakeStatus struct {
	Active bool
	Ports  []int
	// Error is the last bind failure, empty when the listeners are fine.
	Error string
}

type PortWakeStore interface {
	SleepStore
	GetAppSleep(ctx context.Context, serviceName string) (store.AppSleep, error)
	SetAppSleepWakeError(ctx context.Context, serviceName, msg string, now time.Time) error
}

type PortWaker interface {
	// Supported says whether port wake can hold svc's pinned ports, and if not why.
	Supported(svc *store.DesiredService) (bool, string)
	// Status reports the live listener state for name.
	Status(name string) PortWakeStatus
}

type Scheduler struct {
	Sleep   SleepStore
	Apps    Apps
	Traffic Traffic
	Nudger  Nudger
	// Events records slept and woke history; nil skips it.
	Events EventStore
	Logger *slog.Logger
	Now    func() time.Time

	// Optional signals. Without one, that signal is not consulted.
	Metrics    Metrics
	Breakdowns Breakdowns
	Conns      ConnCounter
	Ops        ActiveOps
	Fleet      FleetStore
	PortWake   PortWaker
	PortSync   PortSyncer
	Cfg        Config
	// ObservedFrom starts the observation window; zero means the first tick.
	ObservedFrom time.Time
	// contains filtered or unexported fields
}

type Signals struct {
	// LastRequest is the newest real (not ignored) ingress request, zero if none.
	LastRequest time.Time
	// LastNetwork is the newest moment container traffic was above the floor.
	LastNetwork time.Time
	// OpenConnections counts established connections to the app right now.
	OpenConnections int
	// OperationInFlight is true while a deploy, build or rollback runs.
	OperationInFlight bool
}

type SleepStore interface {
	ListAppSleep(ctx context.Context) ([]store.AppSleep, error)
	SetAppSleeping(ctx context.Context, serviceName string, sleeping bool, now time.Time) error
}

type Snapshot struct {
	LastRequest     time.Time
	LastNetwork     time.Time
	OpenConnections int
	Decision        Decision
}

type Traffic interface {
	LatestByMetric(ctx context.Context, metric string) ([]telemetry.Sample, error)
}