job

func CancelRunContexts ¶

func CancelRunContexts(runID uuid.UUID) int

CancelRunContexts cancels every in-process run context registered for runID and reports how many were cancelled.

func EnumerateLogicalDates ¶

func EnumerateLogicalDates(schedule cron.Schedule, start, end time.Time, loc *time.Location) []time.Time

EnumerateLogicalDates returns all cron fire times in [start, end). loc sets the timezone used when computing schedule boundaries; pass time.UTC when the trigger has no timezone configured.

func FilterDates ¶

func FilterDates(store *backfillstore.Store, jobID uuid.UUID, dates []time.Time, reprocess string) ([]time.Time, error)

FilterDates filters logical dates based on the reprocess policy:

"none"   — skip dates that have any existing run
"failed" — skip dates whose latest run succeeded
"all"    — keep all dates

func RegisterRunCancel ¶

func RegisterRunCancel(parent context.Context, runID uuid.UUID) (context.Context, func())

RegisterRunCancel derives the cancellable context a detached run must execute under. EVERY `run.WithContext(context.Background(), runID)` kickoff site wraps its parent with this call; missing one leaves that entry point's runs uncancellable, which is the bug in the first place.

ctx, release := job.RegisterRunCancel(context.Background(), r.ID)
defer release()
job.New(...).Run(runstorage.WithContext(ctx, r.ID))

func RunBackfill ¶

func RunBackfill(
	ctx context.Context,
	b *models.Backfill,
	j *models.Job,
	schedule cron.Schedule,
	loc *time.Location,
)

RunBackfill executes a backfill by enumerating logical dates, filtering by the reprocess policy, and running each date through the standard job executor with a semaphore controlling max concurrency.

It honours ctx cancellation: when cancelled, no new runs are started but any in-flight runs are allowed to finish.

func SubscribeRunCancellations ¶

func SubscribeRunCancellations(ctx context.Context, bus event.Bus)

SubscribeRunCancellations wires the registry to the in-process event bus: TypeRunCancelled — published by both run.Store.CancelRun and the concurrency `replace` admission, which share cancelRunTx — cancels the run's registered contexts, and the local executor's taskCtx.Done() branch then force-stops the container (internal/job/job.go).

It returns as soon as the subscription is established; the pump runs until ctx is done. A bus that refuses the subscription is logged and ignored rather than fatal: a server that cannot cancel containers is still a server that runs jobs.