feat: update logic

Signed-off-by: Chen Keinan <hen.keinan@gmail.com>

Author: chen-keinan

pkg/cmd/release/promote/promote.go

@@ -92,7 +92,6 @@ func NewCmdPromote(f factory.Factory) *cobra.Command {
 	}
 
 	flags := cmd.Flags()
-	// Reuse all flags from deploy
 	flags.StringVarP(&promoteFlags.Project.Value, promoteFlags.Project.Name, "p", "", "Name or ID of the project to promote the release from")
 	flags.StringArrayVarP(&promoteFlags.Environments.Value, promoteFlags.Environments.Name, "e", nil, "Promote to this environment (can be specified multiple times)")
 	flags.StringArrayVarP(&promoteFlags.Tenants.Value, promoteFlags.Tenants.Name, "", nil, "Promote to this tenant (can be specified multiple times)")
@@ -152,24 +151,26 @@ func promoteRun(cmd *cobra.Command, f factory.Factory, flags *PromoteFlags) erro
 	}
 
 	options := &executor.TaskOptionsPromoteRelease{
-		ProjectName:                    flags.Project.Value,
-		ReleaseVersion:                 flags.ReleaseVersion.Value,
-		SourceEnvironment:              flags.SourceEnvironment.Value,
-		TargetEnvironments:             flags.Environments.Value, // Use Environments from embedded DeployFlags
-		Tenants:                        flags.Tenants.Value,
-		TenantTags:                     flags.TenantTags.Value,
-		ScheduledStartTime:             flags.DeployAt.Value,
-		ScheduledExpiryTime:            flags.MaxQueueTime.Value,
-		ExcludedSteps:                  flags.ExcludedSteps.Value,
-		GuidedFailureMode:              flags.GuidedFailureMode.Value,
-		ForcePackageDownload:           flags.ForcePackageDownload.Value,
-		DeploymentTargets:              flags.DeploymentTargets.Value,
-		ExcludeTargets:                 flags.ExcludeTargets.Value,
-		DeploymentFreezeNames:          flags.DeploymentFreezeNames.Value,
-		DeploymentFreezeOverrideReason: flags.DeploymentFreezeOverrideReason.Value,
-		Variables:                      parsedVariables,
-		UpdateVariables:                flags.UpdateVariables.Value,
-		LatestSuccessful:               flags.LatestSuccessful.Value,
+		TaskOptionsDeployRelease: executor.TaskOptionsDeployRelease{
+			ProjectName:                    flags.Project.Value,
+			ReleaseVersion:                 flags.ReleaseVersion.Value,
+			Environments:                   flags.Environments.Value,
+			Tenants:                        flags.Tenants.Value,
+			TenantTags:                     flags.TenantTags.Value,
+			ScheduledStartTime:             flags.DeployAt.Value,
+			ScheduledExpiryTime:            flags.MaxQueueTime.Value,
+			ExcludedSteps:                  flags.ExcludedSteps.Value,
+			GuidedFailureMode:              flags.GuidedFailureMode.Value,
+			ForcePackageDownload:           flags.ForcePackageDownload.Value,
+			DeploymentTargets:              flags.DeploymentTargets.Value,
+			ExcludeTargets:                 flags.ExcludeTargets.Value,
+			DeploymentFreezeNames:          flags.DeploymentFreezeNames.Value,
+			DeploymentFreezeOverrideReason: flags.DeploymentFreezeOverrideReason.Value,
+			Variables:                      parsedVariables,
+			UpdateVariables:                flags.UpdateVariables.Value,
+		},
+		SourceEnvironment: flags.SourceEnvironment.Value,
+		LatestSuccessful:  flags.LatestSuccessful.Value,
 	}
 
 	// special case for FlagForcePackageDownload bool so we can tell if it was set on the cmdline or missing
@@ -196,7 +197,7 @@ func promoteRun(cmd *cobra.Command, f factory.Factory, flags *PromoteFlags) erro
 			resolvedFlags.Project.Value = options.ProjectName
 			resolvedFlags.ReleaseVersion.Value = options.ReleaseVersion
 			resolvedFlags.SourceEnvironment.Value = options.SourceEnvironment
-			resolvedFlags.Environments.Value = options.TargetEnvironments // Map TargetEnvironments to Environments
+			resolvedFlags.Environments.Value = options.Environments
 			resolvedFlags.Tenants.Value = options.Tenants
 			resolvedFlags.TenantTags.Value = options.TenantTags
 			resolvedFlags.DeployAt.Value = options.ScheduledStartTime
@@ -431,7 +432,7 @@ func AskQuestions(octopus *octopusApiClient.Client, stdout io.Writer, asker ques
 		}
 	}
 
-	err = validateDeployment(isTenanted, options.TargetEnvironments)
+	err = validateDeployment(isTenanted, options.Environments)
 	if err != nil {
 		return err
 	}
@@ -461,14 +462,14 @@ func AskQuestions(octopus *octopusApiClient.Client, stdout io.Writer, asker ques
 	if len(deploymentEnvironmentIDs) == 0 { // if the Q&A process earlier hasn't loaded environments already, we need to load them now
 		switch selectedChannel.Type {
 		case channels.ChannelTypeLifecycle:
-			selectedEnvironments, err := executionscommon.FindEnvironments(octopus, options.TargetEnvironments)
+			selectedEnvironments, err := executionscommon.FindEnvironments(octopus, options.Environments)
 			if err != nil {
 				return err
 			}
 
 			deploymentEnvironmentIDs = util.SliceTransform(selectedEnvironments, func(env *environments.Environment) string { return env.ID })
 		case channels.ChannelTypeEphemeral:
-			deploymentEnvironmentIDs, err = findEphemeralEnvironmentIDs(octopus, space, options.TargetEnvironments)
+			deploymentEnvironmentIDs, err = findEphemeralEnvironmentIDs(octopus, space, options.Environments)
 
 			if err != nil {
 				return err
@@ -593,7 +594,7 @@ func AskQuestions(octopus *octopusApiClient.Client, stdout io.Writer, asker ques
 
 		if !isDeploymentTargetsSpecified {
 			if len(deploymentEnvironmentIDs) == 0 { // if the Q&A process earlier hasn't loaded environments already, we need to load them now
-				selectedEnvironments, err := executionscommon.FindEnvironments(octopus, options.TargetEnvironments)
+				selectedEnvironments, err := executionscommon.FindEnvironments(octopus, options.Environments)
 				if err != nil {
 					return err
 				}
@@ -645,7 +646,7 @@ func selectDeploymentEnvironmentsForEphemeralChannel(octopus *octopusApiClient.C
 	var deploymentEnvironmentIds []string
 	var selectedEnvironments []*ephemeralenvironments.EphemeralEnvironment
 
-	if len(options.TargetEnvironments) == 0 {
+	if len(options.Environments) == 0 {
 		allEphemeralEnvironments, err := ephemeralenvironments.GetAll(octopus, selectedRelease.SpaceID)
 		if err != nil {
 			return nil, err
@@ -677,10 +678,10 @@ func selectDeploymentEnvironmentsForEphemeralChannel(octopus *octopusApiClient.C
 				return nil, err
 			}
 			deploymentEnvironmentIds = util.SliceTransform(selectedEnvironments, func(env *ephemeralenvironments.EphemeralEnvironment) string { return env.ID })
-			options.TargetEnvironments = util.SliceTransform(selectedEnvironments, func(env *ephemeralenvironments.EphemeralEnvironment) string { return env.Name })
+			options.Environments = util.SliceTransform(selectedEnvironments, func(env *ephemeralenvironments.EphemeralEnvironment) string { return env.Name })
 		}
 	} else {
-		_, _ = fmt.Fprintf(stdout, "Environments %s\n", output.Cyan(strings.Join(options.TargetEnvironments, ",")))
+		_, _ = fmt.Fprintf(stdout, "Environments %s\n", output.Cyan(strings.Join(options.Environments, ",")))
 	}
 
 	return deploymentEnvironmentIds, nil
@@ -693,7 +694,7 @@ func selectDeploymentEnvironmentsForLifecycleChannel(octopus *octopusApiClient.C
 
 	if isTenanted {
 		var selectedEnvironment *environments.Environment
-		if len(options.TargetEnvironments) == 0 {
+		if len(options.Environments) == 0 {
 			deployableEnvironmentIDs, nextEnvironmentID, err := FindDeployableEnvironmentIDs(octopus, selectedRelease)
 			if err != nil {
 				return nil, err
@@ -702,9 +703,9 @@ func selectDeploymentEnvironmentsForLifecycleChannel(octopus *octopusApiClient.C
 			if err != nil {
 				return nil, err
 			}
-			options.TargetEnvironments = []string{selectedEnvironment.Name} // executions api allows env names, so let's use these instead so they look nice in generated automationcmd
+			options.Environments = []string{selectedEnvironment.Name} // executions api allows env names, so let's use these instead so they look nice in generated automationcmd
 		} else {
-			selectedEnvironment, err = selectors.FindEnvironment(octopus, options.TargetEnvironments[0])
+			selectedEnvironment, err = selectors.FindEnvironment(octopus, options.Environments[0])
 			if err != nil {
 				return nil, err
 			}
@@ -731,7 +732,7 @@ func selectDeploymentEnvironmentsForLifecycleChannel(octopus *octopusApiClient.C
 			}
 		}
 	} else {
-		if len(options.TargetEnvironments) == 0 {
+		if len(options.Environments) == 0 {
 			deployableEnvironmentIDs, nextEnvironmentID, err := FindDeployableEnvironmentIDs(octopus, selectedRelease)
 			if err != nil {
 				return nil, err
@@ -741,10 +742,10 @@ func selectDeploymentEnvironmentsForLifecycleChannel(octopus *octopusApiClient.C
 				return nil, err
 			}
 			deploymentEnvironmentIds = util.SliceTransform(selectedEnvironments, func(env *environments.Environment) string { return env.ID })
-			options.TargetEnvironments = util.SliceTransform(selectedEnvironments, func(env *environments.Environment) string { return env.Name })
+			options.Environments = util.SliceTransform(selectedEnvironments, func(env *environments.Environment) string { return env.Name })
 		} else {
-			if len(options.TargetEnvironments) > 0 {
-				_, _ = fmt.Fprintf(stdout, "Environments %s\n", output.Cyan(strings.Join(options.TargetEnvironments, ",")))
+			if len(options.Environments) > 0 {
+				_, _ = fmt.Fprintf(stdout, "Environments %s\n", output.Cyan(strings.Join(options.Environments, ",")))
 			}
 		}
 	}

pkg/executor/release.go

@@ -217,38 +217,9 @@ func releaseDeploy(octopus *client.Client, space *spaces.Space, input any) error
 // ----- Promote Release --------------------------------------
 
 type TaskOptionsPromoteRelease struct {
-	ProjectName                    string   // required
+	TaskOptionsDeployRelease
 	SourceEnvironment              string   // the source environment to promote from
-	ReleaseVersion                 string   // the release to deploy
-	TargetEnvironments             []string // multiple for untenanted deployment, only one entry for tenanted deployment
-	Tenants                        []string
-	TenantTags                     []string
-	ScheduledStartTime             string
-	ScheduledExpiryTime            string
-	ExcludedSteps                  []string
-	GuidedFailureMode              string // ["", "true", "false", "default"]. Note default and "" are the same, the only difference is whether interactive mode prompts you
-	ForcePackageDownload           bool
-	DeploymentTargets              []string
-	ExcludeTargets                 []string
-	Variables                      map[string]string
-	UpdateVariables                bool
 	LatestSuccessful               bool
-	DeploymentFreezeNames          []string
-	DeploymentFreezeOverrideReason string
-
-	// extra behaviour commands
-
-	// true if the value was specified on the command line (because ForcePackageDownload is bool, we can't distinguish 'false' from 'missing')
-	ForcePackageDownloadWasSpecified bool
-
-	// so the automation command can mask sensitive variable output
-	SensitiveVariableNames []string
-
-	// printing a link to the release (to check deployment status) requires the release ID, not version.
-	// the interactive process looks this up, so we can cache it here to avoid a second lookup when generating
-	// the link for the browser. It isn't neccessary though
-	ReleaseID string
-
 	// After we send the request to the server, the response is stored here
 	Response *deployments.CreateDeploymentResponseV1
 }
@@ -258,87 +229,8 @@ func releasePromote(octopus *client.Client, space *spaces.Space, input any) erro
 	if !ok {
 		return errors.New("invalid input type; expecting TaskOptionsPromoteRelease")
 	}
-	if space == nil {
-		return errors.New("space must be specified")
-	}
-
-	// we have the provided project name; go look it up
-	if params.ProjectName == "" {
-		return errors.New("project must be specified")
-	}
-	if params.ReleaseVersion == "" {
-		return errors.New("release version must be specified")
-	}
-	if len(params.TargetEnvironments) == 0 {
-		return errors.New("environment(s) must be specified")
-	}
 	if params.SourceEnvironment == "" {
 		return errors.New("source environment must be specified")
 	}
-
-	// common properties
-	abstractCmd := deployments.CreateExecutionAbstractCommandV1{
-		SpaceID:                        space.ID,
-		ProjectIDOrName:                params.ProjectName,
-		ForcePackageDownload:           params.ForcePackageDownload,
-		SpecificMachineNames:           params.DeploymentTargets,
-		ExcludedMachineNames:           params.ExcludeTargets,
-		SkipStepNames:                  params.ExcludedSteps,
-		RunAt:                          params.ScheduledStartTime,
-		NoRunAfter:                     params.ScheduledExpiryTime,
-		Variables:                      params.Variables,
-		DeploymentFreezeNames:          params.DeploymentFreezeNames,
-		DeploymentFreezeOverrideReason: params.DeploymentFreezeOverrideReason,
-	}
-
-	b, err := strconv.ParseBool(params.GuidedFailureMode)
-	if err == nil {
-		abstractCmd.UseGuidedFailure = &b
-	} else {
-		// else they must have specified nothing, or perhaps "default". Sanity check it's not garbage
-		if params.GuidedFailureMode != "" && !strings.EqualFold("default", params.GuidedFailureMode) {
-			return fmt.Errorf("'%s' is not a valid value for guided failure mode", params.GuidedFailureMode)
-		}
-	}
-	// If either tenants or tenantTags are specified then it must be a tenanted deployment.
-	// Otherwise it must be untenanted.
-	// If the server has a tenanted deployment and both TenantNames+Tags are empty, the request fails,
-	// which makes this a safe thing to build our logic on.
-	isTenanted := len(params.Tenants) > 0 || len(params.TenantTags) > 0
-
-	if isTenanted {
-		if len(params.TargetEnvironments) > 1 {
-			return fmt.Errorf("tenanted deployments can only specify one environment")
-		}
-		tenantedCommand := deployments.NewCreateDeploymentTenantedCommandV1(space.ID, params.ProjectName)
-		tenantedCommand.ReleaseVersion = params.ReleaseVersion
-		tenantedCommand.EnvironmentName = params.TargetEnvironments[0]
-		tenantedCommand.Tenants = params.Tenants
-		tenantedCommand.TenantTags = params.TenantTags
-		tenantedCommand.ForcePackageRedeployment = params.ForcePackageDownload
-		tenantedCommand.UpdateVariableSnapshot = params.UpdateVariables
-		tenantedCommand.UpdateVariableSnapshot = params.UpdateVariables
-		tenantedCommand.CreateExecutionAbstractCommandV1 = abstractCmd
-
-		createDeploymentResponse, err := deployments.CreateDeploymentTenantedV1(octopus, tenantedCommand)
-		if err != nil {
-			return err
-		}
-		params.Response = createDeploymentResponse
-	} else {
-		untenantedCommand := deployments.NewCreateDeploymentUntenantedCommandV1(space.ID, params.ProjectName)
-		untenantedCommand.ReleaseVersion = params.ReleaseVersion
-		untenantedCommand.EnvironmentNames = params.TargetEnvironments
-		untenantedCommand.ForcePackageRedeployment = params.ForcePackageDownload
-		untenantedCommand.UpdateVariableSnapshot = params.UpdateVariables
-		untenantedCommand.CreateExecutionAbstractCommandV1 = abstractCmd
-
-		createDeploymentResponse, err := deployments.CreateDeploymentUntenantedV1(octopus, untenantedCommand)
-		if err != nil {
-			return err
-		}
-		params.Response = createDeploymentResponse
-	}
-
-	return nil
+	return releaseDeploy(octopus, space, &params.TaskOptionsDeployRelease)
 }