github.com/argoproj/argo-cd/v2@v2.10.9/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/v2/hack/gen-resources/generators"
    10  	"github.com/argoproj/argo-cd/v2/util/db"
    11  	"github.com/argoproj/argo-cd/v2/util/settings"
    12  
    13  	cmdutil "github.com/argoproj/argo-cd/v2/cmd/util"
    14  	"github.com/argoproj/argo-cd/v2/hack/gen-resources/util"
    15  	"github.com/argoproj/argo-cd/v2/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  
    34  	var generateOpts util.GenerateOpts
    35  
    36  	var command = &cobra.Command{
    37  		Use:   cliName,
    38  		Short: "Generator for argocd resources",
    39  		Run: func(c *cobra.Command, args []string) {
    40  			c.HelpFunc()(c, args)
    41  		},
    42  		DisableAutoGenTag: true,
    43  	}
    44  
    45  	command.AddCommand(NewGenerateCommand(&generateOpts))
    46  	command.AddCommand(NewCleanCommand(&generateOpts))
    47  
    48  	return command
    49  }
    50  
    51  func NewGenerateCommand(opts *util.GenerateOpts) *cobra.Command {
    52  	var file string
    53  	var command = &cobra.Command{
    54  		Use:   "generate [-f file]",
    55  		Short: "Generate entities",
    56  		Long:  "Generate entities",
    57  		Run: func(c *cobra.Command, args []string) {
    58  			log.Printf("Retrieve configuration from %s", file)
    59  			err := util.Parse(opts, file)
    60  			if err != nil {
    61  				log.Fatalf("Failed to retrieve configuration, %v", err.Error())
    62  			}
    63  			argoClientSet := util.ConnectToK8sArgoClientSet()
    64  			clientSet := util.ConnectToK8sClientSet()
    65  
    66  			settingsMgr := settings.NewSettingsManager(context.TODO(), clientSet, opts.Namespace)
    67  			argoDB := db.NewDB(opts.Namespace, settingsMgr, clientSet)
    68  
    69  			pg := generator.NewProjectGenerator(argoClientSet)
    70  			ag := generator.NewApplicationGenerator(argoClientSet, clientSet, argoDB)
    71  			rg := generator.NewRepoGenerator(util.ConnectToK8sClientSet())
    72  			cg := generator.NewClusterGenerator(argoDB, util.ConnectToK8sClientSet(), util.ConnectToK8sConfig())
    73  
    74  			err = pg.Generate(opts)
    75  			if err != nil {
    76  				log.Fatalf("Failed to generate projects, %v", err.Error())
    77  			}
    78  			err = rg.Generate(opts)
    79  			if err != nil {
    80  				log.Fatalf("Failed to generate repositories, %v", err.Error())
    81  			}
    82  			err = cg.Generate(opts)
    83  			if err != nil {
    84  				log.Fatalf("Failed to generate clusters, %v", err.Error())
    85  			}
    86  			err = ag.Generate(opts)
    87  			if err != nil {
    88  				log.Fatalf("Failed to generate applications, %v", err.Error())
    89  			}
    90  		},
    91  	}
    92  	command.Flags().StringVarP(&file, "file", "f", "", "")
    93  	return command
    94  }
    95  
    96  func NewCleanCommand(opts *util.GenerateOpts) *cobra.Command {
    97  	var command = &cobra.Command{
    98  		Use:   "clean",
    99  		Short: "Clean entities",
   100  		Long:  "Clean entities",
   101  		Run: func(c *cobra.Command, args []string) {
   102  			argoClientSet := util.ConnectToK8sArgoClientSet()
   103  			clientSet := util.ConnectToK8sClientSet()
   104  			settingsMgr := settings.NewSettingsManager(context.TODO(), clientSet, opts.Namespace)
   105  			argoDB := db.NewDB(opts.Namespace, settingsMgr, clientSet)
   106  
   107  			pg := generator.NewProjectGenerator(argoClientSet)
   108  			ag := generator.NewApplicationGenerator(argoClientSet, clientSet, argoDB)
   109  			cg := generator.NewClusterGenerator(argoDB, clientSet, util.ConnectToK8sConfig())
   110  			rg := generator.NewRepoGenerator(clientSet)
   111  
   112  			err := pg.Clean(opts)
   113  			if err != nil {
   114  				log.Fatalf("Failed to clean projects, %v", err.Error())
   115  			}
   116  			err = ag.Clean(opts)
   117  			if err != nil {
   118  				log.Fatalf("Failed to clean applications, %v", err.Error())
   119  			}
   120  			err = cg.Clean(opts)
   121  			if err != nil {
   122  				log.Fatalf("Failed to clean clusters, %v", err.Error())
   123  			}
   124  			err = rg.Clean(opts)
   125  			if err != nil {
   126  				log.Fatalf("Failed to clean repositores, %v", err.Error())
   127  			}
   128  		},
   129  	}
   130  	command.PersistentFlags().StringVar(&opts.Namespace, "kube-namespace", "argocd", "Name of the namespace where argocd is running [$KUBE_NAMESPACE]")
   131  	return command
   132  }