fix!: chaos consistency (deploy/undeploy/rollback/upgrade)

See coop-cloud/organising#559

--chaos for rollback/upgrade goes away.

cli/app/rollback.go

@@ -28,7 +28,6 @@ var appRollbackCommand = cli.Command{
 		internal.DebugFlag,
 		internal.NoInputFlag,
 		internal.ForceFlag,
-		internal.ChaosFlag,
 		internal.NoDomainChecksFlag,
 		internal.DontWaitConvergeFlag,
 		internal.OfflineFlag,
@@ -42,21 +41,12 @@ useful if the container runtime has gotten into a weird state.
 
 This action could be destructive, please ensure you have a copy of your app
 data beforehand.
-
-Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
-including unstaged changes and can be useful for live hacking and testing new
-recipes.
 `,
 	BashComplete: autocomplete.AppNameComplete,
 	Action: func(c *cli.Context) error {
 		app := internal.ValidateApp(c)
 		stackName := app.StackName()
 
-		specificVersion := c.Args().Get(1)
-		if specificVersion != "" && internal.Chaos {
-			log.Fatal("cannot use <version> and --chaos together")
-		}
-
 		if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
 			log.Fatal(err)
 		}
@@ -72,12 +62,12 @@ recipes.
 
 		log.Debugf("checking whether %s is already deployed", stackName)
 
-		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
+		deployMeta, err := stack.IsDeployed(context.Background(), cl, stackName)
 		if err != nil {
 			log.Fatal(err)
 		}
 
-		if !isDeployed {
+		if !deployMeta.IsDeployed {
 			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
@@ -91,12 +81,13 @@ recipes.
 			log.Fatal(err)
 		}
 
-		if len(versions) == 0 && !internal.Chaos {
+		if len(versions) == 0 {
 			log.Warn("no published versions in catalogue, trying local recipe repository")
 			recipeVersions, err := app.Recipe.GetRecipeVersions(internal.Offline)
 			if err != nil {
 				log.Warn(err)
 			}
+
 			for _, recipeVersion := range recipeVersions {
 				for version := range recipeVersion {
 					versions = append(versions, version)
@@ -105,76 +96,82 @@ recipes.
 		}
 
 		var availableDowngrades []string
-		if deployedVersion == "unknown" {
+		if deployMeta.Version == "unknown" {
 			availableDowngrades = versions
 			log.Warnf("failed to determine deployed version of %s", app.Name)
 		}
 
+		specificVersion := c.Args().Get(1)
 		if specificVersion != "" {
-			parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
+			parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
 			if err != nil {
 				log.Fatal(err)
 			}
+
 			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
 			if err != nil {
 				log.Fatal(err)
 			}
+
 			if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
-				log.Fatalf("%s is not a downgrade for %s?", deployedVersion, specificVersion)
+				log.Fatalf("%s is not a downgrade for %s?", deployMeta.Version, specificVersion)
 			}
+
 			availableDowngrades = append(availableDowngrades, specificVersion)
 		}
 
-		if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" {
+		if deployMeta.Version != "unknown" && specificVersion == "" {
+			if deployMeta.IsChaos == "true" {
+				log.Warn("attempting to rollback a chaos deployment")
+			}
+
 			for _, version := range versions {
-				parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
+				parsedDeployedVersion, err := tagcmp.Parse(deployMeta.Version)
 				if err != nil {
 					log.Fatal(err)
 				}
+
 				parsedVersion, err := tagcmp.Parse(version)
 				if err != nil {
 					log.Fatal(err)
 				}
+
 				if parsedVersion.IsLessThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
 					availableDowngrades = append(availableDowngrades, version)
 				}
 			}
 
 			if len(availableDowngrades) == 0 && !internal.Force {
-				log.Info("no available downgrades, you're on oldest ✌️")
+				log.Info("no available downgrades")
 				return nil
 			}
 		}
 
 		var chosenDowngrade string
-		if len(availableDowngrades) > 0 && !internal.Chaos {
+		if len(availableDowngrades) > 0 {
 			if internal.Force || internal.NoInput || specificVersion != "" {
 				chosenDowngrade = availableDowngrades[len(availableDowngrades)-1]
 				log.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade)
 			} else {
+				msg := fmt.Sprintf("please select a downgrade (version: %s):", deployMeta.Version)
+				if deployMeta.IsChaos == "true" {
+					msg = fmt.Sprintf("please select a downgrade (version: %s, chaosVersion: %s):", deployMeta.Version, deployMeta.ChaosVersion)
+				}
+
 				prompt := &survey.Select{
-					Message: fmt.Sprintf("Please select a downgrade (current version: %s):", deployedVersion),
+					Message: msg,
 					Options: internal.ReverseStringList(availableDowngrades),
 				}
+
 				if err := survey.AskOne(prompt, &chosenDowngrade); err != nil {
 					return err
 				}
 			}
 		}
 
-		if !internal.Chaos {
-			if err := app.Recipe.EnsureVersion(chosenDowngrade); err != nil {
-				log.Fatal(err)
-			}
-		}
-
-		if internal.Chaos {
-			log.Warn("chaos mode engaged")
-			var err error
-			chosenDowngrade, err = app.Recipe.ChaosVersion()
-			if err != nil {
-				log.Fatal(err)
-			}
+		log.Debugf("choosing %s as version to rollback", chosenDowngrade)
+		if err := app.Recipe.EnsureVersion(chosenDowngrade); err != nil {
+			log.Fatal(err)
 		}
 
 		abraShEnv, err := envfile.ReadAbraShEnvVars(app.Recipe.AbraShPath)
@@ -189,6 +186,7 @@ recipes.
 		if err != nil {
 			log.Fatal(err)
 		}
+
 		deployOpts := stack.Deploy{
 			Composefiles: composeFiles,
 			Namespace:    stackName,
@@ -196,18 +194,25 @@ recipes.
 			ResolveImage: stack.ResolveImageAlways,
 			Detach:       false,
 		}
+
 		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
 		if err != nil {
 			log.Fatal(err)
 		}
+
 		appPkg.ExposeAllEnv(stackName, compose, app.Env)
 		appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
 		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
 		appPkg.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
 		appPkg.SetUpdateLabel(compose, stackName, app.Env)
 
+		chaosVersion := deployMeta.IsChaos
+		if deployMeta.IsChaos == "true" {
+			chaosVersion = deployMeta.ChaosVersion
+		}
+
 		// NOTE(d1): no release notes implemeneted for rolling back
-		if err := internal.NewVersionOverview(app, deployedVersion, chosenDowngrade, ""); err != nil {
+		if err := internal.NewVersionOverview(app, deployMeta.Version, chaosVersion, chosenDowngrade, ""); err != nil {
 			log.Fatal(err)
 		}