commands/operator-sdk: Add CLI support for Ansible Operator

commands/operator-sdk/cmd/build.go

@@ -22,6 +22,7 @@ import (
 	"log"
 	"os"
 	"os/exec"
+	"strings"
 
 	"github.com/operator-framework/operator-sdk/commands/operator-sdk/cmd/cmdutil"
 	cmdError "github.com/operator-framework/operator-sdk/commands/operator-sdk/error"
@@ -135,29 +136,33 @@ func renderTestManifest(image string) {
 const (
 	build      = "./tmp/build/build.sh"
 	configYaml = "./config/config.yaml"
+	mainGo     = "./cmd/%s/main.go"
 )
 
 func buildFunc(cmd *cobra.Command, args []string) {
 	if len(args) != 1 {
 		cmdError.ExitWithError(cmdError.ExitBadArgs, fmt.Errorf("build command needs exactly 1 argument"))
 	}
 
-	bcmd := exec.Command(build)
-	bcmd.Env = append(os.Environ(), fmt.Sprintf("TEST_LOCATION=%v", testLocationBuild))
-	bcmd.Env = append(bcmd.Env, fmt.Sprintf("ENABLE_TESTS=%v", enableTests))
-	o, err := bcmd.CombinedOutput()
-	if err != nil {
-		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to build: (%v)", string(o)))
+	// Don't need to buld go code if Ansible Operator
+	if buildCmd() {
+		bcmd := exec.Command(build)
+		bcmd.Env = append(os.Environ(), fmt.Sprintf("TEST_LOCATION=%v", testLocationBuild))
+		bcmd.Env = append(bcmd.Env, fmt.Sprintf("ENABLE_TESTS=%v", enableTests))
+		o, err := bcmd.CombinedOutput()
+		if err != nil {
+			cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to build: (%v)", string(o)))
+		}
+		fmt.Fprintln(os.Stdout, string(o))
 	}
-	fmt.Fprintln(os.Stdout, string(o))
 
 	image := args[0]
 	baseImageName := image
 	if enableTests {
 		baseImageName += "-intermediate"
 	}
 	dbcmd := exec.Command("docker", "build", ".", "-f", "tmp/build/Dockerfile", "-t", baseImageName)
-	o, err = dbcmd.CombinedOutput()
+	o, err := dbcmd.CombinedOutput()
 	if err != nil {
 		if enableTests {
 			cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to build intermediate image for %s image: (%s)", image, string(o)))
@@ -178,3 +183,16 @@ func buildFunc(cmd *cobra.Command, args []string) {
 		renderTestManifest(image)
 	}
 }
+
+func buildCmd() bool {
+	dir, err := os.Getwd()
+	if err != nil {
+		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to get current working dir: %v", err))
+	}
+	dirSplit := strings.Split(dir, "/")
+	projectName := dirSplit[len(dirSplit)-1]
+	if _, err = os.Stat(fmt.Sprintf(mainGo, projectName)); err == nil {
+		return true
+	}
+	return false
+}

commands/operator-sdk/cmd/generate.go

@@ -29,5 +29,6 @@ func NewGenerateCmd() *cobra.Command {
 	}
 	cmd.AddCommand(generate.NewGenerateK8SCmd())
 	cmd.AddCommand(generate.NewGenerateOlmCatalogCmd())
+	cmd.AddCommand(generate.NewGenerateCrdCmd())
 	return cmd
 }

commands/operator-sdk/cmd/generate/crd.go

@@ -0,0 +1,113 @@
+// Copyright 2018 The Operator-SDK 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.
+
+package generate
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	cmdError "github.com/operator-framework/operator-sdk/commands/operator-sdk/error"
+	"github.com/operator-framework/operator-sdk/pkg/generator"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	apiVersion string
+	kind       string
+)
+
+const (
+	goDir        = "GOPATH"
+	deployCrdDir = "deploy"
+)
+
+func NewGenerateCrdCmd() *cobra.Command {
+	crdCmd := &cobra.Command{
+		Use:   "crd",
+		Short: "Generates a custom resource definition (CRD) and the custom resource (CR) files",
+		Long: `The operator-sdk generate command will create a custom resource definition (CRD) and the custom resource (CR) files for the specified api-version and kind.
+
+Generated CRD filename: <project-name>/deploy/<kind>_crd.yaml
+Generated CR  filename: <project-name>/deploy/<kind>_cr.yaml
+
+	<project-name>/deploy path must already exist
+	--api-version and --kind are required flags to generate the new operator application.
+`,
+		Run: crdFunc,
+	}
+	crdCmd.Flags().StringVar(&apiVersion, "api-version", "", "Kubernetes apiVersion and has a format of $GROUP_NAME/$VERSION (e.g app.example.com/v1alpha1)")
+	crdCmd.MarkFlagRequired("api-version")
+	crdCmd.Flags().StringVar(&kind, "kind", "", "Kubernetes CustomResourceDefintion kind. (e.g AppService)")
+	crdCmd.MarkFlagRequired("kind")
+	return crdCmd
+}
+
+func crdFunc(cmd *cobra.Command, args []string) {
+	if len(args) != 0 {
+		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("crd command doesn't accept any arguments."))
+	}
+	verifyCrdFlags()
+	verifyCrdDeployPath()
+
+	fmt.Fprintln(os.Stdout, "Generating custom resource definition (CRD) file")
+
+	// generate CRD file
+	wd, _ := os.Getwd()
+	if err := generator.RenderDeployCrdFiles(filepath.Join(wd, deployCrdDir), apiVersion, kind); err != nil {
+		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to generate CRD and CR files: (%v)", err))
+	}
+}
+
+func verifyCrdFlags() {
+	if len(apiVersion) == 0 {
+		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("--api-version must not have empty value"))
+	}
+	if len(kind) == 0 {
+		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("--kind must not have empty value"))
+	}
+	kindFirstLetter := string(kind[0])
+	if kindFirstLetter != strings.ToUpper(kindFirstLetter) {
+		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("--kind must start with an uppercase letter"))
+	}
+	if strings.Count(apiVersion, "/") != 1 {
+		cmdError.ExitWithError(cmdError.ExitBadArgs, fmt.Errorf("api-version has wrong format (%v); format must be $GROUP_NAME/$VERSION (e.g app.example.com/v1alpha1)", apiVersion))
+	}
+}
+
+// verifyCrdDeployPath checks if the path <project-name>/deploy sub-directory is exists, and that is rooted under $GOPATH
+func verifyCrdDeployPath() {
+	// check if $GOPATH env exists
+	gp := os.Getenv(goDir)
+	if len(gp) == 0 {
+		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("$GOPATH env not set"))
+	}
+	wd, err := os.Getwd()
+	if err != nil {
+		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to determine the full path of the current directory: %v", err))
+	}
+	// check if this project's repository path is rooted under $GOPATH
+	if !strings.HasPrefix(wd, gp) {
+		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("project's repository path (%v) is not rooted under GOPATH (%v)", wd, gp))
+	}
+	// check if the deploy sub-directory exist
+	_, err = os.Stat(filepath.Join(wd, deployCrdDir))
+	if err != nil {
+		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("the path (./%v) does not exist. run this command in your project directory", deployCrdDir))
+	}
+}

commands/operator-sdk/cmd/new.go

@@ -53,23 +53,29 @@ generates a skeletal app-operator application in $GOPATH/src/github.com/example.
 	newCmd.MarkFlagRequired("api-version")
 	newCmd.Flags().StringVar(&kind, "kind", "", "Kubernetes CustomResourceDefintion kind. (e.g AppService)")
 	newCmd.MarkFlagRequired("kind")
+	newCmd.Flags().StringVar(&operatorType, "type", "go", "Type of operator to initialize (e.g \"ansible\")")
 	newCmd.Flags().BoolVar(&skipGit, "skip-git-init", false, "Do not init the directory as a git repository")
+	newCmd.Flags().BoolVar(&generatePlaybook, "generate-playbook", false, "Generate a playbook skeleton. (Only used for --type ansible)")
 
 	return newCmd
 }
 
 var (
-	apiVersion  string
-	kind        string
-	projectName string
-	skipGit     bool
+	apiVersion       string
+	kind             string
+	operatorType     string
+	projectName      string
+	skipGit          bool
+	generatePlaybook bool
 )
 
 const (
-	gopath    = "GOPATH"
-	src       = "src"
-	dep       = "dep"
-	ensureCmd = "ensure"
+	gopath              = "GOPATH"
+	src                 = "src"
+	dep                 = "dep"
+	ensureCmd           = "ensure"
+	goOperatorType      = "go"
+	ansibleOperatorType = "ansible"
 )
 
 func newFunc(cmd *cobra.Command, args []string) {
@@ -79,13 +85,15 @@ func newFunc(cmd *cobra.Command, args []string) {
 	parse(args)
 	mustBeNewProject()
 	verifyFlags()
-	g := generator.NewGenerator(apiVersion, kind, projectName, repoPath())
+	g := generator.NewGenerator(apiVersion, kind, operatorType, projectName, repoPath(), generatePlaybook)
 	err := g.Render()
 	if err != nil {
 		cmdError.ExitWithError(cmdError.ExitError, fmt.Errorf("failed to create project %v: %v", projectName, err))
 	}
-	pullDep()
-	generate.K8sCodegen(projectName)
+	if operatorType == goOperatorType {
+		pullDep()
+		generate.K8sCodegen(projectName)
+	}
 	initGit()
 }
 
@@ -136,6 +144,12 @@ func verifyFlags() {
 	if len(kind) == 0 {
 		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("--kind must not have empty value"))
 	}
+	if operatorType != goOperatorType && operatorType != ansibleOperatorType {
+		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("--type can only be `go` or `ansible`"))
+	}
+	if operatorType != ansibleOperatorType && generatePlaybook {
+		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("--generate-playbook can only be used with --type `ansible`"))
+	}
 	kindFirstLetter := string(kind[0])
 	if kindFirstLetter != strings.ToUpper(kindFirstLetter) {
 		cmdError.ExitWithError(cmdError.ExitBadArgs, errors.New("--kind must start with an uppercase letter"))