runtime upgrade fix (#234)

Author: roi-codefresh

Makefile

@@ -1,4 +1,4 @@
-VERSION=v0.0.214
+VERSION=v0.0.216
 
 OUT_DIR=dist
 YEAR?=$(shell date +"%Y")

cmd/commands/runtime.go

@@ -357,20 +357,22 @@ func runtimeUninstallCommandPreRunHandler(cmd *cobra.Command, args []string, opt
 	return nil
 }
 
-func runtimeUpgradeCommandPreRunHandler(cmd *cobra.Command, args []string, cloneOpts *git.CloneOptions, runtimeName string) error {
+func runtimeUpgradeCommandPreRunHandler(cmd *cobra.Command, args []string, opts *RuntimeUpgradeOptions) error {
 	handleCliStep(reporter.UpgradePhasePreCheckStart, "Starting pre checks", nil, false)
 
-	err := ensureRuntimeName(cmd.Context(), args, &runtimeName)
+	err := ensureRuntimeName(cmd.Context(), args, &opts.RuntimeName)
 	handleCliStep(reporter.UpgradeStepPreCheckEnsureRuntimeName, "Ensuring runtime name", err, false)
 	if err != nil {
 		return fmt.Errorf("%w", err)
 	}
-	err = ensureRepo(cmd, runtimeName, cloneOpts, true)
+
+	err = ensureRepo(cmd, opts.RuntimeName, opts.CloneOpts, true)
 	handleCliStep(reporter.UpgradeStepPreCheckEnsureRuntimeRepo, "Getting runtime repo", err, false)
 	if err != nil {
 		return fmt.Errorf("%w", err)
 	}
-	err = ensureGitToken(cmd, cloneOpts)
+
+	err = ensureGitToken(cmd, opts.CloneOpts)
 	handleCliStep(reporter.UpgradeStepPreCheckEnsureGitToken, "Getting git token", err, false)
 	if err != nil {
 		return fmt.Errorf("%w", err)
@@ -1090,10 +1092,9 @@ func deleteRuntimeFromPlatform(ctx context.Context, opts *RuntimeUninstallOption
 
 func NewRuntimeUpgradeCommand() *cobra.Command {
 	var (
-		runtimeName     string
 		versionStr      string
-		cloneOpts       *git.CloneOptions
 		finalParameters map[string]string
+		opts            RuntimeUpgradeOptions
 	)
 
 	cmd := &cobra.Command{
@@ -1118,61 +1119,60 @@ func NewRuntimeUpgradeCommand() *cobra.Command {
 
 			createAnalyticsReporter(ctx, reporter.UpgradeFlow)
 
-			err := runtimeUpgradeCommandPreRunHandler(cmd, args, cloneOpts, runtimeName)
+			err := runtimeUpgradeCommandPreRunHandler(cmd, args, &opts)
 			handleCliStep(reporter.UpgradePhasePreCheckFinish, "Finished pre installation checks", err, false)
 			if err != nil {
 				return fmt.Errorf("Pre installation error: %w", err)
 			}
 
 			finalParameters = map[string]string{
-				"Runtime name":   runtimeName,
-				"Repository URL": cloneOpts.Repo,
+				"Runtime name":   opts.RuntimeName,
+				"Repository URL": opts.CloneOpts.Repo,
+			}
+
+			if versionStr != "" {
+				finalParameters["Version"] = versionStr
 			}
 
 			err = getApprovalFromUser(ctx, finalParameters, "runtime upgrade")
 			if err != nil {
 				return fmt.Errorf("%w", err)
 			}
 
-			cloneOpts.Parse()
+			opts.CloneOpts.Parse()
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			var (
-				version *semver.Version
-				err     error
-			)
+			var err error
 			ctx := cmd.Context()
 
 			if versionStr != "" {
-				version, err = semver.NewVersion(versionStr)
+				opts.Version, err = semver.NewVersion(versionStr)
 				if err != nil {
 					return err
 				}
 			}
 
-			err = RunRuntimeUpgrade(ctx, &RuntimeUpgradeOptions{
-				RuntimeName: runtimeName,
-				Version:     version,
-				CloneOpts:   cloneOpts,
-				CommonConfig: &runtime.CommonConfig{
-					CodefreshBaseURL: cfConfig.GetCurrentContext().URL,
-				},
-			})
+			opts.CommonConfig = &runtime.CommonConfig{
+				CodefreshBaseURL: cfConfig.GetCurrentContext().URL,
+			}
+
+			err = RunRuntimeUpgrade(ctx, &opts)
 			handleCliStep(reporter.UpgradePhaseFinish, "Runtime upgrade phase finished", err, false)
 			return err
 		},
 	}
 
 	cmd.Flags().StringVar(&versionStr, "version", "", "The runtime version to upgrade to, defaults to latest")
-	cloneOpts = apu.AddCloneFlags(cmd, &apu.CloneFlagsOptions{})
+	opts.CloneOpts = apu.AddCloneFlags(cmd, &apu.CloneFlagsOptions{})
 
 	return cmd
 }
 
 func RunRuntimeUpgrade(ctx context.Context, opts *RuntimeUpgradeOptions) error {
 	handleCliStep(reporter.UpgradePhaseStart, "Runtime upgrade phase started", nil, true)
 
+	log.G(ctx).Info("Downloading runtime definition")
 	newRt, err := runtime.Download(opts.Version, opts.RuntimeName)
 	handleCliStep(reporter.UpgradeStepDownloadRuntimeDefinition, "Downloading runtime definition", err, false)
 	if err != nil {
@@ -1187,22 +1187,29 @@ func RunRuntimeUpgrade(ctx context.Context, opts *RuntimeUpgradeOptions) error {
 		return err
 	}
 
+	log.G(ctx).Info("Cloning installation repository")
 	r, fs, err := opts.CloneOpts.GetRepo(ctx)
 	handleCliStep(reporter.UpgradeStepGetRepo, "Getting repository", err, false)
 	if err != nil {
 		return err
 	}
 
+	log.G(ctx).Info("Loading current runtime definition")
 	curRt, err := runtime.Load(fs, fs.Join(apstore.Default.BootsrtrapDir, opts.RuntimeName+".yaml"))
 	handleCliStep(reporter.UpgradeStepLoadRuntimeDefinition, "Loading runtime definition", err, false)
 	if err != nil {
 		return fmt.Errorf("failed to load current runtime definition: %w", err)
 	}
 
 	if !newRt.Spec.Version.GreaterThan(curRt.Spec.Version) {
-		return fmt.Errorf("must upgrade to version > %s", curRt.Spec.Version)
+		err = fmt.Errorf("current runtime version (%s) is greater than or equal to the specified version (%s)", curRt.Spec.Version, newRt.Spec.Version)
+	}
+	handleCliStep(reporter.UpgradeStepLoadRuntimeDefinition, "Comparing runtime versions", err, false)
+	if err != nil {
+		return err
 	}
 
+	log.G(ctx).Infof("Upgrading runtime \"%s\" to version: v%s", opts.RuntimeName, newRt.Spec.Version)
 	newComponents, err := curRt.Upgrade(fs, newRt, opts.CommonConfig)
 	handleCliStep(reporter.UpgradeStepUpgradeRuntime, "Upgrading runtime", err, false)
 	if err != nil {
@@ -1217,16 +1224,17 @@ func RunRuntimeUpgrade(ctx context.Context, opts *RuntimeUpgradeOptions) error {
 	}
 
 	for _, component := range newComponents {
-		infoStr := fmt.Sprintf("Creating app '%s'", component.Name)
-		log.G(ctx).Infof(infoStr)
+		log.G(ctx).Infof("Installing new component \"%s\"", component.Name)
 		err = component.CreateApp(ctx, nil, opts.CloneOpts, opts.RuntimeName, store.Get().CFComponentType, "", "")
 		if err != nil {
 			err = fmt.Errorf("failed to create '%s' application: %w", component.Name, err)
 			break
 		}
 	}
 
-	handleCliStep(reporter.UpgradeStepCreateApps, "Creating apps", err, false)
+	handleCliStep(reporter.UpgradeStepInstallNewComponents, "Install new components", err, false)
+
+	log.G(ctx).Infof("Runtime upgraded to version: v%s", newRt.Spec.Version)
 
 	return nil
 }

docs/releases/release_notes.md

@@ -23,7 +23,7 @@ cf version
 
 ```bash
 # download and extract the binary
-curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.214/cf-linux-amd64.tar.gz | tar zx
+curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.216/cf-linux-amd64.tar.gz | tar zx
 
 # move the binary to your $PATH
 mv ./cf-linux-amd64 /usr/local/bin/cf
@@ -36,7 +36,7 @@ cf version
 
 ```bash
 # download and extract the binary
-curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.214/cf-darwin-amd64.tar.gz | tar zx
+curl -L --output - https://github.com/codefresh-io/cli-v2/releases/download/v0.0.216/cf-darwin-amd64.tar.gz | tar zx
 
 # move the binary to your $PATH
 mv ./cf-darwin-amd64 /usr/local/bin/cf

manifests/runtime.yaml

@@ -5,7 +5,7 @@ metadata:
   namespace: "{{ namespace }}"
 spec:
   defVersion: 1.0.0
-  version: 0.0.214
+  version: 0.0.216
   bootstrapSpecifier: github.com/codefresh-io/cli-v2/manifests/argo-cd
   components:
     - name: events

pkg/reporter/reporter.go

@@ -118,9 +118,10 @@ const (
 	UpgradeStepRunPreCheckEnsureCliVersion CliStep = "upgrade.run.step.ensure-cli-version"
 	UpgradeStepGetRepo                     CliStep = "upgrade.run.step.get-repo"
 	UpgradeStepLoadRuntimeDefinition       CliStep = "upgrade.run.step.load-runtime-definition"
+	UpgradeStepCompareRuntimeVersions      CliStep = "upgrade.run.step.compare-runtime-versions"
 	UpgradeStepUpgradeRuntime              CliStep = "upgrade.run.step.upgrade-runtime"
 	UpgradeStepPushRuntimeDefinition       CliStep = "upgrade.run.step.push-runtime-definition"
-	UpgradeStepCreateApps                  CliStep = "upgrade.run.step.create-apps"
+	UpgradeStepInstallNewComponents        CliStep = "upgrade.run.step.install-new-components"
 	UpgradePhaseFinish                     CliStep = "upgrade.run.phase.finish"
 
 	// General

pkg/runtime/runtime.go

@@ -124,13 +124,13 @@ func Download(version *semver.Version, name string) (*Runtime, error) {
 func Load(fs fs.FS, filename string) (*Runtime, error) {
 	cm := &v1.ConfigMap{}
 	if err := fs.ReadYamls(filename, cm); err != nil {
-		return nil, fmt.Errorf("failed to load runtime from '%s': %w", filename, err)
+		return nil, fmt.Errorf("failed to load runtime from \"%s\": %w", filename, err)
 	}
 
 	data := cm.Data["runtime"]
 	runtime := &Runtime{}
 	if err := yaml.Unmarshal([]byte(data), runtime); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal runtime from '%s': %w", filename, err)
+		return nil, fmt.Errorf("failed to unmarshal runtime from \"%s\": %w", filename, err)
 	}
 
 	for i := range runtime.Spec.Components {
@@ -196,21 +196,21 @@ func (r *RuntimeSpec) upgrade(fs fs.FS, newRt *RuntimeSpec) ([]AppDef, error) {
 	for _, newComponent := range newRt.Components {
 		curComponent := r.component(newComponent.Name)
 		if curComponent != nil {
-			log.G().Infof("Upgrading '%s'", newComponent.Name)
+			log.G().Infof("Upgrading \"%s\"", newComponent.Name)
 			baseDir := fs.Join(apstore.Default.AppsDir, curComponent.Name, apstore.Default.BaseDir)
 			if err := updateKustomization(fs, baseDir, curComponent.URL, newComponent.URL); err != nil {
-				return nil, fmt.Errorf("failed to upgrade app '%s': %w", curComponent.Name, err)
+				return nil, fmt.Errorf("failed to upgrade app \"%s\": %w", curComponent.Name, err)
 			}
 		} else {
-			log.G().Debugf("marking '%s' to be created later", newComponent.Name)
+			log.G().Debugf("marking \"%s\" to be created later", newComponent.Name)
 			newComponents = append(newComponents, newComponent)
 		}
 	}
 
 	for _, curComponent := range r.Components {
 		newComponent := newRt.component(curComponent.Name)
 		if newComponent == nil {
-			log.G().Infof("Deleting '%s'", curComponent.Name)
+			log.G().Infof("Deleting \"%s\"", curComponent.Name)
 			if err := curComponent.delete(fs); err != nil {
 				return nil, fmt.Errorf("failed to delete app '%s': %w", curComponent.Name, err)
 			}