Add services column to docker app ls command

- List all the required services and the running services
- Tries to call status json action on all installed app

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

Author: silvin-lubecki

e2e/commands_test.go

@@ -316,8 +316,8 @@ func TestDockerAppLifecycle(t *testing.T) {
 		cmd.Command = dockerCli.Command("app", "ls")
 		checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
 			[]string{
-				`RUNNING APP\s+APP NAME\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]?\sago\s+.+second[s]?\sago\s+`, appName),
+				`RUNNING APP\s+APP NAME\s+SERVICES\s+LAST ACTION\s+RESULT\s+CREATED\s+MODIFIED\s+REFERENCE`,
+				fmt.Sprintf(`%s\s+simple \(1.1.0-beta1\)\s+0/3\s+install\s+failure\s+.+second[s]?\sago\s+.+second[s]?\sago\s+`, appName),
 			})
 
 		// Upgrading a failed installation is not allowed
@@ -344,8 +344,8 @@ func TestDockerAppLifecycle(t *testing.T) {
 		cmd.Command = dockerCli.Command("app", "ls")
 		checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
 			[]string{
-				`RUNNING APP\s+APP NAME\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]?\sago\s+.+second[s]?\sago\s+`, appName),
+				`RUNNING APP\s+APP NAME\s+SERVICES\s+LAST ACTION\s+RESULT\s+CREATED\s+MODIFIED\s+REFERENCE`,
+				fmt.Sprintf(`%s\s+simple \(1.1.0-beta1\)\s+\d/3\s+install\s+success\s+.+second[s]?\sago\s+.+second[s]?\sago\s+`, appName),
 			})
 
 		// Installing again the same application is forbidden

e2e/pushpull_test.go

@@ -91,7 +91,7 @@ func TestPushPullInstall(t *testing.T) {
 		cmd.Command = dockerCli.Command("app", "ls")
 		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]?\sago\s+.+second[s]?\sago\s+%s`, t.Name(), ref+tag),
+				fmt.Sprintf(`%s\s+push-pull \(1.1.0-beta1\)\s+\d/1\s+install\s+success\s+.+second[s]?\sago\s+.+second[s]?\sago\s+%s`, t.Name(), ref+tag),
 			})
 
 		// install should fail (registry is stopped)

internal/commands/list.go

@@ -1,13 +1,18 @@
 package commands
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 	"sort"
 	"strings"
 	"text/tabwriter"
 	"time"
 
+	"github.com/deislabs/cnab-go/action"
+	"github.com/docker/app/internal"
+	"github.com/docker/app/internal/cliopts"
+	"github.com/docker/app/internal/cnab"
 	"github.com/docker/app/internal/store"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
@@ -22,55 +27,79 @@ import (
 var (
 	listColumns = []struct {
 		header string
-		value  func(i *store.Installation) string
+		value  func(i Installation) string
 	}{
-		{"RUNNING APP", func(i *store.Installation) string { return i.Name }},
-		{"APP NAME", 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 {
+		{"RUNNING APP", func(i Installation) string { return i.Name }},
+		{"APP NAME", func(i Installation) string { return fmt.Sprintf("%s (%s)", i.Bundle.Name, i.Bundle.Version) }},
+		{"SERVICES", printServices},
+		{"LAST ACTION", func(i Installation) string { return i.Result.Action }},
+		{"RESULT", func(i Installation) string { return i.Result.Status }},
+		{"CREATED", func(i Installation) string {
 			return fmt.Sprintf("%s ago", units.HumanDuration(time.Since(i.Created)))
 		}},
-		{"MODIFIED", func(i *store.Installation) string {
+		{"MODIFIED", func(i Installation) string {
 			return fmt.Sprintf("%s ago", units.HumanDuration(time.Since(i.Modified)))
 		}},
-		{"REFERENCE", func(i *store.Installation) string { return i.Reference }},
+		{"REFERENCE", func(i Installation) string { return i.Reference }},
 	}
 )
 
-func listCmd(dockerCli command.Cli) *cobra.Command {
-	var template string
+type listOptions struct {
+	template string
+}
+
+func listCmd(dockerCli command.Cli, installerContext *cliopts.InstallerContextOptions) *cobra.Command {
+	var opts listOptions
 	cmd := &cobra.Command{
 		Use:     "ls [OPTIONS]",
 		Short:   "List running Apps",
 		Aliases: []string{"list"},
 		Args:    cli.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runList(dockerCli, template)
+			return runList(dockerCli, opts, installerContext)
 		},
 	}
 
-	cmd.Flags().StringVarP(&template, "format", "f", "", "Format the output using the given syntax or Go template")
+	cmd.Flags().StringVarP(&opts.template, "format", "f", "", "Format the output using the given syntax or Go template")
 	cmd.Flags().SetAnnotation("format", "experimentalCLI", []string{"true"}) //nolint:errcheck
 	return cmd
 }
 
-func runList(dockerCli command.Cli, template string) error {
-	installations, err := getInstallations(dockerCli.CurrentContext(), config.Dir())
+func runList(dockerCli command.Cli, opts listOptions, installerContext *cliopts.InstallerContextOptions) error {
+	// initialize stores
+	appstore, err := store.NewApplicationStore(config.Dir())
+	if err != nil {
+		return err
+	}
+	targetContext := dockerCli.CurrentContext()
+	installationStore, err := appstore.InstallationStore(targetContext)
+	if err != nil {
+		return err
+	}
+
+	fetcher := &serviceFetcher{
+		dockerCli:        dockerCli,
+		opts:             opts,
+		installerContext: installerContext,
+	}
+	installations, err := getInstallations(installationStore, fetcher)
+	if installations == nil && err != nil {
+		return err
+	}
 	if err != nil {
 		return err
 	}
 
-	if template == "json" {
+	if opts.template == "json" {
 		bytes, err := json.MarshalIndent(installations, "", "  ")
 		if err != nil {
 			return errors.Errorf("Failed to marshall json: %s", err)
 		}
 		_, err = dockerCli.Out().Write(bytes)
 		return err
 	}
-	if template != "" {
-		tmpl, err := templates.Parse(template)
+	if opts.template != "" {
+		tmpl, err := templates.Parse(opts.template)
 		if err != nil {
 			return errors.Errorf("Template parsing error: %s", err)
 		}
@@ -94,38 +123,128 @@ func printHeaders(w io.Writer) {
 	fmt.Fprintln(w, strings.Join(headers, "\t"))
 }
 
-func printValues(w io.Writer, installation *store.Installation) {
+func printValues(w io.Writer, installation Installation) {
 	var values []string
 	for _, column := range listColumns {
 		values = append(values, column.value(installation))
 	}
 	fmt.Fprintln(w, strings.Join(values, "\t"))
 }
 
-func getInstallations(targetContext, configDir string) ([]*store.Installation, error) {
-	appstore, err := store.NewApplicationStore(configDir)
-	if err != nil {
-		return nil, err
-	}
-	installationStore, err := appstore.InstallationStore(targetContext)
-	if err != nil {
-		return nil, err
-	}
+type Installation struct {
+	*store.Installation
+	Services appServices `json:",omitempty"`
+}
+
+func getInstallations(installationStore store.InstallationStore, fetcher ServiceFetcher) ([]Installation, error) {
 	installationNames, err := installationStore.List()
 	if err != nil {
 		return nil, err
 	}
-	installations := make([]*store.Installation, len(installationNames))
+	installations := make([]Installation, len(installationNames))
 	for i, name := range installationNames {
 		installation, err := installationStore.Read(name)
 		if err != nil {
 			return nil, err
 		}
-		installations[i] = installation
+		services, err := fetcher.getServices(installation)
+		if err != nil {
+			return nil, err
+		}
+		installations[i] = Installation{Installation: installation, Services: services}
 	}
 	// Sort installations with last modified first
 	sort.Slice(installations, func(i, j int) bool {
 		return installations[i].Modified.After(installations[j].Modified)
 	})
+
 	return installations, nil
 }
+
+type ServiceStatus struct {
+	DesiredTasks int
+	RunningTasks int
+}
+
+type appServices map[string]ServiceStatus
+
+type runningService struct {
+	Spec struct {
+		Name string
+	}
+	ServiceStatus ServiceStatus
+}
+
+type serviceFetcher struct {
+	dockerCli        command.Cli
+	opts             listOptions
+	installerContext *cliopts.InstallerContextOptions
+}
+
+type ServiceFetcher interface {
+	getServices(*store.Installation) (appServices, error)
+}
+
+func (s *serviceFetcher) getServices(installation *store.Installation) (appServices, error) {
+	defer muteDockerCli(s.dockerCli)()
+
+	// bundle without status action returns empty services
+	if !hasAction(installation.Bundle, internal.ActionStatusJSONName) {
+		return nil, nil
+	}
+	creds, err := prepareCredentialSet(installation.Bundle,
+		addDockerCredentials(s.dockerCli.CurrentContext(), s.dockerCli.ContextStore()),
+		addRegistryCredentials(false, s.dockerCli),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	driverImpl, errBuf, err := cnab.SetupDriver(installation, s.dockerCli, s.installerContext, &buf)
+	if err != nil {
+		return nil, err
+	}
+	a := &action.RunCustom{
+		Driver: driverImpl,
+		Action: internal.ActionStatusJSONName,
+	}
+	// fetch output from status JSON action and parse it
+	if err := a.Run(&installation.Claim, creds); err != nil {
+		return nil, fmt.Errorf("failed to get app %q status : %s\n%s", installation.Name, err, errBuf)
+	}
+	var runningServices []runningService
+	if err := json.Unmarshal(buf.Bytes(), &runningServices); err != nil {
+		return nil, err
+	}
+
+	services := make(appServices, len(installation.Bundle.Images))
+	for name := range installation.Bundle.Images {
+		services[name] = getRunningService(runningServices, installation.Name, name)
+	}
+
+	return services, nil
+}
+
+func getRunningService(services []runningService, app, name string) ServiceStatus {
+	for _, s := range services {
+		// swarm services are prefixed by app name
+		if s.Spec.Name == name || s.Spec.Name == fmt.Sprintf("%s_%s", app, name) {
+			return s.ServiceStatus
+		}
+	}
+	return ServiceStatus{}
+}
+
+func printServices(i Installation) string {
+	if len(i.Services) == 0 {
+		return "N/A"
+	}
+	var runningServices int
+	for _, s := range i.Services {
+		if s.RunningTasks > 0 {
+			runningServices++
+		}
+	}
+	return fmt.Sprintf("%d/%d", runningServices, len(i.Services))
+}

internal/commands/list_test.go

@@ -7,18 +7,33 @@ import (
 	"github.com/deislabs/cnab-go/claim"
 	"github.com/docker/app/internal/store"
 	"gotest.tools/assert"
-	"gotest.tools/fs"
 )
 
+type mockInstallationStore struct {
+	installations map[string]*store.Installation
+}
+
+func (m mockInstallationStore) List() ([]string, error) {
+	l := []string{}
+	for k := range m.installations {
+		l = append(l, k)
+	}
+	return l, nil
+}
+func (m mockInstallationStore) Store(installation *store.Installation) error { return nil }
+func (m mockInstallationStore) Read(installationName string) (*store.Installation, error) {
+	return m.installations[installationName], nil
+}
+func (m mockInstallationStore) Delete(installationName string) error { return nil }
+
+type stubServiceFetcher struct{}
+
+func (s stubServiceFetcher) getServices(*store.Installation) (appServices, error) {
+	return map[string]ServiceStatus{"service1": {DesiredTasks: 1, RunningTasks: 1}}, nil
+}
+
 func TestGetInstallationsSorted(t *testing.T) {
-	tmpDir := fs.NewDir(t, "")
-	defer tmpDir.Remove()
-	appstore, err := store.NewApplicationStore(tmpDir.Path())
-	assert.NilError(t, err)
-	installationStore, err := appstore.InstallationStore("my-context")
-	assert.NilError(t, err)
 	now := time.Now()
-
 	oldInstallation := &store.Installation{
 		Claim: claim.Claim{
 			Name:     "old-installation",
@@ -31,13 +46,48 @@ func TestGetInstallationsSorted(t *testing.T) {
 			Modified: now,
 		},
 	}
-	assert.NilError(t, installationStore.Store(newInstallation))
-	assert.NilError(t, installationStore.Store(oldInstallation))
-
-	installations, err := getInstallations("my-context", tmpDir.Path())
+	installationStore := mockInstallationStore{installations: map[string]*store.Installation{"old-installation": oldInstallation, "new-installation": newInstallation}}
+	installations, err := getInstallations(installationStore, &stubServiceFetcher{})
 	assert.NilError(t, err)
 	assert.Equal(t, len(installations), 2)
 	// First installation is the last modified
 	assert.Equal(t, installations[0].Name, "new-installation")
+	assert.Equal(t, installations[0].Services["service1"].DesiredTasks, 1)
 	assert.Equal(t, installations[1].Name, "old-installation")
+	assert.Equal(t, installations[1].Services["service1"].RunningTasks, 1)
+}
+
+func TestPrintServices(t *testing.T) {
+	testCases := []struct {
+		name         string
+		installation Installation
+		expected     string
+	}{
+		{
+			"Failed installation",
+			Installation{},
+			"N/A",
+		},
+		{
+			"Non running service",
+			Installation{Services: map[string]ServiceStatus{
+				"service1": {DesiredTasks: 1, RunningTasks: 0},
+			}},
+			"0/1",
+		},
+		{
+			"Mixed running services and non running",
+			Installation{Services: map[string]ServiceStatus{
+				"service1": {DesiredTasks: 1, RunningTasks: 0},
+				"service2": {DesiredTasks: 5, RunningTasks: 1},
+			}},
+			"1/2",
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			output := printServices(testCase.installation)
+			assert.Equal(t, testCase.expected, output)
+		})
+	}
 }