Merge pull request #517 from silvin-lubecki/show-list-reference

Show application reference in the list command

Author: silvin-lubecki

README.md

@@ -351,6 +351,7 @@ Commands:
   init        Initialize Docker Application definition
   inspect     Shows metadata, parameters and a summary of the Compose file for a given application
   install     Install an application
+  list        List the installations and their last known installation result
   merge       Merge a directory format Docker Application definition into a single file
   pull        Pull an application package from a registry
   push        Push an application package to a registry

e2e/commands_test.go

@@ -320,7 +320,14 @@ func testDockerAppLifecycle(t *testing.T, useBindMount bool) {
 		ExitCode: 1,
 		Err:      "error decoding 'Ports': Invalid hostPort: -1",
 	})
-	// TODO: List the installation and check the failed status
+
+	// List the installation and check the failed status
+	cmd.Command = dockerCli.Command("app", "list")
+	checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
+		[]string{
+			`INSTALLATION\s+APPLICATION\s+LAST ACTION\s+RESULT\s+CREATED\s+MODIFIED\s+REFERENCE`,
+			fmt.Sprintf(`%s\s+simple \(1.1.0-beta1\)\s+install\s+failure\s+.+second[s]?\s+.+second[s]?\s+`, appName),
+		})
 
 	// Upgrading a failed installation is not allowed
 	cmd.Command = dockerCli.Command("app", "upgrade", appName)
@@ -350,6 +357,14 @@ func testDockerAppLifecycle(t *testing.T, useBindMount bool) {
 			fmt.Sprintf("[[:alnum:]]+        %s_api   replicated          [0-1]/1                 python:3.6", appName),
 		})
 
+	// List the installed application
+	cmd.Command = dockerCli.Command("app", "list")
+	checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
+		[]string{
+			`INSTALLATION\s+APPLICATION\s+LAST ACTION\s+RESULT\s+CREATED\s+MODIFIED\s+REFERENCE`,
+			fmt.Sprintf(`%s\s+simple \(1.1.0-beta1\)\s+install\s+success\s+.+second[s]?\s+.+second[s]?\s+`, appName),
+		})
+
 	// Installing again the same application is forbidden
 	cmd.Command = dockerCli.Command("app", "install", "testdata/simple/simple.dockerapp", "--name", appName)
 	icmd.RunCmd(cmd).Assert(t, icmd.Expected{
@@ -420,6 +435,6 @@ func initializeDockerAppEnvironment(t *testing.T, cmd *icmd.Cmd, tmpDir *fs.Dir,
 func checkContains(t *testing.T, combined string, expectedLines []string) {
 	for _, expected := range expectedLines {
 		exp := regexp.MustCompile(expected)
-		assert.Assert(t, exp.MatchString(combined), expected, combined)
+		assert.Assert(t, exp.MatchString(combined), "expected %q != actual %q", expected, combined)
 	}
 }

e2e/pushpull_test.go

@@ -104,20 +104,28 @@ func TestPushPullInstall(t *testing.T) {
 	runWithDindSwarmAndRegistry(t, func(info dindSwarmAndRegistryInfo) {
 		cmd := info.configuredCmd
 		ref := info.registryAddress + "/test/push-pull"
-		cmd.Command = dockerCli.Command("app", "push", "--tag", ref, "--insecure-registries="+info.registryAddress, filepath.Join("testdata", "push-pull", "push-pull.dockerapp"))
+		tag := ":v.0.0.1"
+		cmd.Command = dockerCli.Command("app", "push", "--tag", ref+tag, "--insecure-registries="+info.registryAddress, filepath.Join("testdata", "push-pull", "push-pull.dockerapp"))
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
-		cmd.Command = dockerCli.Command("app", "pull", ref, "--insecure-registries="+info.registryAddress)
+		cmd.Command = dockerCli.Command("app", "pull", ref+tag, "--insecure-registries="+info.registryAddress)
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
 		// stop the registry
 		info.stopRegistry()
 
 		// install without --pull should succeed (rely on local store)
-		cmd.Command = dockerCli.Command("app", "install", "--insecure-registries="+info.registryAddress, ref, "--name", t.Name())
+		cmd.Command = dockerCli.Command("app", "install", "--insecure-registries="+info.registryAddress, ref+tag, "--name", t.Name())
 		icmd.RunCmd(cmd).Assert(t, icmd.Success)
 		cmd.Command = dockerCli.Command("service", "ls")
 		assert.Check(t, cmp.Contains(icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(), ref))
 
+		// listing the installed application shows the pulled application reference
+		cmd.Command = dockerCli.Command("app", "list")
+		checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
+			[]string{
+				fmt.Sprintf(`%s\s+push-pull \(1.1.0-beta1\)\s+install\s+success\s+.+second[s]?\s+.+second[s]?\s+%s`, t.Name(), ref+tag),
+			})
+
 		// install with --pull should fail (registry is stopped)
 		cmd.Command = dockerCli.Command("app", "install", "--pull", "--insecure-registries="+info.registryAddress, ref, "--name", t.Name()+"2")
 		assert.Check(t, cmp.Contains(icmd.RunCmd(cmd).Assert(t, icmd.Expected{ExitCode: 1}).Combined(), "failed to resolve bundle manifest"))

e2e/testdata/plugin-usage-experimental.golden

@@ -9,6 +9,7 @@ Commands:
   init        Initialize Docker Application definition
   inspect     Shows metadata, parameters and a summary of the Compose file for a given application
   install     Install an application
+  list        List the installations and their last known installation result
   merge       Merge a directory format Docker Application definition into a single file
   pull        Pull an application package from a registry
   push        Push an application package to a registry

e2e/testdata/plugin-usage.golden

@@ -9,6 +9,7 @@ Commands:
   init        Initialize Docker Application definition
   inspect     Shows metadata, parameters and a summary of the Compose file for a given application
   install     Install an application
+  list        List the installations and their last known installation result
   merge       Merge a directory format Docker Application definition into a single file
   pull        Pull an application package from a registry
   push        Push an application package to a registry

internal/commands/cnab.go

@@ -201,16 +201,17 @@ func getAppNameKind(name string) (string, nameKind) {
 	return name, nameKindFile
 }
 
-func extractAndLoadAppBasedBundle(dockerCli command.Cli, name string) (*bundle.Bundle, error) {
+func extractAndLoadAppBasedBundle(dockerCli command.Cli, name string) (*bundle.Bundle, string, error) {
 	app, err := packager.Extract(name)
 	if err != nil {
-		return nil, err
+		return nil, "", err
 	}
 	defer app.Cleanup()
-	return makeBundleFromApp(dockerCli, app)
+	bndl, err := makeBundleFromApp(dockerCli, app)
+	return bndl, "", err
 }
 
-func resolveBundle(dockerCli command.Cli, bundleStore appstore.BundleStore, name string, pullRef bool, insecureRegistries []string) (*bundle.Bundle, error) {
+func resolveBundle(dockerCli command.Cli, bundleStore appstore.BundleStore, name string, pullRef bool, insecureRegistries []string) (*bundle.Bundle, string, 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
@@ -220,28 +221,31 @@ func resolveBundle(dockerCli command.Cli, bundleStore appstore.BundleStore, name
 	switch kind {
 	case nameKindFile:
 		if pullRef {
-			return nil, errors.Errorf("%s: cannot pull when referencing a file based app", name)
+			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.NewLoader().Load(name)
+		bndl, err := loader.NewLoader().Load(name)
+		return bndl, "", err
 	case nameKindDir, nameKindEmpty:
 		if pullRef {
 			if kind == nameKindDir {
-				return nil, errors.Errorf("%s: cannot pull when referencing a directory based app", name)
+				return nil, "", errors.Errorf("%s: cannot pull when referencing a directory based app", name)
 			}
-			return nil, errors.Errorf("cannot pull when referencing a directory based app")
+			return nil, "", errors.Errorf("cannot pull when referencing a directory based app")
 		}
 		return extractAndLoadAppBasedBundle(dockerCli, name)
 	case nameKindReference:
 		ref, err := reference.ParseNormalizedNamed(name)
 		if err != nil {
-			return nil, errors.Wrap(err, name)
+			return nil, "", errors.Wrap(err, name)
 		}
-		return bundleStore.LookupOrPullBundle(reference.TagNameOnly(ref), pullRef, dockerCli.ConfigFile(), insecureRegistries)
+		tagRef := reference.TagNameOnly(ref)
+		bndl, err := bundleStore.LookupOrPullBundle(tagRef, pullRef, dockerCli.ConfigFile(), insecureRegistries)
+		return bndl, tagRef.String(), err
 	}
-	return nil, fmt.Errorf("could not resolve bundle %q", name)
+	return nil, "", fmt.Errorf("could not resolve bundle %q", name)
 }
 
 func requiredClaimBindMount(c claim.Claim, targetContextName string, dockerCli command.Cli) (bindMount, error) {
@@ -298,7 +302,7 @@ func isDockerHostLocal(host string) bool {
 }
 
 func prepareCustomAction(actionName string, dockerCli command.Cli, appname string, stdout io.Writer,
-	registryOpts registryOptions, pullOpts pullOptions, paramsOpts parametersOptions) (*action.RunCustom, *claim.Claim, *bytes.Buffer, error) {
+	registryOpts registryOptions, pullOpts pullOptions, paramsOpts parametersOptions) (*action.RunCustom, *appstore.Installation, *bytes.Buffer, error) {
 	s, err := appstore.NewApplicationStore(config.Dir())
 	if err != nil {
 		return nil, nil, nil, err
@@ -307,22 +311,21 @@ func prepareCustomAction(actionName string, dockerCli command.Cli, appname strin
 	if err != nil {
 		return nil, nil, nil, err
 	}
-
-	c, err := claim.New("custom-action")
+	driverImpl, errBuf, err := prepareDriver(dockerCli, bindMount{}, stdout)
 	if err != nil {
 		return nil, nil, nil, err
 	}
-	driverImpl, errBuf, err := prepareDriver(dockerCli, bindMount{}, stdout)
+	bundle, ref, err := resolveBundle(dockerCli, bundleStore, appname, pullOpts.pull, registryOpts.insecureRegistries)
 	if err != nil {
 		return nil, nil, nil, err
 	}
-	bundle, err := resolveBundle(dockerCli, bundleStore, appname, pullOpts.pull, registryOpts.insecureRegistries)
+	installation, err := appstore.NewInstallation("custom-action", ref)
 	if err != nil {
 		return nil, nil, nil, err
 	}
-	c.Bundle = bundle
+	installation.Bundle = bundle
 
-	if err := mergeBundleParameters(c,
+	if err := mergeBundleParameters(installation,
 		withFileParameters(paramsOpts.parametersFiles),
 		withCommandLineParameters(paramsOpts.overrides),
 	); err != nil {
@@ -333,10 +336,10 @@ func prepareCustomAction(actionName string, dockerCli command.Cli, appname strin
 		Action: actionName,
 		Driver: driverImpl,
 	}
-	return a, c, errBuf, nil
+	return a, installation, errBuf, nil
 }
 
-func isInstallationFailed(installation *claim.Claim) bool {
+func isInstallationFailed(installation *appstore.Installation) bool {
 	return installation.Result.Action == claim.ActionInstall &&
 		installation.Result.Status == claim.StatusFailure
 }

internal/commands/inspect.go

@@ -34,11 +34,11 @@ func inspectCmd(dockerCli command.Cli) *cobra.Command {
 
 func runInspect(dockerCli command.Cli, appname string, opts inspectOptions) error {
 	defer muteDockerCli(dockerCli)()
-	a, c, errBuf, err := prepareCustomAction(internal.ActionInspectName, dockerCli, appname, nil, opts.registryOptions, opts.pullOptions, opts.parametersOptions)
+	action, installation, errBuf, err := prepareCustomAction(internal.ActionInspectName, dockerCli, appname, nil, opts.registryOptions, opts.pullOptions, opts.parametersOptions)
 	if err != nil {
 		return err
 	}
-	if err := a.Run(c, nil, nil); err != nil {
+	if err := action.Run(&installation.Claim, nil, nil); err != nil {
 		return fmt.Errorf("inspect failed: %s", errBuf)
 	}
 	return nil

internal/commands/install.go

@@ -5,8 +5,8 @@ import (
 	"os"
 
 	"github.com/deislabs/duffle/pkg/action"
-	"github.com/deislabs/duffle/pkg/claim"
 	"github.com/deislabs/duffle/pkg/credentials"
+	"github.com/docker/app/internal/store"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/spf13/cobra"
@@ -80,7 +80,7 @@ func runInstall(dockerCli command.Cli, appname string, opts installOptions) erro
 		return err
 	}
 
-	bndl, err := resolveBundle(dockerCli, bundleStore, appname, opts.pull, opts.insecureRegistries)
+	bndl, ref, err := resolveBundle(dockerCli, bundleStore, appname, opts.pull, opts.insecureRegistries)
 	if err != nil {
 		return err
 	}
@@ -93,15 +93,15 @@ func runInstall(dockerCli command.Cli, appname string, opts installOptions) erro
 	}
 	if installation, err := installationStore.Read(installationName); err == nil {
 		// A failed installation can be overridden, but with a warning
-		if isInstallationFailed(&installation) {
+		if isInstallationFailed(installation) {
 			fmt.Fprintf(os.Stderr, "WARNING: installing over previously failed installation %q\n", installationName)
 		} else {
 			// Return an error in case of successful installation, or even failed upgrade, which means
 			// their was already a successful installation.
 			return fmt.Errorf("Installation %q already exists, use 'docker app upgrade' instead", installationName)
 		}
 	}
-	c, err := claim.New(installationName)
+	installation, err := store.NewInstallation(installationName, ref)
 	if err != nil {
 		return err
 	}
@@ -110,9 +110,9 @@ func runInstall(dockerCli command.Cli, appname string, opts installOptions) erro
 	if err != nil {
 		return err
 	}
-	c.Bundle = bndl
+	installation.Bundle = bndl
 
-	if err := mergeBundleParameters(c,
+	if err := mergeBundleParameters(installation,
 		withFileParameters(opts.parametersFiles),
 		withCommandLineParameters(opts.overrides),
 		withOrchestratorParameters(opts.orchestrator, opts.kubeNamespace),
@@ -131,10 +131,10 @@ func runInstall(dockerCli command.Cli, appname string, opts installOptions) erro
 	inst := &action.Install{
 		Driver: driverImpl,
 	}
-	err = inst.Run(c, creds, os.Stdout)
+	err = inst.Run(&installation.Claim, creds, os.Stdout)
 	// Even if the installation failed, the installation is persisted with its failure status,
 	// so any installation needs a clean uninstallation.
-	err2 := installationStore.Store(*c)
+	err2 := installationStore.Store(installation)
 	if err != nil {
 		return fmt.Errorf("Installation failed: %s", errBuf)
 	}

internal/commands/list.go

@@ -0,0 +1,97 @@
+package commands
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"github.com/docker/app/internal/store"
+	"github.com/docker/cli/cli"
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/cli/cli/config"
+	units "github.com/docker/go-units"
+	"github.com/spf13/cobra"
+)
+
+type listOptions struct {
+	targetContext string
+}
+
+var (
+	listColumns = []struct {
+		header string
+		value  func(i *store.Installation) string
+	}{
+		{"INSTALLATION", func(i *store.Installation) string { return i.Name }},
+		{"APPLICATION", func(i *store.Installation) string { return fmt.Sprintf("%s (%s)", i.Bundle.Name, i.Bundle.Version) }},
+		{"LAST ACTION", func(i *store.Installation) string { return i.Result.Action }},
+		{"RESULT", func(i *store.Installation) string { return i.Result.Status }},
+		{"CREATED", func(i *store.Installation) string { return units.HumanDuration(time.Since(i.Created)) }},
+		{"MODIFIED", func(i *store.Installation) string { return units.HumanDuration(time.Since(i.Modified)) }},
+		{"REFERENCE", func(i *store.Installation) string { return i.Reference }},
+	}
+)
+
+func listCmd(dockerCli command.Cli) *cobra.Command {
+	var opts listOptions
+
+	cmd := &cobra.Command{
+		Use:     "list [OPTIONS]",
+		Short:   "List the installations and their last known installation result",
+		Aliases: []string{"ls"},
+		Args:    cli.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runList(dockerCli, opts)
+		},
+	}
+	cmd.Flags().StringVar(&opts.targetContext, "target-context", "", "List installations on this context")
+
+	return cmd
+}
+
+func runList(dockerCli command.Cli, opts listOptions) error {
+	targetContext := getTargetContext(opts.targetContext, dockerCli.CurrentContext())
+
+	appstore, err := store.NewApplicationStore(config.Dir())
+	if err != nil {
+		return err
+	}
+	installationStore, err := appstore.InstallationStore(targetContext)
+	if err != nil {
+		return err
+	}
+
+	installations, err := installationStore.List()
+	if err != nil {
+		return err
+	}
+	w := tabwriter.NewWriter(dockerCli.Out(), 0, 0, 1, ' ', 0)
+	printHeaders(w)
+
+	for _, name := range installations {
+		installation, err := installationStore.Read(name)
+		if err != nil {
+			return err
+		}
+		printValues(w, installation)
+	}
+	return w.Flush()
+}
+
+func printHeaders(w io.Writer) {
+	var headers []string
+	for _, column := range listColumns {
+		headers = append(headers, column.header)
+	}
+	fmt.Fprintln(w, strings.Join(headers, "\t"))
+}
+
+func printValues(w io.Writer, installation *store.Installation) {
+	var values []string
+	for _, column := range listColumns {
+		values = append(values, column.value(installation))
+	}
+	fmt.Fprintln(w, strings.Join(values, "\t"))
+}