feat: add option to cancel task on wait timeout

Add cancel on timeout option to the task wait command

Author: kevjt

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/AlecAivazis/survey/v2 v2.3.7
 	github.com/MakeNowJust/heredoc/v2 v2.0.1
 	github.com/OctopusDeploy/go-octodiff v1.0.0
-	github.com/OctopusDeploy/go-octopusdeploy/v2 v2.70.1
+	github.com/OctopusDeploy/go-octopusdeploy/v2 v2.72.0
 	github.com/bmatcuk/doublestar/v4 v4.4.0
 	github.com/briandowns/spinner v1.19.0
 	github.com/google/uuid v1.3.0

go.sum

@@ -46,8 +46,8 @@ github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63n
 github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
 github.com/OctopusDeploy/go-octodiff v1.0.0 h1:U+ORg6azniwwYo+O44giOw6TiD5USk8S4VDhOQ0Ven0=
 github.com/OctopusDeploy/go-octodiff v1.0.0/go.mod h1:Mze0+EkOWTgTmi8++fyUc6r0aLZT7qD9gX+31t8MmIU=
-github.com/OctopusDeploy/go-octopusdeploy/v2 v2.70.1 h1:aW1K0utvdDPSRElTnvp40Xs9oPmJR6IyPAT6PBvPSJs=
-github.com/OctopusDeploy/go-octopusdeploy/v2 v2.70.1/go.mod h1:ZCOnCz9ae/uuOk7AIQ9NzjnzFbuN8Q7H3oj2Eq4QSgQ=
+github.com/OctopusDeploy/go-octopusdeploy/v2 v2.72.0 h1:q7bAzC/gdTvgeVxypHyTSlBYoH0ejbjE3VIyDfJ2lzw=
+github.com/OctopusDeploy/go-octopusdeploy/v2 v2.72.0/go.mod h1:ZCOnCz9ae/uuOk7AIQ9NzjnzFbuN8Q7H3oj2Eq4QSgQ=
 github.com/bmatcuk/doublestar/v4 v4.4.0 h1:LmAwNwhjEbYtyVLzjcP/XeVw4nhuScHGkF/XWXnvIic=
 github.com/bmatcuk/doublestar/v4 v4.4.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/briandowns/spinner v1.19.0 h1:s8aq38H+Qju89yhp89b4iIiMzMm8YN3p6vGpwyh/a8E=

pkg/cmd/task/wait/wait.go

@@ -16,37 +16,49 @@ import (
 )
 
 const (
-	FlagTimeout    = "timeout"
-	FlagProgress   = "progress"
-	DefaultTimeout = 600
+	FlagTimeout         = "timeout"
+	FlagPollInterval    = "poll-interval"
+	FlagCancelOnTimeout = "cancel-on-timeout"
+	FlagProgress        = "progress"
+	DefaultTimeout      = 600
+	DefaultPollInterval = 10
 )
 
 type WaitOptions struct {
 	*cmd.Dependencies
-	TaskIDs                []string
-	GetServerTasksCallback ServerTasksCallback
-	GetTaskDetailsCallback TaskDetailsCallback
-	Timeout               int
-	ShowProgress         bool
+	TaskIDs                   []string
+	GetServerTasksCallback    ServerTasksCallback
+	GetTaskDetailsCallback    TaskDetailsCallback
+	CancelServerTasksCallback ServerTasksCallback
+	Timeout                   int
+	PollInterval              int
+	CancelOnTimeout           bool
+	ShowProgress              bool
 }
 
 type ServerTasksCallback func([]string) ([]*tasks.Task, error)
 type TaskDetailsCallback func(string) (*tasks.TaskDetailsResource, error)
 
-func NewWaitOps(dependencies *cmd.Dependencies, taskIDs []string) *WaitOptions {
+func NewWaitOps(dependencies *cmd.Dependencies, taskIDs []string, timeout int, pollInterval int, cancelOnTimeout bool, showProgress bool) *WaitOptions {
 	return &WaitOptions{
-		Dependencies:           dependencies,
-		TaskIDs:               taskIDs,
-		GetServerTasksCallback: GetServerTasksCallback(dependencies.Client),
-		GetTaskDetailsCallback: GetTaskDetailsCallback(dependencies.Client),
-		Timeout:               DefaultTimeout,
-		ShowProgress:         false,
+		Dependencies:              dependencies,
+		TaskIDs:                   taskIDs,
+		GetServerTasksCallback:    getServerTasksCallback(dependencies.Client),
+		GetTaskDetailsCallback:    getTaskDetailsCallback(dependencies.Client),
+		CancelServerTasksCallback: cancelServerTasksCallback(dependencies.Client),
+		Timeout:                   timeout,
+		PollInterval:              pollInterval,
+		CancelOnTimeout:           cancelOnTimeout,
+		ShowProgress:              showProgress,
 	}
 }
 
 func NewCmdWait(f factory.Factory) *cobra.Command {
 	var timeout int
+	var pollInterval int
+	var cancelOnTimeout bool
 	var showProgress bool
+
 	cmd := &cobra.Command{
 		Use:     "wait [TaskIDs]",
 		Short:   "Wait for task(s) to finish",
@@ -57,18 +69,17 @@ func NewCmdWait(f factory.Factory) *cobra.Command {
 			copy(taskIDs, args)
 
 			taskIDs = append(taskIDs, util.ReadValuesFromPipe()...)
-
 			dependencies := cmd.NewDependencies(f, c)
-			opts := NewWaitOps(dependencies, taskIDs)
-			opts.Timeout = timeout
-			opts.ShowProgress = showProgress
+			opts := NewWaitOps(dependencies, taskIDs, timeout, pollInterval, cancelOnTimeout, showProgress)
 
 			return WaitRun(opts)
 		},
 	}
 
 	flags := cmd.Flags()
-	flags.IntVar(&timeout, FlagTimeout, DefaultTimeout, "Duration to wait (in seconds) before stopping execution")
+	flags.IntVar(&timeout, FlagTimeout, DefaultTimeout, "Time in seconds to wait for the tasks to complete")
+	flags.IntVar(&pollInterval, FlagPollInterval, DefaultPollInterval, "Polling interval in seconds to check task status during wait")
+	flags.BoolVar(&cancelOnTimeout, FlagCancelOnTimeout, false, "Cancel the tasks if the wait timeout is reached")
 	flags.BoolVar(&showProgress, FlagProgress, false, "Show detailed progress of the tasks")
 
 	return cmd
@@ -83,20 +94,20 @@ func WaitRun(opts *WaitOptions) error {
 		return fmt.Errorf("--progress flag is only supported when waiting for a single task")
 	}
 
-	tasks, err := opts.GetServerTasksCallback(opts.TaskIDs)
+	serverTasks, err := opts.GetServerTasksCallback(opts.TaskIDs)
 	if err != nil {
 		return err
 	}
 
-	if len(tasks) == 0 {
+	if len(serverTasks) == 0 {
 		return fmt.Errorf("no server tasks found")
 	}
 
 	pendingTaskIDs := make([]string, 0)
 	failedTaskIDs := make([]string, 0)
 	formatter := NewTaskOutputFormatter(opts.Out)
 
-	for _, t := range tasks {
+	for _, t := range serverTasks {
 		if t.IsCompleted == nil || !*t.IsCompleted {
 			pendingTaskIDs = append(pendingTaskIDs, t.ID)
 		}
@@ -109,7 +120,7 @@ func WaitRun(opts *WaitOptions) error {
 
 	if len(pendingTaskIDs) == 0 {
 		if len(failedTaskIDs) != 0 {
-			return fmt.Errorf("One or more deployment tasks failed: %s", strings.Join(failedTaskIDs, ", "))
+			return fmt.Errorf("one or more deployment tasks failed: %s", strings.Join(failedTaskIDs, ", "))
 		}
 		return nil
 	}
@@ -120,13 +131,13 @@ func WaitRun(opts *WaitOptions) error {
 
 	go func() {
 		for len(pendingTaskIDs) != 0 {
-			time.Sleep(5 * time.Second)
-			tasks, err = opts.GetServerTasksCallback(pendingTaskIDs)
+			time.Sleep(time.Duration(opts.PollInterval) * time.Second)
+			serverTasks, err = opts.GetServerTasksCallback(pendingTaskIDs)
 			if err != nil {
 				gotError <- err
 				return
 			}
-			for _, t := range tasks {
+			for _, t := range serverTasks {
 				if opts.ShowProgress {
 					details, err := opts.GetTaskDetailsCallback(t.ID)
 					if err != nil {
@@ -151,7 +162,7 @@ func WaitRun(opts *WaitOptions) error {
 			}
 		}
 		if len(failedTaskIDs) != 0 {
-			gotError <- fmt.Errorf("One or more deployment tasks failed: %s", strings.Join(failedTaskIDs, ", "))
+			gotError <- fmt.Errorf("one or more deployment tasks failed: %s", strings.Join(failedTaskIDs, ", "))
 			return
 		}
 		done <- true
@@ -163,11 +174,18 @@ func WaitRun(opts *WaitOptions) error {
 	case err := <-gotError:
 		return err
 	case <-time.After(time.Duration(opts.Timeout) * time.Second):
+		if opts.CancelOnTimeout {
+			fmt.Fprintf(opts.Dependencies.Out, "Cancelling remaining tasks: %s\n", strings.Join(pendingTaskIDs, ", "))
+			_, err := opts.CancelServerTasksCallback(pendingTaskIDs)
+			if err != nil {
+				return err
+			}
+		}
 		return fmt.Errorf("timeout while waiting for pending tasks")
 	}
 }
 
-func GetServerTasksCallback(octopus *client.Client) ServerTasksCallback {
+func getServerTasksCallback(octopus *client.Client) ServerTasksCallback {
 	return func(taskIDs []string) ([]*tasks.Task, error) {
 		query := tasks.TasksQuery{
 			IDs: taskIDs,
@@ -187,12 +205,26 @@ func GetServerTasksCallback(octopus *client.Client) ServerTasksCallback {
 	}
 }
 
-func GetTaskDetailsCallback(octopus *client.Client) TaskDetailsCallback {
+func getTaskDetailsCallback(octopus *client.Client) TaskDetailsCallback {
 	return func(taskID string) (*tasks.TaskDetailsResource, error) {
 		return tasks.GetDetails(octopus, octopus.GetSpaceID(), taskID)
 	}
 }
 
+func cancelServerTasksCallback(octopus *client.Client) ServerTasksCallback {
+	return func(taskIDs []string) ([]*tasks.Task, error) {
+		serverTasks := make([]*tasks.Task, len(taskIDs))
+		for _, taskID := range taskIDs {
+			serverTask, err := tasks.Cancel(octopus, octopus.GetSpaceID(), taskID)
+			if err != nil {
+				return nil, err
+			}
+			serverTasks = append(serverTasks, serverTask)
+		}
+		return serverTasks, nil
+	}
+}
+
 func removeTaskID(taskIDs []string, taskID string) []string {
 	for i, p := range taskIDs {
 		if p == taskID {

pkg/cmd/task/wait/wait_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/url"
 	"testing"
+	"time"
 
 	"github.com/MakeNowJust/heredoc/v2"
 	"github.com/OctopusDeploy/cli/pkg/cmd"
@@ -76,6 +77,7 @@ func TestWait(t *testing.T) {
 		GetServerTasksCallback: getServerTaskCallback,
 		GetTaskDetailsCallback: nil,
 		Timeout:                taskWaitCreate.DefaultTimeout,
+		PollInterval:           1,
 		ShowProgress:           false,
 	}
 
@@ -122,11 +124,12 @@ func TestWait_FailedTask(t *testing.T) {
 		GetServerTasksCallback: getServerTaskCallback,
 		GetTaskDetailsCallback: nil,
 		Timeout:                taskWaitCreate.DefaultTimeout,
+		PollInterval:           1,
 		ShowProgress:           false,
 	}
 
 	err := taskWaitCreate.WaitRun(opts)
-	assert.EqualError(t, err, "One or more deployment tasks failed: TaskID1")
+	assert.EqualError(t, err, "one or more deployment tasks failed: TaskID1")
 	expectedOutput := heredoc.Doc(`
   TaskID1: Deploy Bar 1 release 0.0.2 to Foo: Failed
   `)
@@ -177,15 +180,83 @@ func TestWait_FailedPendingTask(t *testing.T) {
 		GetServerTasksCallback: getServerTaskCallback,
 		GetTaskDetailsCallback: nil,
 		Timeout:                taskWaitCreate.DefaultTimeout,
+		PollInterval:           1,
 		ShowProgress:           false,
 	}
 
 	err := taskWaitCreate.WaitRun(opts)
-	assert.EqualError(t, err, "One or more deployment tasks failed: TaskID1")
+	assert.EqualError(t, err, "one or more deployment tasks failed: TaskID1")
 	assert.Equal(t, 2, timesCalled)
 	expectedOutput := heredoc.Doc(`
   TaskID1: Deploy Bar 1 release 0.0.2 to Foo: Executing
   TaskID1: Deploy Bar 1 release 0.0.2 to Foo: Failed
   `)
 	assert.Equal(t, expectedOutput, out.String())
 }
+
+func TestWait__CancelOnTimeout(t *testing.T) {
+	out := bytes.Buffer{}
+	defaultTaskIDs := []string{
+		"TaskID1",
+		"TaskID2",
+	}
+
+	taskList := []*tasks.Task{
+		tasks.NewTask(),
+		tasks.NewTask(),
+	}
+
+	// bool vars as bool constants can't be used as pointers for IsCompleted
+	boolFalse := false
+	boolTrue := true
+
+	taskList[0].ID = defaultTaskIDs[0]
+	taskList[0].IsCompleted = &boolFalse
+	taskList[0].FinishedSuccessfully = &boolFalse
+	taskList[0].Description = "Deploy Bar 1 release 0.0.2 to Foo"
+	taskList[0].State = "Executing"
+
+	taskList[1].ID = defaultTaskIDs[1]
+	taskList[1].IsCompleted = &boolTrue
+	taskList[1].FinishedSuccessfully = &boolTrue
+	taskList[1].Description = "Deploy Bar 2 release 0.0.2 to Foo"
+	taskList[1].State = "Success"
+
+	getServerTaskCallback := func(taskIDs []string) ([]*tasks.Task, error) {
+		time.Sleep(1 * time.Second)
+		assert.Len(t, taskIDs, 2)
+		assert.Equal(t, defaultTaskIDs[0], taskIDs[0])
+		assert.Equal(t, defaultTaskIDs[1], taskIDs[1])
+		return taskList, nil
+	}
+
+	cancelCalled := false
+	cancelServerTaskCallback := func(taskIDs []string) ([]*tasks.Task, error) {
+		cancelCalled = true
+		return []*tasks.Task{}, nil
+	}
+
+	opts := &taskWaitCreate.WaitOptions{
+		Dependencies: &cmd.Dependencies{
+			Out: &out,
+		},
+		TaskIDs:                   defaultTaskIDs,
+		GetServerTasksCallback:    getServerTaskCallback,
+		GetTaskDetailsCallback:    nil,
+		CancelServerTasksCallback: cancelServerTaskCallback,
+		Timeout:                   1,
+		PollInterval:              1,
+		CancelOnTimeout:           true,
+		ShowProgress:              false,
+	}
+
+	err := taskWaitCreate.WaitRun(opts)
+	assert.True(t, cancelCalled)
+	assert.EqualError(t, err, "timeout while waiting for pending tasks")
+	expectedOutput := heredoc.Doc(`
+  TaskID1: Deploy Bar 1 release 0.0.2 to Foo: Executing
+  TaskID2: Deploy Bar 2 release 0.0.2 to Foo: Success
+  Cancelling remaining tasks: TaskID1
+  `)
+	assert.Equal(t, expectedOutput, out.String())
+}