jobs

type BasicJob struct {
	JobFunc JobCallback
	JobBase
}

type BodyProvider func() io.Reader

type GroupWatcher interface {
	OnJobRegistered(name string)
	OnJobDeregistered(name string)
	OnJobScheduled(name string)
	OnJobCompleted(name string, status *statusv1.Status, jobStats JobStats)
}

type GroupWatchers []GroupWatcher

type HTTPJob struct {
	BasicJob
	// contains filtered or unexported fields
}

type HTTPJobConfig struct {
	Client         *http.Client
	Body           BodyProvider
	URL            string
	Method         string
	ExpectedBody   string
	Name           string
	ExpectedStatus int
}

type Job interface {
	// Returns the name
	Name() string
	// Executes the job
	Execute(ctx context.Context) (proto.Message, error)
	// JobWatchers
	JobWatchers() JobWatchers
}

type JobBase struct {
	JobName string
	JWS     JobWatchers
}

type JobCallback func(context.Context) (proto.Message, error)

type JobConfig struct {
	// Initial delay to start the job. Zero value will schedule the job immediately. Negative value will wait for next scheduled interval.
	InitialDelay config.Duration `json:"initial_delay" default:"0s"`

	// Time period between job executions. Zero or negative value means that the job will never execute periodically.
	ExecutionPeriod config.Duration `json:"execution_period" default:"10s"`

	// Execution timeout
	ExecutionTimeout config.Duration `json:"execution_timeout" validate:"gte=0s" default:"5s"`

	// Sets whether the job is initially healthy
	InitiallyHealthy bool `json:"initially_healthy" default:"false"`
}

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

type JobGroupConfig struct {
	SchedulerConfig `json:",inline"`
}

type JobGroupConstructor struct {
	// Name of the job group - config key is <name> and statuses are updated under <name>.<job>
	Name string
	// Config key --  if it is empty then it is <name>.scheduler
	Key           string
	GW            GroupWatchers
	DefaultConfig JobGroupConfig
	SchedulerMode SchedulerMode
}

type JobInfo struct {
	LastRunTime time.Time
	NextRunTime time.Time
	RunCount    int
}

type JobStats struct {
	Duration time.Duration
}

type JobWatcher interface {
	OnJobScheduled()
	OnJobCompleted(status *statusv1.Status, stats JobStats)
}

type JobWatchers []JobWatcher

type MultiJob struct {
	JobBase
	// contains filtered or unexported fields
}

type MultiJobConfig struct {
	JobConfig
}

type MultiJobConstructor struct {
	DefaultConfig MultiJobConfig
	Name          string
	JobGroupName  string
	JWS           JobWatchers
	GWS           GroupWatchers
}

type SchedulerConfig struct {
	// Limits how many jobs can be running at the same time. This is useful when running resource intensive jobs and a precise start time is not critical. 0 = no limit.
	MaxConcurrentJobs int `json:"max_concurrent_jobs" validate:"gte=0" default:"0"`
}

type SchedulerMode int8

type SelfChecksIn struct {
	fx.In

	Liveness  *MultiJob `name:"liveness.service"`
	Readiness *MultiJob `name:"readiness.service"`
}