241 lines
6.6 KiB
Go
241 lines
6.6 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"coopcloud.tech/abra/pkg/autocomplete"
|
|
"coopcloud.tech/abra/pkg/config"
|
|
"coopcloud.tech/abra/pkg/lint"
|
|
"coopcloud.tech/abra/pkg/recipe"
|
|
stack "coopcloud.tech/abra/pkg/upstream/stack"
|
|
"coopcloud.tech/tagcmp"
|
|
|
|
"coopcloud.tech/abra/cli/internal"
|
|
"coopcloud.tech/abra/pkg/client"
|
|
"github.com/AlecAivazis/survey/v2"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/urfave/cli/v2"
|
|
)
|
|
|
|
var appRollbackCommand = cli.Command{
|
|
Name: "rollback",
|
|
Aliases: []string{"rl"},
|
|
Usage: "Roll an app back to a previous version",
|
|
ArgsUsage: "<domain> [<version>]",
|
|
Flags: []cli.Flag{
|
|
internal.DebugFlag,
|
|
internal.NoInputFlag,
|
|
internal.ForceFlag,
|
|
internal.ChaosFlag,
|
|
internal.NoDomainChecksFlag,
|
|
internal.DontWaitConvergeFlag,
|
|
internal.OfflineFlag,
|
|
},
|
|
Before: internal.SubCommandBefore,
|
|
Description: `
|
|
This command rolls an app back to a previous version if one exists.
|
|
|
|
You may pass "--force/-f" to downgrade to the same version again. This can be
|
|
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 {
|
|
logrus.Fatal("cannot use <version> and --chaos together")
|
|
}
|
|
|
|
if err := recipe.EnsureExists(app.Recipe); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if !internal.Chaos {
|
|
if err := recipe.EnsureIsClean(app.Recipe); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if !internal.Offline {
|
|
if err := recipe.EnsureUpToDate(app.Recipe); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
if err := recipe.EnsureLatest(app.Recipe); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
r, err := recipe.Get(app.Recipe, internal.Offline)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if err := lint.LintForErrors(r); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
cl, err := client.New(app.Server)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
logrus.Debugf("checking whether %s is already deployed", stackName)
|
|
|
|
isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if !isDeployed {
|
|
logrus.Fatalf("%s is not deployed?", app.Name)
|
|
}
|
|
|
|
catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if len(versions) == 0 && !internal.Chaos {
|
|
logrus.Warn("no published versions in catalogue, trying local recipe repository")
|
|
recipeVersions, err := recipe.GetRecipeVersions(app.Recipe, internal.Offline)
|
|
if err != nil {
|
|
logrus.Warn(err)
|
|
}
|
|
for _, recipeVersion := range recipeVersions {
|
|
for version := range recipeVersion {
|
|
versions = append(versions, version)
|
|
}
|
|
}
|
|
}
|
|
|
|
var availableDowngrades []string
|
|
if deployedVersion == "unknown" {
|
|
availableDowngrades = versions
|
|
logrus.Warnf("failed to determine deployed version of %s", app.Name)
|
|
}
|
|
|
|
if specificVersion != "" {
|
|
parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
|
|
logrus.Fatalf("%s is not a downgrade for %s?", deployedVersion, specificVersion)
|
|
}
|
|
availableDowngrades = append(availableDowngrades, specificVersion)
|
|
}
|
|
|
|
if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" {
|
|
for _, version := range versions {
|
|
parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
parsedVersion, err := tagcmp.Parse(version)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
if parsedVersion.IsLessThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
|
|
availableDowngrades = append(availableDowngrades, version)
|
|
}
|
|
}
|
|
|
|
if len(availableDowngrades) == 0 && !internal.Force {
|
|
logrus.Info("no available downgrades, you're on oldest ✌️")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var chosenDowngrade string
|
|
if len(availableDowngrades) > 0 && !internal.Chaos {
|
|
if internal.Force || internal.NoInput || specificVersion != "" {
|
|
chosenDowngrade = availableDowngrades[len(availableDowngrades)-1]
|
|
logrus.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade)
|
|
} else {
|
|
prompt := &survey.Select{
|
|
Message: fmt.Sprintf("Please select a downgrade (current version: %s):", deployedVersion),
|
|
Options: internal.ReverseStringList(availableDowngrades),
|
|
}
|
|
if err := survey.AskOne(prompt, &chosenDowngrade); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
if !internal.Chaos {
|
|
if err := recipe.EnsureVersion(app.Recipe, chosenDowngrade); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
if internal.Chaos {
|
|
logrus.Warn("chaos mode engaged")
|
|
var err error
|
|
chosenDowngrade, err = recipe.ChaosVersion(app.Recipe)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
|
|
abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
for k, v := range abraShEnv {
|
|
app.Env[k] = v
|
|
}
|
|
|
|
composeFiles, err := config.GetComposeFiles(app.Recipe, app.Env)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
deployOpts := stack.Deploy{
|
|
Composefiles: composeFiles,
|
|
Namespace: stackName,
|
|
Prune: false,
|
|
ResolveImage: stack.ResolveImageAlways,
|
|
}
|
|
compose, err := config.GetAppComposeConfig(app.Name, deployOpts, app.Env)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
config.ExposeAllEnv(stackName, compose, app.Env)
|
|
config.SetRecipeLabel(compose, stackName, app.Recipe)
|
|
config.SetChaosLabel(compose, stackName, internal.Chaos)
|
|
config.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
|
|
config.SetUpdateLabel(compose, stackName, app.Env)
|
|
|
|
// NOTE(d1): no release notes implemeneted for rolling back
|
|
if err := internal.NewVersionOverview(app, deployedVersion, chosenDowngrade, ""); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
return nil
|
|
},
|
|
}
|