Match bundle image directory structure

This commit introduces a change to the way that the way the API function
bundle.GenerateFunc manages directory structure. Currently, the output
of that function creates a metadata folder with generated annotations
inside the given manifest directory. However, this is not how bundle
images are actually formatted, and the Dockerfile does some indirection
in order to copy the files into the correct directory.

However, we should consider the default behvaior of `generate` to be
"run once" (especially given that by default the regeneration does not
happen in the build function by default). The expectation is that
generate is a scaffolding method. Given that, we should scaffold the
metadata directory in the same manner as it would actually appear in the
union filesystem on the resulting container image.

In order to accomplish this, this PR makes a few functional changes:

- By default, create the metadata directory in the same parent directory
as the given manifest directory. This, at a high level, mirrors the
directory tree that will exist on the resulting bundle.

- Generates the dockerfile in the current working directory that the
function is called from. Modifies the dockerfile to point to the
relative path of the generated files

- Adds an option output directory parameter to the function (as well
as the shadowed `opm alpha bundle build/generate` commands) to
allow the user to generate a *new* bundle directory.

Author: kevinrizza

cmd/opm/alpha/bundle/build.go

@@ -13,6 +13,7 @@ var (
 	packageNameArgs    string
 	channelsArgs       string
 	channelDefaultArgs string
+	outputDirArgs      string
 	overwriteArgs      bool
 )
 
@@ -69,11 +70,13 @@ func newBundleBuildCmd() *cobra.Command {
 
 	bundleBuildCmd.Flags().BoolVarP(&overwriteArgs, "overwrite", "o", false, "To overwrite annotations.yaml locally if existed. By default, overwrite is set to `false`.")
 
+	bundleBuildCmd.Flags().StringVarP(&outputDirArgs, "output-dir", "u", "", "Optional output directory for operator manifests")
+
 	return bundleBuildCmd
 }
 
 func buildFunc(cmd *cobra.Command, args []string) error {
-	err := bundle.BuildFunc(dirBuildArgs, tagBuildArgs, imageBuilderArgs,
+	err := bundle.BuildFunc(dirBuildArgs, outputDirArgs, tagBuildArgs, imageBuilderArgs,
 		packageNameArgs, channelsArgs, channelDefaultArgs, overwriteArgs)
 	if err != nil {
 		return err

cmd/opm/alpha/bundle/generate.go

@@ -41,11 +41,13 @@ func newBundleGenerateCmd() *cobra.Command {
 
 	bundleGenerateCmd.Flags().StringVarP(&channelDefaultArgs, "default", "e", "", "The default channel for the bundle image")
 
+	bundleGenerateCmd.Flags().StringVarP(&outputDirArgs, "output-dir", "u", "", "Optional output directory for operator manifests")
+
 	return bundleGenerateCmd
 }
 
 func generateFunc(cmd *cobra.Command, args []string) error {
-	err := bundle.GenerateFunc(dirBuildArgs, packageNameArgs, channelsArgs, channelDefaultArgs, true)
+	err := bundle.GenerateFunc(dirBuildArgs, outputDirArgs, packageNameArgs, channelsArgs, channelDefaultArgs, true)
 	if err != nil {
 		return err
 	}

docs/design/operator-bundle.md

@@ -119,13 +119,14 @@ Flags:
   -e, --default string     The default channel for the bundle image
   -d, --directory string   The directory where bundle manifests for a specific version are located.
   -h, --help               help for generate
+  -u, --output-dir string  Optional output directory for operator manifests
   -p, --package string     The name of the package that bundle image belongs to
 
   Note:
   * All manifests yaml must be in the same directory.
 ```
 
-The `--directory/-d`, `--channels/-c`, `--package/-p` are required flags while `--default/-e` is optional.
+The `--directory/-d`, `--channels/-c`, `--package/-p` are required flags while `--default/-e` and `--output-dir/-u` are optional.
 
 The command for `generate` task is:
 ```bash
@@ -145,17 +146,35 @@ The `--package` or `-p` is the name of package fo the operator such as `etcd` wh
 
 All information in `annotations.yaml` is also existed in `LABEL` section of `Dockerfile`.
 
-After the generate command is executed, 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:
+After the generate command is executed, the `Dockerfile` is generated in the directory where command is run. By default, the `annotations.yaml` file is located in a folder named `metadata` in the same root directory as the input directory containing manifests. For example:
 ```bash
 $ tree test
 test
-├── etcdcluster.crd.yaml
-├── etcdoperator.clusterserviceversion.yaml
+├── my-manifests
+│   ├── etcdcluster.crd.yaml
+│   └── etcdoperator.clusterserviceversion.yaml
 ├── metadata
 │   └── annotations.yaml
 └── Dockerfile
 ```
 
+If the `--output-dir` parameter is specified, that directory becomes the parent for a new pair of folders `manifests/` and `metadata/`, where `manifests/` is a copy of the passed in directory of manifests and `metadata/` is the folder containing annotations.yaml:
+
+```bash
+$ tree test
+test
+├── my-manifests
+│   ├── etcdcluster.crd.yaml
+│   └── etcdoperator.clusterserviceversion.yaml
+├── my-output-manifest-dir
+│   ├── manifests
+│   │   ├── etcdoperator.clusterserviceversion.yaml
+│   │   └── etcdoperator.clusterserviceversion.yaml
+│   └── metadata
+│       └── annotations.yaml
+└── Dockerfile
+```
+
 The `Dockerfile` can be used manually to build the bundle image using container image tools such as Docker, Podman or Buildah. For example, the Docker build command would be:
 
 ```bash
@@ -175,7 +194,8 @@ Flags:
   -d, --directory string       The directory where bundle manifests for a specific version are located
   -h, --help                   help for build
   -b, --image-builder string   Tool to build container images. One of: [docker, podman, buildah] (default "docker")
-  -0, --overwrite               To overwrite annotations.yaml if existing
+  -u, --output-dir string      Optional output directory for operator manifests
+  -0, --overwrite              To overwrite annotations.yaml if existing
   -p, --package string         The name of the package that bundle image belongs to
   -t, --tag string             The name of the bundle image will be built
 

pkg/lib/bundle/build.go

@@ -4,22 +4,19 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path"
 
 	log "github.com/sirupsen/logrus"
 )
 
 // Create build command to build bundle manifests image
-func BuildBundleImage(directory, imageTag, imageBuilder string) (*exec.Cmd, error) {
+func BuildBundleImage(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, directory)
+		args = append(args, "build", "-f", DockerFile, "-t", imageTag, ".")
 	case "buildah":
-		args = append(args, "bud", "--format=docker", "-f", dockerfilePath, "-t", imageTag, directory)
+		args = append(args, "bud", "--format=docker", "-f", DockerFile, "-t", imageTag, ".")
 	default:
 		return nil, fmt.Errorf("%s is not supported image builder", imageBuilder)
 	}
@@ -53,21 +50,21 @@ func ExecuteCommand(cmd *exec.Cmd) error {
 // @channels: The list of channels that bundle image belongs to
 // @channelDefault: The default channel for the bundle image
 // @overwrite: Boolean flag to enable overwriting annotations.yaml locally if existed
-func BuildFunc(directory, imageTag, imageBuilder, packageName, channels, channelDefault string, overwrite bool) error {
+func BuildFunc(directory, outputDir, imageTag, imageBuilder, packageName, channels, channelDefault string, overwrite bool) error {
 	_, err := os.Stat(directory)
 	if os.IsNotExist(err) {
 		return err
 	}
 
 	// Generate annotations.yaml and Dockerfile
-	err = GenerateFunc(directory, packageName, channels, channelDefault, overwrite)
+	err = GenerateFunc(directory, outputDir, packageName, channels, channelDefault, overwrite)
 	if err != nil {
 		return err
 	}
 
 	// Build bundle image
 	log.Info("Building bundle image")
-	buildCmd, err := BuildBundleImage(path.Clean(directory), imageTag, imageBuilder)
+	buildCmd, err := BuildBundleImage(imageTag, imageBuilder)
 	if err != nil {
 		return err
 	}

pkg/lib/bundle/build_test.go

@@ -12,35 +12,30 @@ func TestBuildBundleImage(t *testing.T) {
 	defer cleanup()
 
 	tests := []struct {
-		directory    string
 		imageTag     string
 		imageBuilder string
 		commandStr   string
 		errorMsg     string
 	}{
 		{
-			testOperatorDir,
 			"test",
 			"docker",
-			"docker build -f /test-operator/Dockerfile -t test /test-operator",
+			"docker build -f bundle.Dockerfile -t test .",
 			"",
 		},
 		{
-			testOperatorDir,
 			"test",
 			"buildah",
-			"buildah bud --format=docker -f /test-operator/Dockerfile -t test /test-operator",
+			"buildah bud --format=docker -f bundle.Dockerfile -t test .",
 			"",
 		},
 		{
-			testOperatorDir,
 			"test",
 			"podman",
-			"podman build -f /test-operator/Dockerfile -t test /test-operator",
+			"podman build -f bundle.Dockerfile -t test .",
 			"",
 		},
 		{
-			testOperatorDir,
 			"test",
 			"hello",
 			"",
@@ -50,7 +45,7 @@ func TestBuildBundleImage(t *testing.T) {
 
 	for _, item := range tests {
 		var cmd *exec.Cmd
-		cmd, err := BuildBundleImage(item.directory, item.imageTag, item.imageBuilder)
+		cmd, err := BuildBundleImage(item.imageTag, item.imageBuilder)
 		if item.errorMsg == "" {
 			require.Contains(t, cmd.String(), item.commandStr)
 		} else {