Add bundle command to create a CNAB from a Docker Application Package

Signed-off-by: Silvin Lubecki <silvin.lubecki@docker.com>

Author: silvin-lubecki

cmd/docker-app/bundle.go

@@ -0,0 +1,119 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+
+	"github.com/deis/duffle/pkg/bundle"
+	"github.com/docker/app/internal/packager"
+	"github.com/docker/app/types"
+	"github.com/docker/app/types/metadata"
+	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/distribution/reference"
+	dockertypes "github.com/docker/docker/api/types"
+	"github.com/docker/docker/pkg/jsonmessage"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+type bundleOptions struct {
+	invocationImageName string
+	namespace           string
+	out                 string
+}
+
+func bundleCmd(dockerCli command.Cli) *cobra.Command {
+	var opts bundleOptions
+	cmd := &cobra.Command{
+		Use:   "bundle [<app-name>]",
+		Short: "Create a CNAB invocation image and bundle.json for the application.",
+		Args:  cli.RequiresMaxArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runBundle(dockerCli, firstOrEmpty(args), opts)
+		},
+	}
+
+	cmd.Flags().StringVarP(&opts.invocationImageName, "invocation-image", "i", "", "specify the name of invocation image to build")
+	cmd.Flags().StringVar(&opts.namespace, "namespace", "", "namespace to use (default: namespace in metadata)")
+	cmd.Flags().StringVarP(&opts.out, "out", "o", "bundle.json", "path to the output bundle.json (- for stdout)")
+	return cmd
+}
+
+func runBundle(dockerCli command.Cli, appName string, opts bundleOptions) error {
+	bundle, err := makeBundle(dockerCli, appName, opts.namespace, opts.invocationImageName)
+	if err != nil {
+		return err
+	}
+	if bundle == nil || len(bundle.InvocationImages) == 0 {
+		return fmt.Errorf("failed to create bundle %q", appName)
+	}
+	fmt.Fprintf(dockerCli.Out(), "Invocation image %q successfully built\n", bundle.InvocationImages[0].Image)
+	bundleBytes, err := json.MarshalIndent(bundle, "", "\t")
+	if err != nil {
+		return err
+	}
+	if opts.out == "-" {
+		_, err = dockerCli.Out().Write(bundleBytes)
+		return err
+	}
+	return ioutil.WriteFile(opts.out, bundleBytes, 0644)
+}
+
+func makeBundle(dockerCli command.Cli, appName, namespace, invocationImageName string) (*bundle.Bundle, error) {
+	app, err := packager.Extract(appName)
+	if err != nil {
+		return nil, err
+	}
+	defer app.Cleanup()
+	return makeBundleFromApp(dockerCli, app, namespace, invocationImageName)
+}
+
+func makeBundleFromApp(dockerCli command.Cli, app *types.App, namespace, invocationImageName string) (*bundle.Bundle, error) {
+	meta := app.Metadata()
+	invocationImageName, err := makeImageName(meta, namespace, invocationImageName, "-invoc")
+	if err != nil {
+		return nil, err
+	}
+	if _, err := makeImageName(app.Metadata(), namespace, "", ""); err != nil {
+		return nil, err
+	}
+
+	buildContext := bytes.NewBuffer(nil)
+	if err := packager.PackInvocationImageContext(app, buildContext); err != nil {
+		return nil, err
+	}
+
+	buildResp, err := dockerCli.Client().ImageBuild(context.TODO(), buildContext, dockertypes.ImageBuildOptions{
+		Dockerfile: "Dockerfile",
+		Tags:       []string{invocationImageName},
+	})
+	if err != nil {
+		return nil, err
+	}
+	defer buildResp.Body.Close()
+
+	if err := jsonmessage.DisplayJSONMessagesStream(buildResp.Body, ioutil.Discard, 0, false, func(jsonmessage.JSONMessage) {}); err != nil {
+		return nil, err
+	}
+	return packager.ToCNAB(app, invocationImageName), nil
+}
+
+func makeImageName(meta metadata.AppMetadata, namespace, name, suffix string) (string, error) {
+	if name == "" {
+		name = fmt.Sprintf("%s:%s%s", meta.Name, meta.Version, suffix)
+	}
+	if namespace == "" {
+		namespace = meta.Namespace
+	}
+	if namespace != "" {
+		name = fmt.Sprintf("%s/%s", namespace, name)
+	}
+	if _, err := reference.ParseNormalizedNamed(name); err != nil {
+		return "", errors.Wrapf(err, "image name %q is invalid, please check namespace, name and version fields", name)
+	}
+	return name, nil
+}

cmd/docker-app/bundle_test.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/docker/app/types/metadata"
+	"gotest.tools/assert"
+)
+
+func TestMakeInvocationImage(t *testing.T) {
+	testcases := []struct {
+		name      string
+		imageName string
+		namespace string
+		meta      metadata.AppMetadata
+		expected  string
+		err       string
+	}{
+		{
+			name:      "specify-image-name",
+			imageName: "my-invocation-image",
+			expected:  "my-invocation-image",
+		},
+		{
+			name:      "specify-image-name-and-namespace",
+			imageName: "my-invocation-image",
+			namespace: "my-namespace",
+			expected:  "my-namespace/my-invocation-image",
+		},
+		{
+			name:     "simple-metadata",
+			meta:     metadata.AppMetadata{Name: "name", Version: "version"},
+			expected: "name:version-invoc",
+		},
+		{
+			name:      "simple-metadata-with-overridden-namespace",
+			namespace: "my-namespace",
+			meta:      metadata.AppMetadata{Name: "name", Version: "version"},
+			expected:  "my-namespace/name:version-invoc",
+		},
+		{
+			name:     "metadata-with-namespace",
+			meta:     metadata.AppMetadata{Name: "name", Version: "version", Namespace: "namespace"},
+			expected: "namespace/name:version-invoc",
+		},
+		{
+			name:      "metadata-with-namespace-and-overridden-namespace",
+			namespace: "my-namespace",
+			meta:      metadata.AppMetadata{Name: "name", Version: "version", Namespace: "namespace"},
+			expected:  "my-namespace/name:version-invoc",
+		},
+		{
+			name: "simple-metadata",
+			meta: metadata.AppMetadata{Name: "WrongName&%*", Version: "version"},
+			err:  "invalid",
+		},
+	}
+	for _, c := range testcases {
+		t.Run(c.name, func(t *testing.T) {
+			actual, err := makeImageName(c.meta, c.namespace, c.imageName, "-invoc")
+			if c.err != "" {
+				assert.ErrorContains(t, err, c.err)
+				assert.Equal(t, actual, "")
+			} else {
+				assert.NilError(t, err)
+				assert.Equal(t, actual, c.expected)
+			}
+		})
+	}
+}

cmd/docker-app/deploy.go

@@ -64,7 +64,7 @@ func runDeploy(dockerCli command.Cli, flags *pflag.FlagSet, appname string, opts
 		return err
 	}
 	defer app.Cleanup()
-	deployOrchestrator, err := command.GetStackOrchestrator(opts.deployOrchestrator, dockerCli.ConfigFile().StackOrchestrator, dockerCli.Err())
+	deployOrchestrator, err := command.GetStackOrchestrator(opts.deployOrchestrator, "", dockerCli.ConfigFile().StackOrchestrator, dockerCli.Err())
 	if err != nil {
 		return err
 	}

cmd/docker-app/root.go

@@ -53,6 +53,7 @@ func addCommands(cmd *cobra.Command, dockerCli command.Cli) {
 		validateCmd(),
 		versionCmd(dockerCli),
 		completionCmd(dockerCli, cmd),
+		bundleCmd(dockerCli),
 	)
 	if internal.Experimental == "on" {
 		cmd.AddCommand(

internal/packager/packing.go

@@ -2,35 +2,80 @@ package packager
 
 import (
 	"archive/tar"
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 
 	"github.com/docker/app/internal"
+	"github.com/docker/app/types"
 	"github.com/docker/docker/pkg/archive"
 )
 
+var dockerFile = `FROM docker/cnab-app-base:` + internal.Version + `
+COPY . .`
+
+const dockerIgnore = "Dockerfile"
+
 func tarAdd(tarout *tar.Writer, path, file string) error {
 	payload, err := ioutil.ReadFile(file)
 	if err != nil {
 		return err
 	}
+	return tarAddBytes(tarout, path, payload)
+}
+
+func tarAddBytes(tarout *tar.Writer, path string, payload []byte) error {
 	h := &tar.Header{
 		Name:     path,
 		Size:     int64(len(payload)),
 		Mode:     0644,
 		Typeflag: tar.TypeReg,
 	}
-	err = tarout.WriteHeader(h)
+	err := tarout.WriteHeader(h)
 	if err != nil {
 		return err
 	}
 	_, err = tarout.Write(payload)
 	return err
 }
 
+// PackInvocationImageContext creates a Docker build context for building a CNAB invocation image
+func PackInvocationImageContext(app *types.App, target io.Writer) error {
+	tarout := tar.NewWriter(target)
+	defer tarout.Close()
+	prefix := fmt.Sprintf("%s%s/", app.Metadata().Name, internal.AppExtension)
+	if len(app.Composes()) != 1 {
+		return errors.New("app should have one and only one compose file")
+	}
+	if len(app.ParametersRaw()) != 1 {
+		return errors.New("app should have one and only parameters file")
+	}
+	if err := tarAddBytes(tarout, "Dockerfile", []byte(dockerFile)); err != nil {
+		return err
+	}
+	if err := tarAddBytes(tarout, ".dockerignore", []byte(dockerIgnore)); err != nil {
+		return err
+	}
+	if err := tarAddBytes(tarout, prefix+internal.MetadataFileName, app.MetadataRaw()); err != nil {
+		return err
+	}
+	if err := tarAddBytes(tarout, prefix+internal.ComposeFileName, app.Composes()[0]); err != nil {
+		return err
+	}
+	if err := tarAddBytes(tarout, prefix+internal.ParametersFileName, app.ParametersRaw()[0]); err != nil {
+		return err
+	}
+	for _, attachment := range app.Attachments() {
+		if err := tarAdd(tarout, prefix+attachment.Path(), filepath.Join(app.Path, attachment.Path())); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // Pack packs the app as a single file
 func Pack(appname string, target io.Writer) error {
 	tarout := tar.NewWriter(target)

internal/packager/packing_test.go

@@ -0,0 +1,64 @@
+package packager
+
+import (
+	"archive/tar"
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/docker/app/types"
+	"gotest.tools/assert"
+)
+
+func TestPackInvocationImageContext(t *testing.T) {
+	app, err := types.NewAppFromDefaultFiles("testdata/packages/packing.dockerapp")
+	assert.NilError(t, err)
+	buf := bytes.NewBuffer(nil)
+	assert.NilError(t, PackInvocationImageContext(app, buf))
+	assert.NilError(t, hasExpectedFiles(buf, map[string]bool{
+		"Dockerfile":                                              true,
+		".dockerignore":                                           true,
+		"packing.dockerapp/metadata.yml":                          true,
+		"packing.dockerapp/docker-compose.yml":                    true,
+		"packing.dockerapp/parameters.yml":                        true,
+		"packing.dockerapp/config.cfg":                            true,
+		"packing.dockerapp/nesteddir/config2.cfg":                 true,
+		"packing.dockerapp/nesteddir/nested2/nested3/config3.cfg": true,
+	}))
+}
+
+func hasExpectedFiles(r io.Reader, expectedFiles map[string]bool) error {
+	tr := tar.NewReader(r)
+	var errors []string
+	originalExpectedFilesCount := len(expectedFiles)
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			break // End of archive
+		}
+		if err != nil {
+			return err
+		}
+		if hdr.Size == 0 {
+			errors = append(errors, fmt.Sprintf("content of '%s' is empty", hdr.Name))
+		}
+		if _, ok := expectedFiles[hdr.Name]; !ok {
+			errors = append(errors, fmt.Sprintf("couldn't find file '%s' in the tar archive", hdr.Name))
+			continue
+		}
+		delete(expectedFiles, hdr.Name)
+	}
+	if len(expectedFiles) != 0 {
+		errors = append(errors, fmt.Sprintf("number of expected files is in archive is '%d', but just '%d' were found",
+			originalExpectedFilesCount, originalExpectedFilesCount-len(expectedFiles)))
+		for k := range expectedFiles {
+			errors = append(errors, fmt.Sprintf("expected file '%s' not found", k))
+		}
+	}
+	if len(errors) != 0 {
+		return fmt.Errorf("%s", strings.Join(errors, "\n"))
+	}
+	return nil
+}

internal/packager/testdata/packages/packing.dockerapp/config.cfg

@@ -0,0 +1 @@
+Contents of config.cfg

internal/packager/testdata/packages/packing.dockerapp/docker-compose.yml

@@ -0,0 +1,29 @@
+version: "3.7"
+services:
+  front:
+    image: nginx:${myapp.nginx_version}
+    deploy:
+      replicas: ${myapp.nginx_replicas}
+  debug:
+    image: busybox:latest
+    ports:
+    - $aport
+    - $sport:$dport
+    privileged: ${privileged}
+    read_only: $read_only
+    tty: $tty
+    stdin_open: $stdin_open
+    deploy:
+      resources:
+        limits:
+          memory: $memory
+    healthcheck:
+      test: ["/ping", "debug"]
+      interval: 2m
+      timeout: $timeout
+  monitor:
+    image: busybox:latest
+    command: monitor --source ${app.name}-${app.version} $$dollar
+    x-enabled: "! ${myapp.debug}"
+  app-watcher:
+    image: $watcher.image

internal/packager/testdata/packages/packing.dockerapp/metadata.yml

@@ -0,0 +1,9 @@
+version: 0.1.0
+name: packing
+namespace: my-namespace
+description: "hello"
+maintainers:
+  - name: bearclaw
+    email: bearclaw@bearclaw.com
+  - name: bob
+    email: bob@bob.com