Introduce Push/Pull with cnab-to-oci

- Brings Push and Pull top level commands
- Using any existing command on a registry ref making it pull the cnab
from the registry
- Added a local CNAB store to avoid pulling the CNABs more than once

Signed-off-by: Simon Ferquel <[email protected]>

Author: simonferquel

cmd/docker-app/bundle.go

@@ -70,13 +70,10 @@ func makeBundle(dockerCli command.Cli, appName string) (*bundle.Bundle, error) {
 
 func makeBundleFromApp(dockerCli command.Cli, app *types.App) (*bundle.Bundle, error) {
 	meta := app.Metadata()
-	invocationImageName, err := makeImageName(meta)
+	invocationImageName, err := makeInvocationImageName(meta)
 	if err != nil {
 		return nil, err
 	}
-	if _, err := makeImageName(meta); err != nil {
-		return nil, err
-	}
 
 	buildContext := bytes.NewBuffer(nil)
 	if err := packager.PackInvocationImageContext(app, buildContext); err != nil {
@@ -98,8 +95,12 @@ func makeBundleFromApp(dockerCli command.Cli, app *types.App) (*bundle.Bundle, e
 	return packager.ToCNAB(app, invocationImageName)
 }
 
-func makeImageName(meta metadata.AppMetadata) (string, error) {
-	name := fmt.Sprintf("%s:%s-invoc", meta.Name, meta.Version)
+func makeInvocationImageName(meta metadata.AppMetadata) (string, error) {
+	return makeCNABImageName(meta, "-invoc")
+}
+
+func makeCNABImageName(meta metadata.AppMetadata, suffix string) (string, error) {
+	name := fmt.Sprintf("%s:%s%s", meta.Name, meta.Version, suffix)
 	if _, err := reference.ParseNormalizedNamed(name); err != nil {
 		return "", errors.Wrapf(err, "image name %q is invalid, please check name and version fields", name)
 	}

cmd/docker-app/bundle_test.go

@@ -27,7 +27,7 @@ func TestMakeInvocationImage(t *testing.T) {
 	}
 	for _, c := range testcases {
 		t.Run(c.name, func(t *testing.T) {
-			actual, err := makeImageName(c.meta)
+			actual, err := makeInvocationImageName(c.meta)
 			if c.err != "" {
 				assert.ErrorContains(t, err, c.err)
 				assert.Equal(t, actual, "", "On "+c.meta.Name)

cmd/docker-app/cnab.go

@@ -14,8 +14,10 @@ import (
 	"github.com/deislabs/duffle/pkg/loader"
 	"github.com/docker/app/internal"
 	"github.com/docker/app/internal/packager"
+	bundlestore "github.com/docker/app/internal/store"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/cli/context/store"
+	"github.com/docker/distribution/reference"
 	"github.com/pkg/errors"
 )
 
@@ -126,7 +128,7 @@ func extractAndLoadAppBasedBundle(dockerCli command.Cli, name string) (*bundle.B
 	return makeBundleFromApp(dockerCli, app)
 }
 
-func resolveBundle(dockerCli command.Cli, name string) (*bundle.Bundle, error) {
+func resolveBundle(dockerCli command.Cli, name string, pullRef bool, insecureRegistries []string) (*bundle.Bundle, error) {
 	// resolution logic:
 	// - if there is a docker-app package in working directory, or an http:// / https:// prefix, use packager.Extract result
 	// - the name has a .json or .cnab extension and refers to an existing file or web resource: load the bundle
@@ -135,15 +137,28 @@ func resolveBundle(dockerCli command.Cli, name string) (*bundle.Bundle, error) {
 	name, kind := getAppNameKind(name)
 	switch kind {
 	case nameKindFile:
+		if pullRef {
+			return nil, errors.Errorf("%s: cannot pull when referencing a file based app", name)
+		}
 		if strings.HasSuffix(name, internal.AppExtension) {
 			return extractAndLoadAppBasedBundle(dockerCli, name)
 		}
 		return loader.NewDetectingLoader().Load(name)
 	case nameKindDir, nameKindEmpty:
+		if pullRef {
+			if kind == nameKindDir {
+				return nil, errors.Errorf("%s: cannot pull when referencing a directory based app", name)
+			}
+			// XXX perhaps getAppNameKind could do the call to findApp?
+			return nil, errors.Errorf("cannot pull when referencing a directory based app")
+		}
 		return extractAndLoadAppBasedBundle(dockerCli, name)
 	case nameKindReference:
-		// TODO: pull the bundle
-		fmt.Fprintln(dockerCli.Err(), "WARNING: pulling a CNAB is not yet supported")
+		ref, err := reference.ParseNormalizedNamed(name)
+		if err != nil {
+			return nil, errors.Wrap(err, name)
+		}
+		return bundlestore.LookupOrPullBundle(dockerCli, reference.TagNameOnly(ref), pullRef, insecureRegistries)
 	}
 	return nil, fmt.Errorf("could not resolve bundle %q", name)
 }

cmd/docker-app/inspect.go

@@ -10,47 +10,58 @@ import (
 	"github.com/spf13/cobra"
 )
 
+type inspectOptions struct {
+	parametersOptions
+	registryOptions
+	pull bool
+}
+
 func inspectCmd(dockerCli command.Cli) *cobra.Command {
-	var opts parametersOptions
+	var opts inspectOptions
 	cmd := &cobra.Command{
 		Use:   "inspect [<app-name>] [-s key=value...] [-f parameters-file...]",
 		Short: "Shows metadata, parameters and a summary of the compose file for a given application",
 		Args:  cli.RequiresMaxArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			muteDockerCli(dockerCli)
-			appname := firstOrEmpty(args)
+			return runInspect(dockerCli, firstOrEmpty(args), opts)
+		},
+	}
+	opts.parametersOptions.addFlags(cmd.Flags())
+	opts.registryOptions.addFlags(cmd.Flags())
+	cmd.Flags().BoolVar(&opts.pull, "pull", false, "Pull the bundle")
+	return cmd
+}
 
-			c, err := claim.New("inspect")
-			if err != nil {
-				return err
-			}
-			driverImpl, err := prepareDriver(dockerCli)
-			if err != nil {
-				return err
-			}
-			bundle, err := resolveBundle(dockerCli, appname)
-			if err != nil {
-				return err
-			}
-			c.Bundle = bundle
+func runInspect(dockerCli command.Cli, appname string, opts inspectOptions) error {
+	muteDockerCli(dockerCli)
 
-			parameters, err := mergeBundleParameters(c.Bundle,
-				withFileParameters(opts.parametersFiles),
-				withCommandLineParameters(opts.overrides),
-			)
-			if err != nil {
-				return err
-			}
-			c.Parameters = parameters
+	c, err := claim.New("inspect")
+	if err != nil {
+		return err
+	}
+	driverImpl, err := prepareDriver(dockerCli)
+	if err != nil {
+		return err
+	}
+	bundle, err := resolveBundle(dockerCli, appname, opts.pull, opts.insecureRegistries)
+	if err != nil {
+		return err
+	}
+	c.Bundle = bundle
 
-			a := &action.RunCustom{
-				Action: internal.Namespace + "inspect",
-				Driver: driverImpl,
-			}
-			err = a.Run(c, map[string]string{"docker.context": ""}, dockerCli.Out())
-			return errors.Wrap(err, "Inspect failed")
-		},
+	parameters, err := mergeBundleParameters(c.Bundle,
+		withFileParameters(opts.parametersFiles),
+		withCommandLineParameters(opts.overrides),
+	)
+	if err != nil {
+		return err
 	}
-	opts.addFlags(cmd.Flags())
-	return cmd
+	c.Parameters = parameters
+
+	a := &action.RunCustom{
+		Action: internal.Namespace + "inspect",
+		Driver: driverImpl,
+	}
+	err = a.Run(c, map[string]string{"docker.context": ""}, dockerCli.Out())
+	return errors.Wrap(err, "Inspect failed")
 }

cmd/docker-app/install.go

@@ -16,11 +16,12 @@ import (
 type installOptions struct {
 	parametersOptions
 	credentialOptions
+	registryOptions
 	orchestrator     string
 	kubeNamespace    string
 	stackName        string
-	insecure         bool
 	sendRegistryAuth bool
+	pull             bool
 }
 
 type nameKind uint
@@ -56,11 +57,12 @@ func installCmd(dockerCli command.Cli) *cobra.Command {
 	}
 	opts.parametersOptions.addFlags(cmd.Flags())
 	opts.credentialOptions.addFlags(cmd.Flags())
+	opts.registryOptions.addFlags(cmd.Flags())
 	cmd.Flags().StringVarP(&opts.orchestrator, "orchestrator", "o", "", "Orchestrator to install on (swarm, kubernetes)")
 	cmd.Flags().StringVar(&opts.kubeNamespace, "kubernetes-namespace", "default", "Kubernetes namespace to install into")
 	cmd.Flags().StringVar(&opts.stackName, "name", "", "Installation name (defaults to application name)")
-	cmd.Flags().BoolVar(&opts.insecure, "insecure", false, "Use insecure registry, without SSL")
 	cmd.Flags().BoolVar(&opts.sendRegistryAuth, "with-registry-auth", false, "Sends registry auth")
+	cmd.Flags().BoolVar(&opts.pull, "pull", false, "Pull the bundle")
 
 	return cmd
 }
@@ -72,7 +74,7 @@ func runInstall(dockerCli command.Cli, appname string, opts installOptions) erro
 	}
 	targetContext := getTargetContext(opts.targetContext, dockerCli.CurrentContext())
 
-	bndl, err := resolveBundle(dockerCli, appname)
+	bndl, err := resolveBundle(dockerCli, appname, opts.pull, opts.insecureRegistries)
 	if err != nil {
 		return err
 	}

cmd/docker-app/main.go

@@ -12,6 +12,7 @@ func main() {
 	dockerCli, err := command.NewDockerCli()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
 	}
 	logrus.SetOutput(dockerCli.Err())
 	cmd := newRootCmd(dockerCli)

cmd/docker-app/pull.go

@@ -1,19 +1,41 @@
 package main
 
 import (
-	"github.com/docker/app/internal/packager"
+	"fmt"
+
+	bundlestore "github.com/docker/app/internal/store"
 	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/distribution/reference"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
 
-func pullCmd() *cobra.Command {
-	return &cobra.Command{
+func pullCmd(dockerCli command.Cli) *cobra.Command {
+	var opts registryOptions
+	cmd := &cobra.Command{
 		Use:   "pull <repotag>",
 		Short: "Pull an application from a registry",
 		Args:  cli.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			_, err := packager.Pull(args[0], ".")
-			return err
+			return runPull(dockerCli, args[0], opts)
 		},
 	}
+	opts.addFlags(cmd.Flags())
+	return cmd
+}
+
+func runPull(dockerCli command.Cli, name string, opts registryOptions) error {
+	ref, err := reference.ParseNormalizedNamed(name)
+	if err != nil {
+		return errors.Wrap(err, name)
+	}
+	bndl, err := bundlestore.LookupOrPullBundle(dockerCli, reference.TagNameOnly(ref), true, opts.insecureRegistries)
+	if err != nil {
+		return errors.Wrap(err, name)
+	}
+
+	fmt.Printf("Successfully pulled %q (%s) from %s\n", bndl.Name, bndl.Version, ref.String())
+
+	return nil
 }