Services: use ServiceStatus on API v1.41 and up

API v1.41 adds a new option to get the number of desired
and running tasks when listing services. This patch enables
this functionality, and provides a fallback mechanism when
using an older API version.

Now that the swarm.Service struct captures this information,
the `ListInfo` type is no longer needed, so it is removed,
and the related list- and formatting functions have been
modified accordingly.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

cli/command/service/formatter.go

@@ -520,17 +520,27 @@ func NewListFormat(source string, quiet bool) formatter.Format {
 	return formatter.Format(source)
 }
 
-// ListInfo stores the information about mode and replicas to be used by template
-type ListInfo struct {
-	Mode     string
-	Replicas string
-}
-
 // ListFormatWrite writes the context
-func ListFormatWrite(ctx formatter.Context, services []swarm.Service, info map[string]ListInfo) error {
+func ListFormatWrite(ctx formatter.Context, services []swarm.Service) error {
 	render := func(format func(subContext formatter.SubContext) error) error {
 		for _, service := range services {
-			serviceCtx := &serviceContext{service: service, mode: info[service.ID].Mode, replicas: info[service.ID].Replicas}
+			serviceCtx := &serviceContext{
+				service: service,
+				mode:    serviceMode(service),
+				replicas: fmt.Sprintf(
+					"%d/%d",
+					service.ServiceStatus.RunningTasks,
+					service.ServiceStatus.DesiredTasks,
+				),
+			}
+
+			if serviceCtx.mode == "replicated" && service.Spec.TaskTemplate.Placement != nil && service.Spec.TaskTemplate.Placement.MaxReplicas > 0 {
+				serviceCtx.replicas += fmt.Sprintf(
+					" (max %d per node)",
+					service.Spec.TaskTemplate.Placement.MaxReplicas,
+				)
+			}
+
 			if err := format(serviceCtx); err != nil {
 				return err
 			}

cli/command/service/formatter_test.go

@@ -84,6 +84,9 @@ bar
 				ID: "id_baz",
 				Spec: swarm.ServiceSpec{
 					Annotations: swarm.Annotations{Name: "baz"},
+					Mode: swarm.ServiceMode{
+						Global: &swarm.GlobalService{},
+					},
 				},
 				Endpoint: swarm.Endpoint{
 					Ports: []swarm.PortConfig{
@@ -95,11 +98,18 @@ bar
 						},
 					},
 				},
+				ServiceStatus: &swarm.ServiceStatus{
+					RunningTasks: 2,
+					DesiredTasks: 4,
+				},
 			},
 			{
 				ID: "id_bar",
 				Spec: swarm.ServiceSpec{
 					Annotations: swarm.Annotations{Name: "bar"},
+					Mode: swarm.ServiceMode{
+						Replicated: &swarm.ReplicatedService{},
+					},
 				},
 				Endpoint: swarm.Endpoint{
 					Ports: []swarm.PortConfig{
@@ -111,21 +121,15 @@ bar
 						},
 					},
 				},
-			},
-		}
-		info := map[string]ListInfo{
-			"id_baz": {
-				Mode:     "global",
-				Replicas: "2/4",
-			},
-			"id_bar": {
-				Mode:     "replicated",
-				Replicas: "2/4",
+				ServiceStatus: &swarm.ServiceStatus{
+					RunningTasks: 2,
+					DesiredTasks: 4,
+				},
 			},
 		}
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
-		err := ListFormatWrite(testcase.context, services, info)
+		err := ListFormatWrite(testcase.context, services)
 		if err != nil {
 			assert.Error(t, err, testcase.expected)
 		} else {
@@ -140,6 +144,9 @@ func TestServiceContextWriteJSON(t *testing.T) {
 			ID: "id_baz",
 			Spec: swarm.ServiceSpec{
 				Annotations: swarm.Annotations{Name: "baz"},
+				Mode: swarm.ServiceMode{
+					Global: &swarm.GlobalService{},
+				},
 			},
 			Endpoint: swarm.Endpoint{
 				Ports: []swarm.PortConfig{
@@ -151,11 +158,18 @@ func TestServiceContextWriteJSON(t *testing.T) {
 					},
 				},
 			},
+			ServiceStatus: &swarm.ServiceStatus{
+				RunningTasks: 2,
+				DesiredTasks: 4,
+			},
 		},
 		{
 			ID: "id_bar",
 			Spec: swarm.ServiceSpec{
 				Annotations: swarm.Annotations{Name: "bar"},
+				Mode: swarm.ServiceMode{
+					Replicated: &swarm.ReplicatedService{},
+				},
 			},
 			Endpoint: swarm.Endpoint{
 				Ports: []swarm.PortConfig{
@@ -167,16 +181,10 @@ func TestServiceContextWriteJSON(t *testing.T) {
 					},
 				},
 			},
-		},
-	}
-	info := map[string]ListInfo{
-		"id_baz": {
-			Mode:     "global",
-			Replicas: "2/4",
-		},
-		"id_bar": {
-			Mode:     "replicated",
-			Replicas: "2/4",
+			ServiceStatus: &swarm.ServiceStatus{
+				RunningTasks: 2,
+				DesiredTasks: 4,
+			},
 		},
 	}
 	expectedJSONs := []map[string]interface{}{
@@ -185,7 +193,7 @@ func TestServiceContextWriteJSON(t *testing.T) {
 	}
 
 	out := bytes.NewBufferString("")
-	err := ListFormatWrite(formatter.Context{Format: "{{json .}}", Output: out}, services, info)
+	err := ListFormatWrite(formatter.Context{Format: "{{json .}}", Output: out}, services)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -199,21 +207,35 @@ func TestServiceContextWriteJSON(t *testing.T) {
 }
 func TestServiceContextWriteJSONField(t *testing.T) {
 	services := []swarm.Service{
-		{ID: "id_baz", Spec: swarm.ServiceSpec{Annotations: swarm.Annotations{Name: "baz"}}},
-		{ID: "id_bar", Spec: swarm.ServiceSpec{Annotations: swarm.Annotations{Name: "bar"}}},
-	}
-	info := map[string]ListInfo{
-		"id_baz": {
-			Mode:     "global",
-			Replicas: "2/4",
+		{
+			ID: "id_baz",
+			Spec: swarm.ServiceSpec{
+				Annotations: swarm.Annotations{Name: "baz"},
+				Mode: swarm.ServiceMode{
+					Global: &swarm.GlobalService{},
+				},
+			},
+			ServiceStatus: &swarm.ServiceStatus{
+				RunningTasks: 2,
+				DesiredTasks: 4,
+			},
 		},
-		"id_bar": {
-			Mode:     "replicated",
-			Replicas: "2/4",
+		{
+			ID: "id_bar",
+			Spec: swarm.ServiceSpec{
+				Annotations: swarm.Annotations{Name: "bar"},
+				Mode: swarm.ServiceMode{
+					Replicated: &swarm.ReplicatedService{},
+				},
+			},
+			ServiceStatus: &swarm.ServiceStatus{
+				RunningTasks: 2,
+				DesiredTasks: 4,
+			},
 		},
 	}
 	out := bytes.NewBufferString("")
-	err := ListFormatWrite(formatter.Context{Format: "{{json .Name}}", Output: out}, services, info)
+	err := ListFormatWrite(formatter.Context{Format: "{{json .Name}}", Output: out}, services)
 	if err != nil {
 		t.Fatal(err)
 	}

cli/command/service/list.go

@@ -2,11 +2,13 @@ package service
 
 import (
 	"context"
-	"fmt"
 	"sort"
 
+	"github.com/docker/docker/client"
 	"vbom.ml/util/sortorder"
 
+	"github.com/docker/docker/api/types/versions"
+
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/cli/command/formatter"
@@ -49,34 +51,34 @@ func runList(dockerCli command.Cli, options listOptions) error {
 	client := dockerCli.Client()
 
 	serviceFilters := options.filter.Value()
-	services, err := client.ServiceList(ctx, types.ServiceListOptions{Filters: serviceFilters})
+	services, err := client.ServiceList(ctx, types.ServiceListOptions{
+		Filters: serviceFilters,
+		// When not running "quiet", also get service status (number of running
+		// and desired tasks). Note that this is only supported on API v1.41 and
+		// up; older API versions ignore this option, and we will have to collect
+		// the information manually below.
+		Status: !options.quiet,
+	})
 	if err != nil {
 		return err
 	}
 
-	sort.Slice(services, func(i, j int) bool {
-		return sortorder.NaturalLess(services[i].Spec.Name, services[j].Spec.Name)
-	})
-	info := map[string]ListInfo{}
 	if len(services) > 0 && !options.quiet {
-		// only non-empty services and not quiet, should we call TaskList and NodeList api
-		taskFilter := filters.NewArgs()
-		for _, service := range services {
-			taskFilter.Add("service", service.ID)
-		}
-
-		tasks, err := client.TaskList(ctx, types.TaskListOptions{Filters: taskFilter})
-		if err != nil {
-			return err
-		}
-
-		nodes, err := client.NodeList(ctx, types.NodeListOptions{})
-		if err != nil {
-			return err
+		// Now that a request was made, we know what API version was used (either
+		// through configuration, or after client and daemon negotiated a version).
+		// If API version v1.41 or up was used; the daemon already did the legwork
+		// for us, and we don't have to calculate the number of desired and running
+		// tasks. On older API versions, we need to do some extra requests to get
+		// that information
+		if versions.LessThan(client.ClientVersion(), "v1.41") {
+			if err := SetServiceStatus(ctx, client, services); err != nil {
+				return err
+			}
 		}
-
-		info = GetServicesStatus(services, nodes, tasks)
 	}
+	sort.Slice(services, func(i, j int) bool {
+		return sortorder.NaturalLess(services[i].Spec.Name, services[j].Spec.Name)
+	})
 
 	format := options.format
 	if len(format) == 0 {
@@ -91,52 +93,62 @@ func runList(dockerCli command.Cli, options listOptions) error {
 		Output: dockerCli.Out(),
 		Format: NewListFormat(format, options.quiet),
 	}
-	return ListFormatWrite(servicesCtx, services, info)
+	return ListFormatWrite(servicesCtx, services)
 }
 
-// GetServicesStatus returns a map of mode and replicas
-func GetServicesStatus(services []swarm.Service, nodes []swarm.Node, tasks []swarm.Task) map[string]ListInfo {
-	running := map[string]int{}
-	tasksNoShutdown := map[string]int{}
+// SetServiceStatus propagates the ServiceStatus field for "services".
+//
+// If API version v1.41 or up is used, this information is already set by the
+// daemon. On older API versions, we need to do some extra requests to get
+// that information
+func SetServiceStatus(ctx context.Context, c client.APIClient, services []swarm.Service) error {
+	serviceIndex := make(map[string]*swarm.Service)
+
+	// only non-empty services and not quiet, should we call TaskList and NodeList api
+	taskFilter := filters.NewArgs()
+	for _, s := range services {
+		s.ServiceStatus = &swarm.ServiceStatus{}
+		serviceIndex[s.ID] = &s
+		taskFilter.Add("service", s.ID)
+	}
+
+	tasks, err := c.TaskList(ctx, types.TaskListOptions{Filters: taskFilter})
+	if err != nil {
+		return err
+	}
 
 	activeNodes := make(map[string]struct{})
-	for _, n := range nodes {
-		if n.Status.State != swarm.NodeStateDown {
-			activeNodes[n.ID] = struct{}{}
+	if len(tasks) > 0 {
+		nodes, err := c.NodeList(ctx, types.NodeListOptions{})
+		if err != nil {
+			return err
+		}
+		for _, n := range nodes {
+			if n.Status.State != swarm.NodeStateDown {
+				activeNodes[n.ID] = struct{}{}
+			}
 		}
 	}
 
 	for _, task := range tasks {
 		if task.DesiredState != swarm.TaskStateShutdown {
-			tasksNoShutdown[task.ServiceID]++
+			serviceIndex[task.ServiceID].ServiceStatus.DesiredTasks++
 		}
 
 		if _, nodeActive := activeNodes[task.NodeID]; nodeActive && task.Status.State == swarm.TaskStateRunning {
-			running[task.ServiceID]++
+			serviceIndex[task.ServiceID].ServiceStatus.RunningTasks++
 		}
 	}
+	return nil
+}
 
-	info := map[string]ListInfo{}
-	for _, service := range services {
-		info[service.ID] = ListInfo{}
-		if service.Spec.Mode.Replicated != nil && service.Spec.Mode.Replicated.Replicas != nil {
-			if service.Spec.TaskTemplate.Placement != nil && service.Spec.TaskTemplate.Placement.MaxReplicas > 0 {
-				info[service.ID] = ListInfo{
-					Mode:     "replicated",
-					Replicas: fmt.Sprintf("%d/%d (max %d per node)", running[service.ID], *service.Spec.Mode.Replicated.Replicas, service.Spec.TaskTemplate.Placement.MaxReplicas),
-				}
-			} else {
-				info[service.ID] = ListInfo{
-					Mode:     "replicated",
-					Replicas: fmt.Sprintf("%d/%d", running[service.ID], *service.Spec.Mode.Replicated.Replicas),
-				}
-			}
-		} else if service.Spec.Mode.Global != nil {
-			info[service.ID] = ListInfo{
-				Mode:     "global",
-				Replicas: fmt.Sprintf("%d/%d", running[service.ID], tasksNoShutdown[service.ID]),
-			}
-		}
+func serviceMode(service swarm.Service) string {
+	switch {
+	case service.Spec.Mode.Global != nil:
+		return "global"
+	case service.Spec.Mode.Replicated != nil:
+		return "replicated"
+	default:
+		return ""
 	}
-	return info
 }