From 2c0d30fbbd5bcbf995e6233dff0a10da3fdffb69 Mon Sep 17 00:00:00 2001
From: Alex Dadgar <alex.dadgar@gmail.com>
Date: Fri, 4 Dec 2015 09:49:42 -0800
Subject: [PATCH] Add periodic index to job table

---
 nomad/state/schema.go           |  8 ++++
 nomad/state/state_store.go      | 12 ++++++
 nomad/state/state_store_test.go | 66 +++++++++++++++++++++++++++++++++
 3 files changed, 86 insertions(+)

diff --git a/nomad/state/schema.go b/nomad/state/schema.go
index f0ee0fd75..d3119016b 100644
--- a/nomad/state/schema.go
+++ b/nomad/state/schema.go
@@ -118,6 +118,14 @@ func jobTableSchema() *memdb.TableSchema {
 					Lowercase: true,
 				},
 			},
+			"periodic": &memdb.IndexSchema{
+				Name:         "periodic",
+				AllowMissing: false,
+				Unique:       false,
+				Indexer: &memdb.FieldSetIndex{
+					Field: "Periodic",
+				},
+			},
 		},
 	}
 }
diff --git a/nomad/state/state_store.go b/nomad/state/state_store.go
index 25c5151f6..f0953d403 100644
--- a/nomad/state/state_store.go
+++ b/nomad/state/state_store.go
@@ -371,6 +371,18 @@ func (s *StateStore) ChildJobs(id string) (memdb.ResultIterator, error) {
 	return iter, nil
 }
 
+// JobsByPeriodic returns an iterator over all the periodic or non-periodic jobs.
+func (s *StateStore) JobsByPeriodic(periodic bool) (memdb.ResultIterator, error) {
+	txn := s.db.Txn(false)
+
+	// Scan all jobs whose parent is the passed id.
+	iter, err := txn.Get("jobs", "periodic", periodic)
+	if err != nil {
+		return nil, err
+	}
+	return iter, nil
+}
+
 // JobsByScheduler returns an iterator over all the jobs with the specific
 // scheduler type.
 func (s *StateStore) JobsByScheduler(schedulerType string) (memdb.ResultIterator, error) {
diff --git a/nomad/state/state_store_test.go b/nomad/state/state_store_test.go
index 23331ee57..a1504e936 100644
--- a/nomad/state/state_store_test.go
+++ b/nomad/state/state_store_test.go
@@ -446,6 +446,72 @@ func TestStateStore_ChildJobs(t *testing.T) {
 	}
 }
 
+func TestStateStore_JobsByPeriodic(t *testing.T) {
+	state := testStateStore(t)
+	var periodic, nonPeriodic []*structs.Job
+
+	for i := 0; i < 10; i++ {
+		job := mock.Job()
+		nonPeriodic = append(nonPeriodic, job)
+
+		err := state.UpsertJob(1000+uint64(i), job)
+		if err != nil {
+			t.Fatalf("err: %v", err)
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		job := mock.PeriodicJob()
+		periodic = append(periodic, job)
+
+		err := state.UpsertJob(2000+uint64(i), job)
+		if err != nil {
+			t.Fatalf("err: %v", err)
+		}
+	}
+
+	iter, err := state.JobsByPeriodic(true)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	var outPeriodic []*structs.Job
+	for {
+		raw := iter.Next()
+		if raw == nil {
+			break
+		}
+		outPeriodic = append(outPeriodic, raw.(*structs.Job))
+	}
+
+	iter, err = state.JobsByPeriodic(false)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	var outNonPeriodic []*structs.Job
+	for {
+		raw := iter.Next()
+		if raw == nil {
+			break
+		}
+		outNonPeriodic = append(outNonPeriodic, raw.(*structs.Job))
+	}
+
+	sort.Sort(JobIDSort(periodic))
+	sort.Sort(JobIDSort(nonPeriodic))
+	sort.Sort(JobIDSort(outPeriodic))
+	sort.Sort(JobIDSort(outNonPeriodic))
+
+	if !reflect.DeepEqual(periodic, outPeriodic) {
+		t.Fatalf("bad: %#v %#v", periodic, outPeriodic)
+	}
+
+	if !reflect.DeepEqual(nonPeriodic, outNonPeriodic) {
+		t.Fatalf("bad: %#v %#v", nonPeriodic, outNonPeriodic)
+	}
+}
+
 func TestStateStore_JobsByScheduler(t *testing.T) {
 	state := testStateStore(t)
 	var serviceJobs []*structs.Job