Merge pull request #632 from droot/feature/scaffolding-v2

Simplified Scaffolding based on the builder pattern

Author: k8s-ci-robot

.gitattributes

@@ -0,0 +1 @@
+test/*.tgz filter=lfs diff=lfs merge=lfs -text

.travis.yml

@@ -9,11 +9,17 @@ go:
 
 git:
   depth: 3
+  lfs_skip_smudge: true
 
 go_import_path: sigs.k8s.io/kubebuilder
 
 before_install:
 - go get -u github.com/golang/dep/cmd/dep
+- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install git-lfs ; fi
+
+before_script:
+ - git lfs install
+ - git lfs pull
 
 # Install must be set to prevent default `go get` to run.
 # The dependencies have already been vendored by `dep` so

CONTRIBUTING.md

@@ -7,7 +7,7 @@ Kubernetes projects require that you sign a Contributor License Agreement (CLA)
 Please see https://git.k8s.io/community/CLA.md for more info.
 
 ## Contributing steps
-
+1. Setup [Git LFS plugin](https://git-lfs.github.com/)
 1. Submit an issue describing your proposed change to the repo in question.
 1. The [repo owners](OWNERS) will respond to your issue promptly.
 1. If your proposed change is accepted, and you haven't already done so, sign a Contributor License Agreement (see details above).
@@ -16,6 +16,10 @@ Please see https://git.k8s.io/community/CLA.md for more info.
 
 ## How to build kubebuilder locally
 
+1. Setup Git LFS
+Install the git-lfs plugin using the instructions from [git-lfs](https://git-lfs.github.com/) page.
+Once installed, run `git lfs install` in your repo to setup git lfs hooks.
+
 1. Build
 ```sh
 $ go build -o /output/path/kubebuilder ./cmd

Makefile

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+#  Copyright 2019 The Kubernetes Authors.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+#
+# Makefile with some common workflow for dev, build and test
+#
+
+all: build test
+
+.PHONY: build test
+
+build:
+	go build -o bin/kubebuilder ./cmd
+
+generate:
+	./generated_golden.sh
+
+test:
+	go test -v ./cmd/... ./pkg/...
+

cmd/api.go

@@ -22,111 +22,94 @@ import (
 	"log"
 	"os"
 	"os/exec"
-	"path/filepath"
-	"strings"
 
 	"github.com/spf13/cobra"
 	flag "github.com/spf13/pflag"
 
 	"sigs.k8s.io/kubebuilder/cmd/util"
 	"sigs.k8s.io/kubebuilder/pkg/scaffold"
-	"sigs.k8s.io/kubebuilder/pkg/scaffold/controller"
-	"sigs.k8s.io/kubebuilder/pkg/scaffold/input"
-	"sigs.k8s.io/kubebuilder/pkg/scaffold/resource"
+	"sigs.k8s.io/kubebuilder/pkg/scaffold/v1/resource"
 )
 
 type apiOptions struct {
-	r                                *resource.Resource
-	resourceFlag, controllerFlag     *flag.Flag
-	doResource, doController, doMake bool
+	apiScaffolder                scaffold.API
+	resourceFlag, controllerFlag *flag.Flag
+
+	// runMake indicates whether to run make or not after scaffolding APIs
+	runMake bool
 }
 
-// APICmd represents the resource command
+func (o *apiOptions) bindCmdFlags(cmd *cobra.Command) {
+	cmd.Flags().BoolVar(&o.runMake, "make", true,
+		"if true, run make after generating files")
+	cmd.Flags().BoolVar(&o.apiScaffolder.DoResource, "resource", true,
+		"if set, generate the resource without prompting the user")
+	o.resourceFlag = cmd.Flag("resource")
+	cmd.Flags().BoolVar(&o.apiScaffolder.DoController, "controller", true,
+		"if set, generate the controller without prompting the user")
+	o.controllerFlag = cmd.Flag("controller")
+	o.apiScaffolder.Resource = resourceForFlags(cmd.Flags())
+}
+
+// resourceForFlags registers flags for Resource fields and returns the Resource
+func resourceForFlags(f *flag.FlagSet) *resource.Resource {
+	r := &resource.Resource{}
+	f.StringVar(&r.Kind, "kind", "", "resource Kind")
+	f.StringVar(&r.Group, "group", "", "resource Group")
+	f.StringVar(&r.Version, "version", "", "resource Version")
+	f.BoolVar(&r.Namespaced, "namespaced", true, "resource is namespaced")
+	f.BoolVar(&r.CreateExampleReconcileBody, "example", true,
+		"if true an example reconcile body should be written while scaffolding a resource.")
+	return r
+}
 
+// APICmd represents the resource command
 func (o *apiOptions) runAddAPI() {
 	dieIfNoProject()
 
 	reader := bufio.NewReader(os.Stdin)
 	if !o.resourceFlag.Changed {
 		fmt.Println("Create Resource under pkg/apis [y/n]?")
-		o.doResource = util.Yesno(reader)
+		o.apiScaffolder.DoResource = util.Yesno(reader)
 	}
 
 	if !o.controllerFlag.Changed {
 		fmt.Println("Create Controller under pkg/controller [y/n]?")
-		o.doController = util.Yesno(reader)
+		o.apiScaffolder.DoController = util.Yesno(reader)
 	}
 
-	if o.r.Group == "" {
-		log.Fatalf("Must specify --group")
-	}
-	if o.r.Version == "" {
-		log.Fatalf("Must specify --version")
-	}
-	if o.r.Kind == "" {
-		log.Fatalf("Must specify --kind")
+	if err := o.apiScaffolder.Validate(); err != nil {
+		log.Fatalln(err)
 	}
 
 	fmt.Println("Writing scaffold for you to edit...")
 
-	r := o.r
-	if o.doResource {
-		fmt.Println(filepath.Join("pkg", "apis", r.Group, r.Version,
-			fmt.Sprintf("%s_types.go", strings.ToLower(r.Kind))))
-		fmt.Println(filepath.Join("pkg", "apis", r.Group, r.Version,
-			fmt.Sprintf("%s_types_test.go", strings.ToLower(r.Kind))))
-
-		err := (&scaffold.Scaffold{}).Execute(input.Options{},
-			&resource.Register{Resource: r},
-			&resource.Types{Resource: r},
-			&resource.VersionSuiteTest{Resource: r},
-			&resource.TypesTest{Resource: r},
-			&resource.Doc{Resource: r},
-			&resource.Group{Resource: r},
-			&resource.AddToScheme{Resource: r},
-			&resource.CRDSample{Resource: r},
-		)
-		if err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		// disable generation of example reconcile body if not scaffolding resource
-		// because this could result in a fork-bomb of k8s resources where watching a
-		// deployment, replicaset etc. results in generating deployment which
-		// end up generating replicaset, pod etc recursively.
-		r.CreateExampleReconcileBody = false
+	if err := o.apiScaffolder.Scaffold(); err != nil {
+		log.Fatal(err)
 	}
 
-	if o.doController {
-		fmt.Println(filepath.Join("pkg", "controller", strings.ToLower(r.Kind),
-			fmt.Sprintf("%s_controller.go", strings.ToLower(r.Kind))))
-		fmt.Println(filepath.Join("pkg", "controller", strings.ToLower(r.Kind),
-			fmt.Sprintf("%s_controller_test.go", strings.ToLower(r.Kind))))
-
-		err := (&scaffold.Scaffold{}).Execute(input.Options{},
-			&controller.Controller{Resource: r},
-			&controller.AddController{Resource: r},
-			&controller.Test{Resource: r},
-			&controller.SuiteTest{Resource: r},
-		)
-		if err != nil {
-			log.Fatal(err)
-		}
+	if err := o.postScaffold(); err != nil {
+		log.Fatal(err)
 	}
+}
 
-	if o.doMake {
+func (o *apiOptions) postScaffold() error {
+	if o.runMake {
 		fmt.Println("Running make...")
 		cm := exec.Command("make") // #nosec
 		cm.Stderr = os.Stderr
 		cm.Stdout = os.Stdout
 		if err := cm.Run(); err != nil {
-			log.Fatal(err)
+			return fmt.Errorf("error running make: %v", err)
 		}
 	}
+	return nil
 }
 
 func newAPICommand() *cobra.Command {
-	o := apiOptions{}
+	options := apiOptions{
+		apiScaffolder: scaffold.API{},
+	}
 
 	apiCmd := &cobra.Command{
 		Use:   "create api",
@@ -158,19 +141,11 @@ After the scaffold is written, api will run make on the project.
 	make run
 `,
 		Run: func(cmd *cobra.Command, args []string) {
-			o.runAddAPI()
+			options.runAddAPI()
 		},
 	}
 
-	apiCmd.Flags().BoolVar(&o.doMake, "make", true,
-		"if true, run make after generating files")
-	apiCmd.Flags().BoolVar(&o.doResource, "resource", true,
-		"if set, generate the resource without prompting the user")
-	o.resourceFlag = apiCmd.Flag("resource")
-	apiCmd.Flags().BoolVar(&o.doController, "controller", true,
-		"if set, generate the controller without prompting the user")
-	o.controllerFlag = apiCmd.Flag("controller")
-	o.r = ResourceForFlags(apiCmd.Flags())
+	options.bindCmdFlags(apiCmd)
 
 	return apiCmd
 }
@@ -181,15 +156,3 @@ func dieIfNoProject() {
 		log.Fatalf("Command must be run from a directory containing %s", "PROJECT")
 	}
 }
-
-// ResourceForFlags registers flags for Resource fields and returns the Resource
-func ResourceForFlags(f *flag.FlagSet) *resource.Resource {
-	r := &resource.Resource{}
-	f.StringVar(&r.Kind, "kind", "", "resource Kind")
-	f.StringVar(&r.Group, "group", "", "resource Group")
-	f.StringVar(&r.Version, "version", "", "resource Version")
-	f.BoolVar(&r.Namespaced, "namespaced", true, "resource is namespaced")
-	f.BoolVar(&r.CreateExampleReconcileBody, "example", true,
-		"if true an example reconcile body should be written while scaffolding a resource.")
-	return r
-}