Add registryimage pkg

In order to assist in the creation of HCP Packer Registry Image metadata
for various Artifacts. A new package is being added to assist in the
  creation of a registryimage.Image from an existing Artifact.

The FromArtifact function provides a simple approach of extracting the
required bits from an Artifact needed by the HCP Packer registry. The
default values, which can be overwritten by the use of a
ArtifactOverrideFunc , were selected to provide some standard defaults
that are set to be available for most plugins were bundled
with Packer prior to v1.7.0. When those defaults are not viable the
package provider override funcs that can be used by the consumer for
setting the appropriate values.

For those  plugins that generate more than one registryimage.Image per
Artifact one can construct a []registryimage.Image and return that
information as the response of Packer core calling
artifact.State(registryimage.ArtifactStateURI).

Author: Wilken Rivera

packer/registryimage/image.go

@@ -0,0 +1,106 @@
+package registryimage
+
+import (
+	"errors"
+
+	"github.com/hashicorp/packer-plugin-sdk/packer"
+)
+
+// ArtifactStateURI represents the key used by Packer when querying an packersdk.Artifact
+// for Image metadata that a particular component would like to have stored on the HCP Packer Registry.
+const ArtifactStateURI = "par.artifact.metadata"
+
+// ArtifactOverrideFunc represents a transformation func that can be applied to a
+// non-nil *Image. See With* functions for examples.
+type ArtifactOverrideFunc func(*Image) error
+
+// Image represents the metadata for some Artifact in the HCP Packer Registry.
+type Image struct {
+	ImageID                      string
+	ProviderName, ProviderRegion string
+	Metadata                     map[string]string
+}
+
+// FromArtifact returns a *Image that can be used by Packer core for publishing to the HCP Packer Registry.
+// By default FromArtifact will use the a.BuilderID as the Image Provider, and the a.Id() as the ImageID that
+// should be tracked within the HCP Packer Registry. No Region is selected by default as region varies per build.
+// The use of one or more ArtifactOverrideFunc can be used to override any of the defaults used.
+func FromArtifact(a packer.Artifact, opts ...ArtifactOverrideFunc) *Image {
+	if a == nil {
+		return nil
+	}
+
+	img := &Image{
+		ProviderName: a.BuilderId(),
+		ImageID:      a.Id(),
+		Metadata:     make(map[string]string),
+	}
+
+	// Let's grab some state data
+	for _, opt := range opts {
+		err := opt(img)
+		if err != nil {
+			return nil
+		}
+	}
+
+	return img
+}
+
+// WithProvider takes a name, and returns a ArtifactOverrideFunc that can be
+// used to override the set name for an existing Image.
+func WithProvider(name string) func(*Image) error {
+	return func(img *Image) error {
+		if img == nil {
+			return errors.New("no go on empty image")
+		}
+
+		img.ProviderName = name
+		return nil
+	}
+}
+
+// WithID takes a id, and returns a ArtifactOverrideFunc that can be
+// used to override the set id for an existing Image.
+func WithID(id string) func(*Image) error {
+	return func(img *Image) error {
+		if img == nil {
+			return errors.New("no go on empty image")
+		}
+
+		img.ImageID = id
+		return nil
+	}
+}
+
+// WithRegion takes a region, and returns a ArtifactOverrideFunc that can be
+// used to override the set region for an existing Image.
+func WithRegion(region string) func(*Image) error {
+	return func(img *Image) error {
+		if img == nil {
+			return errors.New("no go on empty image")
+		}
+
+		img.ProviderRegion = region
+		return nil
+	}
+}
+
+// SetMetadata takes metadata, and returns a ArtifactOverrideFunc that can be
+// used to set metadata for an existing Image. The incoming metadata `md`
+// will be filtered only for keys whose values are of type string.
+// If you wish to override this behavior you may create your own  ArtifactOverrideFunc
+// for manipulating and setting Image metadata.
+func SetMetadata(md map[string]interface{}) func(*Image) error {
+	return func(img *Image) error {
+		for k, v := range md {
+			v, ok := v.(string)
+			if !ok {
+				continue
+			}
+			img.Metadata[k] = v
+		}
+
+		return nil
+	}
+}

packer/registryimage/image_test.go

@@ -0,0 +1,81 @@
+package registryimage
+
+import (
+	"testing"
+
+	"github.com/hashicorp/packer-plugin-sdk/packer"
+)
+
+func TestFromArtifact_defaults(t *testing.T) {
+	artifact := new(packer.MockArtifact)
+
+	img := FromArtifact(artifact)
+
+	if img.ImageID != artifact.Id() {
+		t.Errorf("expected resulting registryimage.Image to have a valid ImageID, but it got %q", img.ImageID)
+	}
+
+	if img.ProviderName != artifact.BuilderId() {
+		t.Errorf("expected resulting registryimage.Image to have a valid ProviderName, but it got %q", img.ProviderName)
+	}
+
+	// By default no ProviderRegion is specified when generating from an Artifact
+	if img.ProviderRegion != "" {
+		t.Errorf("expected resulting registryimage.Image to have no ProviderRegion, but it got %q", img.ProviderRegion)
+	}
+}
+
+func TestFromArtifact_WithRegion(t *testing.T) {
+	region := "TheGreatBeyond"
+
+	artifact := new(packer.MockArtifact)
+	img := FromArtifact(artifact, WithRegion(region))
+
+	if img.ProviderRegion != region {
+		t.Errorf("expected resulting registryimage.Image to have ProviderRegion of %q, but it got %q", region, img.ProviderRegion)
+	}
+}
+
+func TestFromArtifact_WithImageID(t *testing.T) {
+	id := "some-image-id"
+
+	artifact := new(packer.MockArtifact)
+	img := FromArtifact(artifact, WithID(id))
+
+	if img.ImageID != id {
+		t.Errorf("expected resulting registryimage.Image to have ImageID of %q, but it got %q", id, img.ImageID)
+	}
+}
+
+func TestFromArtifact_WithProvider(t *testing.T) {
+	provider := "Provider"
+
+	artifact := new(packer.MockArtifact)
+	img := FromArtifact(artifact, WithProvider(provider))
+
+	if img.ProviderName != provider {
+		t.Errorf("expected resulting registryimage.Image to have ProviderName of %q, but it got %q", provider, img.ProviderName)
+	}
+}
+
+func TestFromArtifact_SetMetadata(t *testing.T) {
+
+	artifact := new(packer.MockArtifact)
+	artifact.StateValues = map[string]interface{}{
+		"cloud":            "foo",
+		"non-string-value": 7,
+		"slice-of-strings": []string{"foo", "bar"},
+	}
+
+	img := FromArtifact(artifact, SetMetadata(artifact.StateValues))
+
+	if len(img.Metadata) == 0 {
+		t.Errorf("expected resulting registryimage.Image to have some Metadata %q, but it got %q", artifact.StateValues["cloud"], img.Metadata)
+	}
+
+	// Only values of string should be stored as metadata
+	if len(img.Metadata) > 1 {
+		t.Errorf("expected resulting registryimage.Image to have some Metadata only for string values %q, but it got %q", artifact.StateValues["cloud"], img.Metadata)
+	}
+
+}