293 lines
8.2 KiB
Go
293 lines
8.2 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"coopcloud.tech/abra/cli/internal"
|
|
appPkg "coopcloud.tech/abra/pkg/app"
|
|
"coopcloud.tech/abra/pkg/autocomplete"
|
|
"coopcloud.tech/abra/pkg/client"
|
|
"coopcloud.tech/abra/pkg/config"
|
|
"coopcloud.tech/abra/pkg/envfile"
|
|
"coopcloud.tech/abra/pkg/lint"
|
|
"coopcloud.tech/abra/pkg/log"
|
|
"coopcloud.tech/abra/pkg/recipe"
|
|
recipePkg "coopcloud.tech/abra/pkg/recipe"
|
|
stack "coopcloud.tech/abra/pkg/upstream/stack"
|
|
"coopcloud.tech/tagcmp"
|
|
"github.com/AlecAivazis/survey/v2"
|
|
"github.com/urfave/cli"
|
|
)
|
|
|
|
var appUpgradeCommand = cli.Command{
|
|
Name: "upgrade",
|
|
Aliases: []string{"up"},
|
|
Usage: "Upgrade an app",
|
|
ArgsUsage: "<domain> [<version>]",
|
|
Flags: []cli.Flag{
|
|
internal.DebugFlag,
|
|
internal.NoInputFlag,
|
|
internal.ForceFlag,
|
|
internal.ChaosFlag,
|
|
internal.NoDomainChecksFlag,
|
|
internal.DontWaitConvergeFlag,
|
|
internal.OfflineFlag,
|
|
internal.ReleaseNotesFlag,
|
|
},
|
|
Before: internal.SubCommandBefore,
|
|
Description: `
|
|
Upgrade an app. You can use it to choose and roll out a new upgrade to an
|
|
existing app.
|
|
|
|
This command specifically supports incrementing the version of running apps, as
|
|
opposed to "abra app deploy <domain>" which will not change the version of a
|
|
deployed app.
|
|
|
|
You may pass "--force/-f" to upgrade 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 {
|
|
log.Fatal("cannot use <version> and --chaos together")
|
|
}
|
|
|
|
r := recipe.Get2(app.Recipe)
|
|
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
r2 := recipePkg.Get2(app.Recipe)
|
|
if err := lint.LintForErrors(r2); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
log.Debugf("checking whether %s is already deployed", stackName)
|
|
|
|
cl, err := client.New(app.Server)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
if !isDeployed {
|
|
log.Fatalf("%s is not deployed?", app.Name)
|
|
}
|
|
|
|
catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
versions, err := recipePkg.GetRecipeCatalogueVersions(app.Recipe, catl)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
if len(versions) == 0 && !internal.Chaos {
|
|
log.Warn("no published versions in catalogue, trying local recipe repository")
|
|
recipeVersions, err := r2.GetRecipeVersions(internal.Offline)
|
|
if err != nil {
|
|
log.Warn(err)
|
|
}
|
|
for _, recipeVersion := range recipeVersions {
|
|
for version := range recipeVersion {
|
|
versions = append(versions, version)
|
|
}
|
|
}
|
|
}
|
|
|
|
var availableUpgrades []string
|
|
if deployedVersion == "unknown" {
|
|
availableUpgrades = versions
|
|
log.Warnf("failed to determine deployed version of %s", app.Name)
|
|
}
|
|
|
|
if specificVersion != "" {
|
|
parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
|
|
log.Fatalf("%s is not an upgrade for %s?", deployedVersion, specificVersion)
|
|
}
|
|
availableUpgrades = append(availableUpgrades, specificVersion)
|
|
}
|
|
|
|
parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" {
|
|
for _, version := range versions {
|
|
parsedVersion, err := tagcmp.Parse(version)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if parsedVersion.IsGreaterThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
|
|
availableUpgrades = append(availableUpgrades, version)
|
|
}
|
|
}
|
|
|
|
if len(availableUpgrades) == 0 && !internal.Force {
|
|
log.Infof("no available upgrades, you're on latest (%s) ✌️", deployedVersion)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var chosenUpgrade string
|
|
if len(availableUpgrades) > 0 && !internal.Chaos {
|
|
if internal.Force || internal.NoInput || specificVersion != "" {
|
|
chosenUpgrade = availableUpgrades[len(availableUpgrades)-1]
|
|
log.Debugf("choosing %s as version to upgrade to", chosenUpgrade)
|
|
} else {
|
|
prompt := &survey.Select{
|
|
Message: fmt.Sprintf("Please select an upgrade (current version: %s):", deployedVersion),
|
|
Options: internal.ReverseStringList(availableUpgrades),
|
|
}
|
|
if err := survey.AskOne(prompt, &chosenUpgrade); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
if internal.Force && chosenUpgrade == "" {
|
|
log.Warnf("%s is already upgraded to latest but continuing (--force/--chaos)", app.Name)
|
|
chosenUpgrade = deployedVersion
|
|
}
|
|
|
|
// if release notes written after git tag published, read them before we
|
|
// check out the tag and then they'll appear to be missing. this covers
|
|
// when we obviously will forget to write release notes before publishing
|
|
var releaseNotes string
|
|
if chosenUpgrade != "" {
|
|
parsedChosenUpgrade, err := tagcmp.Parse(chosenUpgrade)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
for _, version := range versions {
|
|
parsedVersion, err := tagcmp.Parse(version)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if parsedVersion.IsGreaterThan(parsedDeployedVersion) && parsedVersion.IsLessThan(parsedChosenUpgrade) {
|
|
note, err := internal.GetReleaseNotes(app.Recipe, version)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if note != "" {
|
|
releaseNotes += fmt.Sprintf("%s\n", note)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if !internal.Chaos {
|
|
if err := r.EnsureVersion(chosenUpgrade); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
if internal.Chaos {
|
|
log.Warn("chaos mode engaged")
|
|
var err error
|
|
chosenUpgrade, err = r.ChaosVersion()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
|
|
abraShEnv, err := envfile.ReadAbraShEnvVars(abraShPath)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
for k, v := range abraShEnv {
|
|
app.Env[k] = v
|
|
}
|
|
|
|
composeFiles, err := r.GetComposeFiles(app.Env)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
deployOpts := stack.Deploy{
|
|
Composefiles: composeFiles,
|
|
Namespace: stackName,
|
|
Prune: false,
|
|
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)
|
|
appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
|
|
appPkg.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
|
|
appPkg.SetUpdateLabel(compose, stackName, app.Env)
|
|
|
|
envVars, err := appPkg.CheckEnv(app)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
for _, envVar := range envVars {
|
|
if !envVar.Present {
|
|
log.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
|
|
}
|
|
}
|
|
|
|
if internal.ReleaseNotes {
|
|
fmt.Println()
|
|
fmt.Print(releaseNotes)
|
|
return nil
|
|
}
|
|
|
|
if err := internal.NewVersionOverview(app, deployedVersion, chosenUpgrade, releaseNotes); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
log.Debugf("set waiting timeout to %d s", stack.WaitTimeout)
|
|
|
|
if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
postDeployCmds, ok := app.Env["POST_UPGRADE_CMDS"]
|
|
if ok && !internal.DontWaitConverge {
|
|
log.Debugf("run the following post-deploy commands: %s", postDeployCmds)
|
|
if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
|
|
log.Fatalf("attempting to run post deploy commands, saw: %s", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
}
|