refactor egbuilder

cmd/builder/command/add.go

@@ -22,12 +22,12 @@ import (
  "fmt"
  "os"
 
- "github.com/megaease/easegress/v2/cmd/builder/generate"
+ "github.com/megaease/easegress/v2/cmd/builder/gen"
  "github.com/megaease/easegress/v2/cmd/builder/utils"
  "github.com/spf13/cobra"
 )
 
-var addFlags = &generate.ObjectConfig{}
+var addConfig = &gen.Config{}
 
 func AddCmd() *cobra.Command {
  cmd := &cobra.Command{
@@ -37,25 +37,25 @@ func AddCmd() *cobra.Command {
  Run: addRun,
  }
 
- cmd.Flags().StringSliceVar(&addFlags.Filters, "filters", []string{}, "filters to be generated")
- cmd.Flags().StringSliceVar(&addFlags.Resources, "resources", []string{}, "resources to be generated")
+ cmd.Flags().StringSliceVar(&addConfig.Filters, "filters", []string{}, "filters to be generated")
+ cmd.Flags().StringSliceVar(&addConfig.Resources, "resources", []string{}, "resources to be generated")
  return cmd
 }
 
 func addArgs(cmd *cobra.Command, args []string) error {
  if len(args) != 0 {
  return errors.New("add takes no arguments")
  }
- if (len(addFlags.Filters) == 0) && (len(addFlags.Resources) == 0) {
+ if (len(addConfig.Filters) == 0) && (len(addConfig.Resources) == 0) {
  return errors.New("filters or resources is required")
  }
 
- for _, filter := range addFlags.Filters {
+ for _, filter := range addConfig.Filters {
  if !(utils.CapitalVariableName(filter)) {
  return fmt.Errorf("filter %s is not a valid golang variable name with first letter upper case", filter)
  }
  }
- for _, resource := range addFlags.Resources {
+ for _, resource := range addConfig.Resources {
  if !(utils.CapitalVariableName(resource)) {
  return fmt.Errorf("resource %s is not a valid golang variable name with first letter upper case", resource)
  }
@@ -66,84 +66,39 @@ func addArgs(cmd *cobra.Command, args []string) error {
 func addRun(cmd *cobra.Command, args []string) {
  cwd, err := os.Getwd()
  if err != nil {
- utils.ExitWithErrorf("get current working directory failed: %s", err.Error())
+ utils.ExitWithError(err)
  }
- config, err := generate.ReadObjectConfigFile(cwd)
+
+ config := &gen.Config{}
+ err = config.Load(cwd)
  if err != nil {
  utils.ExitWithError(err)
  }
- err = addCheckConfig(config)
+ err = config.CheckDuplicate(addConfig)
  if err != nil {
  utils.ExitWithError(err)
  }
 
  // generate filters and resources dir and files.
- err = utils.MakeDirs(cwd, addFlags.Filters, addFlags.Resources)
+ err = addConfig.GenFilters(cwd)
  if err != nil {
  utils.ExitWithError(err)
  }
- for _, f := range addFlags.Filters {
- file := generate.CreateFilter(f)
- err := file.Save(utils.GetFilterFileName(cwd, f))
- if err != nil {
- utils.ExitWithErrorf("add filter %s failed: %s", f, err.Error())
- } else {
- fmt.Printf("add filter %s successfully\n", f)
- }
- }
- for _, r := range addFlags.Resources {
- file := generate.CreateResource(r)
- err := file.Save(utils.GetResourceFileName(cwd, r))
- if err != nil {
- utils.ExitWithErrorf("add resource %s failed: %s", r, err.Error())
- } else {
- fmt.Printf("add resource %s successfully\n", r)
- }
+ err = addConfig.GenResources(cwd)
+ if err != nil {
+ utils.ExitWithError(err)
  }
 
- config.Filters = append(config.Filters, addFlags.Filters...)
- config.Resources = append(config.Resources, addFlags.Resources...)
+ config.Filters = append(config.Filters, addConfig.Filters...)
+ config.Resources = append(config.Resources, addConfig.Resources...)
 
- // generate registry dir and file.
- err = os.MkdirAll(utils.GetRegistryDir(cwd), os.ModePerm)
- if err != nil {
- utils.ExitWithErrorf("make directory %s failed: %s", utils.GetRegistryDir(cwd), err.Error())
- }
- file := generate.CreateRegistry(config)
- err = file.Save(utils.GetRegistryFileName(cwd))
+ err = config.GenRegistry(cwd)
  if err != nil {
- utils.ExitWithErrorf("update registry file failed: %s", err.Error())
- } else {
- fmt.Println("update registry file successfully")
+ utils.ExitWithError(err)
  }
 
- err = generate.WriteObjectConfigFile(cwd, config)
+ err = config.Save(cwd)
  if err != nil {
  utils.ExitWithError(err)
  }
 }
-
-func addCheckConfig(config *generate.ObjectConfig) error {
- arrToSet := func(arr []string) map[string]struct{} {
- set := make(map[string]struct{})
- for _, a := range arr {
- set[a] = struct{}{}
- }
- return set
- }
-
- filters := arrToSet(config.Filters)
- for _, f := range addFlags.Filters {
- if _, ok := filters[f]; ok {
- return fmt.Errorf("filter %s already exists", f)
- }
- }
-
- resources := arrToSet(config.Resources)
- for _, r := range addFlags.Resources {
- if _, ok := resources[r]; ok {
- return fmt.Errorf("resource %s already exists", r)
- }
- }
- return nil
-}

cmd/builder/command/init.go

@@ -24,13 +24,13 @@ import (
  "os"
  "os/exec"
 
- "github.com/megaease/easegress/v2/cmd/builder/generate"
+ "github.com/megaease/easegress/v2/cmd/builder/gen"
  "github.com/megaease/easegress/v2/cmd/builder/utils"
  "github.com/spf13/cobra"
  "golang.org/x/mod/module"
 )
 
-var initFlags = &generate.ObjectConfig{}
+var initConfig = &gen.Config{}
 
 func InitCmd() *cobra.Command {
  cmd := &cobra.Command{
@@ -40,33 +40,33 @@ func InitCmd() *cobra.Command {
  Run: initRun,
  }
 
- cmd.Flags().StringSliceVar(&initFlags.Filters, "filters", []string{}, "filters to be generated")
- cmd.Flags().StringSliceVar(&initFlags.Resources, "resources", []string{}, "resources to be generated")
- cmd.Flags().StringVar(&initFlags.Repo, "repo", "", "pkg name of the repo")
+ cmd.Flags().StringSliceVar(&initConfig.Filters, "filters", []string{}, "filters to be generated")
+ cmd.Flags().StringSliceVar(&initConfig.Resources, "resources", []string{}, "resources to be generated")
+ cmd.Flags().StringVar(&initConfig.Repo, "repo", "", "pkg name of the repo")
  return cmd
 }
 
 func initArgs(cmd *cobra.Command, args []string) error {
  if len(args) != 0 {
  return errors.New("init takes no arguments")
  }
- if len(initFlags.Repo) == 0 {
+ if len(initConfig.Repo) == 0 {
  return errors.New("repo is required")
  }
- if (len(initFlags.Filters) == 0) && (len(initFlags.Resources) == 0) {
+ if (len(initConfig.Filters) == 0) && (len(initConfig.Resources) == 0) {
  return errors.New("filters or resources is required")
  }
 
- err := module.CheckPath(initFlags.Repo)
+ err := module.CheckPath(initConfig.Repo)
  if err != nil {
- return fmt.Errorf("repo %s is not a valid path, %s", initFlags.Repo, err.Error())
+ return fmt.Errorf("repo %s is not a valid path, %s", initConfig.Repo, err.Error())
  }
- for _, filter := range initFlags.Filters {
+ for _, filter := range initConfig.Filters {
  if !(utils.CapitalVariableName(filter)) {
  return fmt.Errorf("filter %s is not a valid golang variable name with first letter upper case", filter)
  }
  }
- for _, resource := range initFlags.Resources {
+ for _, resource := range initConfig.Resources {
  if !(utils.CapitalVariableName(resource)) {
  return fmt.Errorf("resource %s is not a valid golang variable name with first letter upper case", resource)
  }
@@ -77,7 +77,7 @@ func initArgs(cmd *cobra.Command, args []string) error {
 func initRun(cmd *cobra.Command, args []string) {
  cwd, err := os.Getwd()
  if err != nil {
- utils.ExitWithErrorf("get current working directory failed: %s", err.Error())
+ utils.ExitWithError(err)
  }
  files, err := os.ReadDir(cwd)
  if err != nil {
@@ -89,60 +89,43 @@ func initRun(cmd *cobra.Command, args []string) {
 
  initGenerateFiles(cmd, cwd)
  initGenerateMod(cmd)
- generate.WriteObjectConfigFile(cwd, initFlags)
+ err = initConfig.Save(cwd)
+ if err != nil {
+ utils.ExitWithError(err)
+ }
 }
 
 func initGenerateFiles(_ *cobra.Command, cwd string) {
- // generate filters and resources dir and files.
- err := utils.MakeDirs(cwd, initFlags.Filters, initFlags.Resources)
+ err := initConfig.GenFilters(cwd)
  if err != nil {
  utils.ExitWithError(err)
  }
+ fmt.Println("generate filters success")
 
- for _, f := range initFlags.Filters {
- file := generate.CreateFilter(f)
- err := file.Save(utils.GetFilterFileName(cwd, f))
- if err != nil {
- utils.ExitWithErrorf("generate filter %s failed: %s", f, err.Error())
- } else {
- fmt.Printf("generate filter %s success\n", f)
- }
- }
- for _, r := range initFlags.Resources {
- file := generate.CreateResource(r)
- err := file.Save(utils.GetResourceFileName(cwd, r))
- if err != nil {
- utils.ExitWithErrorf("generate resource %s failed: %s", r, err.Error())
- } else {
- fmt.Printf("generate resource %s success\n", r)
- }
- }
-
- // generate registry dir and file.
- err = os.MkdirAll(utils.GetRegistryDir(cwd), os.ModePerm)
+ err = initConfig.GenResources(cwd)
  if err != nil {
- utils.ExitWithErrorf("make directory %s failed: %s", utils.GetRegistryDir(cwd), err.Error())
+ utils.ExitWithError(err)
  }
- file := generate.CreateRegistry(initFlags)
- err = file.Save(utils.GetRegistryFileName(cwd))
+ fmt.Println("generate resources success")
+
+ err = initConfig.GenRegistry(cwd)
  if err != nil {
- utils.ExitWithErrorf("generate registry file failed: %s", err.Error())
- } else {
- fmt.Printf("generate registry file success\n")
+ utils.ExitWithError(err)
  }
+ fmt.Println("generate registry success")
 }
 
 func initGenerateMod(cmd *cobra.Command) {
  // go mod init
- modInitCmd := exec.Command(utils.GetGo(), "mod", "init", initFlags.Repo)
+ modInitCmd := exec.Command(utils.GetGo(), "mod", "init", initConfig.Repo)
  modInitCmd.Stderr = os.Stderr
  out, err := modInitCmd.Output()
  if err != nil {
  utils.ExitWithErrorf("exec %v: %v: %s", cmd.Args, err, string(out))
  }
 
  // go get easegress
- modGetCmd := exec.Command(utils.GetGo(), "get", utils.EG)
+ modGetCmd := exec.Command(utils.GetGo(), "get", utils.EGPath)
  modGetCmd.Stderr = os.Stderr
  out, err = modGetCmd.Output()
  if err != nil {