Fix bundle library to add package and channels info to annotations

1. Package name, channels, default channel info is now added to
annotations.yaml
2. `bundle generate` will retain overwritten ability while `bundle
build` will only overwrite Dockerfile.
3. Validate annotations.yaml if existed.
4. `--overwrite/o` flag is available to overwrite annotations.yaml
during build command.

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

Author: dinhxuanvu

pkg/lib/bundle/build.go

@@ -40,16 +40,16 @@ func ExecuteCommand(cmd *exec.Cmd) error {
 	return nil
 }
 
-func BuildFunc(directory, imageTag, imageBuilder string) error {
+func BuildFunc(directory, imageTag, imageBuilder, packageName, channels, channelDefault string, overwrite bool) error {
 	// Generate annotations.yaml and Dockerfile
-	err := GenerateFunc(directory)
+	err := GenerateFunc(directory, packageName, channels, channelDefault, overwrite)
 	if err != nil {
 		return err
 	}
 
 	// Build bundle image
 	log.Info("Building bundle image")
-	buildCmd, err := BuildBundleImage(path.Dir(path.Clean(directory)), imageBuilder, imageTag)
+	buildCmd, err := BuildBundleImage(path.Clean(directory), imageBuilder, imageTag)
 	if err != nil {
 		return err
 	}

pkg/lib/bundle/generate.go

@@ -3,7 +3,7 @@ package bundle
 import (
 	"fmt"
 	"io/ioutil"
-	"path"
+	"os"
 	"path/filepath"
 	"strings"
 
@@ -13,27 +13,30 @@ import (
 )
 
 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"
+	defaultPermission   = 0644
+	registryV1Type      = "registry+v1"
+	plainType           = "plain"
+	helmType            = "helm"
+	annotationsFile     = "annotations.yaml"
+	dockerFile          = "Dockerfile"
+	manifestsDir        = "manifests/"
+	metadataDir         = "metadata/"
+	manifestsLabel      = "operators.operatorframework.io.bundle.manifests.v1"
+	metadataLabel       = "operators.operatorframework.io.bundle.metadata.v1"
+	mediatypeLabel      = "operators.operatorframework.io.bundle.mediatype.v1"
+	packageLabel        = "operators.operatorframework.io.bundle.package.v1"
+	channelsLabel       = "operators.operatorframework.io.bundle.channels.v1"
+	channelDefaultLabel = "operators.operatorframework.io.bundle.channel.default.v1"
 )
 
 type AnnotationMetadata struct {
-	Annotations AnnotationType `yaml:"annotations"`
+	Annotations map[string]string `yaml:"annotations"`
 }
 
-type AnnotationType struct {
-	Resources string `yaml:"operators.operatorframework.io.bundle.resources"`
-	MediaType string `yaml:"operators.operatorframework.io.bundle.mediatype"`
-}
-
-func GenerateFunc(directory string) error {
+// GenerateFunc builds annotations.yaml with mediatype, manifests &
+// metadata directories in bundle image, package name, channels and default
+// channels information and then writes the file to `/metadata` directory.
+func GenerateFunc(directory, packageName, channels, channelDefault string, overwrite bool) error {
 	var mediaType string
 
 	// Determine mediaType
@@ -42,33 +45,48 @@ func GenerateFunc(directory string) error {
 		return err
 	}
 
-	// Parent directory
-	parentDir := path.Dir(path.Clean(directory))
-
-	log.Info("Building annotations.yaml file")
+	log.Info("Building annotations.yaml")
 
 	// Generate annotations.yaml
-	content, err := GenerateAnnotations(manifestsMetadata, mediaType)
+	content, err := GenerateAnnotations(mediaType, manifestsDir, metadataDir, packageName, channels, channelDefault)
 	if err != nil {
 		return err
 	}
-	err = WriteFile(annotationsFile, parentDir, content)
-	if err != nil {
+
+	file, err := ioutil.ReadFile(filepath.Join(directory, metadataDir, annotationsFile))
+	if os.IsNotExist(err) || overwrite {
+		err = WriteFile(annotationsFile, filepath.Join(directory, metadataDir), content)
+		if err != nil {
+			return err
+		}
+	} else if err != nil {
 		return err
+	} else {
+		log.Info("An annotations.yaml already exists in directory")
+		if err = ValidateAnnotations(file, content); err != nil {
+			return err
+		}
 	}
 
 	log.Info("Building Dockerfile")
 
 	// Generate Dockerfile
-	content = GenerateDockerfile(manifestsMetadata, mediaType, directory)
-	err = WriteFile(dockerFile, parentDir, content)
+	content, err = GenerateDockerfile(directory, mediaType, manifestsDir, metadataDir, packageName, channels, channelDefault)
+	if err != nil {
+		return err
+	}
+
+	err = WriteFile(dockerFile, directory, content)
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
 
+// GenerateFunc determines mediatype from files (yaml) in given directory
+// Currently able to detect helm chart, registry+v1 (CSV) and plain k8s resources
+// such as CRD.
 func GetMediaType(directory string) (string, error) {
 	var files []string
 
@@ -100,14 +118,97 @@ func GetMediaType(directory string) (string, error) {
 	return plainType, nil
 }
 
-func GenerateAnnotations(resourcesType, mediaType string) ([]byte, error) {
+// ValidateAnnotations validates existing annotations.yaml against generated
+// annotations.yaml to ensure existing annotations.yaml contains expected values.
+func ValidateAnnotations(existing, expected []byte) error {
+	var fileAnnotations AnnotationMetadata
+	var expectedAnnotations AnnotationMetadata
+
+	log.Info("Validating existing annotations.yaml")
+
+	err := yaml.Unmarshal(existing, &fileAnnotations)
+	if err != nil {
+		log.Errorf("Unable to parse existing annotations.yaml")
+		return err
+	}
+
+	err = yaml.Unmarshal(expected, &expectedAnnotations)
+	if err != nil {
+		log.Errorf("Unable to parse expected annotations.yaml")
+		return err
+	}
+
+	if len(fileAnnotations.Annotations) != len(expectedAnnotations.Annotations) {
+		return fmt.Errorf("Unmatched number of fields. Expected (%d) vs existing (%d)",
+			len(expectedAnnotations.Annotations), len(fileAnnotations.Annotations))
+	}
+
+	for label, item := range expectedAnnotations.Annotations {
+		value, ok := fileAnnotations.Annotations[label]
+		if ok == false {
+			return fmt.Errorf("Missing field: %s", label)
+		}
+
+		if item != value {
+			return fmt.Errorf(`Expect field "%s" to have value "%s" instead of "%s"`,
+				label, item, value)
+		}
+	}
+
+	return nil
+}
+
+// ValidateAnnotations validates provided default channel to ensure it exists in
+// provided channel list.
+func ValidateChannelDefault(channels, channelDefault string) (string, error) {
+	var chanDefault string
+	var chanErr error
+	channelList := strings.Split(channels, ",")
+
+	if channelDefault != "" {
+		for _, channel := range channelList {
+			if channel == channelDefault {
+				chanDefault = channelDefault
+				break
+			}
+		}
+		if chanDefault == "" {
+			chanDefault = channelList[0]
+			chanErr = fmt.Errorf(`The channel list "%s" doesn't contain channelDefault "%s"`, channels, channelDefault)
+		}
+	} else {
+		chanDefault = channelList[0]
+	}
+
+	if chanDefault != "" {
+		return chanDefault, chanErr
+	} else {
+		return chanDefault, fmt.Errorf("Invalid channels is provied: %s", channels)
+	}
+}
+
+// GenerateAnnotations builds annotations.yaml with mediatype, manifests &
+// metadata directories in bundle image, package name, channels and default
+// channels information.
+func GenerateAnnotations(mediaType, manifests, metadata, packageName, channels, channelDefault string) ([]byte, error) {
 	annotations := &AnnotationMetadata{
-		Annotations: AnnotationType{
-			Resources: resourcesType,
-			MediaType: mediaType,
+		Annotations: map[string]string{
+			mediatypeLabel:      mediaType,
+			manifestsLabel:      manifests,
+			metadataLabel:       metadata,
+			packageLabel:        packageName,
+			channelsLabel:       channels,
+			channelDefaultLabel: channelDefault,
 		},
 	}
 
+	chanDefault, err := ValidateChannelDefault(channels, channelDefault)
+	if err != nil {
+		return nil, err
+	}
+
+	annotations.Annotations[channelDefaultLabel] = chanDefault
+
 	afile, err := yaml.Marshal(annotations)
 	if err != nil {
 		return nil, err
@@ -116,28 +217,42 @@ func GenerateAnnotations(resourcesType, mediaType string) ([]byte, error) {
 	return afile, nil
 }
 
-func GenerateDockerfile(resourcesType, mediaType, directory string) []byte {
+// GenerateDockerfile builds Dockerfile with mediatype, manifests &
+// metadata directories in bundle image, package name, channels and default
+// channels information in LABEL section.
+func GenerateDockerfile(directory, mediaType, manifests, metadata, packageName, channels, channelDefault string) ([]byte, error) {
 	var fileContent string
 
-	metadataDir := path.Dir(path.Clean(directory))
+	chanDefault, err := ValidateChannelDefault(channels, channelDefault)
+	if err != nil {
+		return nil, err
+	}
 
 	// FROM
 	fileContent += "FROM scratch\n\n"
 
 	// LABEL
-	fileContent += fmt.Sprintf("LABEL %s=%s\n", resourcesLabel, resourcesType)
-	fileContent += fmt.Sprintf("LABEL %s=%s\n\n", mediatypeLabel, mediaType)
+	fileContent += fmt.Sprintf("LABEL %s=%s\n", mediatypeLabel, mediaType)
+	fileContent += fmt.Sprintf("LABEL %s=%s\n", manifestsLabel, manifests)
+	fileContent += fmt.Sprintf("LABEL %s=%s\n", metadataLabel, metadata)
+	fileContent += fmt.Sprintf("LABEL %s=%s\n", packageLabel, packageName)
+	fileContent += fmt.Sprintf("LABEL %s=%s\n", channelsLabel, channels)
+	fileContent += fmt.Sprintf("LABEL %s=%s\n\n", channelDefaultLabel, chanDefault)
 
 	// CONTENT
-	fileContent += fmt.Sprintf("ADD %s %s\n", directory, "/manifests")
-	fileContent += fmt.Sprintf("ADD %s/%s %s%s\n", metadataDir, annotationsFile, "/metadata/", annotationsFile)
+	fileContent += fmt.Sprintf("ADD %s %s\n", filepath.Join(directory, "*.yaml"), "/manifests")
+	fileContent += fmt.Sprintf("ADD %s %s%s\n", filepath.Join(directory, metadata, annotationsFile), "/metadata/", annotationsFile)
 
-	return []byte(fileContent)
+	return []byte(fileContent), nil
 }
 
 // Write `fileName` file with `content` into a `directory`
 // Note: Will overwrite the existing `fileName` file if it exists
 func WriteFile(fileName, directory string, content []byte) error {
+	if _, err := os.Stat(directory); os.IsNotExist(err) {
+		os.Mkdir(directory, os.ModePerm)
+	}
+
 	err := ioutil.WriteFile(filepath.Join(directory, fileName), content, defaultPermission)
 	if err != nil {
 		return err