cron

type Action func(ctx context.Context) error

type Config struct{}

type DailySchedule struct {
	DayOfWeekMask uint
	TimeOfDayUTC  time.Time
}

type EnabledProvider interface {
	Enabled() bool
}

type Event struct {
	*logger.EventMeta
	// contains filtered or unexported fields
}

type ImmediateSchedule struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type IntervalSchedule struct {
	Every      time.Duration
	StartDelay *time.Duration
}

type Job interface {
	Name() string
	Execute(ctx context.Context) error
}

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

type JobInvocation struct {
	ID        string        `json:"id"`
	Name      string        `json:"name"`
	JobMeta   *JobMeta      `json:"-"`
	StartTime time.Time     `json:"startTime"`
	Timeout   time.Time     `json:"timeout"`
	Err       error         `json:"err"`
	Elapsed   time.Duration `json:"elapsed"`

	Context context.Context    `json:"-"`
	Cancel  context.CancelFunc `json:"-"`
}

type JobManager struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type JobMeta struct {
	Name        string         `json:"name"`
	Job         Job            `json:"-"`
	Disabled    bool           `json:"disabled"`
	NextRunTime time.Time      `json:"nextRunTime"`
	Last        *JobInvocation `json:"last"`

	// these are used at runtime and not serialized with the status.
	Schedule                       Schedule             `json:"-"`
	EnabledProvider                func() bool          `json:"-"`
	SerialProvider                 func() bool          `json:"-"`
	TimeoutProvider                func() time.Duration `json:"-"`
	ShouldTriggerListenersProvider func() bool          `json:"-"`
	ShouldWriteOutputProvider      func() bool          `json:"-"`
}

type OnBrokenReceiver interface {
	OnBroken(context.Context)
}

type OnCancellationReceiver interface {
	OnCancellation(context.Context)
}

type OnCompleteReceiver interface {
	OnComplete(context.Context)
}

type OnFailureReceiver interface {
	OnFailure(context.Context)
}

type OnFixedReceiver interface {
	OnFixed(context.Context)
}

type OnStartReceiver interface {
	OnStart(context.Context)
}

type OnTheHourAt struct {
	Minute int
	Second int
}

type OnceAtUTCSchedule struct {
	Time time.Time
}

type Schedule interface {
	// GetNextRuntime should return the next runtime after a given previous runtime. If `after` is <nil> it should be assumed
	// the job hasn't run yet. If <nil> is returned by the schedule it is inferred that the job should not run again.
	GetNextRunTime(*time.Time) *time.Time
}

type ScheduleProvider interface {
	Schedule() Schedule
}

type SerialProvider interface {
	Serial() bool
}

type ShouldTriggerListenersProvider interface {
	ShouldTriggerListeners() bool
}

type ShouldWriteOutputProvider interface {
	ShouldWriteOutput() bool
}

type State string

type Status struct {
	Jobs    []JobMeta
	Running map[string]JobInvocation
}

type StatusProvider interface {
	Status() string
}

type TimeoutProvider interface {
	Timeout() time.Duration
}

type TraceFinisher interface {
	Finish(context.Context)
}

type Tracer interface {
	Start(context.Context) (context.Context, TraceFinisher)
}