Add table formating in CNAB status action

Signed-off-by: Jean-Christophe Sirot <jean-christophe.sirot@docker.com>

Author: Jean-Christophe Sirot

cmd/cnab-run/status.go

@@ -3,24 +3,144 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
+	"sort"
+	"strings"
+	"text/tabwriter"
 
 	"github.com/docker/app/internal"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/cli/command/stack"
 	"github.com/docker/cli/cli/command/stack/options"
 	"github.com/docker/cli/opts"
+	"github.com/docker/distribution/reference"
 	swarmtypes "github.com/docker/docker/api/types/swarm"
+	"github.com/docker/docker/pkg/stringid"
 	"github.com/pkg/errors"
 )
 
+var (
+	listColumns = []struct {
+		header string
+		value  func(s *swarmtypes.Service) string
+	}{
+		{"ID", func(s *swarmtypes.Service) string { return stringid.TruncateID(s.ID) }},
+		{"NAME", func(s *swarmtypes.Service) string { return s.Spec.Name }},
+		{"MODE", func(s *swarmtypes.Service) string {
+			if s.Spec.Mode.Replicated != nil {
+				return "replicated"
+			}
+			return "global"
+		}},
+		{"REPLICAS", func(s *swarmtypes.Service) string {
+			if s.Spec.Mode.Replicated != nil {
+				return fmt.Sprintf("%d/%d", s.ServiceStatus.RunningTasks, s.ServiceStatus.DesiredTasks)
+			}
+			return ""
+		}},
+		{"IMAGE", func(s *swarmtypes.Service) string {
+			ref, err := reference.ParseAnyReference(s.Spec.TaskTemplate.ContainerSpec.Image)
+			if err != nil {
+				return "N/A"
+			}
+			if namedRef, ok := ref.(reference.Named); ok {
+				return reference.FamiliarName(namedRef)
+			}
+			return reference.FamiliarString(ref)
+		}},
+		{"PORTS", func(s *swarmtypes.Service) string {
+			return Ports(s.Endpoint.Ports)
+		}},
+	}
+)
+
+type portRange struct {
+	pStart   uint32
+	pEnd     uint32
+	tStart   uint32
+	tEnd     uint32
+	protocol swarmtypes.PortConfigProtocol
+}
+
+func (pr portRange) String() string {
+	var (
+		pub string
+		tgt string
+	)
+
+	if pr.pEnd > pr.pStart {
+		pub = fmt.Sprintf("%d-%d", pr.pStart, pr.pEnd)
+	} else {
+		pub = fmt.Sprintf("%d", pr.pStart)
+	}
+	if pr.tEnd > pr.tStart {
+		tgt = fmt.Sprintf("%d-%d", pr.tStart, pr.tEnd)
+	} else {
+		tgt = fmt.Sprintf("%d", pr.tStart)
+	}
+	return fmt.Sprintf("*:%s->%s/%s", pub, tgt, pr.protocol)
+}
+
+// Ports formats port configuration. This function is copied et adapted from docker CLI
+// see https://github.com/docker/cli/blob/d6edc912ce/cli/command/service/formatter.go#L655
+func Ports(servicePorts []swarmtypes.PortConfig) string {
+	if servicePorts == nil {
+		return ""
+	}
+
+	pr := portRange{}
+	ports := []string{}
+
+	sort.Slice(servicePorts, func(i, j int) bool {
+		if servicePorts[i].Protocol == servicePorts[j].Protocol {
+			return servicePorts[i].PublishedPort < servicePorts[j].PublishedPort
+		}
+		return servicePorts[i].Protocol < servicePorts[j].Protocol
+	})
+
+	for _, p := range servicePorts {
+		if p.PublishMode == swarmtypes.PortConfigPublishModeIngress {
+			prIsRange := pr.tEnd != pr.tStart
+			tOverlaps := p.TargetPort <= pr.tEnd
+
+			// Start a new port-range if:
+			// - the protocol is different from the current port-range
+			// - published or target port are not consecutive to the current port-range
+			// - the current port-range is a _range_, and the target port overlaps with the current range's target-ports
+			if p.Protocol != pr.protocol || p.PublishedPort-pr.pEnd > 1 || p.TargetPort-pr.tEnd > 1 || prIsRange && tOverlaps {
+				// start a new port-range, and print the previous port-range (if any)
+				if pr.pStart > 0 {
+					ports = append(ports, pr.String())
+				}
+				pr = portRange{
+					pStart:   p.PublishedPort,
+					pEnd:     p.PublishedPort,
+					tStart:   p.TargetPort,
+					tEnd:     p.TargetPort,
+					protocol: p.Protocol,
+				}
+				continue
+			}
+			pr.pEnd = p.PublishedPort
+			pr.tEnd = p.TargetPort
+		}
+	}
+	if pr.pStart > 0 {
+		ports = append(ports, pr.String())
+	}
+	return strings.Join(ports, ", ")
+}
+
 func statusAction(instanceName string) error {
 	cli, err := getCli()
 	if err != nil {
 		return err
 	}
 	services, _ := runningServices(cli, instanceName)
-	fmt.Fprintln(cli.Out(), services)
+	if err := printServices(cli.Out(), services); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -57,3 +177,29 @@ func runningServices(cli command.Cli, instanceName string) ([]swarmtypes.Service
 		Namespace: instanceName,
 	})
 }
+
+func printServices(out io.Writer, services []swarmtypes.Service) error {
+	w := tabwriter.NewWriter(out, 0, 0, 1, ' ', 0)
+	printHeaders(w)
+
+	for _, service := range services {
+		printValues(w, &service)
+	}
+	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, service *swarmtypes.Service) {
+	var values []string
+	for _, column := range listColumns {
+		values = append(values, column.value(service))
+	}
+	fmt.Fprintln(w, strings.Join(values, "\t"))
+}

internal/commands/inspect.go

@@ -1,25 +1,25 @@
 package commands
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"os"
-	"strings"
 
 	"github.com/deislabs/cnab-go/action"
+	"github.com/deislabs/cnab-go/bundle"
 	"github.com/docker/app/internal"
+	"github.com/docker/app/internal/cliopts"
 	"github.com/docker/app/internal/cnab"
 	"github.com/docker/app/internal/inspect"
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/command/stack"
-	"github.com/docker/cli/cli/command/stack/options"
-	"github.com/docker/cli/opts"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 type inspectOptions struct {
 	credentialOptions
+	cliopts.InstallerContextOptions
 	pretty        bool
 	orchestrator  string
 	kubeNamespace string
@@ -29,10 +29,10 @@ func inspectCmd(dockerCli command.Cli) *cobra.Command {
 	var opts inspectOptions
 	cmd := &cobra.Command{
 		Use:   "inspect [OPTIONS] RUNNING_APP",
-		Short: "Shows installation and application metadata, parameters and the containers list of a running application",
+		Short: "Shows installation and App metadata, parameters and the service list of a running App",
 		Example: `$ docker app inspect my-running-app
 $ docker app inspect my-running-app:1.0.0`,
-		Args:   cli.RequiresMaxArgs(1),
+		Args:   cli.ExactArgs(1),
 		Hidden: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return runInspect(dockerCli, firstOrEmpty(args), opts)
@@ -42,6 +42,7 @@ $ docker app inspect my-running-app:1.0.0`,
 	cmd.Flags().StringVar(&opts.orchestrator, "orchestrator", "", "Orchestrator where the App is running on (swarm, kubernetes)")
 	cmd.Flags().StringVar(&opts.kubeNamespace, "namespace", "default", "Kubernetes namespace in which to find the App")
 	opts.credentialOptions.addFlags(cmd.Flags())
+	opts.InstallerContextOptions.AddFlags(cmd.Flags())
 	return cmd
 }
 
@@ -50,18 +51,9 @@ func runInspect(dockerCli command.Cli, appName string, inspectOptions inspectOpt
 	if err != nil {
 		return err
 	}
-	services, err := stack.GetServices(dockerCli, pflag.NewFlagSet("", pflag.ContinueOnError), orchestrator, options.Services{
-		Filter:    opts.NewFilterOpt(),
-		Namespace: inspectOptions.kubeNamespace,
-	})
-	if err != nil {
-		return err
-	}
-	println(services)
 
-	inspectOptions.SetDefaultTargetContext(dockerCli)
 	defer muteDockerCli(dockerCli)()
-	_, installationStore, credentialStore, err := prepareStores(inspectOptions.targetContext)
+	_, installationStore, credentialStore, err := prepareStores(dockerCli.CurrentContext())
 	if err != nil {
 		return err
 	}
@@ -75,48 +67,53 @@ func runInspect(dockerCli command.Cli, appName string, inspectOptions inspectOpt
 		orchestratorName = string(orchestrator)
 	}
 
-	format := "json"
-	actionName := internal.ActionStatusJSONName
-	if inspectOptions.pretty {
-		format = "pretty"
-		actionName = internal.ActionStatusName
-	}
-
-	if err := inspect.Inspect(os.Stdout, installation.Claim, format, orchestratorName); err != nil {
+	creds, err := prepareCredentialSet(installation.Bundle, inspectOptions.CredentialSetOpts(dockerCli, credentialStore)...)
+	if err != nil {
 		return err
 	}
 
-	var statusAction bool
-	for key := range installation.Bundle.Actions {
-		if strings.HasPrefix(key, "io.cnab.status") {
-			statusAction = true
-		}
-	}
-	if !statusAction {
-		return nil
-	}
-
-	bind, err := cnab.RequiredBindMount(inspectOptions.targetContext, orchestratorName, dockerCli.ContextStore())
+	var buf bytes.Buffer
+	driverImpl, errBuf, err := cnab.SetupDriver(installation, dockerCli, inspectOptions.InstallerContextOptions, &buf)
 	if err != nil {
 		return err
 	}
 
-	driverImpl, errBuf := cnab.PrepareDriver(dockerCli, bind, nil)
 	a := &action.RunCustom{
-		Action: actionName,
 		Driver: driverImpl,
 	}
-
-	creds, err := prepareCredentialSet(installation.Bundle, inspectOptions.CredentialSetOpts(dockerCli, credentialStore)...)
-	if err != nil {
-		return err
+	if inspectOptions.pretty && hasAction(installation.Bundle, internal.ActionStatusName) {
+		a.Action = internal.ActionStatusName
+	} else if hasAction(installation.Bundle, internal.ActionStatusJSONName) {
+		a.Action = internal.ActionStatusJSONName
+	} else {
+		return fmt.Errorf("inspect failed: status action is not supported by the App")
 	}
-
-	installation.SetParameter(internal.ParameterInspectFormatName, format)
-	println()
 	if err := a.Run(&installation.Claim, creds, nil); err != nil {
 		return fmt.Errorf("inspect failed: %s\n%s", err, errBuf)
 	}
+
+	if inspectOptions.pretty {
+		if err := inspect.Inspect(os.Stdout, installation, "pretty", orchestratorName); err != nil {
+			return err
+		}
+		fmt.Fprint(os.Stdout, buf.String())
+	} else {
+		var statusJSON interface{}
+		if err := json.Unmarshal(buf.Bytes(), &statusJSON); err != nil {
+			return err
+		}
+		js, err := json.MarshalIndent(struct {
+			AppInfo  inspect.AppInfo `json:",omitempty"`
+			Services interface{}     `json:",omitempty"`
+		}{
+			inspect.GetAppInfo(installation, orchestratorName),
+			statusJSON,
+		}, "", "    ")
+		if err != nil {
+			return err
+		}
+		fmt.Fprint(os.Stdout, string(js))
+	}
 	return nil
 }
 
@@ -132,3 +129,12 @@ func getContextOrchestrator(dockerCli command.Cli, orchestratorFlag string) (com
 	}
 	return orchestrator, nil
 }
+
+func hasAction(bndl *bundle.Bundle, actionName string) bool {
+	for key := range bndl.Actions {
+		if key == actionName {
+			return true
+		}
+	}
+	return false
+}