Merge pull request #671 from njhale/feat/ex-props

Explicit bundle properties

Author: openshift-merge-robot

internal/property/property.go

@@ -30,6 +30,10 @@ func (p Property) Validate() error {
 	return nil
 }
 
+func (p Property) String() string {
+	return fmt.Sprintf("type: %q, value: %q", p.Type, p.Value)
+}
+
 type Package struct {
 	PackageName string `json:"packageName"`
 	Version     string `json:"version"`

pkg/registry/bundle.go

@@ -47,7 +47,7 @@ type Bundle struct {
 	v1beta1crds  []*apiextensionsv1beta1.CustomResourceDefinition
 	v1crds       []*apiextensionsv1.CustomResourceDefinition
 	Dependencies []*Dependency
-	Properties   []*Property
+	Properties   []Property
 	Annotations  *Annotations
 	cacheStale   bool
 }
@@ -182,7 +182,7 @@ func (b *Bundle) ProvidedAPIs() (map[APIKey]struct{}, error) {
 	provided := map[APIKey]struct{}{}
 	crds, err := b.CustomResourceDefinitions()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error getting crds: %s", err)
 	}
 
 	for _, c := range crds {
@@ -210,7 +210,7 @@ func (b *Bundle) ProvidedAPIs() (map[APIKey]struct{}, error) {
 
 	ownedAPIs, _, err := csv.GetApiServiceDefinitions()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error getting apiservice definitions: %s", err)
 	}
 	for _, api := range ownedAPIs {
 		provided[APIKey{Group: api.Group, Version: api.Version, Kind: api.Kind, Plural: api.Name}] = struct{}{}
@@ -256,6 +256,7 @@ func (b *Bundle) AllProvidedAPIsInBundle() error {
 	if err != nil {
 		return err
 	}
+
 	ownedCRDs, _, err := csv.GetCustomResourceDefintions()
 	if err != nil {
 		return err

pkg/registry/csv.go

@@ -263,7 +263,7 @@ func (csv *ClusterServiceVersion) GetApiServiceDefinitions() (owned []*Definitio
 	var objmap map[string]*json.RawMessage
 
 	if err = json.Unmarshal(csv.Spec, &objmap); err != nil {
-		return
+		return nil, nil, fmt.Errorf("error unmarshaling into object map: %s", err)
 	}
 
 	rawValue, ok := objmap[apiServiceDefinitions]

pkg/registry/decode.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/util/yaml"
@@ -42,3 +43,15 @@ func DecodePackageManifest(reader io.Reader) (manifest *PackageManifest, err err
 	manifest = obj
 	return
 }
+
+func decodeFileFS(root fs.FS, path string, into interface{}) error {
+	fileReader, err := root.Open(path)
+	if err != nil {
+		return fmt.Errorf("unable to read file %s: %s", path, err)
+	}
+	defer fileReader.Close()
+
+	decoder := yaml.NewYAMLOrJSONDecoder(fileReader, 30)
+
+	return decoder.Decode(into)
+}

pkg/registry/decode_test.go

@@ -4,6 +4,7 @@ import (
 	"io"
 	"os"
 	"testing"
+	"testing/fstest"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -90,6 +91,25 @@ func TestDecodePackageManifest(t *testing.T) {
 	}
 }
 
+func TestDecodeFileFS(t *testing.T) {
+	type foo struct {
+		Bar string
+	}
+
+	root := fstest.MapFS{
+		"foo.yaml": &fstest.MapFile{Data: []byte("bar: baz")},
+	}
+
+	var nilPtr *foo
+	require.NoError(t, decodeFileFS(root, "foo.yaml", nilPtr))
+	require.Nil(t, nilPtr)
+
+	ptr := &foo{}
+	require.NoError(t, decodeFileFS(root, "foo.yaml", ptr))
+	require.NotNil(t, ptr)
+	require.Equal(t, "baz", ptr.Bar)
+}
+
 func loadFile(t *testing.T, path string) io.Reader {
 	reader, err := os.Open(path)
 	require.NoError(t, err, "unable to load from file %s", path)

pkg/registry/imageinput.go

@@ -1,129 +1,30 @@
 package registry
 
 import (
-	"fmt"
-	"io/ioutil"
+	"os"
 	"path/filepath"
-	"strings"
-
-	"github.com/sirupsen/logrus"
 
 	"github.com/operator-framework/operator-registry/pkg/image"
+	"github.com/sirupsen/logrus"
 )
 
 type ImageInput struct {
-	manifestsDir     string
-	metadataDir      string
-	to               image.Reference
-	from             string
-	AnnotationsFile  *AnnotationsFile
-	dependenciesFile *DependenciesFile
-	Bundle           *Bundle
+	to     image.Reference
+	from   string
+	Bundle *Bundle
 }
 
 func NewImageInput(to image.Reference, from string) (*ImageInput, error) {
-	var annotationsFound, dependenciesFound bool
-	path := from
-	manifests := filepath.Join(path, "manifests")
-	metadata := filepath.Join(path, "metadata")
-	// Get annotations file
-	log := logrus.WithFields(logrus.Fields{"dir": from, "file": metadata, "load": "annotations"})
-	files, err := ioutil.ReadDir(metadata)
-	if err != nil {
-		return nil, fmt.Errorf("unable to read directory %s: %s", metadata, err)
-	}
-
-	// Look for the metadata and manifests sub-directories to find the annotations.yaml
-	// file that will inform how the manifests of the bundle should be loaded into the database.
-	// If dependencies.yaml which contains operator dependencies in metadata directory
-	// exists, parse and load it into the DB
-	annotationsFile := &AnnotationsFile{}
-	dependenciesFile := &DependenciesFile{}
-	for _, f := range files {
-		if !annotationsFound {
-			err = DecodeFile(filepath.Join(metadata, f.Name()), annotationsFile)
-			if err == nil && *annotationsFile != (AnnotationsFile{}) {
-				annotationsFound = true
-				continue
-			}
-		}
-
-		if !dependenciesFound {
-			err = DecodeFile(filepath.Join(metadata, f.Name()), &dependenciesFile)
-			if err != nil {
-				return nil, err
-			}
-			if len(dependenciesFile.Dependencies) > 0 {
-				dependenciesFound = true
-			}
-		}
-	}
-
-	if !annotationsFound {
-		return nil, fmt.Errorf("Could not find annotations file")
-	}
-
-	if !dependenciesFound {
-		log.Info("Could not find optional dependencies file")
-	}
-
-	imageInput := &ImageInput{
-		manifestsDir:     manifests,
-		metadataDir:      metadata,
-		to:               to,
-		from:             from,
-		AnnotationsFile:  annotationsFile,
-		dependenciesFile: dependenciesFile,
-	}
-
-	err = imageInput.getBundleFromManifests()
+	parser := newBundleParser(logrus.WithFields(logrus.Fields{"with": from, "file": filepath.Join(from, "metadata"), "load": "annotations"}))
+	bundle, err := parser.Parse(os.DirFS(from))
 	if err != nil {
 		return nil, err
 	}
+	bundle.BundleImage = to.String()
 
-	return imageInput, nil
-}
-
-func (i *ImageInput) getBundleFromManifests() error {
-	log := logrus.WithFields(logrus.Fields{"dir": i.from, "file": i.manifestsDir, "load": "bundle"})
-
-	csv, err := i.findCSV(i.manifestsDir)
-	if err != nil {
-		return err
-	}
-
-	if csv.Object == nil {
-		return fmt.Errorf("csv is empty: %s", err)
-	}
-
-	log.Info("found csv, loading bundle")
-
-	csvName := csv.GetName()
-
-	bundle, err := loadBundle(csvName, i.manifestsDir)
-	if err != nil {
-		return fmt.Errorf("error loading objs in directory: %s", err)
-	}
-
-	if bundle == nil || bundle.Size() == 0 {
-		return fmt.Errorf("no bundle objects found")
-	}
-
-	// set the bundleimage on the bundle
-	bundle.BundleImage = i.to.String()
-	// set the dependencies on the bundle
-	bundle.Dependencies = i.dependenciesFile.GetDependencies()
-
-	bundle.Name = csvName
-	bundle.Annotations = &i.AnnotationsFile.Annotations
-	bundle.Package = i.AnnotationsFile.Annotations.PackageName
-	bundle.Channels = strings.Split(i.AnnotationsFile.Annotations.Channels, ",")
-
-	if err := bundle.AllProvidedAPIsInBundle(); err != nil {
-		return fmt.Errorf("error checking provided apis in bundle %s: %s", bundle.Name, err)
-	}
-
-	i.Bundle = bundle
-
-	return nil
+	return &ImageInput{
+		to:     to,
+		from:   from,
+		Bundle: bundle,
+	}, nil
 }