separate subcommands into separate files

Signed-off-by: Bryce Palmer <[email protected]>

Author: everettraven

docs/book/src/simple-external-plugin-tutorial/api.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/spf13/pflag"
+	"sigs.k8s.io/kubebuilder/v3/pkg/plugin/external"
+)
+
+// apiCmd handles all the logic for the `create api` subcommand of this sample external plugin
+func apiCmd(pr *external.PluginRequest) external.PluginResponse {
+	pluginResponse := external.PluginResponse{
+		APIVersion: "v1alpha1",
+		Command:    "create api",
+		Universe:   pr.Universe,
+	}
+
+	// Here is an example of parsing a flag from a Kubebuilder external plugin request
+	flags := pflag.NewFlagSet("apiFlags", pflag.ContinueOnError)
+	flags.Int("number", 1, "set a number to be added in the scaffolded apiFile.txt")
+	flags.Parse(pr.Args)
+	number, _ := flags.GetInt("number")
+
+	// Phase 2 Plugins uses the concept of a "universe" to represent the filesystem for a plugin.
+	// This universe is a key:value mapping of filename:contents. Here we are adding the file
+	// "apiFile.txt" to the universe with some content. When this is returned Kubebuilder will
+	// take all values within the "universe" and write them to the user's filesystem.
+	pluginResponse.Universe["apiFile.txt"] = fmt.Sprintf("A simple text file created with the `create api` subcommand\nNUMBER: %d", number)
+
+	return pluginResponse
+}

docs/book/src/simple-external-plugin-tutorial/flags.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"github.com/spf13/pflag"
+	"sigs.k8s.io/kubebuilder/v3/pkg/plugin/external"
+)
+
+// flagsCmd handles all the logic for the `flags` subcommand of the sample external plugin.
+// In Kubebuilder's Phase 2 Plugins the `flags` subcommand is an optional subcommand for
+// external plugins to support. The `flags` subcommand allows for an external plugin
+// to provide Kubebuilder with a list of flags that the `init`, `create api`, `create webhook`,
+// and `edit` subcommands allow. This allows Kubebuilder to give an external plugin the ability
+// to feel like a native Kubebuilder plugin to a Kubebuilder user by only binding the supported
+// flags and failing early if an unknown flag is provided.
+func flagsCmd(pr *external.PluginRequest) external.PluginResponse {
+	pluginResponse := external.PluginResponse{
+		APIVersion: "v1alpha1",
+		Command:    "flags",
+		Universe:   pr.Universe,
+		Flags:      []external.Flag{},
+	}
+
+	// Here is an example of parsing multiple flags from a Kubebuilder external plugin request
+	flagsToParse := pflag.NewFlagSet("flagsFlags", pflag.ContinueOnError)
+	flagsToParse.Bool("init", false, "sets the init flag to true")
+	flagsToParse.Bool("api", false, "sets the api flag to true")
+	flagsToParse.Bool("webhook", false, "sets the webhook flag to true")
+
+	flagsToParse.Parse(pr.Args)
+
+	initFlag, _ := flagsToParse.GetBool("init")
+	apiFlag, _ := flagsToParse.GetBool("api")
+	webhookFlag, _ := flagsToParse.GetBool("webhook")
+
+	// The Phase 2 Plugins implementation will only ever pass a single boolean flag
+	// argument in the JSON request `args` field. The flag will be `--init` if it is
+	// attempting to get the flags for the `init` subcommand, `--api` for `create api`,
+	// `--webhook` for `create webhook`, and `--edit` for `edit`
+	if initFlag {
+		// Add a flag to the JSON response `flags` field that Kubebuilder reads
+		// to ensure it binds to the flags given in the response.
+		pluginResponse.Flags = append(pluginResponse.Flags, external.Flag{
+			Name:    "domain",
+			Type:    "string",
+			Default: "example.domain.com",
+			Usage:   "sets the domain added in the scaffolded initFile.txt",
+		})
+	} else if apiFlag {
+		pluginResponse.Flags = append(pluginResponse.Flags, external.Flag{
+			Name:    "number",
+			Type:    "int",
+			Default: "1",
+			Usage:   "set a number to be added in the scaffolded apiFile.txt",
+		})
+	} else if webhookFlag {
+		pluginResponse.Flags = append(pluginResponse.Flags, external.Flag{
+			Name:    "hooked",
+			Type:    "bool",
+			Default: "false",
+			Usage:   "add the word `hooked` to the end of the scaffolded webhookFile.txt",
+		})
+	} else {
+		pluginResponse.Error = true
+		pluginResponse.ErrorMsgs = []string{
+			"unrecognized flag",
+		}
+	}
+
+	return pluginResponse
+}

docs/book/src/simple-external-plugin-tutorial/helpers.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+
+	"sigs.k8s.io/kubebuilder/v3/pkg/plugin/external"
+)
+
+// returnError is a helper function to return a JSON
+// response that states an error has occurred along
+// with the error message to Kubebuilder. If this
+// function encounters an error printing the JSON
+// response it just prints a normal error message
+// and exits with a non-zero exit code. Kubebuilder
+// will detect that an error has occurred if there is
+// a non-zero exit code from the external plugin, but
+// it is recommended to return a JSON response that states
+// an error has occurred to provide the best user experience
+// and integration with Kubebuilder.
+func returnError(err error) {
+	errResponse := external.PluginResponse{
+		Error: true,
+		ErrorMsgs: []string{
+			err.Error(),
+		},
+	}
+	output, err := json.Marshal(errResponse)
+	if err != nil {
+		log.Fatalf("encountered error marshaling output: %s | OUTPUT: %s", err.Error(), output)
+	}
+
+	fmt.Printf("%s", output)
+}

docs/book/src/simple-external-plugin-tutorial/init.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/spf13/pflag"
+	"sigs.k8s.io/kubebuilder/v3/pkg/plugin/external"
+)
+
+// initCmd handles all the logic for the `init` subcommand of this sample external plugin
+func initCmd(pr *external.PluginRequest) external.PluginResponse {
+	pluginResponse := external.PluginResponse{
+		APIVersion: "v1alpha1",
+		Command:    "init",
+		Universe:   pr.Universe,
+	}
+
+	// Here is an example of parsing a flag from a Kubebuilder external plugin request
+	flags := pflag.NewFlagSet("initFlags", pflag.ContinueOnError)
+	flags.String("domain", "example.domain.com", "sets the domain added in the scaffolded initFile.txt")
+	flags.Parse(pr.Args)
+	domain, _ := flags.GetString("domain")
+
+	// Phase 2 Plugins uses the concept of a "universe" to represent the filesystem for a plugin.
+	// This universe is a key:value mapping of filename:contents. Here we are adding the file
+	// "initFile.txt" to the universe with some content. When this is returned Kubebuilder will
+	// take all values within the "universe" and write them to the user's filesystem.
+	pluginResponse.Universe["initFile.txt"] = fmt.Sprintf("A simple text file created with the `init` subcommand\nDOMAIN: %s", domain)
+
+	return pluginResponse
+}