Add flag --instance-steps to restage command

Signed-off-by: João Pereira <joao.pereira@broadcom.com>

Author: joaopapereira

command/v7/restage_command.go

@@ -1,6 +1,9 @@
 package v7
 
 import (
+	"strconv"
+	"strings"
+
 	"code.cloudfoundry.org/cli/actor/actionerror"
 	"code.cloudfoundry.org/cli/actor/v7action"
 	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/constant"
@@ -9,15 +12,17 @@ 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 RestageCommand struct {
 	BaseCommand
 
 	RequiredArgs        flag.AppName            `positional-args:"yes"`
-	Strategy            flag.DeploymentStrategy `long:"strategy" description:"Deployment strategy can be canary, rolling or null."`
+	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 restaged. Only applies when --strategy flag is specified."`
 	NoWait              bool                    `long:"no-wait" description:"Exit when the first instance of the web process is healthy"`
+	Strategy            flag.DeploymentStrategy `long:"strategy" description:"Deployment strategy can be canary, rolling or null."`
 	usage               interface{}             `usage:"CF_NAME restage APP_NAME\n\n   This command will cause downtime unless you use '--strategy' flag.\n\nEXAMPLES:\n   CF_NAME restage APP_NAME\n   CF_NAME restage APP_NAME --strategy rolling\n   CF_NAME restage APP_NAME --strategy canary --no-wait"`
 	relatedCommands     interface{}             `related_commands:"restart"`
 	envCFStagingTimeout interface{}             `environmentName:"CF_STAGING_TIMEOUT" environmentDescription:"Max wait time for staging, in minutes" environmentDefault:"15"`
@@ -93,6 +98,18 @@ func (cmd RestageCommand) Execute(args []string) error {
 		opts.MaxInFlight = *cmd.MaxInFlight
 	}
 
+	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})
+			}
+		}
+	}
+
 	err = cmd.Stager.StageAndStart(app, cmd.Config.TargetedSpace(), cmd.Config.TargetedOrganization(), pkg.GUID, opts)
 	if err != nil {
 		return mapErr(cmd.Config, cmd.RequiredArgs.AppName, err)
@@ -107,6 +124,10 @@ func (cmd RestageCommand) ValidateFlags() error {
 		return translatableerror.RequiredFlagsError{Arg1: "--max-in-flight", Arg2: "--strategy"}
 	case cmd.Strategy.Name != constant.DeploymentStrategyDefault && 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/restage_command_test.go

@@ -120,6 +120,27 @@ var _ = Describe("restage Command", func() {
 		})
 	})
 
+	When("canary strategy is provided", func() {
+		BeforeEach(func() {
+			cmd.Strategy = flag.DeploymentStrategy{Name: constant.DeploymentStrategyCanary}
+			cmd.InstanceSteps = "1,2,4"
+		})
+
+		It("starts the app with the current droplet", func() {
+			Expect(executeErr).ToNot(HaveOccurred())
+			Expect(fakeAppStager.StageAndStartCallCount()).To(Equal(1))
+
+			inputApp, inputSpace, inputOrg, inputDropletGuid, opts := fakeAppStager.StageAndStartArgsForCall(0)
+			Expect(inputApp).To(Equal(app))
+			Expect(inputDropletGuid).To(Equal(""))
+			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.ApplicationRestarting))
+			Expect(opts.CanarySteps).To(Equal([]resources.CanaryStep{{InstanceWeight: 1}, {InstanceWeight: 2}, {InstanceWeight: 4}}))
+		})
+	})
+
 	It("displays that it's restaging", func() {
 		Expect(testUI.Out).To(Say("Restaging app some-app in org some-org / space some-space as steve..."))
 	})
@@ -226,5 +247,34 @@ var _ = Describe("restage Command", func() {
 			translatableerror.IncorrectUsageError{
 				Message: "--max-in-flight must be greater than or equal to 1",
 			}),
+
+		Entry("instance-steps provided with rolling deployment",
+			func() {
+				cmd.Strategy = flag.DeploymentStrategy{Name: constant.DeploymentStrategyRolling}
+				cmd.InstanceSteps = "1,2,3"
+			},
+			translatableerror.RequiredFlagsError{
+				Arg1: "--instance-steps",
+				Arg2: "--strategy=canary",
+			}),
+
+		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/restage_command_test.go

@@ -31,9 +31,10 @@ var _ = Describe("restage command", func() {
 				Eventually(session).Should(Say("ALIAS:"))
 				Eventually(session).Should(Say("rg"))
 				Eventually(session).Should(Say("OPTIONS:"))
-				Eventually(session).Should(Say(`--strategy\s+Deployment strategy can be canary, rolling or null`))
+				Eventually(session).Should(Say("--instance-steps"))
 				Eventually(session).Should(Say("--max-in-flight"))
 				Eventually(session).Should(Say(`--no-wait\s+Exit when the first instance of the web process is healthy`))
+				Eventually(session).Should(Say(`--strategy\s+Deployment strategy can be canary, rolling or null`))
 				Eventually(session).Should(Say("ENVIRONMENT:"))
 				Eventually(session).Should(Say(`CF_STAGING_TIMEOUT=15\s+Max wait time for staging, in minutes`))
 				Eventually(session).Should(Say(`CF_STARTUP_TIMEOUT=5\s+Max wait time for app instance startup, in minutes`))
@@ -246,10 +247,10 @@ applications:
 					})
 				})
 
-				When("strategy canary is given with a non-default max-in-flight value", func() {
+				When("strategy canary is given with a non-default max-in-flight value and instance-weights", func() {
 					It("restages successfully and notes the max-in-flight value", func() {
 						userName, _ := helpers.GetCredentials()
-						session := helpers.CF("restage", appName, "--strategy", "canary", "--max-in-flight", "2")
+						session := helpers.CF("restage", appName, "--strategy", "canary", "--max-in-flight", "2", "--instance-weights", "1,20")
 						Consistently(session.Err).ShouldNot(Say(`This action will cause app downtime\.`))
 						Eventually(session).Should(Say(`Restaging app %s in org %s / space %s as %s\.\.\.`, appName, orgName, spaceName, userName))
 						Eventually(session).Should(Say(`Creating deployment for app %s\.\.\.`, appName))