add version to deploy to upstream upgrade cmd (#2396)

cmd/kots/cli/upstream-upgrade.go

@@ -152,6 +152,10 @@ func logUpstreamUpgrade(log *logger.CLILogger, res *upstream.UpgradeResponse, ou
 		for _, r := range res.AvailableReleases {
 			log.ActionWithoutSpinner(fmt.Sprintf("Downloading available release: sequence %v, version %v", r.Sequence, r.Version))
 		}
+
+		if res.DeployingRelease != nil {
+			log.ActionWithoutSpinner(fmt.Sprintf("Deploying release: sequence %v, version %v", res.DeployingRelease.Sequence, res.DeployingRelease.Version))
+		}
 	}
 
 	return nil

pkg/handlers/update.go

@@ -26,6 +26,7 @@ type AppUpdateCheckResponse struct {
 	CurrentAppSequence int64              `json:"currentAppSequence"`
 	CurrentRelease     AppUpdateRelease   `json:"currentRelease"`
 	AvailableReleases  []AppUpdateRelease `json:"availableReleases"`
+	DeployingRelease   AppUpdateRelease   `json:"deployingRelease"`
 }
 
 type AppUpdateRelease struct {
@@ -97,6 +98,10 @@ func (h *Handler) AppUpdateCheck(w http.ResponseWriter, r *http.Request) {
 					Version:  ucr.CurrentRelease.Version,
 				},
 				AvailableReleases: availableReleases,
+				DeployingRelease: AppUpdateRelease{
+					Sequence: ucr.DeployingRelease.Sequence,
+					Version:  ucr.DeployingRelease.Version,
+				},
 			}
 		}
 

pkg/updatechecker/updatechecker.go

@@ -158,6 +158,7 @@ type UpdateCheckResponse struct {
 	AvailableUpdates  int64
 	CurrentRelease    UpdateCheckRelease
 	AvailableReleases []UpdateCheckRelease
+	DeployingRelease  UpdateCheckRelease
 }
 
 type UpdateCheckRelease struct {
@@ -265,6 +266,7 @@ func CheckForUpdates(opts CheckForUpdatesOpts) (*UpdateCheckResponse, error) {
 			Version:  appVersions.CurrentVersion.VersionLabel,
 		},
 		AvailableReleases: availableReleases,
+		DeployingRelease:  getVersionToDeploy(opts, d.ClusterID, availableReleases),
 	}
 
 	if len(updates) == 0 {
@@ -338,6 +340,49 @@ func ensureDesiredVersionIsDeployed(opts CheckForUpdatesOpts, clusterID string)
 	return nil
 }
 
+func getVersionToDeploy(opts CheckForUpdatesOpts, clusterID string, availableReleases []UpdateCheckRelease) UpdateCheckRelease {
+	appVersions, err := store.GetStore().GetAppVersions(opts.AppID, clusterID)
+	if err != nil {
+		return UpdateCheckRelease{}
+	}
+	if len(appVersions.AllVersions) == 0 {
+		return UpdateCheckRelease{}
+	}
+
+	// prepend updates
+	for _, u := range availableReleases {
+		appVersions.AllVersions = append([]*downstreamtypes.DownstreamVersion{{VersionLabel: u.Version, Sequence: u.Sequence}}, appVersions.AllVersions...)
+	}
+
+	if opts.DeployLatest && appVersions.AllVersions[0].Sequence != appVersions.CurrentVersion.Sequence {
+		return UpdateCheckRelease{
+			Sequence: appVersions.AllVersions[0].Sequence,
+			Version:  appVersions.AllVersions[0].VersionLabel,
+		}
+	}
+
+	if opts.DeployVersionLabel != "" {
+		var versionToDeploy *downstreamtypes.DownstreamVersion
+		for _, v := range appVersions.AllVersions {
+			if v.VersionLabel == opts.DeployVersionLabel {
+				versionToDeploy = v
+				break
+			}
+		}
+
+		if versionToDeploy != nil && versionToDeploy.Sequence != appVersions.CurrentVersion.Sequence {
+			return UpdateCheckRelease{
+				Sequence: versionToDeploy.Sequence,
+				Version:  versionToDeploy.VersionLabel,
+			}
+		}
+	}
+
+	// todo: get version to deploy for opts.AutoDeploy
+
+	return UpdateCheckRelease{}
+}
+
 func deployLatestVersion(opts CheckForUpdatesOpts, clusterID string) error {
 	appVersions, err := store.GetStore().GetAppVersions(opts.AppID, clusterID)
 	if err != nil {

pkg/upstream/upgrade.go

@@ -28,6 +28,7 @@ type UpgradeResponse struct {
 	AvailableUpdates  int64            `json:"availableUpdates"`
 	CurrentRelease    *UpgradeRelease  `json:"currentRelease,omitempty"`
 	AvailableReleases []UpgradeRelease `json:"availableReleases,omitempty"`
+	DeployingRelease  *UpgradeRelease  `json:"deployingRelease,omitempty"`
 	Error             string           `json:"error,omitempty"`
 }
 
@@ -219,6 +220,9 @@ func Upgrade(appSlug string, options UpgradeOptions) (*UpgradeResponse, error) {
 	if err := json.Unmarshal(b, &ur); err != nil {
 		return nil, errors.Wrap(err, "failed to parse response")
 	}
+	if ur.DeployingRelease.Version == "" {
+		ur.DeployingRelease = nil
+	}
 
 	log.FinishSpinner()