api: avoid codegen for syncing

Given that the values will rarely change, specially considering that any
changes would be backward incompatible change.  As such, it's simpler to
keep syncing manually in the rare occasion and avoid the syncing code
overhead.

api/allocations.go

@@ -12,6 +12,20 @@ var (
 	NodeDownErr = fmt.Errorf("node down")
 )
 
+const (
+	AllocDesiredStatusRun   = "run"   // Allocation should run
+	AllocDesiredStatusStop  = "stop"  // Allocation should stop
+	AllocDesiredStatusEvict = "evict" // Allocation should stop, and was evicted
+)
+
+const (
+	AllocClientStatusPending  = "pending"
+	AllocClientStatusRunning  = "running"
+	AllocClientStatusComplete = "complete"
+	AllocClientStatusFailed   = "failed"
+	AllocClientStatusLost     = "lost"
+)
+
 // Allocations is used to query the alloc-related endpoints.
 type Allocations struct {
 	client *Client

api/jobs.go

@@ -576,13 +576,27 @@ func (p *PeriodicConfig) Canonicalize() {
 func (p *PeriodicConfig) Next(fromTime time.Time) (time.Time, error) {
 	if *p.SpecType == PeriodicSpecCron {
 		if e, err := cronexpr.Parse(*p.Spec); err == nil {
-			return CronParseNext(e, fromTime, *p.Spec)
+			return cronParseNext(e, fromTime, *p.Spec)
 		}
 	}
 
 	return time.Time{}, nil
 }
 
+// cronParseNext is a helper that parses the next time for the given expression
+// but captures any panic that may occur in the underlying library.
+// ---  THIS FUNCTION IS REPLICATED IN nomad/structs/structs.go
+// and should be kept in sync.
+func cronParseNext(e *cronexpr.Expression, fromTime time.Time, spec string) (t time.Time, err error) {
+	defer func() {
+		if recover() != nil {
+			t = time.Time{}
+			err = fmt.Errorf("failed parsing cron expression: %q", spec)
+		}
+	}()
+
+	return e.Next(fromTime), nil
+}
 func (p *PeriodicConfig) GetLocation() (*time.Location, error) {
 	if p.TimeZone == nil || *p.TimeZone == "" {
 		return time.UTC, nil

api/nodes.go

@@ -8,6 +8,18 @@ import (
 	"time"
 )
 
+const (
+	NodeStatusInit  = "initializing"
+	NodeStatusReady = "ready"
+	NodeStatusDown  = "down"
+
+	// NodeSchedulingEligible and Ineligible marks the node as eligible or not,
+	// respectively, for receiving allocations. This is orthoginal to the node
+	// status being ready.
+	NodeSchedulingEligible   = "eligible"
+	NodeSchedulingIneligible = "ineligible"
+)
+
 // Nodes is used to query node-related API endpoints
 type Nodes struct {
 	client *Client

api/tasks.go

@@ -8,6 +8,16 @@ import (
 	"time"
 )
 
+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"
+)
+
 // MemoryStats holds memory usage related stats
 type MemoryStats struct {
 	RSS            uint64
@@ -167,22 +177,28 @@ func NewDefaultReschedulePolicy(jobType string) *ReschedulePolicy {
 	var dp *ReschedulePolicy
 	switch jobType {
 	case "service":
+		// This needs to be in sync with DefaultServiceJobReschedulePolicy
+		// in nomad/structs/structs.go
 		dp = &ReschedulePolicy{
-			Attempts:      intToPtr(defaultServiceJobReschedulePolicyAttempts),
-			Interval:      timeToPtr(defaultServiceJobReschedulePolicyInterval),
-			Delay:         timeToPtr(defaultServiceJobReschedulePolicyDelay),
-			DelayFunction: stringToPtr(defaultServiceJobReschedulePolicyDelayFunction),
-			MaxDelay:      timeToPtr(defaultServiceJobReschedulePolicyMaxDelay),
-			Unlimited:     boolToPtr(defaultServiceJobReschedulePolicyUnlimited),
+			Delay:         timeToPtr(30 * time.Second),
+			DelayFunction: stringToPtr("exponential"),
+			MaxDelay:      timeToPtr(1 * time.Hour),
+			Unlimited:     boolToPtr(true),
+
+			Attempts: intToPtr(0),
+			Interval: timeToPtr(0),
 		}
 	case "batch":
+		// This needs to be in sync with DefaultBatchJobReschedulePolicy
+		// in nomad/structs/structs.go
 		dp = &ReschedulePolicy{
-			Attempts:      intToPtr(defaultBatchJobReschedulePolicyAttempts),
-			Interval:      timeToPtr(defaultBatchJobReschedulePolicyInterval),
-			Delay:         timeToPtr(defaultBatchJobReschedulePolicyDelay),
-			DelayFunction: stringToPtr(defaultBatchJobReschedulePolicyDelayFunction),
-			MaxDelay:      timeToPtr(defaultBatchJobReschedulePolicyMaxDelay),
-			Unlimited:     boolToPtr(defaultBatchJobReschedulePolicyUnlimited),
+			Attempts:      intToPtr(1),
+			Interval:      timeToPtr(24 * time.Hour),
+			Delay:         timeToPtr(5 * time.Second),
+			DelayFunction: stringToPtr("constant"),
+
+			MaxDelay:  timeToPtr(0),
+			Unlimited: boolToPtr(false),
 		}
 
 	case "system":
@@ -552,18 +568,22 @@ func (g *TaskGroup) Canonicalize(job *Job) {
 	var defaultRestartPolicy *RestartPolicy
 	switch *job.Type {
 	case "service", "system":
+		// These needs to be in sync with DefaultServiceJobRestartPolicy in
+		// in nomad/structs/structs.go
 		defaultRestartPolicy = &RestartPolicy{
-			Delay:    timeToPtr(defaultServiceJobRestartPolicyDelay),
-			Attempts: intToPtr(defaultServiceJobRestartPolicyAttempts),
-			Interval: timeToPtr(defaultServiceJobRestartPolicyInterval),
-			Mode:     stringToPtr(defaultServiceJobRestartPolicyMode),
+			Delay:    timeToPtr(15 * time.Second),
+			Attempts: intToPtr(2),
+			Interval: timeToPtr(30 * time.Minute),
+			Mode:     stringToPtr(RestartPolicyModeFail),
 		}
 	default:
+		// These needs to be in sync with DefaultBatchJobRestartPolicy in
+		// in nomad/structs/structs.go
 		defaultRestartPolicy = &RestartPolicy{
-			Delay:    timeToPtr(defaultBatchJobRestartPolicyDelay),
-			Attempts: intToPtr(defaultBatchJobRestartPolicyAttempts),
-			Interval: timeToPtr(defaultBatchJobRestartPolicyInterval),
-			Mode:     stringToPtr(defaultBatchJobRestartPolicyMode),
+			Delay:    timeToPtr(15 * time.Second),
+			Attempts: intToPtr(3),
+			Interval: timeToPtr(24 * time.Hour),
+			Mode:     stringToPtr(RestartPolicyModeFail),
 		}
 	}