Merge pull request #424 from carolynvs/schema-version

Populate Schema Version in the CNAB bundle.json

Author: carolynvs-msft

Gopkg.lock

@@ -1,12 +1,19 @@
 # Stay exactly in step with a specific duffle release
 [[constraint]]
   name = "github.com/deislabs/duffle"
-  version = "=0.1.0-ralpha.5+englishrose"
+  version = "=0.2.0-beta.1"
 
 [[constraint]]
   name = "github.com/deislabs/cnab-go"
   branch = "master"
-  
+
+# Using our branch of cnab-to-oci because it is using a more recent version of cnab-go which we need because
+# it has more recent schema changes from CNAB spec 1.0
+[[constraint]]
+  name = "github.com/docker/cnab-to-oci"
+  branch = "cnab-go-with-schema-version"
+  source = "github.com/deislabs/cnab-to-oci"
+
 [[constraint]]
   name = "github.com/carolynvs/datetime-printer"
   version = "v0.2.0"
@@ -89,9 +96,9 @@
   go-tests = true
   unused-packages = true
 
-# This is temporary until we know what packages we need from duffle
+# This is temporary until we know what packages we need from cnab-go
 [[prune.project]]
-  name = "github.com/deislabs/duffle"
+  name = "github.com/deislabs/cnab-go"
   unused-packages = false
 
 [[constraint]]

Gopkg.toml

@@ -0,0 +1,139 @@
+package configadapter
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/deislabs/cnab-go/bundle"
+	"github.com/deislabs/porter/pkg/config"
+	"github.com/deislabs/porter/pkg/context"
+)
+
+// ManifestConverter converts from a porter manifest to a CNAB bundle definition.
+type ManifestConverter struct {
+	*context.Context
+	Manifest *config.Manifest
+}
+
+func (c *ManifestConverter) ToBundle() bundle.Bundle {
+	fmt.Fprintf(c.Out, "\nGenerating Bundle File with Invocation Image %s =======> \n", c.Manifest.Image)
+	b := bundle.Bundle{
+		Name:        c.Manifest.Name,
+		Description: c.Manifest.Description,
+		Version:     c.Manifest.Version,
+		Custom:      make(map[string]interface{}, 1),
+	}
+	image := bundle.InvocationImage{
+		BaseImage: bundle.BaseImage{
+			Image:     c.Manifest.Image,
+			ImageType: "docker",
+		},
+	}
+
+	b.InvocationImages = []bundle.InvocationImage{image}
+	b.Parameters = c.generateBundleParameters()
+	b.Credentials = c.generateBundleCredentials()
+	b.Images = c.generateBundleImages()
+	b.Custom[config.CustomBundleKey] = c.GenerateStamp()
+
+	return b
+}
+
+func (c *ManifestConverter) generateBundleParameters() bundle.ParametersDefinition {
+	params := bundle.ParametersDefinition{
+		Fields: make(map[string]bundle.ParameterDefinition, len(c.Manifest.Parameters)),
+	}
+	for _, param := range append(c.Manifest.Parameters, c.buildDefaultPorterParameters()...) {
+		fmt.Fprintf(c.Out, "Generating parameter definition %s ====>\n", param.Name)
+		p := bundle.ParameterDefinition{
+			DataType:      param.DataType,
+			Default:       param.Default,
+			AllowedValues: param.AllowedValues,
+			MinValue:      param.MinValue,
+			MaxValue:      param.MaxValue,
+			MinLength:     param.MinLength,
+			MaxLength:     param.MaxLength,
+		}
+
+		// If the default is empty, set required to true.
+		if param.Default == nil {
+			params.Required = append(params.Required, param.Name)
+		}
+
+		if param.Metadata.Description != "" {
+			p.Metadata = &bundle.ParameterMetadata{Description: param.Metadata.Description}
+		}
+
+		if param.Destination != nil {
+			p.Destination = &bundle.Location{
+				EnvironmentVariable: param.Destination.EnvironmentVariable,
+				Path:                param.Destination.Path,
+			}
+		} else {
+			p.Destination = &bundle.Location{
+				EnvironmentVariable: strings.ToUpper(param.Name),
+			}
+		}
+		params.Fields[param.Name] = p
+	}
+	return params
+}
+
+func (c *ManifestConverter) buildDefaultPorterParameters() []config.ParameterDefinition {
+	return []config.ParameterDefinition{
+		{
+			Name: "porter-debug",
+			Destination: &config.Location{
+				EnvironmentVariable: "PORTER_DEBUG",
+			},
+			DataType: "bool",
+			Default:  false,
+			Metadata: config.ParameterMetadata{
+				Description: "Print debug information from Porter when executing the bundle"},
+		},
+	}
+}
+
+func (c *ManifestConverter) generateBundleCredentials() map[string]bundle.Credential {
+	params := map[string]bundle.Credential{}
+	for _, cred := range c.Manifest.Credentials {
+		fmt.Fprintf(c.Out, "Generating credential %s ====>\n", cred.Name)
+		l := bundle.Credential{
+			Description: cred.Description,
+			Required:    cred.Required,
+			Location: bundle.Location{
+				Path:                cred.Path,
+				EnvironmentVariable: cred.EnvironmentVariable,
+			},
+		}
+		params[cred.Name] = l
+	}
+	return params
+}
+
+func (c *ManifestConverter) generateBundleImages() map[string]bundle.Image {
+	images := make(map[string]bundle.Image, len(c.Manifest.ImageMap))
+
+	for i, refImage := range c.Manifest.ImageMap {
+		img := bundle.Image{
+			Description: refImage.Description,
+			BaseImage: bundle.BaseImage{
+				Image:         refImage.Image,
+				Digest:        refImage.Digest,
+				ImageType:     refImage.ImageType,
+				MediaType:     refImage.MediaType,
+				OriginalImage: refImage.OriginalImage,
+				Size:          refImage.Size,
+			},
+		}
+		if refImage.Platform != nil {
+			img.Platform = &bundle.ImagePlatform{
+				Architecture: refImage.Platform.Architecture,
+				OS:           refImage.Platform.OS,
+			}
+		}
+		images[i] = img
+	}
+
+	return images
+}

pkg/cnab/config_adapter/adapter.go

@@ -0,0 +1,81 @@
+package configadapter
+
+import (
+	"testing"
+
+	"github.com/deislabs/porter/pkg/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPorter_generateImages(t *testing.T) {
+	c := config.NewTestConfig(t)
+	c.TestContext.AddTestFile("../../config/testdata/simple.porter.yaml", config.Name)
+
+	err := c.LoadManifest()
+	require.NoError(t, err)
+
+	a := ManifestConverter{
+		Context:  c.Context,
+		Manifest: c.Manifest,
+	}
+
+	mappedImage := config.MappedImage{
+		Description:   "un petite server",
+		Image:         "deislabs/myserver:1.0.0",
+		ImageType:     "docker",
+		Digest:        "abc123",
+		Size:          12,
+		MediaType:     "download",
+		OriginalImage: "deis/myserver:1.0.0",
+		Platform: &config.ImagePlatform{
+			OS:           "linux",
+			Architecture: "amd64",
+		},
+	}
+	a.Manifest.ImageMap = map[string]config.MappedImage{
+		"server": mappedImage,
+	}
+
+	images := a.generateBundleImages()
+
+	require.Len(t, images, 1)
+	img := images["server"]
+	assert.Equal(t, mappedImage.Description, img.Description)
+	assert.Equal(t, mappedImage.Image, img.Image)
+	assert.Equal(t, mappedImage.ImageType, img.ImageType)
+	assert.Equal(t, mappedImage.Digest, img.Digest)
+	assert.Equal(t, mappedImage.Size, img.Size)
+	assert.Equal(t, mappedImage.MediaType, img.MediaType)
+	assert.Equal(t, mappedImage.OriginalImage, img.OriginalImage)
+	assert.Equal(t, mappedImage.Platform.OS, img.Platform.OS)
+	assert.Equal(t, mappedImage.Platform.Architecture, img.Platform.Architecture)
+}
+
+func TestPorter_generateBundleImages_EmptyPlatform(t *testing.T) {
+	c := config.NewTestConfig(t)
+	c.TestContext.AddTestFile("../../config/testdata/simple.porter.yaml", config.Name)
+
+	err := c.LoadManifest()
+	require.NoError(t, err)
+
+	a := ManifestConverter{
+		Context:  c.Context,
+		Manifest: c.Manifest,
+	}
+
+	mappedImage := config.MappedImage{
+		Description: "un petite server",
+		Image:       "deislabs/myserver:1.0.0",
+		ImageType:   "docker",
+		Platform:    nil,
+	}
+	a.Manifest.ImageMap = map[string]config.MappedImage{
+		"server": mappedImage,
+	}
+
+	images := a.generateBundleImages()
+	require.Len(t, images, 1)
+	img := images["server"]
+	assert.Nil(t, img.Platform)
+}