Add --instance-steps to copy-source command

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

Author: joaopapereira

command/v7/copy_source_command.go

@@ -1,13 +1,17 @@
 package v7
 
 import (
+	"strconv"
+	"strings"
+
 	"code.cloudfoundry.org/cli/actor/v7action"
 	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/constant"
 	"code.cloudfoundry.org/cli/api/logcache"
 	"code.cloudfoundry.org/cli/command"
 	"code.cloudfoundry.org/cli/command/flag"
 	"code.cloudfoundry.org/cli/command/translatableerror"
 	"code.cloudfoundry.org/cli/command/v7/shared"
+	"code.cloudfoundry.org/cli/resources"
 	"code.cloudfoundry.org/cli/util/configv3"
 )
 
@@ -16,12 +20,13 @@ type CopySourceCommand struct {
 
 	RequiredArgs        flag.CopySourceArgs     `positional-args:"yes"`
 	usage               interface{}             `usage:"CF_NAME copy-source SOURCE_APP DESTINATION_APP [-s TARGET_SPACE [-o TARGET_ORG]] [--no-restart] [--strategy STRATEGY] [--no-wait]"`
-	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 started. Only applies when --strategy flag is specified."`
 	NoWait              bool                    `long:"no-wait" description:"Exit when the first instance of the web process is healthy"`
 	NoRestart           bool                    `long:"no-restart" description:"Do not restage the destination application"`
 	Organization        string                  `short:"o" long:"organization" description:"Org that contains the destination application"`
 	Space               string                  `short:"s" long:"space" description:"Space that contains the destination application"`
+	Strategy            flag.DeploymentStrategy `long:"strategy" description:"Deployment strategy can be canary, rolling or null"`
 	relatedCommands     interface{}             `related_commands:"apps, push, restage, restart, target"`
 	envCFStagingTimeout interface{}             `environmentName:"CF_STAGING_TIMEOUT" environmentDescription:"Max wait time for staging, in minutes" environmentDefault:"15"`
 	envCFStartupTimeout interface{}             `environmentName:"CF_STARTUP_TIMEOUT" environmentDescription:"Max wait time for app instance startup, in minutes" environmentDefault:"5"`
@@ -57,6 +62,14 @@ func (cmd *CopySourceCommand) ValidateFlags() error {
 		return translatableerror.IncorrectUsageError{Message: "--max-in-flight must be greater than or equal to 1"}
 	}
 
+	if cmd.Strategy.Name != constant.DeploymentStrategyCanary && cmd.InstanceSteps != "" {
+		return translatableerror.RequiredFlagsError{Arg1: "--instance-steps", Arg2: "--strategy=canary"}
+	}
+
+	if len(cmd.InstanceSteps) > 0 && !validateInstanceSteps(cmd.InstanceSteps) {
+		return translatableerror.ParseArgumentError{ArgumentName: "--instance-steps", ExpectedType: "list of weights"}
+	}
+
 	return nil
 }
 
@@ -178,6 +191,18 @@ func (cmd CopySourceCommand) 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(targetApp, targetSpace, targetOrg, pkg.GUID, opts)
 		if err != nil {
 			return mapErr(cmd.Config, targetApp.Name, err)

command/v7/copy_source_command_test.go

@@ -324,6 +324,27 @@ var _ = Describe("copy-source Command", func() {
 			Expect(opts.NoWait).To(Equal(false))
 			Expect(opts.AppAction).To(Equal(constant.ApplicationRestarting))
 		})
+
+		When("instance steps is provided", func() {
+			BeforeEach(func() {
+				cmd.Strategy = flag.DeploymentStrategy{Name: constant.DeploymentStrategyCanary}
+				cmd.InstanceSteps = "1,2,4"
+			})
+
+			It("starts the new app", func() {
+				Expect(executeErr).ToNot(HaveOccurred())
+				Expect(fakeAppStager.StageAndStartCallCount()).To(Equal(1))
+
+				inputApp, inputSpace, inputOrg, inputDropletGuid, opts := fakeAppStager.StageAndStartArgsForCall(0)
+				Expect(inputApp).To(Equal(targetApp))
+				Expect(inputDropletGuid).To(Equal("target-package-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.ApplicationRestarting))
+				Expect(opts.CanarySteps).To(Equal([]resources.CanaryStep{{InstanceWeight: 1}, {InstanceWeight: 2}, {InstanceWeight: 4}}))
+			})
+		})
 	})
 
 	When("the no-wait flag is set", func() {
@@ -440,5 +461,24 @@ var _ = Describe("copy-source 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/copy_source_command_test.go

@@ -384,13 +384,14 @@ var _ = Describe("copy-source command", func() {
 
 		It("copies the app to the provided space using a canary deploy", func() {
 			username, _ := helpers.GetCredentials()
-			session := helpers.CF("copy-source", sourceAppName, targetAppName, "--strategy", "canary")
+			session := helpers.CF("copy-source", sourceAppName, targetAppName, "--strategy", "canary", "--instance-steps", "20,60")
 			Eventually(session).Should(Say("Copying source from app %s to target app %s in org %s / space %s as %s...", sourceAppName, targetAppName, orgName, spaceName, username))
 			Eventually(session).Should(Say("Staging app %s in org %s / space %s as %s...", targetAppName, orgName, spaceName, username))
 			Eventually(session).Should(Say("Waiting for app to deploy..."))
 			Eventually(session).Should(Say("Active deployment with status PAUSED"))
 			Eventually(session).Should(Say("strategy:        canary"))
 			Eventually(session).Should(Say("max-in-flight:   1"))
+			Eventually(session).Should(Say("canary-steps:   1/2"))
 			Eventually(session).Should(Say("Please run `cf continue-deployment %s` to promote the canary deployment, or `cf cancel-deployment %s` to rollback to the previous version.", targetAppName, targetAppName))
 			Eventually(session).Should(Exit(0))
 
@@ -473,12 +474,13 @@ func helpText(session *Session) {
 	Eventually(session).Should(Say("USAGE:"))
 	Eventually(session).Should(Say(`cf copy-source SOURCE_APP DESTINATION_APP \[-s TARGET_SPACE \[-o TARGET_ORG\]\] \[--no-restart\] \[--strategy STRATEGY\] \[--no-wait\]`))
 	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\s+Defines the maximum number of instances`))
 	Eventually(session).Should(Say(`--no-wait\s+ Exit when the first instance of the web process is healthy`))
 	Eventually(session).Should(Say(`--no-restart\s+Do not restage the destination application`))
 	Eventually(session).Should(Say(`--organization, -o\s+Org that contains the destination application`))
 	Eventually(session).Should(Say(`--space, -s\s+Space that contains the destination application`))
+	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`))