Add cgroup limiting to Linux Executor

api/allocations.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"sort"
 	"time"
 )
 
@@ -21,6 +22,7 @@ func (a *Allocations) List(q *QueryOptions) ([]*AllocationListStub, *QueryMeta,
 	if err != nil {
 		return nil, nil, err
 	}
+	sort.Sort(AllocIndexSort(resp))
 	return resp, qm, nil
 }
 
@@ -84,3 +86,18 @@ type AllocationListStub struct {
 	CreateIndex        uint64
 	ModifyIndex        uint64
 }
+
+// AllocIndexSort reverse sorts allocs by CreateIndex.
+type AllocIndexSort []*AllocationListStub
+
+func (a AllocIndexSort) Len() int {
+	return len(a)
+}
+
+func (a AllocIndexSort) Less(i, j int) bool {
+	return a[i].CreateIndex > a[j].CreateIndex
+}
+
+func (a AllocIndexSort) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}

api/allocations_test.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"reflect"
+	"sort"
 	"testing"
 )
 
@@ -49,3 +51,21 @@ func TestAllocations_List(t *testing.T) {
 		t.Fatalf("bad: %#v", allocs)
 	}
 }
+
+func TestAllocations_CreateIndexSort(t *testing.T) {
+	allocs := []*AllocationListStub{
+		&AllocationListStub{CreateIndex: 2},
+		&AllocationListStub{CreateIndex: 1},
+		&AllocationListStub{CreateIndex: 5},
+	}
+	sort.Sort(AllocIndexSort(allocs))
+
+	expect := []*AllocationListStub{
+		&AllocationListStub{CreateIndex: 5},
+		&AllocationListStub{CreateIndex: 2},
+		&AllocationListStub{CreateIndex: 1},
+	}
+	if !reflect.DeepEqual(allocs, expect) {
+		t.Fatalf("\n\n%#v\n\n%#v", allocs, expect)
+	}
+}

api/compose_test.go

@@ -32,14 +32,15 @@ func TestCompose(t *testing.T) {
 		AddTask(task)
 
 	// Compose a job
-	job := NewServiceJob("job1", "myjob", 2).
+	job := NewServiceJob("job1", "myjob", "region1", 2).
 		SetMeta("foo", "bar").
 		AddDatacenter("dc1").
 		Constrain(HardConstraint("kernel.name", "=", "linux")).
 		AddTaskGroup(grp)
 
 	// Check that the composed result looks correct
 	expect := &Job{
+		Region:   "region1",
 		ID:       "job1",
 		Name:     "myjob",
 		Type:     JobTypeService,

api/evaluations.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"sort"
 	"time"
 )
 
@@ -21,6 +22,7 @@ func (e *Evaluations) List(q *QueryOptions) ([]*Evaluation, *QueryMeta, error) {
 	if err != nil {
 		return nil, nil, err
 	}
+	sort.Sort(EvalIndexSort(resp))
 	return resp, qm, nil
 }
 
@@ -42,6 +44,7 @@ func (e *Evaluations) Allocations(evalID string, q *QueryOptions) ([]*Allocation
 	if err != nil {
 		return nil, nil, err
 	}
+	sort.Sort(AllocIndexSort(resp))
 	return resp, qm, nil
 }
 
@@ -60,4 +63,22 @@ type Evaluation struct {
 	Wait              time.Duration
 	NextEval          string
 	PreviousEval      string
+	CreateIndex       uint64
+	ModifyIndex       uint64
+}
+
+// EvalIndexSort is a wrapper to sort evaluations by CreateIndex.
+// We reverse the test so that we get the highest index first.
+type EvalIndexSort []*Evaluation
+
+func (e EvalIndexSort) Len() int {
+	return len(e)
+}
+
+func (e EvalIndexSort) Less(i, j int) bool {
+	return e[i].CreateIndex > e[j].CreateIndex
+}
+
+func (e EvalIndexSort) Swap(i, j int) {
+	e[i], e[j] = e[j], e[i]
 }

api/evaluations_test.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"reflect"
+	"sort"
 	"strings"
 	"testing"
 )
@@ -94,3 +96,21 @@ func TestEvaluations_Allocations(t *testing.T) {
 		t.Fatalf("expected 0 allocs, got: %d", n)
 	}
 }
+
+func TestEvaluations_Sort(t *testing.T) {
+	evals := []*Evaluation{
+		&Evaluation{CreateIndex: 2},
+		&Evaluation{CreateIndex: 1},
+		&Evaluation{CreateIndex: 5},
+	}
+	sort.Sort(EvalIndexSort(evals))
+
+	expect := []*Evaluation{
+		&Evaluation{CreateIndex: 5},
+		&Evaluation{CreateIndex: 2},
+		&Evaluation{CreateIndex: 1},
+	}
+	if !reflect.DeepEqual(evals, expect) {
+		t.Fatalf("\n\n%#v\n\n%#v", evals, expect)
+	}
+}

api/jobs.go

@@ -1,5 +1,9 @@
 package api
 
+import (
+	"sort"
+)
+
 const (
 	// JobTypeService indicates a long-running processes
 	JobTypeService = "service"
@@ -38,6 +42,7 @@ func (j *Jobs) List(q *QueryOptions) ([]*JobListStub, *QueryMeta, error) {
 	if err != nil {
 		return nil, qm, err
 	}
+	sort.Sort(JobIDSort(resp))
 	return resp, qm, nil
 }
 
@@ -59,6 +64,7 @@ func (j *Jobs) Allocations(jobID string, q *QueryOptions) ([]*AllocationListStub
 	if err != nil {
 		return nil, nil, err
 	}
+	sort.Sort(AllocIndexSort(resp))
 	return resp, qm, nil
 }
 
@@ -70,6 +76,7 @@ func (j *Jobs) Evaluations(jobID string, q *QueryOptions) ([]*Evaluation, *Query
 	if err != nil {
 		return nil, nil, err
 	}
+	sort.Sort(EvalIndexSort(resp))
 	return resp, qm, nil
 }
 
@@ -94,6 +101,7 @@ func (j *Jobs) ForceEvaluate(jobID string, q *WriteOptions) (string, *WriteMeta,
 
 // Job is used to serialize a job.
 type Job struct {
+	Region            string
 	ID                string
 	Name              string
 	Type              string
@@ -122,26 +130,42 @@ type JobListStub struct {
 	ModifyIndex       uint64
 }
 
+// JobIDSort is used to sort jobs by their job ID's.
+type JobIDSort []*JobListStub
+
+func (j JobIDSort) Len() int {
+	return len(j)
+}
+
+func (j JobIDSort) Less(a, b int) bool {
+	return j[a].ID < j[b].ID
+}
+
+func (j JobIDSort) Swap(a, b int) {
+	j[a], j[b] = j[b], j[a]
+}
+
 // NewServiceJob creates and returns a new service-style job
 // for long-lived processes using the provided name, ID, and
 // relative job priority.
-func NewServiceJob(id, name string, pri int) *Job {
-	return newJob(id, name, JobTypeService, pri)
+func NewServiceJob(id, name, region string, pri int) *Job {
+	return newJob(id, name, region, JobTypeService, pri)
 }
 
 // NewBatchJob creates and returns a new batch-style job for
 // short-lived processes using the provided name and ID along
 // with the relative job priority.
-func NewBatchJob(id, name string, pri int) *Job {
-	return newJob(id, name, JobTypeBatch, pri)
+func NewBatchJob(id, name, region string, pri int) *Job {
+	return newJob(id, name, region, JobTypeBatch, pri)
 }
 
 // newJob is used to create a new Job struct.
-func newJob(jobID, jobName, jobType string, pri int) *Job {
+func newJob(id, name, region, typ string, pri int) *Job {
 	return &Job{
-		ID:       jobID,
-		Name:     jobName,
-		Type:     jobType,
+		Region:   region,
+		ID:       id,
+		Name:     name,
+		Type:     typ,
 		Priority: pri,
 	}
 }

api/jobs_test.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"reflect"
+	"sort"
 	"strings"
 	"testing"
 )
@@ -218,8 +219,9 @@ func TestJobs_ForceEvaluate(t *testing.T) {
 }
 
 func TestJobs_NewBatchJob(t *testing.T) {
-	job := NewBatchJob("job1", "myjob", 5)
+	job := NewBatchJob("job1", "myjob", "region1", 5)
 	expect := &Job{
+		Region:   "region1",
 		ID:       "job1",
 		Name:     "myjob",
 		Type:     JobTypeBatch,
@@ -231,8 +233,9 @@ func TestJobs_NewBatchJob(t *testing.T) {
 }
 
 func TestJobs_NewServiceJob(t *testing.T) {
-	job := NewServiceJob("job1", "myjob", 5)
+	job := NewServiceJob("job1", "myjob", "region1", 5)
 	expect := &Job{
+		Region:   "region1",
 		ID:       "job1",
 		Name:     "myjob",
 		Type:     JobTypeService,
@@ -301,3 +304,21 @@ func TestJobs_Constrain(t *testing.T) {
 		t.Fatalf("expect: %#v, got: %#v", expect, job.Constraints)
 	}
 }
+
+func TestJobs_Sort(t *testing.T) {
+	jobs := []*JobListStub{
+		&JobListStub{ID: "job2"},
+		&JobListStub{ID: "job0"},
+		&JobListStub{ID: "job1"},
+	}
+	sort.Sort(JobIDSort(jobs))
+
+	expect := []*JobListStub{
+		&JobListStub{ID: "job0"},
+		&JobListStub{ID: "job1"},
+		&JobListStub{ID: "job2"},
+	}
+	if !reflect.DeepEqual(jobs, expect) {
+		t.Fatalf("\n\n%#v\n\n%#v", jobs, expect)
+	}
+}

api/nodes.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"sort"
 	"strconv"
 )
 
@@ -16,11 +17,12 @@ func (c *Client) Nodes() *Nodes {
 
 // List is used to list out all of the nodes
 func (n *Nodes) List(q *QueryOptions) ([]*NodeListStub, *QueryMeta, error) {
-	var resp []*NodeListStub
+	var resp NodeIndexSort
 	qm, err := n.client.query("/v1/nodes", &resp, q)
 	if err != nil {
 		return nil, nil, err
 	}
+	sort.Sort(NodeIndexSort(resp))
 	return resp, qm, nil
 }
 
@@ -51,6 +53,7 @@ func (n *Nodes) Allocations(nodeID string, q *QueryOptions) ([]*AllocationListSt
 	if err != nil {
 		return nil, nil, err
 	}
+	sort.Sort(AllocIndexSort(resp))
 	return resp, qm, nil
 }
 
@@ -95,6 +98,21 @@ type NodeListStub struct {
 	ModifyIndex       uint64
 }
 
+// NodeIndexSort reverse sorts nodes by CreateIndex
+type NodeIndexSort []*NodeListStub
+
+func (n NodeIndexSort) Len() int {
+	return len(n)
+}
+
+func (n NodeIndexSort) Less(i, j int) bool {
+	return n[i].CreateIndex > n[j].CreateIndex
+}
+
+func (n NodeIndexSort) Swap(i, j int) {
+	n[i], n[j] = n[j], n[i]
+}
+
 // nodeEvalResponse is used to decode a force-eval.
 type nodeEvalResponse struct {
 	EvalID string

api/nodes_test.go

@@ -2,6 +2,8 @@ package api
 
 import (
 	"fmt"
+	"reflect"
+	"sort"
 	"strings"
 	"testing"
 
@@ -201,3 +203,21 @@ func TestNodes_ForceEvaluate(t *testing.T) {
 		t.Fatalf("err: %s", err)
 	}
 }
+
+func TestNodes_Sort(t *testing.T) {
+	nodes := []*NodeListStub{
+		&NodeListStub{CreateIndex: 2},
+		&NodeListStub{CreateIndex: 1},
+		&NodeListStub{CreateIndex: 5},
+	}
+	sort.Sort(NodeIndexSort(nodes))
+
+	expect := []*NodeListStub{
+		&NodeListStub{CreateIndex: 5},
+		&NodeListStub{CreateIndex: 2},
+		&NodeListStub{CreateIndex: 1},
+	}
+	if !reflect.DeepEqual(nodes, expect) {
+		t.Fatalf("\n\n%#v\n\n%#v", nodes, expect)
+	}
+}