github.com/argoproj/argo-cd/v3@v3.2.1/hack/gen-resources/cmd/commands/cmd.go (about)

     1  package commands
     2  
     3  import (
     4  	"context"
     5  	"log"
     6  
     7  	"github.com/spf13/cobra"
     8  
     9  	generator "github.com/argoproj/argo-cd/v3/hack/gen-resources/generators"
    10  	"github.com/argoproj/argo-cd/v3/util/db"
    11  	"github.com/argoproj/argo-cd/v3/util/settings"
    12  
    13  	cmdutil "github.com/argoproj/argo-cd/v3/cmd/util"
    14  	"github.com/argoproj/argo-cd/v3/hack/gen-resources/util"
    15  	"github.com/argoproj/argo-cd/v3/util/cli"
    16  )
    17  
    18  const (
    19  	cliName = "argocd-generator"
    20  )
    21  
    22  func init() {
    23  	cobra.OnInitialize(initConfig)
    24  }
    25  
    26  func initConfig() {
    27  	cli.SetLogFormat(cmdutil.LogFormat)
    28  	cli.SetLogLevel(cmdutil.LogLevel)
    29  }
    30  
    31  // NewCommand returns a new instance of an argocd command
    32  func NewCommand() *cobra.Command {
    33  	var generateOpts util.GenerateOpts
    34  
    35  	command := &cobra.Command{
    36  		Use:   cliName,
    37  		Short: "Generator for argocd resources",
    38  		Run: func(c *cobra.Command, args []string) {
    39  			c.HelpFunc()(c, args)
    40  		},
    41  		DisableAutoGenTag: true,
    42  	}
    43  
    44  	command.AddCommand(NewGenerateCommand(&generateOpts))
    45  	command.AddCommand(NewCleanCommand(&generateOpts))
    46  
    47  	return command
    48  }
    49  
    50  func NewGenerateCommand(opts *util.GenerateOpts) *cobra.Command {
    51  	var file string
    52  	command := &cobra.Command{
    53  		Use:   "generate [-f file]",
    54  		Short: "Generate entities",
    55  		Long:  "Generate entities",
    56  		Run: func(_ *cobra.Command, _ []string) {
    57  			log.Printf("Retrieve configuration from %s", file)
    58  			err := util.Parse(opts, file)
    59  			if err != nil {
    60  				log.Fatalf("Failed to retrieve configuration, %v", err.Error())
    61  			}
    62  			argoClientSet := util.ConnectToK8sArgoClientSet()
    63  			clientSet := util.ConnectToK8sClientSet()
    64  
    65  			settingsMgr := settings.NewSettingsManager(context.TODO(), clientSet, opts.Namespace)
    66  			argoDB := db.NewDB(opts.Namespace, settingsMgr, clientSet)
    67  
    68  			pg := generator.NewProjectGenerator(argoClientSet)
    69  			ag := generator.NewApplicationGenerator(argoClientSet, clientSet)
    70  			rg := generator.NewRepoGenerator(util.ConnectToK8sClientSet())
    71  			cg := generator.NewClusterGenerator(argoDB, util.ConnectToK8sClientSet(), util.ConnectToK8sConfig())
    72  
    73  			err = pg.Generate(opts)
    74  			if err != nil {
    75  				log.Fatalf("Failed to generate projects, %v", err.Error())
    76  			}
    77  			err = rg.Generate(opts)
    78  			if err != nil {
    79  				log.Fatalf("Failed to generate repositories, %v", err.Error())
    80  			}
    81  			err = cg.Generate(opts)
    82  			if err != nil {
    83  				log.Fatalf("Failed to generate clusters, %v", err.Error())
    84  			}
    85  			err = ag.Generate(opts)
    86  			if err != nil {
    87  				log.Fatalf("Failed to generate applications, %v", err.Error())
    88  			}
    89  		},
    90  	}
    91  	command.Flags().StringVarP(&file, "file", "f", "", "")
    92  	return command
    93  }
    94  
    95  func NewCleanCommand(opts *util.GenerateOpts) *cobra.Command {
    96  	command := &cobra.Command{
    97  		Use:   "clean",
    98  		Short: "Clean entities",
    99  		Long:  "Clean entities",
   100  		Run: func(_ *cobra.Command, _ []string) {
   101  			argoClientSet := util.ConnectToK8sArgoClientSet()
   102  			clientSet := util.ConnectToK8sClientSet()
   103  			settingsMgr := settings.NewSettingsManager(context.TODO(), clientSet, opts.Namespace)
   104  			argoDB := db.NewDB(opts.Namespace, settingsMgr, clientSet)
   105  
   106  			pg := generator.NewProjectGenerator(argoClientSet)
   107  			ag := generator.NewApplicationGenerator(argoClientSet, clientSet)
   108  			cg := generator.NewClusterGenerator(argoDB, clientSet, util.ConnectToK8sConfig())
   109  			rg := generator.NewRepoGenerator(clientSet)
   110  
   111  			err := pg.Clean(opts)
   112  			if err != nil {
   113  				log.Fatalf("Failed to clean projects, %v", err.Error())
   114  			}
   115  			err = ag.Clean(opts)
   116  			if err != nil {
   117  				log.Fatalf("Failed to clean applications, %v", err.Error())
   118  			}
   119  			err = cg.Clean(opts)
   120  			if err != nil {
   121  				log.Fatalf("Failed to clean clusters, %v", err.Error())
   122  			}
   123  			err = rg.Clean(opts)
   124  			if err != nil {
   125  				log.Fatalf("Failed to clean repositores, %v", err.Error())
   126  			}
   127  		},
   128  	}
   129  	command.PersistentFlags().StringVar(&opts.Namespace, "kube-namespace", "argocd", "Name of the namespace where argocd is running [$KUBE_NAMESPACE]")
   130  	return command
   131  }