structs

package
v0.3.0 Latest Latest
Warning

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

 Go to latest Published: Feb 25, 2016 License: MPL-2.0 Imports: 23 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"
	JobTypeSystem  = "system"
)
View Source 
const (
	JobStatusPending = "pending" // Pending means the job is waiting on scheduling
	JobStatusRunning = "running" // Running means the job has non-terminal allocations
	JobStatusDead    = "dead"    // Dead means all evaluation's and allocations are terminal
)
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 (
	// PeriodicSpecCron is used for a cron spec.
	PeriodicSpecCron = "cron"

	// PeriodicSpecTest is only used by unit tests. It is a sorted, comma
	// seperated list of unix timestamps at which to launch.
	PeriodicSpecTest = "_internal_test"
)
View Source 
const (
	// RestartPolicyModeDelay causes an artificial delay till the next interval is
	// reached when the specified attempts have been reached in the interval.
	RestartPolicyModeDelay = "delay"

	// RestartPolicyModeFail causes a job to fail if the specified number of
	// attempts are reached within an interval.
	RestartPolicyModeFail = "fail"
)
View Source 
const (
	ServiceCheckHTTP   = "http"
	ServiceCheckTCP    = "tcp"
	ServiceCheckDocker = "docker"
	ServiceCheckScript = "script"
)
View Source 
const (
	TaskStatePending = "pending" // The task is waiting to be run.
	TaskStateRunning = "running" // The task is currently running.
	TaskStateDead    = "dead"    // Terminal state of task.
)

Set of possible states for a task.

View Source 
const (
	// A Driver failure indicates that the task could not be started due to a
	// failure in the driver.
	TaskDriverFailure = "Driver Failure"

	// Task Received signals that the task has been pulled by the client at the
	// given timestamp.
	TaskReceived = "Received"

	// Task Started signals that the task was started and its timestamp can be
	// used to determine the running length of the task.
	TaskStarted = "Started"

	// Task terminated indicates that the task was started and exited.
	TaskTerminated = "Terminated"

	// Task Killed indicates a user has killed the task.
	TaskKilled = "Killed"
)
View Source 
const (
	ConstraintDistinctHosts = "distinct_hosts"
	ConstraintRegex         = "regexp"
	ConstraintVersion       = "version"
)
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 (
	EvalStatusBlocked   = "blocked"
	EvalStatusPending   = "pending"
	EvalStatusComplete  = "complete"
	EvalStatusFailed    = "failed"
	EvalStatusCancelled = "canceled"
)
View Source 
const (
	EvalTriggerJobRegister   = "job-register"
	EvalTriggerJobDeregister = "job-deregister"
	EvalTriggerPeriodicJob   = "periodic-job"
	EvalTriggerNodeUpdate    = "node-update"
	EvalTriggerScheduled     = "scheduled"
	EvalTriggerForceGC       = "force-gc"
	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"

	// CoreJobJobGC is used for the garbage collection of eligible jobs. We
	// periodically scan garbage collectible jobs and check if both their
	// evaluations and allocations are terminal. If so, we delete these out of
	// the system.
	CoreJobJobGC = "job-gc"
)
View Source 
const (
	// DefaultKillTimeout is the default timeout between signaling a task it
	// will be killed and killing it.
	DefaultKillTimeout = 5 * time.Second
)
View Source 
const (
	// NodeUniqueNamespace is a prefix that can be appended to node meta or
	// attribute keys to mark them for exclusion in computed node class.
	NodeUniqueNamespace = "unique."
)
View Source 
const (
	NomadConsulPrefix = "nomad-registered-service"
)
View Source 
const (
	// PeriodicLaunchSuffix is the string appended to the periodic jobs ID
	// when launching derived instances of it.
	PeriodicLaunchSuffix = "/periodic-"
)

Variables

View Source 
var (
	ErrNoLeader     = fmt.Errorf("No cluster leader")
	ErrNoRegionPath = fmt.Errorf("No path to region")
)
View Source 
var HashiMsgpackHandle = func() *hcodec.MsgpackHandle {
	h := &hcodec.MsgpackHandle{RawToString: true}

	h.MapType = reflect.TypeOf(map[string]interface{}(nil))
	return h
}()
View Source 
var MsgpackHandle = func() *codec.MsgpackHandle {
	h := &codec.MsgpackHandle{RawToString: true}

	h.MapType = reflect.TypeOf(map[string]interface{}(nil))
	return h
}()

msgpackHandle is a shared handle for encoding/decoding of structs

Functions

func CopyMapStringFloat64 added in v0.3.0 

func CopyMapStringFloat64(m map[string]float64) map[string]float64

func CopyMapStringInt added in v0.3.0 

func CopyMapStringInt(m map[string]int) map[string]int

func CopyMapStringString added in v0.3.0 

func CopyMapStringString(m map[string]string) map[string]string

Helpers for copying generic structures.

func CopySliceString added in v0.3.0 

func CopySliceString(s []string) []string

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 IsUniqueNamespace added in v0.3.0 

func IsUniqueNamespace(key string) bool

IsUniqueNamespace returns whether the key is under the unique namespace.

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 UniqueNamespace added in v0.3.0 

func UniqueNamespace(key string) string

UniqueNamespace takes a key and returns the key marked under the unique namespace.

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
	TaskStates         map[string]*TaskState
	CreateIndex        uint64
	ModifyIndex        uint64
	CreateTime         int64
}

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 constraint
	NodesFiltered int

	// NodesAvailable is the number of nodes available for evaluation per DC.
	NodesAvailable map[string]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) Copy added in v0.3.0 

func (a *AllocMetric) Copy() *AllocMetric

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

	// Job is the shared parent job of the allocations.
	// It is pulled out since it is common to reduce payload size.
	Job *Job

	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

	// Services is a map of service names to service ids
	Services map[string]string

	// 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

	// TaskStates stores the state of each task,
	TaskStates map[string]*TaskState

	// Raft Indexes
	CreateIndex uint64
	ModifyIndex uint64

	// AllocModifyIndex is not updated when the client updates allocations. This
	// lets the client pull only the allocs updated by the server.
	AllocModifyIndex uint64

	// CreateTime is the time the allocation has finished scheduling and been
	// verified by the plan applier.
	CreateTime int64
}

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) Copy added in v0.3.0 

func (a *Allocation) Copy() *Allocation

func (*Allocation) PopulateServiceIDs added in v0.2.3 

func (a *Allocation) PopulateServiceIDs(tg *TaskGroup)

PopulateServiceIDs generates the service IDs for all the service definitions in that Allocation

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 or actual status is terminal and will no longer transition.

type AllocsGetRequest added in v0.3.0 

type AllocsGetRequest struct {
	AllocIDs []string
	QueryOptions
}

AllocsGetcRequest is used to query a set of allocations

type AllocsGetResponse added in v0.3.0 

type AllocsGetResponse struct {
	Allocs []*Allocation
	QueryMeta
}

AllocsGetResponse is used to return a set of allocations

type Bitmap added in v0.3.0 

type Bitmap []byte

Bitmap is a simple uncompressed bitmap

func NewBitmap added in v0.3.0 

func NewBitmap(size int) (Bitmap, error)

NewBitmap returns a bitmap with up to size indexes

func (Bitmap) Check added in v0.3.0 

func (b Bitmap) Check(idx uint) bool

Check is used to check the given index of the bitmap

func (Bitmap) Clear added in v0.3.0 

func (b Bitmap) Clear()

Clear is used to efficiently clear the bitmap

func (Bitmap) Set added in v0.3.0 

func (b Bitmap) Set(idx uint)

Set is used to set the given index of the bitmap

type Constraint 

type Constraint struct {
	LTarget string // Left-hand target
	RTarget string // Right-hand target
	Operand string // Constraint operand (<=, <, =, !=, >, >=), contains, near
	// contains filtered or unexported fields
}

Constraints are used to restrict placement options.

func CopySliceConstraints added in v0.3.0 

func CopySliceConstraints(s []*Constraint) []*Constraint

func EscapedConstraints added in v0.3.0 

func EscapedConstraints(constraints []*Constraint) []*Constraint

EscapedConstraints takes a set of constraints and returns the set that escapes computed node classes.

func (*Constraint) Copy added in v0.3.0 

func (c *Constraint) Copy() *Constraint

func (*Constraint) String 

func (c *Constraint) String() string

func (*Constraint) Validate added in v0.2.0 

func (c *Constraint) Validate() error

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

	// ClassEligibility tracks computed node classes that have been explicitely
	// marked as eligible or ineligible.
	ClassEligibility map[string]bool

	// EscapedComputedClass marks whether the job has constraints that are not
	// captured by computed node classes.
	EscapedComputedClass bool

	// 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) BlockedEval added in v0.3.0 

func (e *Evaluation) BlockedEval(classEligibility map[string]bool, escaped bool) *Evaluation

BlockedEval creates a blocked evaluation to followup this eval to place any failed allocations. It takes the classes marked explicitely eligible or ineligible and whether the job has escaped computed node classes.

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) ShouldBlock added in v0.3.0 

func (e *Evaluation) ShouldBlock() bool

ShouldBlock checks if a given evaluation should be entered into the blocked eval tracker.

func (*Evaluation) ShouldEnqueue 

func (e *Evaluation) ShouldEnqueue() bool

ShouldEnqueue checks if a given evaluation should be enqueued into the eval_broker

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

	// ParentID is the unique identifier of the job that spawned this job.
	ParentID 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

	// Periodic is used to define the interval the job is run at.
	Periodic *PeriodicConfig

	// GC is used to mark the job as available for garbage collection after it
	// has no outstanding evaluations or allocations.
	GC bool

	// 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
	JobModifyIndex 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) Copy added in v0.3.0 

func (j *Job) Copy() *Job

Copy returns a deep copy of the Job. It is expected that callers use recover. This job can panic if the deep copy failed as it uses reflection.

func (*Job) InitFields added in v0.3.0 

func (j *Job) InitFields()

InitFields is used to initialize fields in the Job. This should be called when registering a Job.

func (*Job) IsPeriodic added in v0.2.2 

func (j *Job) IsPeriodic() bool

IsPeriodic returns whether a job is periodic.

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
	ParentID          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 LogConfig added in v0.3.0 

type LogConfig struct {
	MaxFiles      int `mapstructure:"max_files"`
	MaxFileSizeMB int `mapstructure:"max_file_size"`
}

LogConfig provides configuration for log rotation

func DefaultLogConfig added in v0.3.0 

func DefaultLogConfig() *LogConfig

func (*LogConfig) Validate added in v0.3.0 

func (l *LogConfig) Validate() error

Validate returns an error if the log config specified are less than the minimum allowed.

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]Bitmap  // 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) Release added in v0.3.0 

func (idx *NetworkIndex) Release()

Release is called when the network index is no longer needed to attempt to re-use some of the memory it has allocated

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 []Port // Reserved ports
	DynamicPorts  []Port // 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) MapLabelToValues added in v0.2.0 

func (n *NetworkResource) MapLabelToValues(port_map map[string]int) map[string]int

func (*NetworkResource) MeetsMinResources added in v0.3.0 

func (n *NetworkResource) MeetsMinResources() error

MeetsMinResources returns an error if the resources specified are less than the minimum allowed.

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

	// HTTPAddr is the address on which the Nomad client is listening for http
	// requests
	HTTPAddr 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

	// ComputedClass is a unique id that identifies nodes with a common set of
	// attributes and capabilities.
	ComputedClass 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) ComputeClass added in v0.3.0 

func (n *Node) ComputeClass() error

ComputeClass computes a derived class for the node based on its attributes. ComputedClass is a unique id that identifies nodes with a common set of attributes and capabilities. Thus, when calculating a node's computed class we avoid including any uniquely identifing fields.

func (*Node) Copy added in v0.3.0 

func (n *Node) Copy() *Node

func (Node) HashInclude added in v0.3.0 

func (n Node) HashInclude(field string, v interface{}) (bool, error)

HashInclude is used to blacklist uniquely identifying node fields from being included in the computed node class.

func (Node) HashIncludeMap added in v0.3.0 

func (n Node) HashIncludeMap(field string, k, v interface{}) (bool, error)

HashIncludeMap is used to blacklist uniquely identifying node map keys from being included in the computed node class.

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 NodeClientAllocsResponse added in v0.3.0 

type NodeClientAllocsResponse struct {
	Allocs map[string]uint64
	QueryMeta
}

NodeClientAllocsResponse is used to return allocs meta data 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 PeriodicConfig added in v0.2.2 

type PeriodicConfig struct {
	// Enabled determines if the job should be run periodically.
	Enabled bool

	// Spec specifies the interval the job should be run as. It is parsed based
	// on the SpecType.
	Spec string

	// SpecType defines the format of the spec.
	SpecType string

	// ProhibitOverlap enforces that spawned jobs do not run in parallel.
	ProhibitOverlap bool `mapstructure:"prohibit_overlap"`
}

Periodic defines the interval a job should be run at.

func (*PeriodicConfig) Copy added in v0.3.0 

func (p *PeriodicConfig) Copy() *PeriodicConfig

func (*PeriodicConfig) Next added in v0.2.2 

func (p *PeriodicConfig) Next(fromTime time.Time) time.Time

Next returns the closest time instant matching the spec that is after the passed time. If no matching instance exists, the zero value of time.Time is returned. The `time.Location` of the returned value matches that of the passed time.

func (*PeriodicConfig) Validate added in v0.2.2 

func (p *PeriodicConfig) Validate() error

type PeriodicForceRequest added in v0.3.0 

type PeriodicForceRequest struct {
	JobID string
	WriteRequest
}

PeriodicForceReqeuest is used to force a specific periodic job.

type PeriodicForceResponse added in v0.3.0 

type PeriodicForceResponse struct {
	EvalID          string
	EvalCreateIndex uint64
	WriteMeta
}

PeriodicForceResponse is used to respond to a periodic job force launch

type PeriodicLaunch added in v0.3.0 

type PeriodicLaunch struct {
	ID     string    // ID of the periodic job.
	Launch time.Time // The last launch time.

	// Raft Indexes
	CreateIndex uint64
	ModifyIndex uint64
}

PeriodicLaunch tracks the last launch time of a periodic job.

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

	// Job is the parent job of all the allocations in the Plan.
	// Since a Plan only involves a single Job, we can reduce the size
	// of the plan by only including it once.
	Job *Job

	// 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 Port added in v0.2.0 

type Port struct {
	Label string
	Value int `mapstructure:"static"`
}

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

	// If set, used as prefix for resource list searches
	Prefix string
}

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 DefaultResources added in v0.3.0 

func DefaultResources() *Resources

DefaultResources returns the minimum resources a task can use and be valid.

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) MeetsMinResources added in v0.3.0 

func (r *Resources) MeetsMinResources() error

MeetsMinResources returns an error if the resources specified are less than the minimum allowed.

func (*Resources) Merge added in v0.3.0 

func (r *Resources) Merge(other *Resources)

Merge merges this resource with another resource.

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 RestartPolicy added in v0.2.0 

type RestartPolicy struct {
	// Attempts is the number of restart that will occur in an interval.
	Attempts int

	// Interval is a duration in which we can limit the number of restarts
	// within.
	Interval time.Duration

	// Delay is the time between a failure and a restart.
	Delay time.Duration

	// Mode controls what happens when the task restarts more than attempt times
	// in an interval.
	Mode string
}

RestartPolicy configures how Tasks are restarted when they crash or fail.

func NewRestartPolicy added in v0.2.0 

func NewRestartPolicy(jobType string) *RestartPolicy

func (*RestartPolicy) Copy added in v0.3.0 

func (r *RestartPolicy) Copy() *RestartPolicy

func (*RestartPolicy) Validate added in v0.2.0 

func (r *RestartPolicy) Validate() error

type Service added in v0.2.0 

type Service struct {
	Name      string          // Name of the service, defaults to id
	Tags      []string        // List of tags for the service
	PortLabel string          `mapstructure:"port"` // port for the service
	Checks    []*ServiceCheck // List of checks associated with the service
}

The Service model represents a Consul service defintion

func (*Service) Copy added in v0.3.0 

func (s *Service) Copy() *Service

func (*Service) Hash added in v0.2.1 

func (s *Service) Hash() string

Hash calculates the hash of the check based on it's content and the service which owns it

func (*Service) InitFields added in v0.2.2 

func (s *Service) InitFields(job string, taskGroup string, task string)

InitFields interpolates values of Job, Task Group and Task in the Service Name. This also generates check names, service id and check ids.

func (*Service) Validate added in v0.2.0 

func (s *Service) Validate() error

Validate checks if the Check definition is valid

type ServiceCheck added in v0.2.0 

type ServiceCheck struct {
	Name     string        // Name of the check, defaults to id
	Type     string        // Type of the check - tcp, http, docker and script
	Script   string        // Script to invoke for script check
	Path     string        // path of the health check url for http type check
	Protocol string        // Protocol to use if check is http, defaults to http
	Interval time.Duration // Interval of the check
	Timeout  time.Duration // Timeout of the response from the check before consul fails the check
}

The ServiceCheck data model represents the consul health check that Nomad registers for a Task

func (*ServiceCheck) Copy added in v0.3.0 

func (sc *ServiceCheck) Copy() *ServiceCheck

func (*ServiceCheck) Hash added in v0.2.1 

func (sc *ServiceCheck) Hash(serviceID string) string

func (*ServiceCheck) Validate added in v0.2.0 

func (sc *ServiceCheck) Validate() error

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]interface{}

	// Map of environment variables to be used by the driver
	Env map[string]string

	// List of service definitions exposed by the Task
	Services []*Service

	// 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

	// KillTimeout is the time between signaling a task that it will be
	// killed and killing it.
	KillTimeout time.Duration `mapstructure:"kill_timeout"`

	// LogConfig provides configuration for log rotation
	LogConfig *LogConfig `mapstructure:"logs"`
}

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

func (*Task) Copy added in v0.3.0 

func (t *Task) Copy() *Task

func (*Task) FindHostAndPortFor added in v0.2.1 

func (t *Task) FindHostAndPortFor(portLabel string) (string, int)

func (*Task) GoString 

func (t *Task) GoString() string

func (*Task) InitFields added in v0.3.0 

func (t *Task) InitFields(job *Job, tg *TaskGroup)

InitFields initializes fields in the task.

func (*Task) InitServiceFields added in v0.3.0 

func (t *Task) InitServiceFields(job string, taskGroup string)

InitServiceFields interpolates values of Job, Task Group and Tasks in all the service Names of a Task. This also generates the service id, check id and check names.

func (*Task) Validate 

func (t *Task) Validate() error

Validate is used to sanity check a task group

type TaskEvent added in v0.2.0 

type TaskEvent struct {
	Type string
	Time int64 // Unix Nanosecond timestamp

	// Driver Failure fields.
	DriverError string // A driver error occured while starting the task.

	// Task Terminated Fields.
	ExitCode int    // The exit code of the task.
	Signal   int    // The signal that terminated the task.
	Message  string // A possible message explaining the termination of the task.

	// Task Killed Fields.
	KillError string // Error killing the task.
}

TaskEvent is an event that effects the state of a task and contains meta-data appropriate to the events type.

func NewTaskEvent added in v0.2.0 

func NewTaskEvent(event string) *TaskEvent

func (*TaskEvent) Copy added in v0.3.0 

func (te *TaskEvent) Copy() *TaskEvent

func (*TaskEvent) SetDriverError added in v0.2.0 

func (e *TaskEvent) SetDriverError(err error) *TaskEvent

func (*TaskEvent) SetExitCode added in v0.2.0 

func (e *TaskEvent) SetExitCode(c int) *TaskEvent

func (*TaskEvent) SetExitMessage added in v0.2.0 

func (e *TaskEvent) SetExitMessage(err error) *TaskEvent

func (*TaskEvent) SetKillError added in v0.2.0 

func (e *TaskEvent) SetKillError(err error) *TaskEvent

func (*TaskEvent) SetSignal added in v0.2.0 

func (e *TaskEvent) SetSignal(s int) *TaskEvent

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

	//RestartPolicy of a TaskGroup
	RestartPolicy *RestartPolicy

	// 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) Copy added in v0.3.0 

func (tg *TaskGroup) Copy() *TaskGroup

func (*TaskGroup) GoString 

func (tg *TaskGroup) GoString() string

func (*TaskGroup) InitFields added in v0.3.0 

func (tg *TaskGroup) InitFields(job *Job)

InitFields is used to initialize fields in the TaskGroup.

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 TaskState added in v0.2.0 

type TaskState struct {
	// The current state of the task.
	State string

	// Series of task events that transistion the state of the task.
	Events []*TaskEvent
}

TaskState tracks the current state of a task and events that caused state transistions.

func (*TaskState) Copy added in v0.3.0 

func (ts *TaskState) Copy() *TaskState

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 include 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.