scheduler

type CmpBasedTaskComparator ¶

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

CmpBasedTaskComparator runs the tasks through a slice of comparator functions determining which is more important.

func NewCmpBasedTaskComparator(id string) *CmpBasedTaskComparator

func (self *CmpBasedTaskComparator) Len() int

func (self *CmpBasedTaskComparator) Less(i, j int) bool

func (self *CmpBasedTaskComparator) Swap(i, j int)

type CmpBasedTaskPrioritizer ¶

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

func (prioritizer *CmpBasedTaskPrioritizer) PrioritizeTasks(distroId string, tasks []task.Task, versions map[string]model.Version) ([]task.Task, error)

type CmpBasedTaskQueues ¶

type CmpBasedTaskQueues struct {
	HighPriorityTasks []task.Task
	PatchTasks        []task.Task
	RepotrackerTasks  []task.Task
}

CmpBasedTaskQueues represents the three types of queues that are created for merging together into one queue. The HighPriorityTasks list represent the tasks that are always placed at the front of the queue PatchTasks and RepotrackerTasks are interleaved after the high priority tasks.

type Configuration ¶

type Configuration struct {
	DistroID         string
	TaskFinder       string
	FreeHostFraction float64
}

type DBTaskQueuePersister ¶

type DBTaskQueuePersister struct{}

DBTaskQueuePersister saves a queue to the database.

func (self *DBTaskQueuePersister) PersistTaskQueue(distro string, tasks []task.Task, distroQueueInfo model.DistroQueueInfo) ([]model.TaskQueueItem, error)

type HostAllocator ¶

type HostAllocator func(context.Context, HostAllocatorData) (int, error)

HostAllocator is responsible for determining how many new hosts should be spun up.

func GetHostAllocator(name string) HostAllocator

type HostAllocatorData ¶

type HostAllocatorData struct {
	Distro           distro.Distro
	ExistingHosts    []host.Host
	FreeHostFraction float64
	UsesContainers   bool
	ContainerPool    *evergreen.ContainerPool
	DistroQueueInfo  model.DistroQueueInfo
}

type Scheduler ¶

type Scheduler struct {
	*evergreen.Settings
	TaskPrioritizer
	TaskQueuePersister
	HostAllocator

	FindRunnableTasks TaskFinder
}

Responsible for prioritizing and scheduling tasks to be run, on a per-distro basis.

type TaskFinder ¶

type TaskFinder func(distro.Distro) ([]task.Task, error)

func GetTaskFinder(version string) TaskFinder

type TaskGroupData ¶

type TaskGroupData struct {
	Hosts []host.Host
	Info  model.TaskGroupInfo
}

type TaskPrioritizer ¶

type TaskPrioritizer interface {
	// Takes in a slice of tasks and the current MCI settings.
	// Returns the slice of tasks, sorted in the order in which they should
	// be run, as well as an error if appropriate.
	PrioritizeTasks(distroId string, tasks []task.Task, versions map[string]model.Version) ([]task.Task, error)
}

TaskPrioritizer is responsible for taking in a slice of tasks, and ordering them according to which should be run first.

type TaskQueuePersister ¶

type TaskQueuePersister interface {
	// distro, tasks, duration cache
	PersistTaskQueue(string, []task.Task, model.DistroQueueInfo) ([]model.TaskQueueItem, error)
}

TaskQueuePersister is responsible for taking a task queue for a particular distro and saving it.