abra/cli/recipe/version.go

package recipe

import (
	"fmt"
	"sort"
	"strings"

	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/formatter"
	"coopcloud.tech/abra/pkg/i18n"
	"coopcloud.tech/abra/pkg/log"
	recipePkg "coopcloud.tech/abra/pkg/recipe"
	"github.com/spf13/cobra"
)

// translators: `abra recipe versions` aliases. use a comma separated list of aliases
// with no spaces in between
var recipeVersionsAliases = i18n.G("v")

var RecipeVersionCommand = &cobra.Command{
	// translators: `recipe versions` command
	Use:     i18n.G("versions <recipe> [flags]"),
	Aliases: strings.Split(recipeVersionsAliases, ","),
	// translators: Short description for `recipe versions` command
	Short: i18n.G("List recipe versions"),
	Args:  cobra.ExactArgs(1),
	ValidArgsFunction: func(
		cmd *cobra.Command,
		args []string,
		toComplete string) ([]string, cobra.ShellCompDirective) {
		return autocomplete.RecipeNameComplete()
	},
	Run: func(cmd *cobra.Command, args []string) {
		var warnMessages []string

		recipe := internal.ValidateRecipe(args, cmd.Name())

		catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline)
		if err != nil {
			log.Fatal(err)
		}

		recipeMeta, ok := catl[recipe.Name]
		if !ok {
			warnMessages = append(warnMessages, i18n.G("retrieved versions from local recipe repository"))

			recipeVersions, warnMsg, err := recipe.GetRecipeVersions()
			if err != nil {
				warnMessages = append(warnMessages, err.Error())
			}
			if len(warnMsg) > 0 {
				warnMessages = append(warnMessages, warnMsg...)
			}

			recipeMeta = recipePkg.RecipeMeta{Versions: recipeVersions}
		}

		if len(recipeMeta.Versions) == 0 {
			log.Fatal(i18n.G("%s has no published versions?", recipe.Name))
		}

		for i := len(recipeMeta.Versions) - 1; i >= 0; i-- {
			table, err := formatter.CreateTable()
			if err != nil {
				log.Fatal(err)
			}

			table.Headers(i18n.G("SERVICE"), i18n.G("IMAGE"), i18n.G("TAG"), i18n.G("VERSION"))

			for version, meta := range recipeMeta.Versions[i] {
				var allRows [][]string
				var rows [][]string

				for service, serviceMeta := range meta {
					recipeVersion := version
					if service != "app" {
						recipeVersion = ""
					}

					rows = append(rows, []string{
						service,
						serviceMeta.Image,
						serviceMeta.Tag,
						recipeVersion,
					})

					allRows = append(allRows, []string{
						version,
						service,
						serviceMeta.Image,
						serviceMeta.Tag,
						recipeVersion,
					})
				}

				sort.Slice(rows, sortServiceByName(rows))

				table.Rows(rows...)

				if !internal.MachineReadable {
					if err := formatter.PrintTable(table); err != nil {
						log.Fatal(err)
					}
					continue
				}

				if internal.MachineReadable {
					sort.Slice(allRows, sortServiceByName(allRows))
					headers := []string{i18n.G("VERSION"), i18n.G("SERVICE"), i18n.G("NAME"), i18n.G("TAG")}
					out, err := formatter.ToJSON(headers, allRows)
					if err != nil {
						log.Fatal(i18n.G("unable to render to JSON: %s", err))
					}
					fmt.Println(out)
					continue
				}
			}
		}

		if !internal.MachineReadable {
			for _, warnMsg := range warnMessages {
				log.Warn(warnMsg)
			}
		}
	},
}

func sortServiceByName(versions [][]string) func(i, j int) bool {
	return func(i, j int) bool {
		return versions[i][0] < versions[j][0]
	}
}

func init() {
	RecipeVersionCommand.Flags().BoolVarP(
		&internal.MachineReadable,
		i18n.G("machine"),
		i18n.G("m"),
		false,
		i18n.G("print machine-readable output"),
	)
}