✨ Support bulk task cancel using filter criteria. (#774)

Update the bulk (cancel) action route to be an action against the
collection. Also, instead of passing a list of IDs in the body, use a
filter instead. This is more flexible and RESTful.

Example:
/tasks/cancel?filter=id:(1|2|3)
/tasks/cancel?filter=application.id:44
/tasks/cancel?filter=kind:analysis,state=Pending

The only downside is the url length may be an issue for many thousands
of cancels (by id). However, I don't see that as a mainstream use-case.
I would think that use-case would be better supported by filtering by
other than id. To cancel all running tasks, an empty filter may be
passed.

---------

Signed-off-by: Jeff Ortel <[email protected]>

Author: jortel

api/task.go

@@ -25,16 +25,15 @@ const (
 	TasksReportRoot          = TasksRoot + "/report"
 	TasksReportQueueRoot     = TasksReportRoot + "/queue"
 	TasksReportDashboardRoot = TasksReportRoot + "/dashboard"
+	TasksCancelRoot          = TasksRoot + "/cancel"
 	TaskRoot                 = TasksRoot + "/:" + ID
 	TaskReportRoot           = TaskRoot + "/report"
 	TaskAttachedRoot         = TaskRoot + "/attached"
 	TaskBucketRoot           = TaskRoot + "/bucket"
 	TaskBucketContentRoot    = TaskBucketRoot + "/*" + Wildcard
 	TaskSubmitRoot           = TaskRoot + "/submit"
 	TaskCancelRoot           = TaskRoot + "/cancel"
-	TaskCancelListRoot       = TasksRoot + "/cancel/list"
 )
-
 const (
 	Submit = "submit"
 )
@@ -60,7 +59,7 @@ func (h TaskHandler) AddRoutes(e *gin.Engine) {
 	// Actions
 	routeGroup.PUT(TaskSubmitRoot, Transaction, h.Submit)
 	routeGroup.PUT(TaskCancelRoot, h.Cancel)
-	routeGroup.PUT(TaskCancelListRoot, h.CancelList)
+	routeGroup.PUT(TasksCancelRoot, h.BulkCancel)
 	// Bucket
 	routeGroup = e.Group("/")
 	routeGroup.Use(Required("tasks.bucket"))
@@ -470,13 +469,13 @@ func (h TaskHandler) Submit(ctx *gin.Context) {
 	h.Update(ctx)
 }
 
-// // Cancel godoc
-// // @summary Cancel a task.
-// // @description Cancel a task.
-// // @tags tasks
-// // @success 202
-// // @router /tasks/{id}/cancel [put]
-// // @param id path int true "Task ID"
+// Cancel godoc
+// @summary Cancel a task.
+// @description Cancel a task.
+// @tags tasks
+// @success 202
+// @router /tasks/{id}/cancel [put]
+// @param id path int true "Task ID"
 func (h TaskHandler) Cancel(ctx *gin.Context) {
 	id := h.pk(ctx)
 	rtx := RichContext(ctx)
@@ -489,35 +488,60 @@ func (h TaskHandler) Cancel(ctx *gin.Context) {
 	h.Status(ctx, http.StatusAccepted)
 }
 
-// CancelList godoc
-// @summary Cancel multiple tasks.
-// @description Cancel multiple tasks by IDs.
+// BulkCancel godoc
+// @summary Cancel tasks matched by the filter.
+// @description Cancel tasks matched by the filter.
+// @description Caution: an empty filter matches all tasks.
+// @description Filters:
+// @description - id
+// @description - name
+// @description - locator
+// @description - kind
+// @description - addon
+// @description - state
+// @description - application.id
 // @tags tasks
 // @success 202
 // @router /tasks/cancel/list [put]
 // @param tasks body []uint true "List of Task IDs"
-func (h TaskHandler) CancelList(ctx *gin.Context) {
-    ids := []uint{}
-
-    if err := h.Bind(ctx, &ids); err != nil {
-        _ = ctx.Error(err)
-        return
-    }
-
-    rtx := RichContext(ctx)
-
-    for _, id := range ids {
-        err := rtx.TaskManager.Cancel(h.DB(ctx), id)
-        if err != nil {
-            _ = ctx.Error(err)
-            return
-        }
-    }
+func (h TaskHandler) BulkCancel(ctx *gin.Context) {
+	filter, err := qf.New(ctx,
+		[]qf.Assert{
+			{Field: "id", Kind: qf.LITERAL},
+			{Field: "name", Kind: qf.STRING},
+			{Field: "locator", Kind: qf.STRING},
+			{Field: "kind", Kind: qf.STRING},
+			{Field: "addon", Kind: qf.STRING},
+			{Field: "state", Kind: qf.STRING},
+			{Field: "application.id", Kind: qf.STRING},
+		})
+	if err != nil {
+		_ = ctx.Error(err)
+		return
+	}
+	filter = filter.Renamed("application.id", "applicationId")
+	db := h.DB(ctx)
+	db = db.Model(&model.Task{})
+	db = filter.Where(db)
+	matched := []*model.Task{}
+	err = db.Find(&matched).Error
+	if err != nil {
+		_ = ctx.Error(err)
+		return
+	}
+	db = h.DB(ctx)
+	rtx := RichContext(ctx)
+	for _, m := range matched {
+		err := rtx.TaskManager.Cancel(db, m.ID)
+		if err != nil {
+			_ = ctx.Error(err)
+			return
+		}
+	}
 
-    h.Status(ctx, http.StatusAccepted)
+	h.Status(ctx, http.StatusAccepted)
 }
 
-
 // BucketGet godoc
 // @summary Get bucket content by ID and path.
 // @description Get bucket content by ID and path.

binding/task.go

@@ -30,10 +30,10 @@ func (h *Task) List() (list []api.Task, err error) {
 	return
 }
 
-// CancelMultipleTasks - Cancel multiple tasks by their IDs.
-func (h *Task) CancelMultipleTasks(ids []uint) (err error) {
-    err = h.client.Put(api.TaskCancelListRoot, ids)
-    return
+// BulkCancel - Cancel tasks matched by filter.
+func (h *Task) BulkCancel(filter Filter) (err error) {
+	err = h.client.Put(api.TasksCancelRoot, 0, filter.Param())
+	return
 }
 
 // Update a Task.

test/api/task/api_test.go

@@ -4,6 +4,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/konveyor/tackle2-hub/binding"
+	"github.com/konveyor/tackle2-hub/binding/filter"
 	"github.com/konveyor/tackle2-hub/test/assert"
 )
 
@@ -110,3 +112,12 @@ func TestTaskList(t *testing.T) {
 		assert.Must(t, Task.Delete(r.ID))
 	}
 }
+
+func TestBulkCancel(t *testing.T) {
+	f := binding.Filter{}
+	f.And("id").Eq(filter.Any{1, 2, 3})
+	err := Task.BulkCancel(f)
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+}