Merge pull request #50 from redhat-nfvpe/code-refactor-jam

Code jam refactoring

Author: aneeshkp

cmd/helm2go-operator-sdk/new/chart.go

@@ -38,7 +38,9 @@ type HelmChartClient struct {
 
 //NewChartClient creates a new chart client
 func NewChartClient() *HelmChartClient {
-	return &HelmChartClient{}
+	client := HelmChartClient{}
+	client.PathConfig, _ = GetBasePathConfig()
+	return &client
 }
 
 // SetValues ingests alle the necessary values for the client
@@ -53,7 +55,7 @@ func (hc *HelmChartClient) SetValues(helmChartRef, helmChartVersion, helmChartRe
 	hc.HelmChartKeyFile = helmChartKeyFile
 }
 
-//LoadChart ...
+//LoadChart uses the chart client's values to retreive the appropriate chart
 func (hc *HelmChartClient) LoadChart() error {
 	var chartPath string
 	chartPath = hc.HelmChartRef
@@ -112,9 +114,9 @@ func (hc *HelmChartClient) DoHelmGoConversion() (*resourcecache.ResourceCache, e
 		return nil, fmt.Errorf("error injecting template values: %v", err)
 	}
 	// write the rendered charts to output directory
-	d := hc.PathConfig.GetBasePath()
-	fmt.Printf("PATH CONFIG BASE: %s\n", d)
-	temp, err := render.InjectedToTemp(f, d)
+	basePath := hc.PathConfig.GetBasePath()
+
+	temp, err := render.InjectedToTemp(f, basePath)
 	if err != nil {
 		return nil, fmt.Errorf("error writing template values to temp files: %v", err)
 	}
@@ -140,19 +142,21 @@ func (hc *HelmChartClient) DoHelmGoConversion() (*resourcecache.ResourceCache, e
 
 func scaffoldOverwrite(outputDir, kind, apiVersion string, rcache *resourcecache.ResourceCache) error {
 
-	ok := templating.OverwriteController(outputDir, kind, apiVersion, rcache)
-	if !ok {
-		fmt.Println(ok)
+	if err := templating.OverwriteController(outputDir, kind, apiVersion, rcache); err != nil {
+		return fmt.Errorf("error while overwriting controller: %v", err)
 	}
 	// create templates for writing to file
 	templates := templating.CacheTemplating(rcache, outputDir, kind, apiVersion)
 	// templates to files; outputDir is the parent directory where the operator scaffolding lives
 	resDir := filepath.Join(outputDir, "pkg", "resources")
+
 	// create the necessary package resource specific folders
-	ok = templating.ResourceFileStructure(rcache, resDir)
-	ok = templating.TemplatesToFiles(templates, resDir)
-	if !ok {
-		return fmt.Errorf("Writing to File Error")
+	if err := templating.ResourceFileStructure(rcache, resDir); err != nil {
+		return fmt.Errorf("error creating resource file structure: %v", err)
 	}
+	if err := templating.TemplatesToFiles(templates, resDir); err != nil {
+		return fmt.Errorf("error writing to template: %v", err)
+	}
+
 	return nil
 }

cmd/helm2go-operator-sdk/new/cmd.go

@@ -27,7 +27,11 @@ func GetNewCmd() *cobra.Command {
 	newCmd.Flags().StringVar(&apiVersion, "api-version", "", "Kubernetes apiVersion and has a format of $GROUP_NAME/$VERSION (e.g app.example.com/v1alpha1)")
 	newCmd.Flags().StringVar(&kind, "kind", "", "Kubernetes CustomResourceDefintion kind. (e.g AppService)")
 	newCmd.Flags().BoolVar(&clusterScoped, "cluster-scoped", false, "Operator cluster scoped or not")
+
+	// debug flags
 	newCmd.Flags().BoolVar(&mock, "mock", false, "Used for testing")
+	// newCmd.Flags().MarkHidden("mock")
+
 	return newCmd
 }
 
@@ -52,7 +56,6 @@ func newFunc(cmd *cobra.Command, args []string) error {
 
 	chartClient := NewChartClient()
 	chartClient.SetValues(helmChartRef, helmChartVersion, helmChartRepo, username, password, helmChartCAFile, helmChartCertFile, helmChartKeyFile)
-	chartClient.PathConfig, _ = GetBasePathConfig()
 
 	if err := parse(args); err != nil {
 		log.Error("error parsing arguments: ", err)
@@ -68,23 +71,29 @@ func newFunc(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	// for testing
+	if mock {
+		return nil
+	}
+
 	log.Infof("🤠 Creating Go Operator %s from Helm Chart %s!", operatorName, chartClient.HelmChartRef)
 
 	// load the spcecified helm chart
-
 	err := chartClient.LoadChart()
 
 	if err != nil {
 		log.Error("error loading chart: ", err)
 		return err
 	}
 
+	// convert helm resources to Go resource cache
 	rcache, err := chartClient.DoHelmGoConversion()
 	if err != nil {
 		log.Error("error performing chart conversion: ", err)
 		return err
 	}
 
+	// output directory is the path/to/command/operator-name
 	outputDir = filepath.Join(chartClient.PathConfig.GetBasePath(), operatorName)
 
 	//create the operator-sdk scaffold

cmd/helm2go-operator-sdk/new/cmd_util.go

@@ -41,11 +41,11 @@ func verifyFlags() error {
 
 func parse(args []string) error {
 	if len(args) != 1 {
-		return fmt.Errorf("Please Specify Operator Name")
+		return fmt.Errorf("please specify operator name")
 	}
 	operatorName = args[0]
 	if len(operatorName) == 0 {
-		return fmt.Errorf("Project Name Must Not Be Empty")
+		return fmt.Errorf("operator name should not be empty")
 	}
 	return nil
 }

cmd/helm2go-operator-sdk/new/scaffold.go

@@ -8,6 +8,9 @@ import (
 )
 
 func doGoScaffold() error {
+	// for testing purposes
+	fmt.Printf("What is mock")
+	fmt.Print(mock)
 	if mock {
 		return nil
 	}

internal/pkg/load/convert.go

@@ -19,10 +19,10 @@ import (
 
 // YAMLUnmarshalResources converts a directory of injected YAML files to Kubernetes resources; resouresPath is assumed to be an absolute path
 // if conversion of any resource fails method will panic; adds resources to resource cache
-func YAMLUnmarshalResources(rp string, validMap *validatemap.ValidateMap, rc *resourcecache.ResourceCache) (*resourcecache.ResourceCache, error) {
+func YAMLUnmarshalResources(resourcesPath string, validMap *validatemap.ValidateMap, resourceCache *resourcecache.ResourceCache) (*resourcecache.ResourceCache, error) {
 
 	// TODO convert all the files in a directory
-	files, err := ioutil.ReadDir(rp)
+	files, err := ioutil.ReadDir(resourcesPath)
 	if err != nil {
 		return nil, err
 	}
@@ -34,7 +34,7 @@ func YAMLUnmarshalResources(rp string, validMap *validatemap.ValidateMap, rc *re
 			continue
 		}
 
-		file := filepath.Join(rp, f.Name())
+		file := filepath.Join(resourcesPath, f.Name())
 		// obtain the converted result resourceKind
 		rconfig, err := yamlUnmarshalSingleResource(file)
 		if err != nil {
@@ -43,7 +43,7 @@ func YAMLUnmarshalResources(rp string, validMap *validatemap.ValidateMap, rc *re
 			} else if err.Error() == "not yaml" {
 				continue
 			} else if err.Error() == "unknown type" {
-				return nil, fmt.Errorf("resource: %v is of unknown type", rconfig.r)
+				return nil, fmt.Errorf("resource: %v is of unknown type", rconfig.resource)
 			} else if err.Error() == "deprecated" {
 				log.Printf("%s contains deprecated api version; exiting", f.Name())
 				os.Exit(1)
@@ -56,13 +56,13 @@ func YAMLUnmarshalResources(rp string, validMap *validatemap.ValidateMap, rc *re
 		}
 		// add resource to cache
 		// initializes the kind type
-		rc.SetKindType(rconfig.kt)
+		resourceCache.SetKindType(rconfig.kindType)
 		// set the correct cache information
-		rc.SetResourceForKindType(rconfig.kt, rconfig.pt)
-		rs := rc.GetResourceForKindType(rconfig.kt)
-		rs.SetResourceFunctions(string(rconfig.kt), rconfig.r)
+		resourceCache.SetResourceForKindType(rconfig.kindType, rconfig.packageType)
+		rs := resourceCache.GetResourceForKindType(rconfig.kindType)
+		rs.SetResourceFunctions(string(rconfig.kindType), rconfig.resource)
 	}
-	return rc, nil
+	return resourceCache, nil
 }
 
 // yamlUnmarshalSingleResource converts injected YAML files to a Kubernetes resource; rp is assumed to be an absolute path

internal/pkg/load/kinds.go

@@ -10,26 +10,16 @@ import (
 var AcceptedK8sTypes = regexp.MustCompile(`(Role|ClusterRole|RoleBinding|ClusterRoleBinding|ServiceAccount|Service|Deployment)`)
 
 type resourceConfig struct {
-	r  interface{}
-	kt resourcecache.KindType
-	pt resourcecache.PackageType
+	resource    interface{}
+	kindType    resourcecache.KindType
+	packageType resourcecache.PackageType
 }
 
 func (rc *resourceConfig) toResourceCache() *resourcecache.Resource {
-	var r resourcecache.Resource
+	var resource resourcecache.Resource
 
-	r.PackageName = rc.pt
-	r.FileName = string(rc.kt)
+	resource.PackageName = rc.packageType
+	resource.FileName = string(rc.kindType)
 
-	// put things into resourcecache format
-
-	return &r
+	return &resource
 }
-
-// func getKindType(kind string) *resourcecache.KindType {
-// 	var kt resourcecache.KindType
-// 	switch kind {
-// 	case resourcecache.KindTypeConfigMap.(string):
-// 		kt =
-// 	}
-// }

internal/pkg/load/validation.go

@@ -13,42 +13,40 @@ import (
 	"github.com/redhat-nfvpe/helm2go-operator-sdk/internal/validatemap"
 )
 
-var cd string
-
 // PerformResourceValidation validates templated resources to identify deprecated API versions
-func PerformResourceValidation(rp string) (*validatemap.ValidateMap, error) {
-	cd = rp
+func PerformResourceValidation(resourcesPath string) (*validatemap.ValidateMap, error) {
 	// collect all templated files in directory
-	files, err := ioutil.ReadDir(rp)
+	// TODO: need to test with nested templates
+	files, err := ioutil.ReadDir(resourcesPath)
 	if err != nil {
-		return nil, fmt.Errorf("error reading files in directory %s: %v", rp, err)
+		return nil, fmt.Errorf("error reading files in directory %s: %v", resourcesPath, err)
 	}
 
 	var validMap validatemap.ValidateMap
 
-	for _, f := range files {
-		rconfig, err := yamlUnmarshalSingleResource(filepath.Join(rp, f.Name()))
+	for _, file := range files {
+		rconfig, err := yamlUnmarshalSingleResource(filepath.Join(resourcesPath, file.Name()))
 		if err != nil {
 			reader := bufio.NewReader(os.Stdin)
 			if e := err.Error(); e == "deprecated" {
-				fmt.Printf("Resource: %v has a deprecated API version. Please enter 'continue' to proceed without this resource or 'stop' to exit the program: ", reflect.TypeOf(rconfig.r))
+				fmt.Printf("Resource: %v has a deprecated API version. Please enter 'continue' to proceed without this resource or 'stop' to exit the program: ", reflect.TypeOf(rconfig.resource))
 				text, _ := reader.ReadString('\n')
 				if isStop(text) {
-					cleanUpAndExit()
+					cleanUpAndExit(resourcesPath)
 				}
 				if isContinue(text) {
-					addResourceToContinue(&validMap, f.Name())
+					addResourceToContinue(&validMap, file.Name())
 				}
 			} else if e == "unsupported" {
 
-				fmt.Printf("Resource: %v is unsupported. Please enter 'continue' to proceed without this resource, or 'stop' to exit the program: ", reflect.TypeOf(rconfig.r))
+				fmt.Printf("Resource: %v is unsupported. Please enter 'continue' to proceed without this resource, or 'stop' to exit the program: ", reflect.TypeOf(rconfig.resource))
 				text, _ := reader.ReadString('\n')
 
 				if isStop(text) {
-					cleanUpAndExit()
+					cleanUpAndExit(resourcesPath)
 				}
 				if isContinue(text) {
-					addResourceToContinue(&validMap, f.Name())
+					addResourceToContinue(&validMap, file.Name())
 				}
 			} else if e == "not yaml" || e == "empty" {
 				continue
@@ -72,11 +70,11 @@ func matchString(text string, contains string) bool {
 	return strings.Contains(text, contains)
 }
 
-func cleanUpAndExit() {
+func cleanUpAndExit(resourcesPath string) {
 	// log exit begin
 	log.Println("Cleanup Temp Started")
 	// clean up temp folder
-	temp := filepath.Dir(filepath.Dir(cd))
+	temp := filepath.Dir(filepath.Dir(resourcesPath))
 	err := os.RemoveAll(temp)
 	if err != nil {
 		log.Printf("Error While Cleaning Up Temp: %v", err)