Hugo
f227020b67
This commit changes the logic around selecting jobs to run. Before this, Boundary used a view "job_jobs_to_run" which was a collation of all jobs that were not running and scheduled to run. When jobs were requested to run, Boundary would look at this view, grab a certain amount of jobs and insert them into the "job_run" table. Importantly, while the amount of jobs to be scheduled at once defaulted to 1 in the scheduler package, this was entirely overriden in the controller package to -1 (no limit, run all jobs that the query would return). With this commit, Boundary now looks at the "job" table directly for jobs to run, regardless of job run status. This was done to improve DB performance as the view (which queried all "job_run" rows) was causing significant DB contention. Additionally, the option to limit job runs is now removed since it was already hardcoded to -1 and not user-configurable anyways. Should the need arise to implement this limit again, this will have to be done in a different way since the new query does not account for running jobs and limiting the rows returned after jobs are already running would yield a no-op (the new query inserts nothing into "job_run" if any given job is already running).
96 lines
2.8 KiB
Go
96 lines
2.8 KiB
Go
// Copyright (c) HashiCorp, Inc.
|
|
// SPDX-License-Identifier: BUSL-1.1
|
|
|
|
package scheduler
|
|
|
|
import "time"
|
|
|
|
const (
|
|
defaultRunJobsInterval = time.Minute
|
|
defaultMonitorInterval = 30 * time.Second
|
|
defaultInterruptThreshold = 5 * time.Minute
|
|
)
|
|
|
|
// getOpts - iterate the inbound Options and return a struct
|
|
func getOpts(opt ...Option) options {
|
|
opts := getDefaultOptions()
|
|
for _, o := range opt {
|
|
o(&opts)
|
|
}
|
|
return opts
|
|
}
|
|
|
|
// Option - how Options are passed as arguments
|
|
type Option func(*options)
|
|
|
|
// options = how options are represented
|
|
type options struct {
|
|
withNextRunIn time.Duration
|
|
withRunJobInterval time.Duration
|
|
withMonitorInterval time.Duration
|
|
withInterruptThreshold time.Duration
|
|
withRunNow bool
|
|
}
|
|
|
|
func getDefaultOptions() options {
|
|
return options{
|
|
withRunJobInterval: defaultRunJobsInterval,
|
|
withMonitorInterval: defaultMonitorInterval,
|
|
withInterruptThreshold: defaultInterruptThreshold,
|
|
}
|
|
}
|
|
|
|
// WithRunJobsInterval provides an option to provide the interval at which the scheduler
|
|
// will query the repository for jobs to run.
|
|
// If WithRunJobsInterval == 0, then default interval is used.
|
|
func WithRunJobsInterval(l time.Duration) Option {
|
|
return func(o *options) {
|
|
o.withRunJobInterval = l
|
|
if o.withRunJobInterval == 0 {
|
|
o.withRunJobInterval = defaultRunJobsInterval
|
|
}
|
|
}
|
|
}
|
|
|
|
// WithMonitorInterval provides an option to provide the interval at which the scheduler
|
|
// will query running jobs for status and update the repository accordingly.
|
|
// If WithMonitorInterval == 0, then default interval is used.
|
|
func WithMonitorInterval(l time.Duration) Option {
|
|
return func(o *options) {
|
|
o.withMonitorInterval = l
|
|
if o.withMonitorInterval == 0 {
|
|
o.withMonitorInterval = defaultMonitorInterval
|
|
}
|
|
}
|
|
}
|
|
|
|
// WithInterruptThreshold provides an option to provide the duration after which a controller
|
|
// will interrupt a running job that is not updating its status.
|
|
// If WithInterruptThreshold == 0, then default duration is used.
|
|
func WithInterruptThreshold(l time.Duration) Option {
|
|
return func(o *options) {
|
|
o.withInterruptThreshold = l
|
|
if o.withInterruptThreshold == 0 {
|
|
o.withInterruptThreshold = defaultInterruptThreshold
|
|
}
|
|
}
|
|
}
|
|
|
|
// WithNextRunIn provides an option to provide the duration until the next run is scheduled.
|
|
// If this option is not provided the NextScheduledRun of the job will default to the
|
|
// current database time, and be available to run immediately.
|
|
func WithNextRunIn(d time.Duration) Option {
|
|
return func(o *options) {
|
|
o.withNextRunIn = d
|
|
}
|
|
}
|
|
|
|
// WithRunNow provides an option to trigger the scheduling loop after updating the next run time
|
|
// of a specific job. Note this does not guarantee the job will run on the scheduler that updated
|
|
// the job run time.
|
|
func WithRunNow(b bool) Option {
|
|
return func(o *options) {
|
|
o.withRunNow = b
|
|
}
|
|
}
|