Update bundle validation lib for sdk consumption

Updated the bundle validation lib functions to expose separate functions
for pulling and validating bundles -- this allows the operator sdk to
run this validation against locally created bundle directories

Condensed some of the bundle image parsing code to use the common
containertool functions already defined elsewhere in the project

Additionally, updated the logging and validation error collection to be
more configurable

Author: kevinrizza

cmd/opm/alpha/bundle/validate.go

@@ -1,6 +1,9 @@
 package bundle
 
 import (
+	"io/ioutil"
+	"os"
+
 	"github.com/operator-framework/operator-registry/pkg/lib/bundle"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -11,12 +14,10 @@ func newBundleValidateCmd() *cobra.Command {
 		Use:   "validate",
 		Short: "Validate bundle image",
 		Long: `The "opm alpha bundle validate" command will validate bundle image
-    from a remote source to determine if its format and content information are
-    accurate.
-
-        $ opm alpha bundle validate --tag quay.io/test/test-operator:latest \
-		--image-builder docker`,
-		RunE: validateFunc,
+from a remote source to determine if its format and content information are
+accurate.`,
+		Example: `$ opm alpha bundle validate --tag quay.io/test/test-operator:latest --image-builder docker`,
+		RunE:    validateFunc,
 	}
 
 	bundleValidateCmd.Flags().StringVarP(&tagBuildArgs, "tag", "t", "",
@@ -31,10 +32,36 @@ func newBundleValidateCmd() *cobra.Command {
 }
 
 func validateFunc(cmd *cobra.Command, args []string) error {
-	err := bundle.ValidateFunc(tagBuildArgs, imageBuilderArgs)
+	logger := log.WithFields(log.Fields{"container-tool": imageBuilderArgs})
+	log.SetLevel(log.DebugLevel)
+
+	imageValidator := bundle.NewImageValidator(imageBuilderArgs, logger)
+
+	dir, err := ioutil.TempDir("", "bundle-")
+	logger.Infof("Create a temp directory at %s", dir)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		err := os.RemoveAll(dir)
+		if err != nil {
+			logger.Error(err.Error())
+		}
+	}()
+
+	err = imageValidator.PullBundleImage(tagBuildArgs, dir)
 	if err != nil {
 		return err
 	}
 
+	logger.Info("Unpacked image layers, validating bundle image contents")
+
+	err = imageValidator.ValidateBundle(dir)
+	if err != nil {
+		return err
+	}
+
+	logger.Info("All validation tests have been completed successfully")
+
 	return nil
 }

pkg/containertools/imagereader.go

@@ -58,16 +58,17 @@ func (b ImageLayerReader) GetImageData(image, outputDir string, opts ...GetImage
 		return err
 	}
 
-	workingDir := options.WorkingDir
-	if workingDir == "" {
+	rootTarfile := filepath.Join(options.WorkingDir, "bundle.tar")
+
+	if options.WorkingDir == "" {
 		workingDir, err := ioutil.TempDir("./", "bundle_staging_")
 		if err != nil {
 			return err
 		}
 		defer os.RemoveAll(workingDir)
-	}
 
-	rootTarfile := filepath.Join(workingDir, "bundle.tar")
+		rootTarfile = filepath.Join(workingDir, "bundle.tar")
+	}
 
 	err = b.Cmd.Save(image, rootTarfile)
 	if err != nil {

pkg/lib/bundle/errors.go

@@ -0,0 +1,32 @@
+package bundle
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ValidationError is an imlementation of the Error type
+// that defines a set of errors when validating the bundle
+type ValidationError struct {
+	AnnotationErrors []error
+	FormatErrors     []error
+}
+
+func (v ValidationError) Error() string {
+	var errs []string
+	for _, err := range v.AnnotationErrors {
+		errs = append(errs, err.Error())
+	}
+	for _, err := range v.FormatErrors {
+		errs = append(errs, err.Error())
+	}
+	return fmt.Sprintf("Bundle validation errors: %s",
+		strings.Join(errs, ","))
+}
+
+func NewValidationError(annotationErrs, formatErrs []error) ValidationError {
+	return ValidationError{
+		AnnotationErrors: annotationErrs,
+		FormatErrors:     formatErrs,
+	}
+}

pkg/lib/bundle/generate.go

@@ -10,6 +10,8 @@ import (
 	log "github.com/sirupsen/logrus"
 
 	"gopkg.in/yaml.v2"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	k8syaml "k8s.io/apimachinery/pkg/util/yaml"
 )
 
 const (
@@ -93,34 +95,53 @@ func GenerateFunc(directory, packageName, channels, channelDefault string, overw
 	return nil
 }
 
-// GenerateFunc determines mediatype from files (yaml) in given directory
+// GetMediaType 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
+	k8sFiles := make(map[string]*unstructured.Unstructured)
 
 	// Read all file names in directory
 	items, _ := ioutil.ReadDir(directory)
 	for _, item := range items {
 		if item.IsDir() {
 			continue
-		} else if filepath.Ext(item.Name()) == ".yaml" {
-			files = append(files, item.Name())
+		}
+
+		files = append(files, item.Name())
+
+		fileWithPath := filepath.Join(directory, item.Name())
+		fileBlob, err := ioutil.ReadFile(fileWithPath)
+		if err != nil {
+			return "", fmt.Errorf("Unable to read file %s in bundle", fileWithPath)
+		}
+
+		dec := k8syaml.NewYAMLOrJSONDecoder(strings.NewReader(string(fileBlob)), 10)
+		unst := &unstructured.Unstructured{}
+		if err := dec.Decode(unst); err == nil {
+			k8sFiles[item.Name()] = unst
 		}
 	}
 
 	if len(files) == 0 {
 		return "", fmt.Errorf("The directory %s contains no yaml files", directory)
 	}
 
-	// Validate the file names to determine media type
-	for _, file := range files {
-		if file == "Chart.yaml" {
+	// Validate the files to determine media type
+	for _, fileName := range files {
+		// TODO: be more robust here, we should validate the format of helm charts
+		// instead of file name
+		fmt.Println(fileName)
+		if fileName == "Chart.yaml" {
 			return HelmType, nil
-		} else if strings.HasSuffix(file, "clusterserviceversion.yaml") {
-			return RegistryV1Type, nil
-		} else {
-			continue
+		}
+
+		// Check if one of the k8s files is a CSV
+		if k8sFile, ok := k8sFiles[fileName]; ok {
+			if k8sFile.GetObjectKind().GroupVersionKind().Kind == "ClusterServiceVersion" {
+				return RegistryV1Type, nil
+			}
 		}
 	}
 
@@ -167,7 +188,7 @@ func ValidateAnnotations(existing, expected []byte) error {
 	return nil
 }
 
-// ValidateAnnotations validates provided default channel to ensure it exists in
+// ValidateChannelDefault validates provided default channel to ensure it exists in
 // provided channel list.
 func ValidateChannelDefault(channels, channelDefault string) (string, error) {
 	var chanDefault string

pkg/lib/bundle/generate_test.go

@@ -10,46 +10,40 @@ import (
 )
 
 func TestGetMediaType(t *testing.T) {
-	setup("")
-	defer cleanup()
-
-	testDir := getTestDir()
 	tests := []struct {
 		directory string
 		mediaType string
 		errorMsg  string
 	}{
 		{
-			testDir,
+			"./testdata/get_mediatype/registry_v1_bundle",
 			RegistryV1Type,
 			"",
 		},
 		{
-			testDir,
+			"./testdata/get_mediatype/helm_bundle",
 			HelmType,
 			"",
 		},
 		{
-			testDir,
+			"./testdata/get_mediatype/plain_bundle",
 			PlainType,
 			"",
 		},
 		{
-			testDir,
+			"./testdata/get_mediatype/empty_bundle",
 			"",
-			fmt.Sprintf("The directory %s contains no yaml files", testDir),
+			fmt.Sprintf("The directory contains no files"),
 		},
 	}
 
 	for _, item := range tests {
-		createFiles(testDir, item.mediaType)
 		manifestType, err := GetMediaType(item.directory)
 		if item.errorMsg == "" {
 			require.Equal(t, item.mediaType, manifestType)
 		} else {
-			require.Equal(t, item.errorMsg, err.Error())
+			require.Error(t, err)
 		}
-		clearDir(testDir)
 	}
 }
 

pkg/lib/bundle/interfaces.go

@@ -0,0 +1,26 @@
+package bundle
+
+import (
+	"github.com/operator-framework/operator-registry/pkg/containertools"
+
+	"github.com/sirupsen/logrus"
+)
+
+// BundleImageValidator provides a toolset for pulling and then validating
+// bundle container images
+type BundleImageValidator interface {
+	// PullBundleImage takes an imageTag to pull and a directory to push
+	// the contents of the image to
+	PullBundleImage(imageTag string, directory string) error
+	// Validate bundle takes a directory containing the contents of a bundle image
+	// and validates that the format is correct
+	ValidateBundle(directory string) error
+}
+
+// NewImageValidator is a constructor that returns an ImageValidator
+func NewImageValidator(containerTool string, logger *logrus.Entry) BundleImageValidator {
+	return imageValidator{
+		imageReader: containertools.NewImageReader(containerTool, logger),
+		logger:      logger,
+	}
+}