Add --instance-steps to rollback

Signed-off-by: João Pereira <[email protected]>

Author: joaopapereira

command/v7/rollback_command.go

@@ -2,6 +2,8 @@ package v7
 
 import (
 	"fmt"
+	"strconv"
+	"strings"
 
 	"code.cloudfoundry.org/cli/actor/sharedaction"
 	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/constant"
@@ -10,13 +12,15 @@ import (
 	"code.cloudfoundry.org/cli/command/flag"
 	"code.cloudfoundry.org/cli/command/translatableerror"
 	"code.cloudfoundry.org/cli/command/v7/shared"
+	"code.cloudfoundry.org/cli/resources"
 )
 
 type RollbackCommand struct {
 	BaseCommand
 
-	Force           bool                    `short:"f" description:"Force rollback without confirmation"`
 	RequiredArgs    flag.AppName            `positional-args:"yes"`
+	Force           bool                    `short:"f" description:"Force rollback without confirmation"`
+	InstanceSteps   string                  `long:"instance-steps" description:"An array of percentage steps to deploy when using deployment strategy canary. (e.g. 20,40,60)"`
 	MaxInFlight     *int                    `long:"max-in-flight" description:"Defines the maximum number of instances that will be actively being rolled back."`
 	Strategy        flag.DeploymentStrategy `long:"strategy" description:"Deployment strategy can be canary or rolling. When not specified, it defaults to rolling."`
 	Version         flag.Revision           `long:"version" required:"true" description:"Roll back to the specified revision"`
@@ -120,6 +124,18 @@ func (cmd RollbackCommand) Execute(args []string) error {
 		opts.Strategy = cmd.Strategy.Name
 	}
 
+	if cmd.InstanceSteps != "" {
+		if len(cmd.InstanceSteps) > 0 {
+			for _, v := range strings.Split(cmd.InstanceSteps, ",") {
+				parsedInt, err := strconv.ParseInt(v, 0, 64)
+				if err != nil {
+					return err
+				}
+				opts.CanarySteps = append(opts.CanarySteps, resources.CanaryStep{InstanceWeight: parsedInt})
+			}
+		}
+	}
+
 	startAppErr := cmd.Stager.StartApp(app, cmd.Config.TargetedSpace(), cmd.Config.TargetedOrganization(), revision.GUID, opts)
 	if startAppErr != nil {
 		return startAppErr
@@ -134,6 +150,10 @@ func (cmd RollbackCommand) ValidateFlags() error {
 	switch {
 	case cmd.MaxInFlight != nil && *cmd.MaxInFlight < 1:
 		return translatableerror.IncorrectUsageError{Message: "--max-in-flight must be greater than or equal to 1"}
+	case cmd.Strategy.Name != constant.DeploymentStrategyCanary && cmd.InstanceSteps != "":
+		return translatableerror.RequiredFlagsError{Arg1: "--instance-steps", Arg2: "--strategy=canary"}
+	case len(cmd.InstanceSteps) > 0 && !validateInstanceSteps(cmd.InstanceSteps):
+		return translatableerror.ParseArgumentError{ArgumentName: "--instance-steps", ExpectedType: "list of weights"}
 	}
 
 	return nil

command/v7/rollback_command_test.go

@@ -23,21 +23,22 @@ import (
 
 var _ = Describe("rollback Command", func() {
 	var (
-		app             string
+		appName         string
 		binaryName      string
 		executeErr      error
 		fakeActor       *v7fakes.FakeActor
 		fakeConfig      *commandfakes.FakeConfig
 		fakeSharedActor *commandfakes.FakeSharedActor
 		input           *Buffer
 		testUI          *ui.UI
+		app             resources.Application
 
 		fakeAppStager *sharedfakes.FakeAppStager
 		cmd           v7.RollbackCommand
 	)
 
 	BeforeEach(func() {
-		app = "some-app"
+		appName = "some-app"
 		binaryName = "faceman"
 		fakeActor = new(v7fakes.FakeActor)
 		fakeAppStager = new(sharedfakes.FakeAppStager)
@@ -50,6 +51,10 @@ var _ = Describe("rollback Command", func() {
 			resources.Revision{Version: 2},
 			resources.Revision{Version: 1},
 		}
+		app = resources.Application{
+			GUID: "123",
+			Name: "some-app",
+		}
 
 		fakeActor.GetRevisionsByApplicationNameAndSpaceReturns(
 			revisions, v7action.Warnings{"warning-2"}, nil,
@@ -68,7 +73,7 @@ var _ = Describe("rollback Command", func() {
 		})
 
 		cmd = v7.RollbackCommand{
-			RequiredArgs: flag.AppName{AppName: app},
+			RequiredArgs: flag.AppName{AppName: appName},
 			BaseCommand: v7.BaseCommand{
 				UI:          testUI,
 				Config:      fakeConfig,
@@ -150,7 +155,7 @@ var _ = Describe("rollback Command", func() {
 		When("the app has at least one revision", func() {
 			BeforeEach(func() {
 				fakeActor.GetApplicationByNameAndSpaceReturns(
-					resources.Application{GUID: "123"},
+					app,
 					v7action.Warnings{"app-warning-1"},
 					nil,
 				)
@@ -169,7 +174,7 @@ var _ = Describe("rollback Command", func() {
 			It("fetches the app and revision revision", func() {
 				Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1), "GetApplicationByNameAndSpace call count")
 				appName, spaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0)
-				Expect(appName).To(Equal(app))
+				Expect(appName).To(Equal(appName))
 				Expect(spaceGUID).To(Equal("some-space-guid"))
 
 				Expect(fakeActor.GetRevisionByApplicationAndVersionCallCount()).To(Equal(1), "GetRevisionByApplicationAndVersion call count")
@@ -192,7 +197,7 @@ var _ = Describe("rollback Command", func() {
 					Expect(revisionGUID).To(Equal("some-1-guid"))
 					Expect(opts.AppAction).To(Equal(constant.ApplicationRollingBack))
 
-					Expect(testUI.Out).ToNot(Say("Rolling '%s' back to revision '1' will create a new revision. The new revision '3' will use the settings from revision '1'.", app))
+					Expect(testUI.Out).ToNot(Say("Rolling '%s' back to revision '1' will create a new revision. The new revision '3' will use the settings from revision '1'.", appName))
 					Expect(testUI.Out).ToNot(Say("Are you sure you want to continue?"))
 
 					Expect(testUI.Out).To(Say("Rolling back to revision 1 for app some-app in org some-org / space some-space as steve..."))
@@ -221,7 +226,7 @@ var _ = Describe("rollback Command", func() {
 					Expect(opts.Strategy).To(Equal(constant.DeploymentStrategyRolling))
 					Expect(opts.MaxInFlight).To(Equal(5))
 
-					Expect(testUI.Out).To(Say("Rolling '%s' back to revision '1' will create a new revision. The new revision will use the settings from revision '1'.", app))
+					Expect(testUI.Out).To(Say("Rolling '%s' back to revision '1' will create a new revision. The new revision will use the settings from revision '1'.", appName))
 					Expect(testUI.Out).To(Say("Are you sure you want to continue?"))
 					Expect(testUI.Out).To(Say("Rolling back to revision 1 for app some-app in org some-org / space some-space as steve..."))
 
@@ -252,6 +257,31 @@ var _ = Describe("rollback Command", func() {
 				})
 			})
 
+			When("canary strategy is provided", func() {
+				BeforeEach(func() {
+					cmd.Strategy = flag.DeploymentStrategy{Name: constant.DeploymentStrategyCanary}
+					cmd.InstanceSteps = "1,2,4"
+
+					_, err := input.Write([]byte("y\n"))
+					Expect(err).NotTo(HaveOccurred())
+				})
+
+				It("starts the app with the current droplet", func() {
+
+					Expect(executeErr).ToNot(HaveOccurred())
+					Expect(fakeAppStager.StartAppCallCount()).To(Equal(1))
+
+					inputApp, inputSpace, inputOrg, inputDropletGuid, opts := fakeAppStager.StartAppArgsForCall(0)
+					Expect(inputApp).To(Equal(app))
+					Expect(inputDropletGuid).To(Equal("some-1-guid"))
+					Expect(inputSpace).To(Equal(cmd.Config.TargetedSpace()))
+					Expect(inputOrg).To(Equal(cmd.Config.TargetedOrganization()))
+					Expect(opts.Strategy).To(Equal(constant.DeploymentStrategyCanary))
+					Expect(opts.AppAction).To(Equal(constant.ApplicationRollingBack))
+					Expect(opts.CanarySteps).To(Equal([]resources.CanaryStep{{InstanceWeight: 1}, {InstanceWeight: 2}, {InstanceWeight: 4}}))
+				})
+			})
+
 			When("user says no to prompt", func() {
 				BeforeEach(func() {
 					_, err := input.Write([]byte("n\n"))
@@ -261,8 +291,8 @@ var _ = Describe("rollback Command", func() {
 				It("does not execute the command and outputs warnings", func() {
 					Expect(fakeAppStager.StartAppCallCount()).To(Equal(0), "GetStartApp call count")
 
-					Expect(testUI.Out).To(Say("Rolling '%s' back to revision '1' will create a new revision. The new revision will use the settings from revision '1'.", app))
-					Expect(testUI.Out).To(Say("App '%s' has not been rolled back to revision '1'.", app))
+					Expect(testUI.Out).To(Say("Rolling '%s' back to revision '1' will create a new revision. The new revision will use the settings from revision '1'.", appName))
+					Expect(testUI.Out).To(Say("App '%s' has not been rolled back to revision '1'.", appName))
 
 					Expect(testUI.Err).To(Say("app-warning-1"))
 					Expect(testUI.Err).To(Say("revision-warning-3"))
@@ -280,7 +310,7 @@ var _ = Describe("rollback Command", func() {
 
 					Expect(fakeAppStager.StartAppCallCount()).To(Equal(0), "GetStartApp call count")
 
-					Expect(testUI.Out).To(Say("App '%s' has not been rolled back to revision '1'.", app))
+					Expect(testUI.Out).To(Say("App '%s' has not been rolled back to revision '1'.", appName))
 				})
 			})
 		})
@@ -305,5 +335,24 @@ var _ = Describe("rollback Command", func() {
 			translatableerror.IncorrectUsageError{
 				Message: "--max-in-flight must be greater than or equal to 1",
 			}),
+
+		Entry("instance-steps no strategy provided",
+			func() {
+				cmd.InstanceSteps = "1,2,3"
+			},
+			translatableerror.RequiredFlagsError{
+				Arg1: "--instance-steps",
+				Arg2: "--strategy=canary",
+			}),
+
+		Entry("instance-steps a valid list of ints",
+			func() {
+				cmd.Strategy = flag.DeploymentStrategy{Name: constant.DeploymentStrategyCanary}
+				cmd.InstanceSteps = "some,thing,not,right"
+			},
+			translatableerror.ParseArgumentError{
+				ArgumentName: "--instance-steps",
+				ExpectedType: "list of weights",
+			}),
 	)
 })

integration/v7/isolated/rollback_command_test.go

@@ -35,6 +35,7 @@ var _ = Describe("rollback command", func() {
 				Expect(session).To(Say(`cf rollback APP_NAME \[--version VERSION\]`))
 				Expect(session).To(Say("OPTIONS:"))
 				Expect(session).To(Say(`-f\s+Force rollback without confirmation`))
+				Expect(session).To(Say("--instance-steps"))
 				Expect(session).To(Say("--max-in-flight"))
 				Expect(session).To(Say(`--strategy\s+Deployment strategy can be canary or rolling. When not specified, it defaults to rolling.`))
 				Expect(session).To(Say(`--version\s+Roll back to the specified revision`))
@@ -158,7 +159,7 @@ applications:
 							})
 
 							It("uses the given strategy to rollback and notes the max-in-flight value", func() {
-								session := helpers.CFWithStdin(buffer, "rollback", appName, "--version", "1", "--strategy", "canary")
+								session := helpers.CFWithStdin(buffer, "rollback", appName, "--version", "1", "--strategy", "canary", "--instance-steps", "10,50")
 								Eventually(session).Should(Exit(0))
 
 								Expect(session).To(HaveRollbackPrompt())