deploy/cmd/argocd/commands/applicationset.go

package commands

import (
	"context"
	"fmt"
	"io"
	"os"
	"reflect"
	"text/tabwriter"

	k8swatch "k8s.io/apimachinery/pkg/watch"

	"github.com/mattn/go-isatty"
	"github.com/spf13/cobra"
	"google.golang.org/grpc/codes"

	"github.com/hanzoai/deploy/cmd/argocd/commands/admin"
	"github.com/hanzoai/deploy/cmd/argocd/commands/headless"
	"github.com/hanzoai/deploy/cmd/argocd/commands/utils"
	cmdutil "github.com/hanzoai/deploy/cmd/util"
	argocdclient "github.com/hanzoai/deploy/pkg/apiclient"
	"github.com/hanzoai/deploy/pkg/apiclient/applicationset"
	arogappsetv1 "github.com/hanzoai/deploy/pkg/apis/application/v1alpha1"
	"github.com/hanzoai/deploy/util/argo"
	"github.com/hanzoai/deploy/util/errors"
	"github.com/hanzoai/deploy/util/grpc"
	utilio "github.com/hanzoai/deploy/util/io"
	"github.com/hanzoai/deploy/util/templates"
)

var appSetExample = templates.Examples(`
	# Get an ApplicationSet.
	argocd appset get APPSETNAME

	# List all the ApplicationSets
	argocd appset list

	# Create an ApplicationSet from a YAML stored in a file or at given URL
	argocd appset create <filename or URL> (<filename or URL>...)

	# Delete an ApplicationSet
	argocd appset delete APPSETNAME (APPSETNAME...)

	# Namespace precedence for --appset-namespace (-N):
	# - get/delete: if the argument is namespace/name, that namespace wins; -N is ignored.
	# - create/generate: metadata.namespace in the YAML wins when set; -N applies only when the manifest omits namespace.
	`)

// NewAppSetCommand returns a new instance of an `argocd appset` command
func NewAppSetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
	command := &cobra.Command{
		Use:     "appset",
		Short:   "Manage ApplicationSets",
		Example: appSetExample,
		Run: func(c *cobra.Command, args []string) {
			c.HelpFunc()(c, args)
			os.Exit(1)
		},
	}
	command.AddCommand(NewApplicationSetGetCommand(clientOpts))
	command.AddCommand(NewApplicationSetCreateCommand(clientOpts))
	command.AddCommand(NewApplicationSetListCommand(clientOpts))
	command.AddCommand(NewApplicationSetDeleteCommand(clientOpts))
	command.AddCommand(NewApplicationSetGenerateCommand(clientOpts))
	return command
}

// NewApplicationSetGetCommand returns a new instance of an `argocd appset get` command
func NewApplicationSetGetCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
	var (
		output          string
		showParams      bool
		appSetNamespace string
	)
	command := &cobra.Command{
		Use:   "get APPSETNAME",
		Short: "Get ApplicationSet details",
		Example: templates.Examples(`
	# Get ApplicationSets
	argocd appset get APPSETNAME

	# Get ApplicationSet in a specific namespace using qualified name (namespace/name)
	argocd appset get APPSET_NAMESPACE/APPSETNAME

	# Get ApplicationSet in a specific namespace using --appset-namespace flag
	argocd appset get --appset-namespace=APPSET_NAMESPACE APPSETNAME

		`),
		Run: func(c *cobra.Command, args []string) {
			ctx := c.Context()

			if len(args) == 0 {
				c.HelpFunc()(c, args)
				os.Exit(1)
			}
			acdClient := headless.NewClientOrDie(clientOpts, c)
			conn, appIf := acdClient.NewApplicationSetClientOrDie()
			defer utilio.Close(conn)

			appSetName, appSetNs := argo.ParseFromQualifiedName(args[0], appSetNamespace)

			appSet, err := appIf.Get(ctx, &applicationset.ApplicationSetGetQuery{Name: appSetName, AppsetNamespace: appSetNs})
			errors.CheckError(err)

			switch output {
			case "yaml", "json":
				err := PrintResource(appSet, output)
				errors.CheckError(err)
			case "wide", "":
				printAppSetSummaryTable(appSet)
				if len(appSet.Status.Conditions) > 0 {
					fmt.Println()
					w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
					printAppSetConditions(w, appSet)
					_ = w.Flush()
					fmt.Println()
				}
				if showParams {
					printHelmParams(appSet.Spec.Template.Spec.GetSource().Helm)
				}
			default:
				errors.CheckError(fmt.Errorf("unknown output format: %s", output))
			}
		},
	}
	command.Flags().StringVarP(&output, "output", "o", "wide", "Output format. One of: json|yaml|wide")
	command.Flags().BoolVar(&showParams, "show-params", false, "Show ApplicationSet parameters and overrides")
	command.Flags().StringVarP(&appSetNamespace, "appset-namespace", "N", "", "Only get ApplicationSet from a namespace (ignored when qualified name is provided)")
	return command
}

// NewApplicationSetCreateCommand returns a new instance of an `argocd appset create` command
func NewApplicationSetCreateCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
	var (
		output               string
		upsert, dryRun, wait bool
		appSetNamespace      string
	)
	command := &cobra.Command{
		Use:   "create",
		Short: "Create one or more ApplicationSets",
		Example: templates.Examples(`
	# Create ApplicationSets
	argocd appset create <filename or URL> (<filename or URL>...)

	# Create ApplicationSet in a specific namespace using
	argocd appset create --appset-namespace=APPSET_NAMESPACE <filename or URL> (<filename or URL>...)

	# Dry-run AppSet creation to see what applications would be managed
	argocd appset create --dry-run <filename or URL> -o json | jq -r '.status.resources[].name' 
		`),
		Run: func(c *cobra.Command, args []string) {
			ctx := c.Context()

			if len(args) == 0 {
				c.HelpFunc()(c, args)
				os.Exit(1)
			}
			argocdClient := headless.NewClientOrDie(clientOpts, c)
			fileURL := args[0]
			appsets, err := cmdutil.ConstructApplicationSet(fileURL)
			errors.CheckError(err)

			if len(appsets) == 0 {
				fmt.Print("No ApplicationSets found while parsing the input file")
				os.Exit(1)
			}

			for _, appset := range appsets {
				if appset.Name == "" {
					errors.Fatal(errors.ErrorGeneric, fmt.Sprintf("Error creating ApplicationSet %s. ApplicationSet does not have Name field set", appset))
				}

				conn, appIf := argocdClient.NewApplicationSetClientOrDie()
				defer utilio.Close(conn)

				if appset.Namespace == "" && appSetNamespace != "" {
					fmt.Printf("ApplicationSet YAML file does not have namespace; using --appset-namespace=%q.\n", appSetNamespace)
					appset.Namespace = appSetNamespace
				}

				// Get app before creating to see if it is being updated or no change
				existing, err := appIf.Get(ctx, &applicationset.ApplicationSetGetQuery{Name: appset.Name, AppsetNamespace: appset.Namespace})
				if grpc.UnwrapGRPCStatus(err).Code() != codes.NotFound {
					errors.CheckError(err)
				}

				appSetCreateRequest := applicationset.ApplicationSetCreateRequest{
					Applicationset: appset,
					Upsert:         upsert,
					DryRun:         dryRun,
				}
				created, err := appIf.Create(ctx, &appSetCreateRequest)
				errors.CheckError(err)

				dryRunMsg := ""
				if dryRun {
					dryRunMsg = " (dry-run)"
				}

				var action string
				switch {
				case existing == nil:
					action = "created"
				case !hasAppSetChanged(existing, created, upsert):
					action = "unchanged"
				default:
					action = "updated"
				}

				c.PrintErrf("ApplicationSet '%s' %s%s\n", created.Name, action, dryRunMsg)

				switch output {
				case "yaml", "json":
					err := PrintResource(created, output)
					errors.CheckError(err)
				case "wide", "":
					printAppSetSummaryTable(created)

					if len(created.Status.Conditions) > 0 {
						fmt.Println()
						w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
						printAppSetConditions(w, created)
						_ = w.Flush()
						fmt.Println()
					}
				default:
					errors.CheckError(fmt.Errorf("unknown output format: %s", output))
				}

				if wait && !dryRun {
					err := waitForApplicationSetResourcesUpToDate(ctx, argocdClient, created.QualifiedName())
					errors.CheckError(err)
					c.PrintErrf("ApplicationSet '%s' resources are up to date\n", created.Name)
				}
			}
		},
	}
	command.Flags().BoolVar(&upsert, "upsert", false, "Allows to override ApplicationSet with the same name even if supplied ApplicationSet spec is different from existing spec")
	command.Flags().BoolVar(&dryRun, "dry-run", false, "Allows to evaluate the ApplicationSet template on the server to get a preview of the applications that would be created")
	command.Flags().BoolVar(&wait, "wait", false, "Wait until the ApplicationSet's resources are up to date. Will block indefinitely if the ApplicationSet has errors")
	command.Flags().StringVarP(&output, "output", "o", "wide", "Output format. One of: json|yaml|wide")
	command.Flags().StringVarP(&appSetNamespace, "appset-namespace", "N", "", "Namespace where the ApplicationSet will be created in (ignored when provided YAML file has namespace set in metadata)")
	return command
}

// NewApplicationSetGenerateCommand returns a new instance of an `argocd appset generate` command
func NewApplicationSetGenerateCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
	var output string
	var appSetNamespace string
	command := &cobra.Command{
		Use:   "generate",
		Short: "Generate apps of ApplicationSet rendered templates",
		Example: templates.Examples(`
	# Generate apps of ApplicationSet rendered templates
	argocd appset generate <filename or URL> (<filename or URL>...)

	# Generate apps of ApplicationSet rendered templates in a specific namespace
	argocd appset generate --appset-namespace=APPSET_NAMESPACE <filename or URL> (<filename or URL>...)
`),
		Run: func(c *cobra.Command, args []string) {
			ctx := c.Context()

			if len(args) == 0 {
				c.HelpFunc()(c, args)
				os.Exit(1)
			}
			argocdClient := headless.NewClientOrDie(clientOpts, c)
			fileURL := args[0]
			appsets, err := cmdutil.ConstructApplicationSet(fileURL)
			errors.CheckError(err)

			if len(appsets) != 1 {
				fmt.Print("Input file must contain one ApplicationSet")
				os.Exit(1)
			}
			appset := appsets[0]
			if appset.Name == "" {
				errors.Fatal(errors.ErrorGeneric, fmt.Sprintf("Error generating apps for ApplicationSet %s. ApplicationSet does not have Name field set", appset))
			}

			if appset.Namespace == "" && appSetNamespace != "" {
				fmt.Printf("ApplicationSet YAML file does not have namespace; using --appset-namespace=%q.\n", appSetNamespace)
				appset.Namespace = appSetNamespace
			}

			conn, appIf := argocdClient.NewApplicationSetClientOrDie()
			defer utilio.Close(conn)

			req := applicationset.ApplicationSetGenerateRequest{
				ApplicationSet: appset,
			}
			resp, err := appIf.Generate(ctx, &req)
			errors.CheckError(err)

			var appsList []arogappsetv1.Application
			for i := range resp.Applications {
				appsList = append(appsList, *resp.Applications[i])
			}

			switch output {
			case "yaml", "json":
				var resources []any
				for i := range appsList {
					app := appsList[i]
					// backfill api version and kind because k8s client always return empty values for these fields
					app.APIVersion = arogappsetv1.ApplicationSchemaGroupVersionKind.GroupVersion().String()
					app.Kind = arogappsetv1.ApplicationSchemaGroupVersionKind.Kind
					resources = append(resources, app)
				}

				cobra.CheckErr(admin.PrintResources(output, os.Stdout, resources...))
			case "wide", "":
				printApplicationTable(appsList, &output)
			default:
				errors.CheckError(fmt.Errorf("unknown output format: %s", output))
			}
		},
	}
	command.Flags().StringVarP(&output, "output", "o", "wide", "Output format. One of: json|yaml|wide")
	command.Flags().StringVarP(&appSetNamespace, "appset-namespace", "N", "", "Namespace used for generating Applications (ignored when provided YAML file has namespace set in metadata)")
	return command
}

// NewApplicationSetListCommand returns a new instance of an `argocd appset list` command
func NewApplicationSetListCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
	var (
		output          string
		selector        string
		projects        []string
		appSetNamespace string
	)
	command := &cobra.Command{
		Use:   "list",
		Short: "List ApplicationSets",
		Example: templates.Examples(`
	# List all ApplicationSets
	argocd appset list
		`),
		Run: func(c *cobra.Command, _ []string) {
			ctx := c.Context()

			conn, appIf := headless.NewClientOrDie(clientOpts, c).NewApplicationSetClientOrDie()
			defer utilio.Close(conn)
			appsets, err := appIf.List(ctx, &applicationset.ApplicationSetListQuery{Selector: selector, Projects: projects, AppsetNamespace: appSetNamespace})
			errors.CheckError(err)

			appsetList := appsets.Items

			switch output {
			case "yaml", "json":
				err := PrintResourceList(appsetList, output, false)
				errors.CheckError(err)
			case "name":
				printApplicationSetNames(appsetList)
			case "wide", "":
				printApplicationSetTable(appsetList, &output)
			default:
				errors.CheckError(fmt.Errorf("unknown output format: %s", output))
			}
		},
	}
	command.Flags().StringVarP(&output, "output", "o", "wide", "Output format. One of: wide|name|json|yaml")
	command.Flags().StringVarP(&selector, "selector", "l", "", "List applicationsets by label")
	command.Flags().StringArrayVarP(&projects, "project", "p", []string{}, "Filter by project name")
	command.Flags().StringVarP(&appSetNamespace, "appset-namespace", "N", "", "Only list applicationsets in namespace")

	return command
}

// NewApplicationSetDeleteCommand returns a new instance of an `argocd appset delete` command
func NewApplicationSetDeleteCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command {
	var (
		noPrompt        bool
		wait            bool
		appSetNamespace string
	)
	command := &cobra.Command{
		Use:   "delete",
		Short: "Delete one or more ApplicationSets",
		Example: templates.Examples(`
	# Delete an applicationset
	argocd appset delete APPSETNAME (APPSETNAME...)

	# Delete ApplicationSet in a specific namespace using qualified name (namespace/name)
	argocd appset delete APPSET_NAMESPACE/APPSETNAME

	# Delete ApplicationSet in a specific namespace using --appset-namespace flag
	argocd appset delete --appset-namespace=APPSET_NAMESPACE APPSETNAME
		`),
		Run: func(c *cobra.Command, args []string) {
			ctx := c.Context()

			if len(args) == 0 {
				c.HelpFunc()(c, args)
				os.Exit(1)
			}
			acdClient := headless.NewClientOrDie(clientOpts, c)
			conn, appIf := acdClient.NewApplicationSetClientOrDie()
			defer utilio.Close(conn)
			isTerminal := isatty.IsTerminal(os.Stdout.Fd()) || isatty.IsCygwinTerminal(os.Stdout.Fd())
			numOfApps := len(args)
			promptFlag := c.Flag("yes")
			if promptFlag.Changed && promptFlag.Value.String() == "true" {
				noPrompt = true
			}

			var (
				confirmAll = false
				confirm    = false
			)

			// This is for backward compatibility,
			// before we showed the prompts only when condition isTerminal && !noPrompt is true
			promptUtil := utils.NewPrompt(isTerminal && !noPrompt)

			for _, appSetQualifiedName := range args {
				appSetName, appSetNs := argo.ParseFromQualifiedName(appSetQualifiedName, appSetNamespace)

				appsetDeleteReq := applicationset.ApplicationSetDeleteRequest{
					Name:            appSetName,
					AppsetNamespace: appSetNs,
				}
				messageForSingle := "Are you sure you want to delete '" + appSetQualifiedName + "' and all its Applications? [y/n] "
				messageForAll := "Are you sure you want to delete '" + appSetQualifiedName + "' and all its Applications? [y/n/a] where 'a' is to delete all specified ApplicationSets and their Applications without prompting"
				if !confirmAll {
					confirm, confirmAll = promptUtil.ConfirmBaseOnCount(messageForSingle, messageForAll, numOfApps)
				}
				if confirm || confirmAll {
					_, err := appIf.Delete(ctx, &appsetDeleteReq)
					errors.CheckError(err)

					if wait {
						_, getErr := appIf.Get(ctx, &applicationset.ApplicationSetGetQuery{
							Name: appSetName, AppsetNamespace: appSetNs,
						})
						if getErr == nil {
							appEventCh := acdClient.WatchApplicationSetWithRetry(ctx, appSetQualifiedName, "")
							for appEvent := range appEventCh {
								if appEvent != nil && appEvent.Type == k8swatch.Deleted {
									break
								}
							}
						}
					}
					fmt.Printf("applicationset '%s' deleted\n", appSetQualifiedName)
				} else {
					fmt.Println("The command to delete '" + appSetQualifiedName + "' was cancelled.")
				}
			}
		},
	}
	command.Flags().BoolVarP(&noPrompt, "yes", "y", false, "Turn off prompting to confirm cascaded deletion of Application resources")
	command.Flags().BoolVar(&wait, "wait", false, "Wait until deletion of the applicationset(s) completes")
	command.Flags().StringVarP(&appSetNamespace, "appset-namespace", "N", "", "Namespace where the ApplicationSet will be deleted from (ignored when qualified name is provided)")
	return command
}

// Print simple list of application names
func printApplicationSetNames(apps []arogappsetv1.ApplicationSet) {
	for _, app := range apps {
		fmt.Println(app.QualifiedName())
	}
}

// Print table of application data
func printApplicationSetTable(apps []arogappsetv1.ApplicationSet, output *string) {
	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
	var fmtStr string
	headers := []any{"NAME", "PROJECT", "SYNCPOLICY", "HEALTH", "CONDITIONS"}
	if *output == "wide" {
		fmtStr = "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"
		headers = append(headers, "REPO", "PATH", "TARGET")
	} else {
		fmtStr = "%s\t%s\t%s\t%s\t%s\n"
	}
	_, _ = fmt.Fprintf(w, fmtStr, headers...)
	for _, app := range apps {
		conditions := make([]arogappsetv1.ApplicationSetCondition, 0)
		for _, condition := range app.Status.Conditions {
			if condition.Status == arogappsetv1.ApplicationSetConditionStatusTrue {
				conditions = append(conditions, condition)
			}
		}
		vals := []any{
			app.QualifiedName(),
			app.Spec.Template.Spec.Project,
			app.Spec.SyncPolicy,
			app.Status.Health.Status,
			conditions,
		}
		if *output == "wide" {
			vals = append(vals, app.Spec.Template.Spec.GetSource().RepoURL, app.Spec.Template.Spec.GetSource().Path, app.Spec.Template.Spec.GetSource().TargetRevision)
		}
		_, _ = fmt.Fprintf(w, fmtStr, vals...)
	}
	_ = w.Flush()
}

func getServerForAppSet(appSet *arogappsetv1.ApplicationSet) string {
	if appSet.Spec.Template.Spec.Destination.Server == "" {
		return appSet.Spec.Template.Spec.Destination.Name
	}

	return appSet.Spec.Template.Spec.Destination.Server
}

func printAppSetSummaryTable(appSet *arogappsetv1.ApplicationSet) {
	fmt.Printf(printOpFmtStr, "Name:", appSet.QualifiedName())
	fmt.Printf(printOpFmtStr, "Project:", appSet.Spec.Template.Spec.GetProject())
	fmt.Printf(printOpFmtStr, "Server:", getServerForAppSet(appSet))
	fmt.Printf(printOpFmtStr, "Namespace:", appSet.Spec.Template.Spec.Destination.Namespace)
	fmt.Printf(printOpFmtStr, "Health Status:", appSet.Status.Health.Status)
	if !appSet.Spec.Template.Spec.HasMultipleSources() {
		fmt.Println("Source:")
	} else {
		fmt.Println("Sources:")
	}

	// if no source has been defined, print the default value for a source
	if len(appSet.Spec.Template.Spec.GetSources()) == 0 {
		src := appSet.Spec.Template.Spec.GetSource()
		printAppSourceDetails(&src)
	} else {
		// otherwise range over the sources and print each source details
		for _, source := range appSet.Spec.Template.Spec.GetSources() {
			printAppSourceDetails(&source)
		}
	}

	var (
		syncPolicyStr string
		syncPolicy    = appSet.Spec.Template.Spec.SyncPolicy
	)
	if syncPolicy != nil && syncPolicy.IsAutomatedSyncEnabled() {
		syncPolicyStr = "Automated"
		if syncPolicy.Automated.GetPrune() {
			syncPolicyStr += " (Prune)"
		}
	} else {
		syncPolicyStr = "<none>"
	}
	fmt.Printf(printOpFmtStr, "SyncPolicy:", syncPolicyStr)
}

func printAppSetConditions(w io.Writer, appSet *arogappsetv1.ApplicationSet) {
	_, _ = fmt.Fprint(w, "CONDITION\tSTATUS\tMESSAGE\tLAST TRANSITION\n")
	for _, item := range appSet.Status.Conditions {
		_, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", item.Type, item.Status, item.Message, item.LastTransitionTime)
	}
}

func isApplicationSetResourcesUpToDate(appSet *arogappsetv1.ApplicationSet) bool {
	for _, c := range appSet.Status.Conditions {
		if c.Type == arogappsetv1.ApplicationSetConditionResourcesUpToDate {
			return c.Status == arogappsetv1.ApplicationSetConditionStatusTrue
		}
	}
	return false
}

func waitForApplicationSetResourcesUpToDate(ctx context.Context, acdClient argocdclient.Client, appSetName string) error {
	appEventCh := acdClient.WatchApplicationSetWithRetry(ctx, appSetName, "")
	for appEvent := range appEventCh {
		if appEvent == nil {
			continue
		}
		if appEvent.Type == k8swatch.Deleted {
			return fmt.Errorf("ApplicationSet %q was deleted before reaching ResourcesUpToDate", appSetName)
		}
		if isApplicationSetResourcesUpToDate(&appEvent.ApplicationSet) {
			return nil
		}
	}
	return fmt.Errorf("watch stream closed for ApplicationSet %q before reaching ResourcesUpToDate", appSetName)
}

func hasAppSetChanged(appReq, appRes *arogappsetv1.ApplicationSet, upsert bool) bool {
	// upsert==false, no change occurred from create command
	if !upsert {
		return false
	}

	// Server will return nils for empty labels, annotations, finalizers
	if len(appReq.Labels) == 0 {
		appReq.Labels = nil
	}
	if len(appReq.Annotations) == 0 {
		appReq.Annotations = nil
	}
	if len(appReq.Finalizers) == 0 {
		appReq.Finalizers = nil
	}

	if reflect.DeepEqual(appRes.Spec, appReq.Spec) &&
		reflect.DeepEqual(appRes.Labels, appReq.Labels) &&
		reflect.DeepEqual(appRes.Annotations, appReq.Annotations) &&
		reflect.DeepEqual(appRes.Finalizers, appReq.Finalizers) {
		return false
	}

	return true
}