scheduledtask

type AppStore interface {
	GetDesiredService(ctx context.Context, name string) (*store.DesiredService, error)
}

type AttemptFunc func(ctx context.Context, completion, attempt int) AttemptOutcome

type AttemptOutcome struct {
	RunID  string
	Status string
}

type HTTPConfigStore interface {
	GetScheduledTaskHTTP(ctx context.Context, taskID string) (store.ScheduledTaskHTTP, error)
}

type HTTPTarget interface {
	Prepare(ctx context.Context, svc *store.DesiredService) (baseURL string, err error)
}

type HistoryStore interface {
	CreateScheduledTaskRun(ctx context.Context, run store.ScheduledTaskRun) error
	FinishScheduledTaskRun(ctx context.Context, run store.ScheduledTaskRun) error
	PruneScheduledTaskRuns(ctx context.Context, taskID string, keep int, outputCutoff time.Time) error
}

type Limits struct {
	DefaultTimeout      time.Duration
	MaxRetries          int
	RetryBackoff        time.Duration
	MaxRetryBackoff     time.Duration
	CatchUpLookback     time.Duration
	HistoryKeep         int
	OutputRetention     time.Duration
	MaxPerApp           int
	MaxConcurrentPerApp int
	MaxOutputBytes      int
	BackgroundTimeout   time.Duration
}

type NodeRuntimeResolver func(nodeID string) (docker.Runtime, error)

type OneShot struct {
	// Sleep waits between retries; nil uses a context-aware timer.
	Sleep func(ctx context.Context, d time.Duration) error
	// Now returns the current time; nil uses time.Now.
	Now func() time.Time
	// contains filtered or unexported fields
}

type OneShotEntry struct {
	ID     string
	App    string
	TaskID string
	Spec   OneShotSpec
	Job    *OneShot
}

type OneShotLimits struct {
	BackoffLimit   int
	Timeout        time.Duration
	MaxCompletions int
	MaxParallelism int
	Keep           int
}

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

type OneShotSnapshot struct {
	State          string
	Completions    int
	Succeeded      int
	FailedAttempts int
	Active         int
	RunIDs         []string
	Message        string
	StartedAt      time.Time
	FinishedAt     *time.Time
}

type OneShotSpec struct {
	Completions  int
	Parallelism  int
	BackoffLimit int
	BackoffBase  time.Duration
	BackoffMax   time.Duration
}

type Recoverer interface {
	Cleanup(ctx context.Context, runs []store.ScheduledTaskRun)
}

type RunStore interface {
	RecordScheduledTaskRun(ctx context.Context, id string, ranAt time.Time, status, output string) error
}

type Runner struct {
	Apps     AppStore
	Runs     RunStore
	History  HistoryStore
	Specs    SpecBuilder
	Resolver NodeRuntimeResolver
	Logger   *slog.Logger
	Limits   Limits
	// Target and HTTPConfigs serve http-mode jobs; Client overrides the
	// HTTP client (nil uses http.DefaultClient).
	Target      HTTPTarget
	HTTPConfigs HTTPConfigStore
	Client      *http.Client
	// NamePrefix namespaces fresh job containers (the brand short name).
	NamePrefix string

	// Now returns the current time; nil falls back to time.Now.
	Now func() time.Time
	// Timeout overrides every attempt's timeout when positive; a test seam.
	Timeout time.Duration
	// Sleep waits between retries; nil uses a context-aware timer.
	Sleep func(ctx context.Context, d time.Duration) error
	// contains filtered or unexported fields
}

type ScheduleStore interface {
	ListEnabledScheduledTasks(ctx context.Context) ([]store.ScheduledTask, error)
	ClaimScheduledTaskRun(ctx context.Context, run store.ScheduledTaskRun) (bool, error)
	InterruptRunningScheduledTaskRuns(ctx context.Context, now time.Time) ([]store.ScheduledTaskRun, error)
}

type Scheduler struct {
	Store  ScheduleStore
	Runner TaskRunner
	Logger *slog.Logger
	// Now returns the current time; nil falls back to time.Now.
	Now func() time.Time
	// Grace is how late an occurrence may be and still count as on time;
	// zero means twice the interval passed to Run.
	Grace time.Duration
	// Lookback is the default catch-up window when a job sets none.
	Lookback time.Duration
	// NewID mints run IDs; nil uses NewRunID.
	NewID func() (string, error)
	// contains filtered or unexported fields
}

type SpecBuilder interface {
	BuildJobSpec(ctx context.Context, svc *store.DesiredService, rt docker.Runtime, name string, command []string, res *docker.Resources) (application.JobSpec, error)
	JobSecretValues(ctx context.Context, svc *store.DesiredService, rt docker.Runtime) ([]string, error)
}

type TaskRunner interface {
	RunTrigger(ctx context.Context, task store.ScheduledTask, trig Trigger) error
}

type Trigger struct {
	Kind string
	// RunID is the pre-claimed history row, set by Scheduler; empty makes
	// the runner create one.
	RunID        string
	ScheduledFor *time.Time
	CatchUp      bool
}