scheduler

type Backend ¶

type Backend interface {
	// GetOffer returns an offer for a task.
	GetOffer(*tes.Task) *Offer
}

Backend is responsible for scheduling a task. It has a single method which is responsible for taking a Task and returning an Offer, or nil if there is no node matching the task request. An Offer includes the ID of the offered node.

Offers include scores which describe how well the task fits the node. Scores may describe a wide variety of metrics: resource usage, packing, startup time, cost, etc. Scores and weights are used to control the behavior of schedulers, and to combine offers from multiple schedulers.

type Client ¶

type Client interface {
	events.EventServiceClient
	pbs.SchedulerServiceClient
	Close()
}

Client is a client for the scheduler and event gRPC services.

func NewClient(conf config.Scheduler) (Client, error)

type ComputeBackend ¶

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

ComputeBackend represents the funnel scheduler backend.

func NewComputeBackend(db Database) *ComputeBackend

func (b *ComputeBackend) Submit(task *tes.Task) error

type Database ¶

type Database interface {
	QueueTask(*tes.Task) error
	ReadQueue(int) []*tes.Task
	ListNodes(context.Context, *pbs.ListNodesRequest) (*pbs.ListNodesResponse, error)
	PutNode(context.Context, *pbs.Node) (*pbs.PutNodeResponse, error)
	DeleteNode(context.Context, *pbs.Node) error
	WriteContext(context.Context, *events.Event) error
}

Database represents the interface to the database used by the scheduler, scaler, etc. Mostly, this exists so it can be mocked during testing.

type Node ¶

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

Node is a structure used for tracking available resources on a compute resource.

func NewNode(conf config.Config, log *logger.Logger, factory WorkerFactory) (*Node, error)

func NewNoopNode(conf config.Config, log *logger.Logger) (*Node, error)

func (n *Node) Run(ctx context.Context)

type Offer ¶

type Offer struct {
	TaskID string
	Node   *pbs.Node
	Scores Scores
}

Offer describes a node offered by a scheduler for a task. The Scores describe how well the task fits this node, which could be used by other a scheduler to pick the best offer.

func DefaultScheduleAlgorithm(j *tes.Task, nodes []*pbs.Node, weights map[string]float32) *Offer

func NewOffer(n *pbs.Node, t *tes.Task, s Scores) *Offer

type Predicate ¶

type Predicate func(*tes.Task, *pbs.Node) error

Predicate is a function that checks whether a task fits a node.

func NodeHasTag(tag string) Predicate

type Scaler ¶

type Scaler interface {
	// StartNode is where the work is done to start a node instance,
	// for example, calling out to Google Cloud APIs.
	StartNode(*pbs.Node) error
	// ShouldStartNode allows scalers to filter out nodes they are interested in.
	// If "true" is returned, Scaler.StartNode() will be called with this Node.
	ShouldStartNode(*pbs.Node) bool
}

Scaler represents a service that can start node instances, for example the Google Cloud Scheduler backend.

type Scheduler ¶

type Scheduler struct {
	Log     *logger.Logger
	DB      Database
	Conf    config.Scheduler
	Backend Backend
}

Scheduler handles scheduling tasks to nodes and support many backends.

func (s *Scheduler) CheckNodes() error

func (s *Scheduler) Run(ctx context.Context) error

func (s *Scheduler) Scale(ctx context.Context) error

func (s *Scheduler) Schedule(ctx context.Context) error

type Scores ¶

type Scores map[string]float32

Scores describe how well a task fits a node.

func DefaultScores(w *pbs.Node, t *tes.Task) Scores

func (s Scores) Average() float32

func (s Scores) Weighted(w map[string]float32) Scores

type WorkerFactory ¶

type WorkerFactory func(c config.Worker, taskID string, log *logger.Logger) (worker.Worker, error)

WorkerFactory is a function which creates a new worker instance.