mirror of https://github.com/docker/cli.git
344 lines
9.4 KiB
Go
344 lines
9.4 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/docker/cli/internal/test"
|
|
// Import builders to get the builder function as package function
|
|
. "github.com/docker/cli/internal/test/builders"
|
|
"github.com/docker/docker/api/types"
|
|
"github.com/docker/docker/api/types/swarm"
|
|
"github.com/docker/docker/api/types/versions"
|
|
"gotest.tools/assert"
|
|
is "gotest.tools/assert/cmp"
|
|
"gotest.tools/golden"
|
|
)
|
|
|
|
func TestServiceListOrder(t *testing.T) {
|
|
cli := test.NewFakeCli(&fakeClient{
|
|
serviceListFunc: func(ctx context.Context, options types.ServiceListOptions) ([]swarm.Service, error) {
|
|
return []swarm.Service{
|
|
newService("a57dbe8", "service-1-foo"),
|
|
newService("a57dbdd", "service-10-foo"),
|
|
newService("aaaaaaa", "service-2-foo"),
|
|
}, nil
|
|
},
|
|
})
|
|
cmd := newListCommand(cli)
|
|
cmd.SetArgs([]string{})
|
|
cmd.Flags().Set("format", "{{.Name}}")
|
|
assert.NilError(t, cmd.Execute())
|
|
golden.Assert(t, cli.OutBuffer().String(), "service-list-sort.golden")
|
|
}
|
|
|
|
// TestServiceListServiceStatus tests that the ServiceStatus struct is correctly
|
|
// propagated. For older API versions, the ServiceStatus is calculated locally,
|
|
// based on the tasks that are present in the swarm, and the nodes that they are
|
|
// running on.
|
|
// If the list command is ran with `--quiet` option, no attempt should be done to
|
|
// propagate the ServiceStatus struct if not present, and it should be set to an
|
|
// empty struct.
|
|
func TestServiceListServiceStatus(t *testing.T) {
|
|
type listResponse struct {
|
|
ID string
|
|
Replicas string
|
|
}
|
|
|
|
type testCase struct {
|
|
doc string
|
|
withQuiet bool
|
|
opts clusterOpts
|
|
cluster *cluster
|
|
expected []listResponse
|
|
}
|
|
|
|
tests := []testCase{
|
|
{
|
|
// Getting no nodes, services or tasks back from the daemon should
|
|
// not cause any problems
|
|
doc: "empty cluster",
|
|
cluster: &cluster{}, // force an empty cluster
|
|
expected: []listResponse{},
|
|
},
|
|
{
|
|
// Services are running, but no active nodes were found. On API v1.40
|
|
// and below, this will cause looking up the "running" tasks to fail,
|
|
// as well as looking up "desired" tasks for global services.
|
|
doc: "API v1.40 no active nodes",
|
|
opts: clusterOpts{
|
|
apiVersion: "1.40",
|
|
activeNodes: 0,
|
|
runningTasks: 2,
|
|
desiredTasks: 4,
|
|
},
|
|
expected: []listResponse{
|
|
{ID: "replicated", Replicas: "0/4"},
|
|
{ID: "global", Replicas: "0/0"},
|
|
{ID: "none-id", Replicas: "0/0"},
|
|
},
|
|
},
|
|
{
|
|
doc: "API v1.40 3 active nodes, 1 task running",
|
|
opts: clusterOpts{
|
|
apiVersion: "1.40",
|
|
activeNodes: 3,
|
|
runningTasks: 1,
|
|
desiredTasks: 2,
|
|
},
|
|
expected: []listResponse{
|
|
{ID: "replicated", Replicas: "1/2"},
|
|
{ID: "global", Replicas: "1/3"},
|
|
{ID: "none-id", Replicas: "0/0"},
|
|
},
|
|
},
|
|
{
|
|
doc: "API v1.40 3 active nodes, all tasks running",
|
|
opts: clusterOpts{
|
|
apiVersion: "1.40",
|
|
activeNodes: 3,
|
|
runningTasks: 3,
|
|
desiredTasks: 3,
|
|
},
|
|
expected: []listResponse{
|
|
{ID: "replicated", Replicas: "3/3"},
|
|
{ID: "global", Replicas: "3/3"},
|
|
{ID: "none-id", Replicas: "0/0"},
|
|
},
|
|
},
|
|
|
|
{
|
|
// Services are running, but no active nodes were found. On API v1.41
|
|
// and up, the ServiceStatus is sent by the daemon, so this should not
|
|
// affect the results.
|
|
doc: "API v1.41 no active nodes",
|
|
opts: clusterOpts{
|
|
apiVersion: "1.41",
|
|
activeNodes: 0,
|
|
runningTasks: 2,
|
|
desiredTasks: 4,
|
|
},
|
|
expected: []listResponse{
|
|
{ID: "replicated", Replicas: "2/4"},
|
|
{ID: "global", Replicas: "0/0"},
|
|
{ID: "none-id", Replicas: "0/0"},
|
|
},
|
|
},
|
|
{
|
|
doc: "API v1.41 3 active nodes, 1 task running",
|
|
opts: clusterOpts{
|
|
apiVersion: "1.41",
|
|
activeNodes: 3,
|
|
runningTasks: 1,
|
|
desiredTasks: 2,
|
|
},
|
|
expected: []listResponse{
|
|
{ID: "replicated", Replicas: "1/2"},
|
|
{ID: "global", Replicas: "1/3"},
|
|
{ID: "none-id", Replicas: "0/0"},
|
|
},
|
|
},
|
|
{
|
|
doc: "API v1.41 3 active nodes, all tasks running",
|
|
opts: clusterOpts{
|
|
apiVersion: "1.41",
|
|
activeNodes: 3,
|
|
runningTasks: 3,
|
|
desiredTasks: 3,
|
|
},
|
|
expected: []listResponse{
|
|
{ID: "replicated", Replicas: "3/3"},
|
|
{ID: "global", Replicas: "3/3"},
|
|
{ID: "none-id", Replicas: "0/0"},
|
|
},
|
|
},
|
|
}
|
|
|
|
matrix := make([]testCase, 0)
|
|
for _, quiet := range []bool{false, true} {
|
|
for _, tc := range tests {
|
|
if quiet {
|
|
tc.withQuiet = quiet
|
|
tc.doc = tc.doc + " with quiet"
|
|
}
|
|
matrix = append(matrix, tc)
|
|
}
|
|
}
|
|
|
|
for _, tc := range matrix {
|
|
tc := tc
|
|
t.Run(tc.doc, func(t *testing.T) {
|
|
if tc.cluster == nil {
|
|
tc.cluster = generateCluster(t, tc.opts)
|
|
}
|
|
cli := test.NewFakeCli(&fakeClient{
|
|
serviceListFunc: func(ctx context.Context, options types.ServiceListOptions) ([]swarm.Service, error) {
|
|
if !options.Status || versions.LessThan(tc.opts.apiVersion, "1.41") {
|
|
// Don't return "ServiceStatus" if not requested, or on older API versions
|
|
for i := range tc.cluster.services {
|
|
tc.cluster.services[i].ServiceStatus = nil
|
|
}
|
|
}
|
|
return tc.cluster.services, nil
|
|
},
|
|
taskListFunc: func(context.Context, types.TaskListOptions) ([]swarm.Task, error) {
|
|
return tc.cluster.tasks, nil
|
|
},
|
|
nodeListFunc: func(ctx context.Context, options types.NodeListOptions) ([]swarm.Node, error) {
|
|
return tc.cluster.nodes, nil
|
|
},
|
|
})
|
|
cmd := newListCommand(cli)
|
|
cmd.SetArgs([]string{})
|
|
if tc.withQuiet {
|
|
cmd.SetArgs([]string{"--quiet"})
|
|
}
|
|
_ = cmd.Flags().Set("format", "{{ json .}}")
|
|
assert.NilError(t, cmd.Execute())
|
|
|
|
lines := strings.Split(strings.TrimSpace(cli.OutBuffer().String()), "\n")
|
|
jsonArr := fmt.Sprintf("[%s]", strings.Join(lines, ","))
|
|
results := make([]listResponse, 0)
|
|
assert.NilError(t, json.Unmarshal([]byte(jsonArr), &results))
|
|
|
|
if tc.withQuiet {
|
|
// With "quiet" enabled, ServiceStatus should not be propagated
|
|
for i := range tc.expected {
|
|
tc.expected[i].Replicas = "0/0"
|
|
}
|
|
}
|
|
assert.Check(t, is.DeepEqual(tc.expected, results), "%+v", results)
|
|
})
|
|
}
|
|
}
|
|
|
|
type clusterOpts struct {
|
|
apiVersion string
|
|
activeNodes uint64
|
|
desiredTasks uint64
|
|
runningTasks uint64
|
|
}
|
|
|
|
type cluster struct {
|
|
services []swarm.Service
|
|
tasks []swarm.Task
|
|
nodes []swarm.Node
|
|
}
|
|
|
|
func generateCluster(t *testing.T, opts clusterOpts) *cluster {
|
|
t.Helper()
|
|
c := cluster{
|
|
services: generateServices(t, opts),
|
|
nodes: generateNodes(t, opts.activeNodes),
|
|
}
|
|
c.tasks = generateTasks(t, c.services, c.nodes, opts)
|
|
return &c
|
|
}
|
|
|
|
func generateServices(t *testing.T, opts clusterOpts) []swarm.Service {
|
|
t.Helper()
|
|
|
|
// Can't have more global tasks than nodes
|
|
globalTasks := opts.runningTasks
|
|
if globalTasks > opts.activeNodes {
|
|
globalTasks = opts.activeNodes
|
|
}
|
|
|
|
return []swarm.Service{
|
|
*Service(
|
|
ServiceID("replicated"),
|
|
ServiceName("01-replicated-service"),
|
|
ReplicatedService(opts.desiredTasks),
|
|
ServiceStatus(opts.desiredTasks, opts.runningTasks),
|
|
),
|
|
*Service(
|
|
ServiceID("global"),
|
|
ServiceName("02-global-service"),
|
|
GlobalService(),
|
|
ServiceStatus(opts.activeNodes, globalTasks),
|
|
),
|
|
*Service(
|
|
ServiceID("none-id"),
|
|
ServiceName("03-none-service"),
|
|
),
|
|
}
|
|
}
|
|
|
|
func generateTasks(t *testing.T, services []swarm.Service, nodes []swarm.Node, opts clusterOpts) []swarm.Task {
|
|
t.Helper()
|
|
tasks := make([]swarm.Task, 0)
|
|
|
|
for _, s := range services {
|
|
if s.Spec.Mode.Replicated == nil && s.Spec.Mode.Global == nil {
|
|
continue
|
|
}
|
|
var runningTasks, failedTasks, desiredTasks uint64
|
|
|
|
// Set the number of desired tasks to generate, based on the service's mode
|
|
if s.Spec.Mode.Replicated != nil {
|
|
desiredTasks = *s.Spec.Mode.Replicated.Replicas
|
|
} else if s.Spec.Mode.Global != nil {
|
|
desiredTasks = opts.activeNodes
|
|
}
|
|
|
|
for _, n := range nodes {
|
|
if runningTasks < opts.runningTasks && n.Status.State != swarm.NodeStateDown {
|
|
tasks = append(tasks, swarm.Task{
|
|
NodeID: n.ID,
|
|
ServiceID: s.ID,
|
|
Status: swarm.TaskStatus{State: swarm.TaskStateRunning},
|
|
DesiredState: swarm.TaskStateRunning,
|
|
})
|
|
runningTasks++
|
|
}
|
|
|
|
// If the number of "running" tasks is lower than the desired number
|
|
// of tasks of the service, fill in the remaining number of tasks
|
|
// with failed tasks. These tasks have a desired "running" state,
|
|
// and thus will be included when calculating the "desired" tasks
|
|
// for services.
|
|
if failedTasks < (desiredTasks - opts.runningTasks) {
|
|
tasks = append(tasks, swarm.Task{
|
|
NodeID: n.ID,
|
|
ServiceID: s.ID,
|
|
Status: swarm.TaskStatus{State: swarm.TaskStateFailed},
|
|
DesiredState: swarm.TaskStateRunning,
|
|
})
|
|
failedTasks++
|
|
}
|
|
|
|
// Also add tasks with DesiredState: Shutdown. These should not be
|
|
// counted as running or desired tasks.
|
|
tasks = append(tasks, swarm.Task{
|
|
NodeID: n.ID,
|
|
ServiceID: s.ID,
|
|
Status: swarm.TaskStatus{State: swarm.TaskStateShutdown},
|
|
DesiredState: swarm.TaskStateShutdown,
|
|
})
|
|
}
|
|
}
|
|
return tasks
|
|
}
|
|
|
|
// generateNodes generates a "nodes" endpoint API response with the requested
|
|
// number of "ready" nodes. In addition, a "down" node is generated.
|
|
func generateNodes(t *testing.T, activeNodes uint64) []swarm.Node {
|
|
t.Helper()
|
|
nodes := make([]swarm.Node, 0)
|
|
var i uint64
|
|
for i = 0; i < activeNodes; i++ {
|
|
nodes = append(nodes, swarm.Node{
|
|
ID: fmt.Sprintf("node-ready-%d", i),
|
|
Status: swarm.NodeStatus{State: swarm.NodeStateReady},
|
|
})
|
|
nodes = append(nodes, swarm.Node{
|
|
ID: fmt.Sprintf("node-down-%d", i),
|
|
Status: swarm.NodeStatus{State: swarm.NodeStateDown},
|
|
})
|
|
}
|
|
return nodes
|
|
}
|