jobs

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 {
	// 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 {
	// 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
}

type JobInfo struct {
	LastExecuteTime time.Time
	ExecuteCount    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 {
	// When true, the scheduler will run jobs synchronously,
	// waiting for each execution instance of the job to return
	// before starting the next execution. Running with this
	// option effectively serializes all job execution.
	BlockingExecution bool `json:"blocking_execution" default:"false"`

	// 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. If BlockingExecution is set, then WorkerLimit
	// is ignored.
	WorkerLimit int `json:"worker_limit" default:"0"`
}

type SelfChecksIn struct {
	fx.In

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