structs

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 28, 2015 License: MPL-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source
const (
	// MinDynamicPort is the smallest dynamic port generated
	MinDynamicPort = 20000

	// MaxDynamicPort is the largest dynamic port generated
	MaxDynamicPort = 60000
)
View Source
const (
	ProtocolVersion = "protocol"
	APIMajorVersion = "api.major"
	APIMinorVersion = "api.minor"
)
View Source
const (
	NodeStatusInit  = "initializing"
	NodeStatusReady = "ready"
	NodeStatusDown  = "down"
)
View Source
const (
	// JobTypeNomad is reserved for internal system tasks and is
	// always handled by the CoreScheduler.
	JobTypeCore    = "_core"
	JobTypeService = "service"
	JobTypeBatch   = "batch"
)
View Source
const (
	JobStatusPending  = "pending"  // Pending means the job is waiting on scheduling
	JobStatusRunning  = "running"  // Running means the entire job is running
	JobStatusComplete = "complete" // Complete means there was a clean termination
	JobStatusDead     = "dead"     // Dead means there was abnormal termination
)
View Source
const (
	// JobMinPriority is the minimum allowed priority
	JobMinPriority = 1

	// JobDefaultPriority is the default priority if not
	// not specified.
	JobDefaultPriority = 50

	// JobMaxPriority is the maximum allowed priority
	JobMaxPriority = 100

	// Ensure CoreJobPriority is higher than any user
	// specified job so that it gets priority. This is important
	// for the system to remain healthy.
	CoreJobPriority = JobMaxPriority * 2
)
View Source
const (
	AllocDesiredStatusRun    = "run"    // Allocation should run
	AllocDesiredStatusStop   = "stop"   // Allocation should stop
	AllocDesiredStatusEvict  = "evict"  // Allocation should stop, and was evicted
	AllocDesiredStatusFailed = "failed" // Allocation failed to be done
)
View Source
const (
	AllocClientStatusPending = "pending"
	AllocClientStatusRunning = "running"
	AllocClientStatusDead    = "dead"
	AllocClientStatusFailed  = "failed"
)
View Source
const (
	EvalStatusPending  = "pending"
	EvalStatusComplete = "complete"
	EvalStatusFailed   = "failed"
)
View Source
const (
	EvalTriggerJobRegister   = "job-register"
	EvalTriggerJobDeregister = "job-deregister"
	EvalTriggerNodeUpdate    = "node-update"
	EvalTriggerScheduled     = "scheduled"
	EvalTriggerRollingUpdate = "rolling-update"
)
View Source
const (
	// CoreJobEvalGC is used for the garbage collection of evaluations
	// and allocations. We periodically scan evaluations in a terminal state,
	// in which all the corresponding allocations are also terminal. We
	// delete these out of the system to bound the state.
	CoreJobEvalGC = "eval-gc"

	// CoreJobNodeGC is used for the garbage collection of failed nodes.
	// We periodically scan nodes in a terminal state, and if they have no
	// corresponding allocations we delete these out of the system.
	CoreJobNodeGC = "node-gc"
)

Variables

View Source
var (
	ErrNoLeader     = fmt.Errorf("No cluster leader")
	ErrNoRegionPath = fmt.Errorf("No path to region")
)

Functions

func Decode

func Decode(buf []byte, out interface{}) error

Decode is used to decode a MsgPack encoded object

func Encode

func Encode(t MessageType, msg interface{}) ([]byte, error)

Encode is used to encode a MsgPack object with type prefix

func GenerateUUID

func GenerateUUID() string

GenerateUUID is used to generate a random UUID

func IntContains

func IntContains(haystack []int, needle int) bool

IntContains scans an integer slice for a value

func ScoreFit

func ScoreFit(node *Node, util *Resources) float64

ScoreFit is used to score the fit based on the Google work published here: http://www.columbia.edu/~cs2035/courses/ieor4405.S13/datacenter_scheduling.ppt This is equivalent to their BestFit v3

func ShouldDrainNode

func ShouldDrainNode(status string) bool

ShouldDrainNode checks if a given node status should trigger an evaluation. Some states don't require any further action.

func ValidNodeStatus

func ValidNodeStatus(status string) bool

ValidNodeStatus is used to check if a node status is valid

Types

type AllocListRequest

type AllocListRequest struct {
	QueryOptions
}

AllocListRequest is used to request a list of allocations

type AllocListResponse

type AllocListResponse struct {
	Allocations []*AllocListStub
	QueryMeta
}

AllocListResponse is used for a list request

type AllocListStub

type AllocListStub struct {
	ID                 string
	EvalID             string
	Name               string
	NodeID             string
	JobID              string
	TaskGroup          string
	DesiredStatus      string
	DesiredDescription string
	ClientStatus       string
	ClientDescription  string
	CreateIndex        uint64
	ModifyIndex        uint64
}

AllocListStub is used to return a subset of alloc information

type AllocMetric

type AllocMetric struct {
	// NodesEvaluated is the number of nodes that were evaluated
	NodesEvaluated int

	// NodesFiltered is the number of nodes filtered due to
	// a hard constraint
	NodesFiltered int

	// ClassFiltered is the number of nodes filtered by class
	ClassFiltered map[string]int

	// ConstraintFiltered is the number of failures caused by constraint
	ConstraintFiltered map[string]int

	// NodesExhausted is the number of nodes skipped due to being
	// exhausted of at least one resource
	NodesExhausted int

	// ClassExhausted is the number of nodes exhausted by class
	ClassExhausted map[string]int

	// DimensionExhausted provides the count by dimension or reason
	DimensionExhausted map[string]int

	// Scores is the scores of the final few nodes remaining
	// for placement. The top score is typically selected.
	Scores map[string]float64

	// AllocationTime is a measure of how long the allocation
	// attempt took. This can affect performance and SLAs.
	AllocationTime time.Duration

	// CoalescedFailures indicates the number of other
	// allocations that were coalesced into this failed allocation.
	// This is to prevent creating many failed allocations for a
	// single task group.
	CoalescedFailures int
}

AllocMetric is used to track various metrics while attempting to make an allocation. These are used to debug a job, or to better understand the pressure within the system.

func (*AllocMetric) EvaluateNode

func (a *AllocMetric) EvaluateNode()

func (*AllocMetric) ExhaustedNode

func (a *AllocMetric) ExhaustedNode(node *Node, dimension string)

func (*AllocMetric) FilterNode

func (a *AllocMetric) FilterNode(node *Node, constraint string)

func (*AllocMetric) ScoreNode

func (a *AllocMetric) ScoreNode(node *Node, name string, score float64)

type AllocSpecificRequest

type AllocSpecificRequest struct {
	AllocID string
	QueryOptions
}

AllocSpecificRequest is used to query a specific allocation

type AllocUpdateRequest

type AllocUpdateRequest struct {
	// Alloc is the list of new allocations to assign
	Alloc []*Allocation
	WriteRequest
}

AllocUpdateRequest is used to submit changes to allocations, either to cause evictions or to assign new allocaitons. Both can be done within a single transaction

type Allocation

type Allocation struct {
	// ID of the allocation (UUID)
	ID string

	// ID of the evaluation that generated this allocation
	EvalID string

	// Name is a logical name of the allocation.
	Name string

	// NodeID is the node this is being placed on
	NodeID string

	// Job is the parent job of the task group being allocated.
	// This is copied at allocation time to avoid issues if the job
	// definition is updated.
	JobID string
	Job   *Job

	// TaskGroup is the name of the task group that should be run
	TaskGroup string

	// Resources is the total set of resources allocated as part
	// of this allocation of the task group.
	Resources *Resources

	// TaskResources is the set of resources allocated to each
	// task. These should sum to the total Resources.
	TaskResources map[string]*Resources

	// Metrics associated with this allocation
	Metrics *AllocMetric

	// Desired Status of the allocation on the client
	DesiredStatus string

	// DesiredStatusDescription is meant to provide more human useful information
	DesiredDescription string

	// Status of the allocation on the client
	ClientStatus string

	// ClientStatusDescription is meant to provide more human useful information
	ClientDescription string

	// Raft Indexes
	CreateIndex uint64
	ModifyIndex uint64
}

Allocation is used to allocate the placement of a task group to a node.

func FilterTerminalAllocs

func FilterTerminalAllocs(allocs []*Allocation) []*Allocation

FilterTerminalAllocs filters out all allocations in a terminal state

func RemoveAllocs

func RemoveAllocs(alloc []*Allocation, remove []*Allocation) []*Allocation

RemoveAllocs is used to remove any allocs with the given IDs from the list of allocations

func (*Allocation) Stub

func (a *Allocation) Stub() *AllocListStub

Stub returns a list stub for the allocation

func (*Allocation) TerminalStatus

func (a *Allocation) TerminalStatus() bool

TerminalStatus returns if the desired status is terminal and will no longer transition. This is not based on the current client status.

type Constraint

type Constraint struct {
	Hard    bool   // Hard or soft constraint
	LTarget string // Left-hand target
	RTarget string // Right-hand target
	Operand string // Constraint operand (<=, <, =, !=, >, >=), contains, near
	Weight  int    // Soft constraints can vary the weight
}

Constraints are used to restrict placement options in the case of a hard constraint, and used to prefer a placement in the case of a soft constraint.

func (*Constraint) String

func (c *Constraint) String() string

type EvalAckRequest

type EvalAckRequest struct {
	EvalID string
	Token  string
	WriteRequest
}

EvalAckRequest is used to Ack/Nack a specific evaluation

type EvalAllocationsResponse

type EvalAllocationsResponse struct {
	Allocations []*AllocListStub
	QueryMeta
}

EvalAllocationsResponse is used to return the allocations for an evaluation

type EvalDeleteRequest

type EvalDeleteRequest struct {
	Evals  []string
	Allocs []string
	WriteRequest
}

EvalDeleteRequest is used for deleting an evaluation.

type EvalDequeueRequest

type EvalDequeueRequest struct {
	Schedulers []string
	Timeout    time.Duration
	WriteRequest
}

EvalDequeueRequest is used when we want to dequeue an evaluation

type EvalDequeueResponse

type EvalDequeueResponse struct {
	Eval  *Evaluation
	Token string
	QueryMeta
}

EvalDequeueResponse is used to return from a dequeue

type EvalListRequest

type EvalListRequest struct {
	QueryOptions
}

EvalListRequest is used to list the evaluations

type EvalListResponse

type EvalListResponse struct {
	Evaluations []*Evaluation
	QueryMeta
}

EvalListResponse is used for a list request

type EvalSpecificRequest

type EvalSpecificRequest struct {
	EvalID string
	QueryOptions
}

EvalSpecificRequest is used when we just need to specify a target evaluation

type EvalUpdateRequest

type EvalUpdateRequest struct {
	Evals     []*Evaluation
	EvalToken string
	WriteRequest
}

EvalUpdateRequest is used for upserting evaluations.

type Evaluation

type Evaluation struct {
	// ID is a randonly generated UUID used for this evaluation. This
	// is assigned upon the creation of the evaluation.
	ID string

	// Priority is used to control scheduling importance and if this job
	// can preempt other jobs.
	Priority int

	// Type is used to control which schedulers are available to handle
	// this evaluation.
	Type string

	// TriggeredBy is used to give some insight into why this Eval
	// was created. (Job change, node failure, alloc failure, etc).
	TriggeredBy string

	// JobID is the job this evaluation is scoped to. Evaluations cannot
	// be run in parallel for a given JobID, so we serialize on this.
	JobID string

	// JobModifyIndex is the modify index of the job at the time
	// the evaluation was created
	JobModifyIndex uint64

	// NodeID is the node that was affected triggering the evaluation.
	NodeID string

	// NodeModifyIndex is the modify index of the node at the time
	// the evaluation was created
	NodeModifyIndex uint64

	// Status of the evaluation
	Status string

	// StatusDescription is meant to provide more human useful information
	StatusDescription string

	// Wait is a minimum wait time for running the eval. This is used to
	// support a rolling upgrade.
	Wait time.Duration

	// NextEval is the evaluation ID for the eval created to do a followup.
	// This is used to support rolling upgrades, where we need a chain of evaluations.
	NextEval string

	// PreviousEval is the evaluation ID for the eval creating this one to do a followup.
	// This is used to support rolling upgrades, where we need a chain of evaluations.
	PreviousEval string

	// Raft Indexes
	CreateIndex uint64
	ModifyIndex uint64
}

Evaluation is used anytime we need to apply business logic as a result of a change to our desired state (job specification) or the emergent state (registered nodes). When the inputs change, we need to "evaluate" them, potentially taking action (allocation of work) or doing nothing if the state of the world does not require it.

func (*Evaluation) Copy

func (e *Evaluation) Copy() *Evaluation

func (*Evaluation) GoString

func (e *Evaluation) GoString() string

func (*Evaluation) MakePlan

func (e *Evaluation) MakePlan(j *Job) *Plan

MakePlan is used to make a plan from the given evaluation for a given Job

func (*Evaluation) NextRollingEval

func (e *Evaluation) NextRollingEval(wait time.Duration) *Evaluation

NextRollingEval creates an evaluation to followup this eval for rolling updates

func (*Evaluation) ShouldEnqueue

func (e *Evaluation) ShouldEnqueue() bool

ShouldEnqueue checks if a given evaluation should be enqueued

func (*Evaluation) TerminalStatus

func (e *Evaluation) TerminalStatus() bool

TerminalStatus returns if the current status is terminal and will no longer transition.

type GenericRequest

type GenericRequest struct {
	QueryOptions
}

GenericRequest is used to request where no specific information is needed.

type GenericResponse

type GenericResponse struct {
	WriteMeta
}

GenericResponse is used to respond to a request where no specific response information is needed.

type Job

type Job struct {
	// Region is the Nomad region that handles scheduling this job
	Region string

	// ID is a unique identifier for the job per region. It can be
	// specified hierarchically like LineOfBiz/OrgName/Team/Project
	ID string

	// Name is the logical name of the job used to refer to it. This is unique
	// per region, but not unique globally.
	Name string

	// Type is used to control various behaviors about the job. Most jobs
	// are service jobs, meaning they are expected to be long lived.
	// Some jobs are batch oriented meaning they run and then terminate.
	// This can be extended in the future to support custom schedulers.
	Type string

	// Priority is used to control scheduling importance and if this job
	// can preempt other jobs.
	Priority int

	// AllAtOnce is used to control if incremental scheduling of task groups
	// is allowed or if we must do a gang scheduling of the entire job. This
	// can slow down larger jobs if resources are not available.
	AllAtOnce bool `mapstructure:"all_at_once"`

	// Datacenters contains all the datacenters this job is allowed to span
	Datacenters []string

	// Constraints can be specified at a job level and apply to
	// all the task groups and tasks.
	Constraints []*Constraint

	// TaskGroups are the collections of task groups that this job needs
	// to run. Each task group is an atomic unit of scheduling and placement.
	TaskGroups []*TaskGroup

	// Update is used to control the update strategy
	Update UpdateStrategy

	// Meta is used to associate arbitrary metadata with this
	// job. This is opaque to Nomad.
	Meta map[string]string

	// Job status
	Status string

	// StatusDescription is meant to provide more human useful information
	StatusDescription string

	// Raft Indexes
	CreateIndex uint64
	ModifyIndex uint64
}

Job is the scope of a scheduling request to Nomad. It is the largest scoped object, and is a named collection of task groups. Each task group is further composed of tasks. A task group (TG) is the unit of scheduling however.

func (*Job) LookupTaskGroup

func (j *Job) LookupTaskGroup(name string) *TaskGroup

LookupTaskGroup finds a task group by name

func (*Job) Stub

func (j *Job) Stub() *JobListStub

Stub is used to return a summary of the job

func (*Job) Validate

func (j *Job) Validate() error

Validate is used to sanity check a job input

type JobAllocationsResponse

type JobAllocationsResponse struct {
	Allocations []*AllocListStub
	QueryMeta
}

JobAllocationsResponse is used to return the allocations for a job

type JobDeregisterRequest

type JobDeregisterRequest struct {
	JobID string
	WriteRequest
}

JobDeregisterRequest is used for Job.Deregister endpoint to deregister a job as being a schedulable entity.

type JobDeregisterResponse

type JobDeregisterResponse struct {
	EvalID          string
	EvalCreateIndex uint64
	JobModifyIndex  uint64
	QueryMeta
}

JobDeregisterResponse is used to respond to a job deregistration

type JobEvaluateRequest

type JobEvaluateRequest struct {
	JobID string
	WriteRequest
}

JobEvaluateRequest is used when we just need to re-evaluate a target job

type JobEvaluationsResponse

type JobEvaluationsResponse struct {
	Evaluations []*Evaluation
	QueryMeta
}

JobEvaluationsResponse is used to return the evaluations for a job

type JobListRequest

type JobListRequest struct {
	QueryOptions
}

JobListRequest is used to parameterize a list request

type JobListResponse

type JobListResponse struct {
	Jobs []*JobListStub
	QueryMeta
}

JobListResponse is used for a list request

type JobListStub

type JobListStub struct {
	ID                string
	Name              string
	Type              string
	Priority          int
	Status            string
	StatusDescription string
	CreateIndex       uint64
	ModifyIndex       uint64
}

JobListStub is used to return a subset of job information for the job list

type JobRegisterRequest

type JobRegisterRequest struct {
	Job *Job
	WriteRequest
}

JobRegisterRequest is used for Job.Register endpoint to register a job as being a schedulable entity.

type JobRegisterResponse

type JobRegisterResponse struct {
	EvalID          string
	EvalCreateIndex uint64
	JobModifyIndex  uint64
	QueryMeta
}

JobRegisterResponse is used to respond to a job registration

type JobSpecificRequest

type JobSpecificRequest struct {
	JobID string
	QueryOptions
}

JobSpecificRequest is used when we just need to specify a target job

type MessageType

type MessageType uint8
const (
	NodeRegisterRequestType MessageType = iota
	NodeDeregisterRequestType
	NodeUpdateStatusRequestType
	NodeUpdateDrainRequestType
	JobRegisterRequestType
	JobDeregisterRequestType
	EvalUpdateRequestType
	EvalDeleteRequestType
	AllocUpdateRequestType
	AllocClientUpdateRequestType
)
const (
	// IgnoreUnknownTypeFlag is set along with a MessageType
	// to indicate that the message type can be safely ignored
	// if it is not recognized. This is for future proofing, so
	// that new commands can be added in a way that won't cause
	// old servers to crash when the FSM attempts to process them.
	IgnoreUnknownTypeFlag MessageType = 128
)

type NetworkIndex

type NetworkIndex struct {
	AvailNetworks  []*NetworkResource          // List of available networks
	AvailBandwidth map[string]int              // Bandwidth by device
	UsedPorts      map[string]map[int]struct{} // Ports by IP
	UsedBandwidth  map[string]int              // Bandwidth by device
}

NetworkIndex is used to index the available network resources and the used network resources on a machine given allocations

func NewNetworkIndex

func NewNetworkIndex() *NetworkIndex

NewNetworkIndex is used to construct a new network index

func (*NetworkIndex) AddAllocs

func (idx *NetworkIndex) AddAllocs(allocs []*Allocation) (collide bool)

AddAllocs is used to add the used network resources. Returns true if there is a collision

func (*NetworkIndex) AddReserved

func (idx *NetworkIndex) AddReserved(n *NetworkResource) (collide bool)

AddReserved is used to add a reserved network usage, returns true if there is a port collision

func (*NetworkIndex) AssignNetwork

func (idx *NetworkIndex) AssignNetwork(ask *NetworkResource) (out *NetworkResource, err error)

AssignNetwork is used to assign network resources given an ask. If the ask cannot be satisfied, returns nil

func (*NetworkIndex) Overcommitted

func (idx *NetworkIndex) Overcommitted() bool

Overcommitted checks if the network is overcommitted

func (*NetworkIndex) SetNode

func (idx *NetworkIndex) SetNode(node *Node) (collide bool)

SetNode is used to setup the available network resources. Returns true if there is a collision

type NetworkResource

type NetworkResource struct {
	Device        string   // Name of the device
	CIDR          string   // CIDR block of addresses
	IP            string   // IP address
	MBits         int      // Throughput
	ReservedPorts []int    `mapstructure:"reserved_ports"` // Reserved ports
	DynamicPorts  []string `mapstructure:"dynamic_ports"`  // Dynamically assigned ports
}

NetworkResource is used to represent available network resources

func (*NetworkResource) Add

func (n *NetworkResource) Add(delta *NetworkResource)

Add adds the resources of the delta to this, potentially returning an error if not possible.

func (*NetworkResource) Copy

func (n *NetworkResource) Copy() *NetworkResource

Copy returns a deep copy of the network resource

func (*NetworkResource) GoString

func (n *NetworkResource) GoString() string

func (*NetworkResource) ListStaticPorts

func (n *NetworkResource) ListStaticPorts() []int

ListStaticPorts returns the list of Static ports allocated to this NetworkResource. These are presumed to have known semantics so there is no mapping information.

func (*NetworkResource) MapDynamicPorts

func (n *NetworkResource) MapDynamicPorts() map[string]int

MapDynamicPorts returns a mapping of Label:PortNumber for dynamic ports allocated on this NetworkResource. The ordering of Label:Port pairs is random.

Details:

The jobspec lets us ask for two types of ports: Reserved ports and Dynamic ports. Reserved ports are identified by the port number, while Dynamic ports are identified by a Label.

When we ask nomad to run a job it checks to see if the Reserved ports we requested are available. If they are, it then tries to provision any Dynamic ports that we have requested. When available ports are found to satisfy our dynamic port requirements, they are APPENDED to the reserved ports list. In effect, the reserved ports list serves double-duty. First it indicates the ports we *want*, and then it indicates the ports we are *using*.

After the the offer process is complete and the job is scheduled we want to see which ports were made available to us. To see the dynamic ports that were allocated to us we look at the last N ports in our reservation, where N is how many dynamic ports we requested.

MapDynamicPorts matches these port numbers with their labels and gives you the port mapping.

Also, be aware that this is intended to be called in the context of task.Resources after an offer has been made. If you call it in some other context the behavior is unspecified, including maybe crashing. So don't do that.

type Node

type Node struct {
	// ID is a unique identifier for the node. It can be constructed
	// by doing a concatenation of the Name and Datacenter as a simple
	// approach. Alternatively a UUID may be used.
	ID string

	// Datacenter for this node
	Datacenter string

	// Node name
	Name string

	// Attributes is an arbitrary set of key/value
	// data that can be used for constraints. Examples
	// include "kernel.name=linux", "arch=386", "driver.docker=1",
	// "docker.runtime=1.8.3"
	Attributes map[string]string

	// Resources is the available resources on the client.
	// For example 'cpu=2' 'memory=2048'
	Resources *Resources

	// Reserved is the set of resources that are reserved,
	// and should be subtracted from the total resources for
	// the purposes of scheduling. This may be provide certain
	// high-watermark tolerances or because of external schedulers
	// consuming resources.
	Reserved *Resources

	// Links are used to 'link' this client to external
	// systems. For example 'consul=foo.dc1' 'aws=i-83212'
	// 'ami=ami-123'
	Links map[string]string

	// Meta is used to associate arbitrary metadata with this
	// client. This is opaque to Nomad.
	Meta map[string]string

	// NodeClass is an opaque identifier used to group nodes
	// together for the purpose of determining scheduling pressure.
	NodeClass string

	// Drain is controlled by the servers, and not the client.
	// If true, no jobs will be scheduled to this node, and existing
	// allocations will be drained.
	Drain bool

	// Status of this node
	Status string

	// StatusDescription is meant to provide more human useful information
	StatusDescription string

	// Raft Indexes
	CreateIndex uint64
	ModifyIndex uint64
}

Node is a representation of a schedulable client node

func (*Node) Stub

func (n *Node) Stub() *NodeListStub

Stub returns a summarized version of the node

func (*Node) TerminalStatus

func (n *Node) TerminalStatus() bool

TerminalStatus returns if the current status is terminal and will no longer transition.

type NodeAllocsResponse

type NodeAllocsResponse struct {
	Allocs []*Allocation
	QueryMeta
}

NodeAllocsResponse is used to return allocs for a single node

type NodeDeregisterRequest

type NodeDeregisterRequest struct {
	NodeID string
	WriteRequest
}

NodeDeregisterRequest is used for Node.Deregister endpoint to deregister a node as being a schedulable entity.

type NodeDrainUpdateResponse

type NodeDrainUpdateResponse struct {
	EvalIDs         []string
	EvalCreateIndex uint64
	NodeModifyIndex uint64
	QueryMeta
}

NodeDrainUpdateResponse is used to respond to a node drain update

type NodeEvaluateRequest

type NodeEvaluateRequest struct {
	NodeID string
	WriteRequest
}

NodeEvaluateRequest is used to re-evaluate the ndoe

type NodeListRequest

type NodeListRequest struct {
	QueryOptions
}

NodeListRequest is used to parameterize a list request

type NodeListResponse

type NodeListResponse struct {
	Nodes []*NodeListStub
	QueryMeta
}

JobListResponse is used for a list request

type NodeListStub

type NodeListStub struct {
	ID                string
	Datacenter        string
	Name              string
	NodeClass         string
	Drain             bool
	Status            string
	StatusDescription string
	CreateIndex       uint64
	ModifyIndex       uint64
}

NodeListStub is used to return a subset of job information for the job list

type NodeRegisterRequest

type NodeRegisterRequest struct {
	Node *Node
	WriteRequest
}

NodeRegisterRequest is used for Node.Register endpoint to register a node as being a schedulable entity.

type NodeSpecificRequest

type NodeSpecificRequest struct {
	NodeID string
	QueryOptions
}

NodeSpecificRequest is used when we just need to specify a target node

type NodeUpdateDrainRequest

type NodeUpdateDrainRequest struct {
	NodeID string
	Drain  bool
	WriteRequest
}

NodeUpdateDrainRequest is used for updatin the drain status

type NodeUpdateResponse

type NodeUpdateResponse struct {
	HeartbeatTTL    time.Duration
	EvalIDs         []string
	EvalCreateIndex uint64
	NodeModifyIndex uint64
	QueryMeta
}

NodeUpdateResponse is used to respond to a node update

type NodeUpdateStatusRequest

type NodeUpdateStatusRequest struct {
	NodeID string
	Status string
	WriteRequest
}

NodeUpdateStatusRequest is used for Node.UpdateStatus endpoint to update the status of a node.

type Plan

type Plan struct {
	// EvalID is the evaluation ID this plan is associated with
	EvalID string

	// EvalToken is used to prevent a split-brain processing of
	// an evaluation. There should only be a single scheduler running
	// an Eval at a time, but this could be violated after a leadership
	// transition. This unique token is used to reject plans that are
	// being submitted from a different leader.
	EvalToken string

	// Priority is the priority of the upstream job
	Priority int

	// AllAtOnce is used to control if incremental scheduling of task groups
	// is allowed or if we must do a gang scheduling of the entire job.
	// If this is false, a plan may be partially applied. Otherwise, the
	// entire plan must be able to make progress.
	AllAtOnce bool

	// NodeUpdate contains all the allocations for each node. For each node,
	// this is a list of the allocations to update to either stop or evict.
	NodeUpdate map[string][]*Allocation

	// NodeAllocation contains all the allocations for each node.
	// The evicts must be considered prior to the allocations.
	NodeAllocation map[string][]*Allocation

	// FailedAllocs are allocations that could not be made,
	// but are persisted so that the user can use the feedback
	// to determine the cause.
	FailedAllocs []*Allocation
}

Plan is used to submit a commit plan for task allocations. These are submitted to the leader which verifies that resources have not been overcommitted before admiting the plan.

func (*Plan) AppendAlloc

func (p *Plan) AppendAlloc(alloc *Allocation)

func (*Plan) AppendFailed

func (p *Plan) AppendFailed(alloc *Allocation)

func (*Plan) AppendUpdate

func (p *Plan) AppendUpdate(alloc *Allocation, status, desc string)

func (*Plan) IsNoOp

func (p *Plan) IsNoOp() bool

IsNoOp checks if this plan would do nothing

func (*Plan) PopUpdate

func (p *Plan) PopUpdate(alloc *Allocation)

type PlanRequest

type PlanRequest struct {
	Plan *Plan
	WriteRequest
}

PlanRequest is used to submit an allocation plan to the leader

type PlanResponse

type PlanResponse struct {
	Result *PlanResult
	WriteMeta
}

PlanResponse is used to return from a PlanRequest

type PlanResult

type PlanResult struct {
	// NodeUpdate contains all the updates that were committed.
	NodeUpdate map[string][]*Allocation

	// NodeAllocation contains all the allocations that were committed.
	NodeAllocation map[string][]*Allocation

	// FailedAllocs are allocations that could not be made,
	// but are persisted so that the user can use the feedback
	// to determine the cause.
	FailedAllocs []*Allocation

	// RefreshIndex is the index the worker should refresh state up to.
	// This allows all evictions and allocations to be materialized.
	// If any allocations were rejected due to stale data (node state,
	// over committed) this can be used to force a worker refresh.
	RefreshIndex uint64

	// AllocIndex is the Raft index in which the evictions and
	// allocations took place. This is used for the write index.
	AllocIndex uint64
}

PlanResult is the result of a plan submitted to the leader.

func (*PlanResult) FullCommit

func (p *PlanResult) FullCommit(plan *Plan) (bool, int, int)

FullCommit is used to check if all the allocations in a plan were committed as part of the result. Returns if there was a match, and the number of expected and actual allocations.

func (*PlanResult) IsNoOp

func (p *PlanResult) IsNoOp() bool

IsNoOp checks if this plan result would do nothing

type QueryMeta

type QueryMeta struct {
	// This is the index associated with the read
	Index uint64

	// If AllowStale is used, this is time elapsed since
	// last contact between the follower and leader. This
	// can be used to gauge staleness.
	LastContact time.Duration

	// Used to indicate if there is a known leader node
	KnownLeader bool
}

QueryMeta allows a query response to include potentially useful metadata about a query

type QueryOptions

type QueryOptions struct {
	// The target region for this query
	Region string

	// If set, wait until query exceeds given index. Must be provided
	// with MaxQueryTime.
	MinQueryIndex uint64

	// Provided with MinQueryIndex to wait for change.
	MaxQueryTime time.Duration

	// If set, any follower can service the request. Results
	// may be arbitrarily stale.
	AllowStale bool
}

QueryOptions is used to specify various flags for read queries

func (QueryOptions) AllowStaleRead

func (q QueryOptions) AllowStaleRead() bool

func (QueryOptions) IsRead

func (q QueryOptions) IsRead() bool

QueryOption only applies to reads, so always true

func (QueryOptions) RequestRegion

func (q QueryOptions) RequestRegion() string

type RPCInfo

type RPCInfo interface {
	RequestRegion() string
	IsRead() bool
	AllowStaleRead() bool
}

RPCInfo is used to describe common information about query

type Resources

type Resources struct {
	CPU      int
	MemoryMB int `mapstructure:"memory"`
	DiskMB   int `mapstructure:"disk"`
	IOPS     int
	Networks []*NetworkResource
}

Resources is used to define the resources available on a client

func AllocsFit

func AllocsFit(node *Node, allocs []*Allocation, netIdx *NetworkIndex) (bool, string, *Resources, error)

AllocsFit checks if a given set of allocations will fit on a node. The netIdx can optionally be provided if its already been computed. If the netIdx is provided, it is assumed that the client has already ensured there are no collisions.

func (*Resources) Add

func (r *Resources) Add(delta *Resources) error

Add adds the resources of the delta to this, potentially returning an error if not possible.

func (*Resources) Copy

func (r *Resources) Copy() *Resources

Copy returns a deep copy of the resources

func (*Resources) GoString

func (r *Resources) GoString() string

func (*Resources) NetIndex

func (r *Resources) NetIndex(n *NetworkResource) int

NetIndex finds the matching net index using device name

func (*Resources) Superset

func (r *Resources) Superset(other *Resources) (bool, string)

Superset checks if one set of resources is a superset of another. This ignores network resources, and the NetworkIndex should be used for that.

type SingleAllocResponse

type SingleAllocResponse struct {
	Alloc *Allocation
	QueryMeta
}

SingleAllocResponse is used to return a single allocation

type SingleEvalResponse

type SingleEvalResponse struct {
	Eval *Evaluation
	QueryMeta
}

SingleEvalResponse is used to return a single evaluation

type SingleJobResponse

type SingleJobResponse struct {
	Job *Job
	QueryMeta
}

SingleJobResponse is used to return a single job

type SingleNodeResponse

type SingleNodeResponse struct {
	Node *Node
	QueryMeta
}

SingleNodeResponse is used to return a single node

type Task

type Task struct {
	// Name of the task
	Name string

	// Driver is used to control which driver is used
	Driver string

	// Config is provided to the driver to initialize
	Config map[string]string

	// Constraints can be specified at a task level and apply only to
	// the particular task.
	Constraints []*Constraint

	// Resources is the resources needed by this task
	Resources *Resources

	// Meta is used to associate arbitrary metadata with this
	// task. This is opaque to Nomad.
	Meta map[string]string
}

Task is a single process typically that is executed as part of a task group.

func (*Task) GoString

func (t *Task) GoString() string

func (*Task) Validate

func (t *Task) Validate() error

Validate is used to sanity check a task group

type TaskGroup

type TaskGroup struct {
	// Name of the task group
	Name string

	// Count is the number of replicas of this task group that should
	// be scheduled.
	Count int

	// Constraints can be specified at a task group level and apply to
	// all the tasks contained.
	Constraints []*Constraint

	// Tasks are the collection of tasks that this task group needs to run
	Tasks []*Task

	// Meta is used to associate arbitrary metadata with this
	// task group. This is opaque to Nomad.
	Meta map[string]string
}

TaskGroup is an atomic unit of placement. Each task group belongs to a job and may contain any number of tasks. A task group support running in many replicas using the same configuration..

func (*TaskGroup) GoString

func (tg *TaskGroup) GoString() string

func (*TaskGroup) LookupTask

func (tg *TaskGroup) LookupTask(name string) *Task

LookupTask finds a task by name

func (*TaskGroup) Validate

func (tg *TaskGroup) Validate() error

Validate is used to sanity check a task group

type UpdateStrategy

type UpdateStrategy struct {
	// Stagger is the amount of time between the updates
	Stagger time.Duration

	// MaxParallel is how many updates can be done in parallel
	MaxParallel int `mapstructure:"max_parallel"`
}

UpdateStrategy is used to modify how updates are done

func (*UpdateStrategy) Rolling

func (u *UpdateStrategy) Rolling() bool

Rolling returns if a rolling strategy should be used

type VersionResponse

type VersionResponse struct {
	Build    string
	Versions map[string]int
	QueryMeta
}

VersionResponse is used for the Status.Version reseponse

type WriteMeta

type WriteMeta struct {
	// This is the index associated with the write
	Index uint64
}

WriteMeta allows a write response to includ e potentially useful metadata about the write

type WriteRequest

type WriteRequest struct {
	// The target region for this write
	Region string
}

func (WriteRequest) AllowStaleRead

func (w WriteRequest) AllowStaleRead() bool

func (WriteRequest) IsRead

func (w WriteRequest) IsRead() bool

WriteRequest only applies to writes, always false

func (WriteRequest) RequestRegion

func (w WriteRequest) RequestRegion() string

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL