Added some query filters on Job executions

dkron/api.go

@@ -328,16 +328,28 @@ func (h *HTTPTransport) restoreHandler(c *gin.Context) {
 func (h *HTTPTransport) executionsHandler(c *gin.Context) {
 	jobName := c.Param("job")
 
+	sort := c.DefaultQuery("_sort", "")
+	if sort == "id" {
+		sort = "started_at"
+	}
+	order := c.DefaultQuery("_order", "DESC")
+
 	job, err := h.agent.Store.GetJob(jobName, nil)
 	if err != nil {
 		c.AbortWithError(http.StatusNotFound, err)
 		return
 	}
 
-	executions, err := h.agent.Store.GetExecutions(job.Name, job.GetTimeLocation())
+	executions, err := h.agent.Store.GetExecutions(job.Name, job.GetTimeLocation(), 
+		&ExecutionOptions{
+			Sort:     sort,
+			Order:    order,
+		},
+	)
 	if err != nil {
 		if err == buntdb.ErrNotFound {
 			renderJSON(c, http.StatusOK, &[]Execution{})
+			log.Error(err)
 			return
 		}
 		log.Error(err)

dkron/grpc_test.go

@@ -76,14 +76,14 @@ func TestGRPCExecutionDone(t *testing.T) {
 
 	rc := NewGRPCClient(nil, a)
 	rc.ExecutionDone(a.advertiseRPCAddr(), testExecution)
-	execs, err := a.Store.GetExecutions("test", nil)
+	execs, err := a.Store.GetExecutions("test", nil, &ExecutionOptions{})
 	require.NoError(t, err)
 
 	assert.Len(t, execs, 1)
 	assert.Equal(t, string(testExecution.Output), string(execs[0].Output))
 
 	// Test run a dependent job
-	execs, err = a.Store.GetExecutions("child-test", nil)
+	execs, err = a.Store.GetExecutions("child-test", nil, &ExecutionOptions{})
 	require.NoError(t, err)
 
 	assert.Len(t, execs, 1)

dkron/storage.go

@@ -16,7 +16,7 @@ type Storage interface {
 	SetExecutionDone(execution *Execution) (bool, error)
 	GetJobs(options *JobOptions) ([]*Job, error)
 	GetJob(name string, options *JobOptions) (*Job, error)
-	GetExecutions(jobName string, timezone *time.Location) ([]*Execution, error)
+	GetExecutions(jobName string, timezone *time.Location, opts *ExecutionOptions) ([]*Execution, error)
 	GetExecutionGroup(execution *Execution, timezone *time.Location) ([]*Execution, error)
 	GetGroupedExecutions(jobName string, timezone *time.Location) (map[int64][]*Execution, []int64, error)
 	Shutdown() error

dkron/store.go

@@ -47,6 +47,12 @@ type JobOptions struct {
 	Status   string
 }
 
+// ExecutionOptions additional options like "Sort" will be ready for JSON marshall
+type ExecutionOptions struct {
+	Sort 	string
+	Order 	string
+}
+
 type kv struct {
 	Key   string
 	Value []byte
@@ -56,6 +62,8 @@ type kv struct {
 func NewStore() (*Store, error) {
 	db, err := buntdb.Open(":memory:")
 	db.CreateIndex("name", jobsPrefix+":*", buntdb.IndexJSON("name"))
+	db.CreateIndex("started_at", executionsPrefix+":*", buntdb.IndexJSON("started_at"))
+	db.CreateIndex("finished_at", executionsPrefix+":*", buntdb.IndexJSON("finished_at"))
 	db.CreateIndex("displayname", jobsPrefix+":*", buntdb.IndexJSON("displayname"))
 	db.CreateIndex("schedule", jobsPrefix+":*", buntdb.IndexJSON("schedule"))
 	db.CreateIndex("success_count", jobsPrefix+":*", buntdb.IndexJSON("success_count"))
@@ -416,49 +424,55 @@ func (s *Store) DeleteJob(name string) (*Job, error) {
 }
 
 // GetExecutions returns the executions given a Job name.
-func (s *Store) GetExecutions(jobName string, timezone *time.Location) ([]*Execution, error) {
+func (s *Store) GetExecutions(jobName string, timezone *time.Location, opts *ExecutionOptions) ([]*Execution, error) {
 	prefix := fmt.Sprintf("%s:%s:", executionsPrefix, jobName)
 
-	kvs, err := s.list(prefix, true)
+	kvs, err := s.list(prefix, true, opts)
 	if err != nil {
 		return nil, err
 	}
 
 	return s.unmarshalExecutions(kvs, timezone)
 }
 
-func (s *Store) list(prefix string, checkRoot bool) ([]kv, error) {
+func (s *Store) list(prefix string, checkRoot bool, opts *ExecutionOptions) ([]kv, error) {
 	var found bool
 	kvs := []kv{}
 
-	err := s.db.View(s.listTxFunc(prefix, &kvs, &found))
+	err := s.db.View(s.listTxFunc(prefix, &kvs, &found, opts))
 	if err == nil && !found && checkRoot {
 		return nil, buntdb.ErrNotFound
 	}
 
 	return kvs, err
 }
 
-func (*Store) listTxFunc(prefix string, kvs *[]kv, found *bool) func(tx *buntdb.Tx) error {
-	return func(tx *buntdb.Tx) error {
-		err := tx.Ascend("", func(key, value string) bool {
-			if strings.HasPrefix(key, prefix) {
-				*found = true
-				// ignore self in listing
-				if !bytes.Equal(trimDirectoryKey([]byte(key)), []byte(prefix)) {
-					kv := kv{Key: key, Value: []byte(value)}
-					*kvs = append(*kvs, kv)
-				}
+func (*Store) listTxFunc(prefix string, kvs *[]kv, found *bool, opts *ExecutionOptions) func(tx *buntdb.Tx) error {
+	fnc := func(key, value string) bool {
+		if strings.HasPrefix(key, prefix) {
+			*found = true
+			// ignore self in listing
+			if !bytes.Equal(trimDirectoryKey([]byte(key)), []byte(prefix)) {
+				kv := kv{Key: key, Value: []byte(value)}
+				*kvs = append(*kvs, kv)
 			}
-			return true
-		})
+		}
+		return true
+	}
+
+	return func(tx *buntdb.Tx) (err error) {
+		if opts.Order == "DESC" {
+			err = tx.Descend(opts.Sort, fnc)
+		} else {
+			err = tx.Ascend(opts.Sort, fnc)
+		}
 		return err
 	}
 }
 
 // GetExecutionGroup returns all executions in the same group of a given execution
 func (s *Store) GetExecutionGroup(execution *Execution, timezone *time.Location) ([]*Execution, error) {
-	res, err := s.GetExecutions(execution.JobName, timezone)
+	res, err := s.GetExecutions(execution.JobName, timezone, &ExecutionOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -475,7 +489,7 @@ func (s *Store) GetExecutionGroup(execution *Execution, timezone *time.Location)
 // GetGroupedExecutions returns executions for a job grouped and with an ordered index
 // to facilitate access.
 func (s *Store) GetGroupedExecutions(jobName string, timezone *time.Location) (map[int64][]*Execution, []int64, error) {
-	execs, err := s.GetExecutions(jobName, timezone)
+	execs, err := s.GetExecutions(jobName, timezone, &ExecutionOptions{})
 	if err != nil {
 		return nil, nil, err
 	}
@@ -545,7 +559,7 @@ func (s *Store) SetExecution(execution *Execution) (string, error) {
 		return "", err
 	}
 
-	execs, err := s.GetExecutions(execution.JobName, nil)
+	execs, err := s.GetExecutions(execution.JobName, nil, &ExecutionOptions{})
 	if err != nil && err != buntdb.ErrNotFound {
 		log.WithError(err).
 			WithField("job", execution.JobName).
@@ -640,7 +654,7 @@ func (s *Store) computeStatus(jobName string, exGroup int64, tx *buntdb.Tx) (str
 	found := false
 	prefix := fmt.Sprintf("%s:%s:", executionsPrefix, jobName)
 
-	if err := s.listTxFunc(prefix, &kvs, &found)(tx); err != nil {
+	if err := s.listTxFunc(prefix, &kvs, &found, &ExecutionOptions{})(tx); err != nil {
 		return "", err
 	}
 

dkron/store_test.go

@@ -69,7 +69,10 @@ func TestStore(t *testing.T) {
 	_, err = s.SetExecution(testExecution2)
 	require.NoError(t, err)
 
-	execs, err := s.GetExecutions("test", nil)
+	execs, err := s.GetExecutions("test", nil, &ExecutionOptions{
+		Sort: "started_at",
+		Order: "DESC", 
+	})
 	assert.NoError(t, err)
 
 	testExecution.Id = testExecution.Key()