Unmarshal ImageMetas from Lock file in config

- Use custom unmarshaler for image metas
- Move Metas from image package to config package
- Rename Metas to ImageMetas

pkg/kbld/cmd/image.go

@@ -8,15 +8,14 @@ import (
 	"strings"
 
 	ctlconf "github.com/k14s/kbld/pkg/kbld/config"
-	ctlimg "github.com/k14s/kbld/pkg/kbld/image"
 	"sigs.k8s.io/yaml"
 )
 
 type Images []Image
 
 type Image struct {
 	URL      string
-	Metas    []ctlimg.Meta // empty when deserialized
+	Metas    []ctlconf.Meta // empty when deserialized
 	metasRaw []interface{} // populated when deserialized
 }
 
@@ -39,21 +38,6 @@ func (i Image) Description() string {
 	return strings.TrimSpace(string(yamlBytes))
 }
 
-func (i Image) MetasDescription() []ctlconf.ImageMeta {
-	imageMetas, err := yaml.Marshal(i.Metas)
-	if err != nil {
-		return nil
-	}
-
-	var metas []ctlconf.ImageMeta
-	err = yaml.Unmarshal(imageMetas, &metas)
-	if err != nil {
-		return nil
-	}
-
-	return metas
-}
-
 type imageStruct struct {
 	URL   string
 	Metas []interface{}

pkg/kbld/cmd/resolve.go

@@ -263,14 +263,9 @@ func (o *ResolveOptions) imgpkgLockAnnotations(i ProcessedImageItem) map[string]
 	anns := map[string]string{
 		ctlconf.ImagesLockKbldID: i.UnprocessedImageURL.URL,
 	}
-
-	imageMetas := i.Image.MetasDescription()
-	if imageMetas != nil && len(imageMetas) > 0 {
-		var metas []ctlconf.ImageMeta
-		for _, m := range imageMetas {
-			metas = append(metas, m)
-		}
-		metaYaml, err := yaml.Marshal(metas)
+	imageMetas := i.Metas
+	if len(imageMetas) > 0 {
+		metaYaml, err := yaml.Marshal(imageMetas)
 		if err != nil {
 			return anns
 		}

pkg/kbld/config/config.go

@@ -68,18 +68,7 @@ type ImageOverride struct {
 	NewImage     string                     `json:"newImage"`
 	Preresolved  bool                       `json:"preresolved,omitempty"`
 	TagSelection *versions.VersionSelection `json:"tagSelection,omitempty"`
-	ImageMetas   []ImageMeta                `json:",omitempty"`
-}
-
-type ImageMeta struct {
-	URL       string   `json:",omitempty" yaml:",omitempty"`
-	Type      string   `json:",omitempty" yaml:",omitempty"`
-	Tag       string   `json:",omitempty" yaml:",omitempty"`
-	Path      string   `json:",omitempty" yaml:",omitempty"`
-	RemoteURL string   `json:",omitempty" yaml:",omitempty"`
-	SHA       string   `json:",omitempty" yaml:",omitempty"`
-	Dirty     bool     `json:",omitempty" yaml:",omitempty"`
-	Tags      []string `json:",omitempty" yaml:",omitempty"`
+	ImageMetas   []Meta                     `json:",omitempty"`
 }
 
 type ImageDestination struct {
@@ -180,18 +169,17 @@ func NewConfigFromImagesLock(res ctlres.Resource) (Config, error) {
 	overridesConfig := NewConfig()
 
 	for _, image := range imagesLock.Images {
-		var iMetas []ImageMeta
-		err := yaml.Unmarshal([]byte(image.Annotations[ImagesLockKbldMetas]), &iMetas)
+		imageMeta, err := metasHistory(image.Annotations[ImagesLockKbldMetas])
 		if err != nil {
-			return Config{}, fmt.Errorf("Unmarshaling %s metas annotation: %s", res.Description(), err)
+			return Config{}, fmt.Errorf("Unmarshaling %s as %s annotation:  %s", res.Description(), ImagesLockKbldMetas, err)
 		}
 		iOverride := ImageOverride{
 			ImageRef: ImageRef{
 				Image: image.Annotations[ImagesLockKbldID],
 			},
 			NewImage:    image.Image,
 			Preresolved: true,
-			ImageMetas:  iMetas,
+			ImageMetas:  imageMeta,
 		}
 		overridesConfig.Overrides = append(overridesConfig.Overrides, iOverride)
 	}

pkg/kbld/config/image_meta.go

@@ -0,0 +1,96 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"sigs.k8s.io/yaml"
+)
+
+type Meta interface {
+	meta()
+}
+
+type ImageMeta struct {
+	Metas []Meta
+}
+
+type BuiltImageSourceGit struct {
+	Type      string // always set to 'git'
+	RemoteURL string `json:",omitempty" yaml:",omitempty"`
+	SHA       string
+	Dirty     bool
+	Tags      []string `json:",omitempty" yaml:",omitempty"`
+}
+
+type BuiltImageSourceLocal struct {
+	Type string // always set to 'local'
+	Path string
+}
+
+type ResolvedImageSourceURL struct {
+	Type string // always set to 'resolved'
+	URL  string
+	Tag  string
+}
+
+type TaggedImageMeta struct {
+	Type string // always set to 'tagged'
+	Tags []string
+}
+
+type PreresolvedImageSourceURL struct {
+	Type string // always set to 'preresolved'
+	URL  string
+	Tag  string `json:",omitempty" yaml:",omitempty"`
+}
+
+func (BuiltImageSourceGit) meta()       {}
+func (BuiltImageSourceLocal) meta()     {}
+func (ResolvedImageSourceURL) meta()    {}
+func (TaggedImageMeta) meta()           {}
+func (PreresolvedImageSourceURL) meta() {}
+
+func metasHistory(metas string) ([]Meta, error) {
+	imageMeta := ImageMeta{}
+	err := yaml.Unmarshal([]byte(metas), &imageMeta)
+	if err != nil {
+		return []Meta{}, err
+	}
+	return imageMeta.Metas, nil
+}
+
+var _ json.Unmarshaler = &ImageMeta{}
+
+func (m *ImageMeta) UnmarshalJSON(data []byte) error {
+	var list []interface{}
+	err := yaml.Unmarshal(data, &list)
+	if err != nil {
+		return err
+	}
+
+	var local BuiltImageSourceLocal
+	var git BuiltImageSourceGit
+	var res ResolvedImageSourceURL
+	var preres PreresolvedImageSourceURL
+	var tag TaggedImageMeta
+
+	for _, item := range list {
+		yamlItem, _ := yaml.Marshal(&item)
+		switch {
+		case yaml.Unmarshal(yamlItem, &local) == nil && local.Type == "local":
+			m.Metas = append(m.Metas, local)
+		case yaml.Unmarshal(yamlItem, &git) == nil && git.Type == "git":
+			m.Metas = append(m.Metas, git)
+		case yaml.Unmarshal(yamlItem, &res) == nil && res.Type == "resolved":
+			m.Metas = append(m.Metas, res)
+		case yaml.Unmarshal(yamlItem, &preres) == nil && preres.Type == "preresolved":
+			m.Metas = append(m.Metas, preres)
+		case yaml.Unmarshal(yamlItem, &tag) == nil && tag.Type == "tagged":
+			m.Metas = append(m.Metas, tag)
+		default:
+			return fmt.Errorf("Unknown Image Meta")
+		}
+	}
+	return nil
+}

pkg/kbld/image/built.go

@@ -30,7 +30,7 @@ func NewBuiltImage(url string, buildSource ctlconf.Source, imgDst *ctlconf.Image
 	return BuiltImage{url, buildSource, imgDst, docker, pack, kubectlBuildkit, ko}
 }
 
-func (i BuiltImage) URL() (string, []Meta, error) {
+func (i BuiltImage) URL() (string, []ctlconf.Meta, error) {
 	metas, err := i.sources()
 	if err != nil {
 		return "", nil, err
@@ -90,7 +90,7 @@ func (i BuiltImage) URL() (string, []Meta, error) {
 	}
 }
 
-func (i BuiltImage) optionalPushWithDocker(dockerTmpRef ctlbdk.DockerTmpRef, metas []Meta) (string, []Meta, error) {
+func (i BuiltImage) optionalPushWithDocker(dockerTmpRef ctlbdk.DockerTmpRef, metas []ctlconf.Meta) (string, []ctlconf.Meta, error) {
 	if i.imgDst != nil {
 		digest, err := i.docker.Push(dockerTmpRef, i.imgDst.NewImage)
 		if err != nil {
@@ -108,32 +108,15 @@ func (i BuiltImage) optionalPushWithDocker(dockerTmpRef ctlbdk.DockerTmpRef, met
 	return dockerTmpRef.AsString(), metas, nil
 }
 
-type BuiltImageSourceGit struct {
-	Type      string // always set to 'git'
-	RemoteURL string `json:",omitempty" yaml:",omitempty"`
-	SHA       string
-	Dirty     bool
-	Tags      []string `json:",omitempty" yaml:",omitempty"`
-}
-
-func (BuiltImageSourceGit) meta() {}
-
-type BuiltImageSourceLocal struct {
-	Type string // always set to 'local'
-	Path string
-}
-
-func (BuiltImageSourceLocal) meta() {}
-
-func (i BuiltImage) sources() ([]Meta, error) {
-	var sources []Meta
+func (i BuiltImage) sources() ([]ctlconf.Meta, error) {
+	var sources []ctlconf.Meta
 
 	absPath, err := filepath.Abs(i.buildSource.Path)
 	if err != nil {
 		return nil, err
 	}
 
-	sources = append(sources, BuiltImageSourceLocal{
+	sources = append(sources, ctlconf.BuiltImageSourceLocal{
 		Type: "local",
 		Path: absPath,
 	})
@@ -142,7 +125,7 @@ func (i BuiltImage) sources() ([]Meta, error) {
 
 	if gitRepo.IsValid() {
 		var err error
-		git := BuiltImageSourceGit{Type: "git"}
+		git := ctlconf.BuiltImageSourceGit{Type: "git"}
 
 		git.RemoteURL, err = gitRepo.RemoteURL()
 		if err != nil {

pkg/kbld/image/digested.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	regname "github.com/google/go-containerregistry/pkg/name"
+	ctlconf "github.com/k14s/kbld/pkg/kbld/config"
 )
 
 const digestSep = "@"
@@ -40,7 +41,7 @@ func NewDigestedImageFromParts(url, digest string) DigestedImage {
 	return DigestedImage{nameWithDigest, nil}
 }
 
-func (i DigestedImage) URL() (string, []Meta, error) {
+func (i DigestedImage) URL() (string, []ctlconf.Meta, error) {
 	if i.parseErr != nil {
 		return "", nil, i.parseErr
 	}

pkg/kbld/image/factory.go

@@ -14,11 +14,7 @@ import (
 )
 
 type Image interface {
-	URL() (string, []Meta, error)
-}
-
-type Meta interface {
-	meta()
+	URL() (string, []ctlconf.Meta, error)
 }
 
 type Factory struct {

pkg/kbld/image/preresolved.go

@@ -4,33 +4,20 @@
 package image
 
 import (
-	"github.com/k14s/kbld/pkg/kbld/config"
+	ctlconf "github.com/k14s/kbld/pkg/kbld/config"
 )
 
 type PreresolvedImage struct {
 	url   string
-	metas []config.ImageMeta
+	metas []ctlconf.Meta
 }
 
-type PreresolvedImageSourceURL struct {
-	Type string // always set to 'preresolved'
-	URL  string
-	Tag  string `json:",omitempty" yaml:",omitempty"`
-}
-
-func (PreresolvedImageSourceURL) meta() {}
-
-func NewPreresolvedImage(url string, metas []config.ImageMeta) PreresolvedImage {
+func NewPreresolvedImage(url string, metas []ctlconf.Meta) PreresolvedImage {
 	return PreresolvedImage{url, metas}
 }
 
-func (i PreresolvedImage) URL() (string, []Meta, error) {
-	var imageMetas []Meta
-	for _, m := range i.metas {
-		imageMetas = append(imageMetas, PreresolvedImageSourceURL{Type: m.Type, URL: m.URL, Tag: m.Tag})
-	}
-	imageMetas = append(imageMetas, PreresolvedImageSourceURL{Type: "preresolved", URL: i.url})
+func (i PreresolvedImage) URL() (string, []ctlconf.Meta, error) {
+	imageMetas := append(i.metas, ctlconf.PreresolvedImageSourceURL{Type: "preresolved", URL: i.url})
 
 	return i.url, imageMetas, nil
-
 }

pkg/kbld/image/resolved.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 
 	regname "github.com/google/go-containerregistry/pkg/name"
+	ctlconf "github.com/k14s/kbld/pkg/kbld/config"
 	ctlreg "github.com/k14s/kbld/pkg/kbld/registry"
 )
 
@@ -16,19 +17,11 @@ type ResolvedImage struct {
 	registry ctlreg.Registry
 }
 
-type ResolvedImageSourceURL struct {
-	Type string // always set to 'resolved'
-	URL  string
-	Tag  string
-}
-
-func (ResolvedImageSourceURL) meta() {}
-
 func NewResolvedImage(url string, registry ctlreg.Registry) ResolvedImage {
 	return ResolvedImage{url, registry}
 }
 
-func (i ResolvedImage) URL() (string, []Meta, error) {
+func (i ResolvedImage) URL() (string, []ctlconf.Meta, error) {
 	tag, err := regname.NewTag(i.url, regname.WeakValidation)
 	if err != nil {
 		return "", nil, err
@@ -56,7 +49,7 @@ func (i ResolvedImage) URL() (string, []Meta, error) {
 		return "", nil, err
 	}
 
-	metas = append(metas, ResolvedImageSourceURL{Type: "resolved", URL: i.url, Tag: tag.TagStr()})
+	metas = append(metas, ctlconf.ResolvedImageSourceURL{Type: "resolved", URL: i.url, Tag: tag.TagStr()})
 
 	return url, metas, nil
 }

pkg/kbld/image/tag_selected.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 
 	regname "github.com/google/go-containerregistry/pkg/name"
+	ctlconf "github.com/k14s/kbld/pkg/kbld/config"
 	ctlreg "github.com/k14s/kbld/pkg/kbld/registry"
 	versions "github.com/vmware-tanzu/carvel-vendir/pkg/vendir/versions/v1alpha1"
 )
@@ -24,7 +25,7 @@ func NewTagSelectedImage(url string, selection *versions.VersionSelection,
 	return TagSelectedImage{url, selection, registry}
 }
 
-func (i TagSelectedImage) URL() (string, []Meta, error) {
+func (i TagSelectedImage) URL() (string, []ctlconf.Meta, error) {
 	repo, err := regname.NewRepository(i.url, regname.WeakValidation)
 	if err != nil {
 		return "", nil, err