structs

package
v0.1.2 Latest Latest
Warning

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

 Go to latest Published: Oct 6, 2015 License: MPL-2.0 Imports: 11 Imported by: 2,376

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

	// Map of environment variables to be used by the driver
	Env 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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.