forked from coop-cloud/abra
344 lines
8.6 KiB
Go
344 lines
8.6 KiB
Go
package recipe
|
|
|
|
import (
|
|
"fmt"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
|
|
abraFormatter "coopcloud.tech/abra/cli/formatter"
|
|
"coopcloud.tech/abra/cli/internal"
|
|
"coopcloud.tech/abra/pkg/autocomplete"
|
|
"coopcloud.tech/abra/pkg/config"
|
|
gitPkg "coopcloud.tech/abra/pkg/git"
|
|
"coopcloud.tech/abra/pkg/recipe"
|
|
recipePkg "coopcloud.tech/abra/pkg/recipe"
|
|
"coopcloud.tech/tagcmp"
|
|
"github.com/AlecAivazis/survey/v2"
|
|
"github.com/docker/distribution/reference"
|
|
"github.com/go-git/go-git/v5"
|
|
"github.com/go-git/go-git/v5/plumbing"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/urfave/cli/v2"
|
|
)
|
|
|
|
var recipeReleaseCommand = &cli.Command{
|
|
Name: "release",
|
|
Usage: "Release a new recipe version",
|
|
Aliases: []string{"rl"},
|
|
ArgsUsage: "<recipe> [<version>]",
|
|
Description: `
|
|
This command is used to specify a new tag for a recipe. These tags are used to
|
|
identify different versions of the recipe and are published on the Co-op Cloud
|
|
recipe catalogue.
|
|
|
|
These tags take the following form:
|
|
|
|
a.b.c+x.y.z
|
|
|
|
Where the "a.b.c" part is a semantic version of the recipe by the recipe
|
|
maintainer. And the "x.y.z" part is the image tag of the recipe "app" service
|
|
(the main container which contains the software to be used).
|
|
|
|
We maintain a semantic versioning scheme ("a.b.c") alongside the libre app
|
|
versioning scheme in order to maximise the chances that the nature of recipe
|
|
updates are properly communicated.
|
|
|
|
Abra does its best to read the "a.b.c" version scheme and communicate what
|
|
action needs to be taken when performing different operations such as an update
|
|
or a rollback of an app.
|
|
|
|
You may invoke this command in "wizard" mode and be prompted for input:
|
|
|
|
abra recipe release gitea
|
|
|
|
`,
|
|
Flags: []cli.Flag{
|
|
internal.DryFlag,
|
|
internal.MajorFlag,
|
|
internal.MinorFlag,
|
|
internal.PatchFlag,
|
|
internal.PushFlag,
|
|
internal.CommitFlag,
|
|
internal.CommitMessageFlag,
|
|
internal.TagMessageFlag,
|
|
},
|
|
BashComplete: autocomplete.RecipeNameComplete,
|
|
Action: func(c *cli.Context) error {
|
|
recipe := internal.ValidateRecipeWithPrompt(c)
|
|
directory := path.Join(config.APPS_DIR, recipe.Name)
|
|
tagString := c.Args().Get(1)
|
|
mainApp := internal.GetMainApp(recipe)
|
|
|
|
imagesTmp, err := getImageVersions(recipe)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
mainAppVersion := imagesTmp[mainApp]
|
|
|
|
if err := recipePkg.EnsureExists(recipe.Name); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if mainAppVersion == "" {
|
|
logrus.Fatalf("main app service version for %s is empty?", recipe.Name)
|
|
}
|
|
|
|
if tagString != "" {
|
|
if _, err := tagcmp.Parse(tagString); err != nil {
|
|
logrus.Fatal("invalid tag specified")
|
|
}
|
|
}
|
|
|
|
if (!internal.Major && !internal.Minor && !internal.Patch) && tagString == "" {
|
|
logrus.Fatal("please specify <version> or bump type (--major/--minor/--patch)")
|
|
}
|
|
|
|
if (internal.Major || internal.Minor || internal.Patch) && tagString != "" {
|
|
logrus.Fatal("cannot specify tag and bump type at the same time")
|
|
}
|
|
|
|
// bumpType is used to decide what part of the tag should be incremented
|
|
bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch)
|
|
if bumpType != 0 {
|
|
// a bitwise check if the number is a power of 2
|
|
if (bumpType & (bumpType - 1)) != 0 {
|
|
logrus.Fatal("you can only use one of: --major, --minor, --patch.")
|
|
}
|
|
}
|
|
|
|
if err := internal.PromptBumpType(tagString); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if internal.TagMessage == "" && !internal.NoInput {
|
|
prompt := &survey.Input{
|
|
Message: "tag message",
|
|
Default: "chore: publish new release",
|
|
}
|
|
|
|
if err := survey.AskOne(prompt, &internal.TagMessage); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
var createTagOptions git.CreateTagOptions
|
|
createTagOptions.Message = internal.TagMessage
|
|
|
|
if !internal.Commit && !internal.NoInput {
|
|
prompt := &survey.Confirm{
|
|
Message: "git commit changes also?",
|
|
}
|
|
|
|
if err := survey.AskOne(prompt, &internal.Commit); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if !internal.Push && !internal.NoInput {
|
|
prompt := &survey.Confirm{
|
|
Message: "git push changes also?",
|
|
}
|
|
|
|
if err := survey.AskOne(prompt, &internal.Push); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if internal.Commit || internal.CommitMessage != "" {
|
|
if internal.CommitMessage == "" && !internal.NoInput {
|
|
prompt := &survey.Input{
|
|
Message: "commit message",
|
|
Default: "chore: publish new %s version",
|
|
}
|
|
if err := survey.AskOne(prompt, &internal.CommitMessage); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
if internal.CommitMessage == "" {
|
|
logrus.Fatal("no commit message specified?")
|
|
}
|
|
|
|
if err := gitPkg.Commit("compose.**yml", internal.CommitMessage, internal.Dry, false); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
}
|
|
|
|
repo, err := git.PlainOpen(directory)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
head, err := repo.Head()
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if tagString != "" {
|
|
tag, err := tagcmp.Parse(tagString)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if tag.MissingMinor {
|
|
tag.Minor = "0"
|
|
tag.MissingMinor = false
|
|
}
|
|
|
|
if tag.MissingPatch {
|
|
tag.Patch = "0"
|
|
tag.MissingPatch = false
|
|
}
|
|
|
|
tagString = fmt.Sprintf("%s+%s", tag.String(), mainAppVersion)
|
|
if internal.Dry {
|
|
hash := abraFormatter.SmallSHA(head.Hash().String())
|
|
logrus.Info(fmt.Sprintf("dry run: not creating tag %s at %s", tagString, hash))
|
|
return nil
|
|
}
|
|
|
|
repo.CreateTag(tagString, head.Hash(), &createTagOptions)
|
|
hash := abraFormatter.SmallSHA(head.Hash().String())
|
|
logrus.Info(fmt.Sprintf("created tag %s at %s", tagString, hash))
|
|
if internal.Push && !internal.Dry {
|
|
if err := repo.Push(&git.PushOptions{}); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
logrus.Info(fmt.Sprintf("pushed tag %s to remote", tagString))
|
|
} else {
|
|
logrus.Info("dry run: no changes pushed")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// get the latest tag with its hash, name etc
|
|
var lastGitTag tagcmp.Tag
|
|
iter, err := repo.Tags()
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if err := iter.ForEach(func(ref *plumbing.Reference) error {
|
|
obj, err := repo.TagObject(ref.Hash())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
tagcmpTag, err := tagcmp.Parse(obj.Name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if (lastGitTag == tagcmp.Tag{}) {
|
|
lastGitTag = tagcmpTag
|
|
} else if tagcmpTag.IsGreaterThan(lastGitTag) {
|
|
lastGitTag = tagcmpTag
|
|
}
|
|
|
|
return nil
|
|
}); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
if lastGitTag.String() == "" || lastGitTag.String() == ".." {
|
|
logrus.Warn("no previous git tags found, this is the initial release?")
|
|
}
|
|
|
|
newTag := lastGitTag
|
|
var newtagString string
|
|
if bumpType > 0 {
|
|
if internal.Patch {
|
|
now, err := strconv.Atoi(newTag.Patch)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
newTag.Patch = strconv.Itoa(now + 1)
|
|
} else if internal.Minor {
|
|
now, err := strconv.Atoi(newTag.Minor)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
newTag.Patch = "0"
|
|
newTag.Minor = strconv.Itoa(now + 1)
|
|
} else if internal.Major {
|
|
now, err := strconv.Atoi(newTag.Major)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
newTag.Patch = "0"
|
|
newTag.Minor = "0"
|
|
newTag.Major = strconv.Itoa(now + 1)
|
|
}
|
|
}
|
|
|
|
newTag.Metadata = mainAppVersion
|
|
newtagString = newTag.String()
|
|
if internal.Dry {
|
|
hash := abraFormatter.SmallSHA(head.Hash().String())
|
|
logrus.Info(fmt.Sprintf("dry run: not creating tag %s at %s", newtagString, hash))
|
|
return nil
|
|
}
|
|
|
|
repo.CreateTag(newtagString, head.Hash(), &createTagOptions)
|
|
hash := abraFormatter.SmallSHA(head.Hash().String())
|
|
logrus.Info(fmt.Sprintf("created tag %s at %s", newtagString, hash))
|
|
if internal.Push && !internal.Dry {
|
|
if err := repo.Push(&git.PushOptions{}); err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
logrus.Info(fmt.Sprintf("pushed tag %s to remote", newtagString))
|
|
} else {
|
|
logrus.Info("dry run: no changes pushed")
|
|
}
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
// getImageVersions retrieves image versions for a recipe
|
|
func getImageVersions(recipe recipe.Recipe) (map[string]string, error) {
|
|
var services = make(map[string]string)
|
|
|
|
for _, service := range recipe.Config.Services {
|
|
if service.Image == "" {
|
|
continue
|
|
}
|
|
|
|
img, err := reference.ParseNormalizedNamed(service.Image)
|
|
if err != nil {
|
|
return services, err
|
|
}
|
|
|
|
path := reference.Path(img)
|
|
if strings.Contains(path, "library") {
|
|
path = strings.Split(path, "/")[1]
|
|
}
|
|
|
|
var tag string
|
|
switch img.(type) {
|
|
case reference.NamedTagged:
|
|
tag = img.(reference.NamedTagged).Tag()
|
|
case reference.Named:
|
|
return services, fmt.Errorf("%s service is missing image tag?", path)
|
|
}
|
|
|
|
services[path] = tag
|
|
}
|
|
|
|
return services, nil
|
|
}
|
|
|
|
// btoi converts a boolean value into an integer
|
|
func btoi(b bool) int {
|
|
if b {
|
|
return 1
|
|
}
|
|
|
|
return 0
|
|
}
|