Merge branch 'master' into ginko-testing

Author: sjakati98

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,16 +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 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
 	}

docs/CLI-Reference.md

@@ -1,33 +1,66 @@
 # CLI Guide
 
-**_Note:_** Binary has not yet been build.
-
 ```terminal
 Usage:
-    go run main.go [command]
+    helm2go-operator-sdk [command] [arguments] [flags]
 ```
 
-## convert
+## new
 ---
 Scaffolds a Go Operator for a corresponding Helm Chart.
 
 ### Args
 * `operator-name` - name of the new operator
 
 ### Flags
-* `--helm-chart` - Name of the helm chart. If using an external repo, specify the name within the repo i.e. `nginx`. If using a local chart provide `path/to/chart`
-    * `--helm-chart-repo` - Specify external chart repo if necessary.
-    * `--helm-chart-version` - Specify external chart version if necessary.
-    * `--username` - Specify external repo username if necessary.
-    * `--password` - Specify external repo password if necessary.
-    * `--helm-chart-cert-file` - Specify Cert File for external repo if necessary.
-    * `--helm-chart-key-file` - Specify Key File for external repo if necessary.
-    * `--helm-chart-ca-file` - Specify CA File for external repo if necessary.
-* `--api-version` - Kubernetes API Version and has a format of `<groupName>/<version>` i.e. `app.example.com/v1alpha1`
-* `--kind` - Kubernetes Custom Resource Definition kind.
+* **Required:**` --helm-chart` - Name of the helm chart. If using an external repo, specify the name within the repo i.e. `nginx`. If using a local chart provide `path/to/chart`
+* `--helm-chart-repo` - Specify external chart repo if necessary.
+* `--helm-chart-version` - Specify external chart version if necessary.
+* `--username` - Specify external repo username if necessary.
+* `--password` - Specify external repo password if necessary.
+* `--helm-chart-cert-file` - Specify Cert File for external repo if necessary.
+* `--helm-chart-key-file` - Specify Key File for external repo if necessary.
+* `--helm-chart-ca-file` - Specify CA File for external repo if necessary.
+* **Required:** `--api-version` - Kubernetes API Version and has a format of `<groupName>/<version>` i.e. `app.example.com/v1alpha1`
+* **Required:** `--kind` - Kubernetes Custom Resource Definition kind.
 * `--cluster-scoped` - Operator cluster scoped or not.
 
 ### Example
 ```
-$ go run main.go convert nginx-operator --helm-chart=path/to/chart --api-version=web.example.com/v1alpha1 --kind=Nginx
-```
+$ helm2go-operator-sdk new nginx-operator --helm-chart=path/to/chart --api-version=web.example.com/v1alpha1 --kind=Nginx
+```
+
+The resulting structure will be:
+```
+<project-name>
+|   build/
+|   |   Dockerfile
+|   |   bin/
+|   |   _output/
+|   cmd/.
+|   |   manager/
+|   |   |   main.go
+|   deploy/
+|   |   operator.yaml
+|   |   role_binding.yaml
+|   |   role.yaml
+|   |   service_account.yaml
+|   |   crds/
+|   |   |   <api-version>_<kind>_cr.yaml
+|   |   |   <api-version>_<kind>_crd.yaml
+|   pkg/
+|   |   apis/
+|   |   |   <api-version>/
+|   |   |   |   doc.go
+|   |   |   |   memcached_types.go
+|   |   |   |   ...
+|   |   |   ...
+|   |   controller/
+|   |   |   <kind>/
+|   |   |   <kind>_controller.go
+|   |   |   ...
+|   |   resources/
+|   |   |   ...
+|   ...
+```
+

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)

internal/pkg/load/validation_test.go

@@ -1,6 +1,8 @@
 package load
 
 import (
+	"os"
+	"path/filepath"
 	"testing"
 
 	. "github.com/onsi/ginkgo"
@@ -14,7 +16,8 @@ func TestValidation(t *testing.T) {
 
 var _ = Describe("Resource Validation", func() {
 	It("Validates Resources", func() {
-		_, err := PerformResourceValidation("/home/sjakati/go/src/github.com/redhat-nfvpe/helm2go-operator-sdk/test/resources")
+		gopath := os.Getenv("GOPATH")
+		_, err := PerformResourceValidation(filepath.Join(gopath, "/src/github.com/redhat-nfvpe/helm2go-operator-sdk/test/resources"))
 		Expect(err).ToNot(HaveOccurred())
 	})
 })