Clean up library code, unit tests and documentation details

1. Move bundle funcs to /pkg as a bundle package

2. ix some minor errors in unit test.

3. Modify bundle doc to reflect recent changes

+ operator-sdk information
+ Folder structure

4. Add bundle command to opm binary as hidden commands

+ The bundle commands are only available for internal development use
as a part of opm binary.

5. Move bundle doc under /docs/design.

Signed-off-by: Vu Dinh <[email protected]>

Author: dinhxuanvu

cmd/operator-cli/main.go

@@ -1,11 +1,7 @@
 package bundle
 
 import (
-	"fmt"
-	"os"
-	"os/exec"
-	"path"
-
+	"github.com/operator-framework/operator-registry/pkg/lib/bundle"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
@@ -21,7 +17,7 @@ func newBundleBuildCmd() *cobra.Command {
 	bundleBuildCmd := &cobra.Command{
 		Use:   "build",
 		Short: "Build operator bundle image",
-		Long: `The operator-cli bundle build command will generate operator
+		Long: `The opm bundle build command will generate operator
         bundle metadata if needed and build bundle image with operator manifest
         and metadata.
 
@@ -33,7 +29,7 @@ func newBundleBuildCmd() *cobra.Command {
         After the build process is completed, a container image would be built
         locally in docker and available to push to a container registry.
 
-        $ operator-cli bundle build -dir /test/0.0.1/ -t quay.io/example/operator:v0.0.1
+        $ opm bundle build -dir /test/0.0.1/ -t quay.io/example/operator:v0.0.1
 
         Note: Bundle image is not runnable.
         `,
@@ -55,54 +51,11 @@ func newBundleBuildCmd() *cobra.Command {
 	return bundleBuildCmd
 }
 
-// Create build command to build bundle manifests image
-func buildBundleImage(directory, imageTag, imageBuilder string) (*exec.Cmd, error) {
-	var args []string
-
-	dockerfilePath := path.Join(directory, dockerFile)
-
-	switch imageBuilder {
-	case "docker", "podman":
-		args = append(args, "build", "-f", dockerfilePath, "-t", imageTag, ".")
-	case "buildah":
-		args = append(args, "bud", "--format=docker", "-f", dockerfilePath, "-t", imageTag, ".")
-	default:
-		return nil, fmt.Errorf("%s is not supported image builder", imageBuilder)
-	}
-
-	return exec.Command(imageBuilder, args...), nil
-}
-
-func executeCommand(cmd *exec.Cmd) error {
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	log.Debugf("Running %#v", cmd.Args)
-
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("Failed to exec %#v: %v", cmd.Args, err)
-	}
-
-	return nil
-}
-
 func buildFunc(cmd *cobra.Command, args []string) error {
-	// Generate annotations.yaml and Dockerfile
-	err := generateFunc(cmd, args)
-	if err != nil {
-		return err
-	}
-
-	// Build bundle image
-	log.Info("Building bundle image")
-	buildCmd, err := buildBundleImage(path.Dir(path.Clean(dirBuildArgs)), tagBuildArgs, imageBuilderArgs)
+	err := bundle.BuildFunc(dirBuildArgs, tagBuildArgs, imageBuilderArgs)
 	if err != nil {
 		return err
 	}
 
-	if err := executeCommand(buildCmd); err != nil {
-		return err
-	}
-
 	return nil
 }

cmd/operator-cli/bundle/build.go cmd/opm/bundle/build.go

@@ -6,9 +6,10 @@ import (
 
 func NewCmd() *cobra.Command {
 	runCmd := &cobra.Command{
-		Use:   "bundle",
-		Short: "Operator bundle commands",
-		Long:  `Generate operator bundle metadata and build bundle image.`,
+		Hidden: true,
+		Use:    "bundle",
+		Short:  "Operator bundle commands",
+		Long:   `Generate operator bundle metadata and build bundle image.`,
 	}
 
 	runCmd.AddCommand(newBundleGenerateCmd())

cmd/operator-cli/bundle/cmd.go cmd/opm/bundle/cmd.go

@@ -0,0 +1,59 @@
+package bundle
+
+import (
+	"github.com/operator-framework/operator-registry/pkg/lib/bundle"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	defaultPermission = 0644
+	registryV1Type    = "registry+v1"
+	plainType         = "plain"
+	helmType          = "helm"
+	manifestsMetadata = "manifests+metadata"
+	annotationsFile   = "annotations.yaml"
+	dockerFile        = "Dockerfile"
+	resourcesLabel    = "operators.operatorframework.io.bundle.resources"
+	mediatypeLabel    = "operators.operatorframework.io.bundle.mediatype"
+)
+
+type AnnotationMetadata struct {
+	Annotations AnnotationType `yaml:"annotations"`
+}
+
+type AnnotationType struct {
+	Resources string `yaml:"operators.operatorframework.io.bundle.resources"`
+	MediaType string `yaml:"operators.operatorframework.io.bundle.mediatype"`
+}
+
+// newBundleGenerateCmd returns a command that will generate operator bundle
+// annotations.yaml metadata
+func newBundleGenerateCmd() *cobra.Command {
+	bundleGenerateCmd := &cobra.Command{
+		Use:   "generate",
+		Short: "Generate operator bundle metadata and Dockerfile",
+		Long: `The opm buindle generate command will generate operator
+        bundle metadata if needed and a Dockerfile to build Operator bundle image.
+
+        $ opm bundle generate -d /test/0.0.1/
+        `,
+		RunE: generateFunc,
+	}
+
+	bundleGenerateCmd.Flags().StringVarP(&dirBuildArgs, "directory", "d", "", "The directory where bundle manifests are located.")
+	if err := bundleGenerateCmd.MarkFlagRequired("directory"); err != nil {
+		log.Fatalf("Failed to mark `directory` flag for `generate` subcommand as required")
+	}
+
+	return bundleGenerateCmd
+}
+
+func generateFunc(cmd *cobra.Command, args []string) error {
+	err := bundle.GenerateFunc(dirBuildArgs)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

cmd/opm/bundle/generate.go

@@ -4,6 +4,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 
+	"github.com/operator-framework/operator-registry/cmd/opm/bundle"
 	"github.com/operator-framework/operator-registry/cmd/opm/registry"
 )
 
@@ -15,6 +16,7 @@ func main() {
 	}
 
 	rootCmd.AddCommand(registry.NewOpmRegistryCmd())
+	rootCmd.AddCommand(bundle.NewCmd())
 
 	if err := rootCmd.Execute(); err != nil {
 		logrus.Panic(err.Error())

cmd/opm/main.go

@@ -1,6 +1,6 @@
 # Operator Bundle
 
-An `Operator Bundle` is a container image that stores Kubernetes manifests and metadata associated with an operator. A bundle is meant to present a specific version of an operator.
+An `Operator Bundle` is a container image that stores Kubernetes manifests and metadata associated with an operator. A bundle is meant to present a *specific* version of an operator.
 
 ## Operator Bundle Overview
 
@@ -13,7 +13,7 @@ The operator manifests refers to a set of Kubernetes manifest(s) the defines the
 * API(s) provided and required.
 * Related images.
 
-An `Operator Bundle` is built as scratch (non-runnable) container image that contains operator manifests and specific metadata in designated directories inside the image. Then, it can be pushed and pulled from an OCI-compliant container registry. Ultimately, an operator bundle will be used by [Operator Registry](https://github.com/operator-framework/operator-registry) and [Operator-Lifecycle-Manager (OLM)](https://github.com/operator-framework/operator-lifecycle-manager) to install an operator in OLM-enabled clusters.
+An `Operator Bundle` is built as a scratch (non-runnable) container image that contains operator manifests and specific metadata in designated directories inside the image. Then, it can be pushed and pulled from an OCI-compliant container registry. Ultimately, an operator bundle will be used by [Operator Registry](https://github.com/operator-framework/operator-registry) and [Operator-Lifecycle-Manager (OLM)](https://github.com/operator-framework/operator-lifecycle-manager) to install an operator in OLM-enabled clusters.
 
 ### Bundle Annotations
 
@@ -34,19 +34,19 @@ annotations:
 ```
 
 *Notes:*
-* In case of a mismatch, the `annotations.yaml` file is authoritative because on-cluster operator-registry that relies on these annotations has access to the yaml file only.
+* In case of a mismatch, the `annotations.yaml` file is authoritative because the on-cluster operator-registry that relies on these annotations has access to the yaml file only.
 * The potential use case for the `LABELS` is - an external off-cluster tool can inspect the image to check the type of a given bundle image without downloading the content.
 
 This example uses [Operator Registry Manifests](https://github.com/operator-framework/operator-registry#manifest-format) format to build an operator bundle image. The source directory of an operator registry bundle has the following layout.
 ```
 $ tree test
 test
-├── 0.1.0
-│   ├── testbackup.crd.yaml
-│   ├── testcluster.crd.yaml
-│   ├── testoperator.v0.1.0.clusterserviceversion.yaml
-│   └── testrestore.crd.yaml
-└── annotations.yaml
+├── testbackup.crd.yaml
+├── testcluster.crd.yaml
+├── testoperator.v0.1.0.clusterserviceversion.yaml
+├── testrestore.crd.yaml
+└── metadata
+    └── annotations.yaml
 ```
 
 ### Bundle Dockerfile
@@ -60,7 +60,7 @@ FROM scratch
 LABEL operators.operatorframework.io.bundle.resources=manifests+metadata
 LABEL operators.operatorframework.io.bundle.mediatype=registry+v1
 
-ADD test/0.1.0 /manifests
+ADD test/*.yaml /manifests
 ADD test/annotations.yaml /metadata/annotations.yaml
 ```
 
@@ -77,68 +77,69 @@ $ tree
     └── annotations.yaml
 ```
 
-## Operator Bundle Command-Line Tool
+## Operator Bundle Commands
 
-A CLI tool is available to generate Bundle annotations and Dockerfile based on provided operator manifests.
+Operator SDK CLI is available to generate Bundle annotations and Dockerfile based on provided operator manifests.
 
-### Bundle CLI
+### Operator SDK CLI
 
-In order to build `operator-cli` CLI tool, follow these steps:
+In order to use Operator SDK CLI, follow the operator-SDK installation instruction:
 
-1. Clone [Operator-Lifecycle-Manager (OLM)](https://github.com/operator-framework/operator-lifecycle-manager) repository.
-2. Build `operator-cli` binary:
-```bash
-$ go build ./cmd/operator-cli/
-```
+1. Install the [Operator SDK CLI](https://github.com/operator-framework/operator-sdk/blob/master/doc/user/install-operator-sdk.md)
 
 Now, a binary named `operator-cli` is available in OLM's directory to use.
 ```bash
-$ ./operator-cli
-Generate operator bundle metadata and build bundle image.
+$ ./operator-sdk
+An SDK for building operators with ease
 
 Usage:
-   bundle [command]
+  operator-sdk [command]
 
 Available Commands:
-  build       Build operator bundle image
-  generate    Generate operator bundle metadata and Dockerfile
+    bundle      Operator bundle commands
 
 Flags:
-  -h, --help   help for bundle
+  -h, --help      help for operator-sdk
+      --verbose   Enable verbose logging
 
-Use " bundle [command] --help" for more information about a command.
+Use "operator-sdk [command] --help" for more information about a command.
 ```
 
 ### Generate Bundle Annotations and DockerFile
 
-Using `operator-cli` CLI, bundle annotations can be generated from provided operator manifests. The command for `generate` task is:
+Using `operator-sdk` CLI, bundle annotations can be generated from provided operator manifests. The command for `generate` task is:
 ```bash
-$ ./operator-cli bundle generate --directory /test/0.0.1/
+$ ./operator-sdk bundle generate --directory /test/
 ```
-The `--directory` or `-d` specifies the directory where the operator manifests are located. The `annotations.yaml` and `Dockerfile` are generated in the same directory where the manifests folder is located (not where the YAML manifests are located). For example:
+The `--directory` or `-d` specifies the directory where the operator manifests are located. The `Dockerfile` is generated in the same directory where the YAML manifests are located while the `annotations.yaml` file is located in a folder named `metadata`. For example:
 ```bash
 $ tree test
 test
-├── 0.0.1
-│   ├── testbackup.crd.yaml
-│   ├── testcluster.crd.yaml
-│   ├── testoperator.v0.1.0.clusterserviceversion.yaml
-│   └── testrestore.crd.yaml
-├── annotations.yaml
+├── testbackup.crd.yaml
+├── testcluster.crd.yaml
+├── testoperator.v0.1.0.clusterserviceversion.yaml
+├── testrestore.crd.yaml
+├── metadata
+│   └── annotations.yaml
 └── Dockerfile
 ```
 
-Note: If there are `annotations.yaml` and `Dockerfile` existing in the directory, they will be overwritten.
+*Notes:*
+* If there are `annotations.yaml` and `Dockerfile` existing in the directory, they will be overwritten.
 
 ### Build Bundle Image
 
 Operator bundle image can be built from provided operator manifests using `build` command:
 ```bash
-$ ./operator-cli bundle build --directory /test/0.0.1/ --tag quay.io/coreos/test-operator.v0.0.1:latest
+$ ./operator-sdk bundle build --directory /test/0.1.0/ --tag quay.io/coreos/test-operator.v0.1.0:latest
 ```
 The `--directory` or `-d` specifies the directory where the operator manifests are located. The `--tag` or `-t` specifies the image tag that you want the operator bundle image to have. By using `build` command, the `annotations.yaml` and `Dockerfile` are automatically generated in the background.
 
 The default image builder is `Docker`. However, ` Buildah` and `Podman` are also supported. An image builder can specified via `--image-builder` or `-b` optional tag in `build` command. For example:
 ```bash
-$ ./operator-cli bundle build --directory /test/0.0.1/ --tag quay.io/coreos/test-operator.v0.0.1:latest --image-builder podman
+$ ./operator-sdk bundle build --directory /test/0.1.0/ --tag quay.io/coreos/test-operator.v0.1.0:latest --image-builder podman
 ```
+
+*Notes:*
+* If there are `annotations.yaml` and `Dockerfile` existing in the directory, they will be overwritten.
+* The directory where the operator manifests are located must must be inside the context of the build which in this case is inside the directory where you run the command.