vendor: github.com/moby/moby/api, moby/moby/client master

cli/command/container/client_test.go

@@ -35,7 +35,7 @@ type fakeClient struct {
 	containerRestartFunc    func(ctx context.Context, containerID string, options client.ContainerStopOptions) error
 	containerStopFunc       func(ctx context.Context, containerID string, options client.ContainerStopOptions) error
 	containerKillFunc       func(ctx context.Context, containerID, signal string) error
-	containerPruneFunc      func(ctx context.Context, pruneFilters client.Filters) (container.PruneReport, error)
+	containerPruneFunc      func(ctx context.Context, options client.ContainerPruneOptions) (client.ContainerPruneResult, error)
 	containerAttachFunc     func(ctx context.Context, containerID string, options client.ContainerAttachOptions) (client.HijackedResponse, error)
 	containerDiffFunc       func(ctx context.Context, containerID string) ([]container.FilesystemChange, error)
 	containerRenameFunc     func(ctx context.Context, oldName, newName string) error
@@ -171,11 +171,11 @@ func (f *fakeClient) ContainerKill(ctx context.Context, containerID, signal stri
 	return nil
 }
 
-func (f *fakeClient) ContainersPrune(ctx context.Context, pruneFilters client.Filters) (container.PruneReport, error) {
+func (f *fakeClient) ContainersPrune(ctx context.Context, options client.ContainerPruneOptions) (client.ContainerPruneResult, error) {
 	if f.containerPruneFunc != nil {
-		return f.containerPruneFunc(ctx, pruneFilters)
+		return f.containerPruneFunc(ctx, options)
 	}
-	return container.PruneReport{}, nil
+	return client.ContainerPruneResult{}, nil
 }
 
 func (f *fakeClient) ContainerRestart(ctx context.Context, containerID string, options client.ContainerStopOptions) error {

cli/command/container/prune.go

@@ -11,6 +11,7 @@ import (
 	"github.com/docker/cli/internal/prompt"
 	"github.com/docker/cli/opts"
 	"github.com/docker/go-units"
+	"github.com/moby/moby/client"
 	"github.com/spf13/cobra"
 )
 
@@ -73,17 +74,19 @@ func runPrune(ctx context.Context, dockerCli command.Cli, options pruneOptions)
 		}
 	}
 
-	report, err := dockerCli.Client().ContainersPrune(ctx, pruneFilters)
+	res, err := dockerCli.Client().ContainersPrune(ctx, client.ContainerPruneOptions{
+		Filters: pruneFilters,
+	})
 	if err != nil {
 		return 0, "", err
 	}
 
-	if len(report.ContainersDeleted) > 0 {
+	if len(res.Report.ContainersDeleted) > 0 {
 		output = "Deleted Containers:\n"
-		for _, id := range report.ContainersDeleted {
+		for _, id := range res.Report.ContainersDeleted {
 			output += id + "\n"
 		}
-		spaceReclaimed = report.SpaceReclaimed
+		spaceReclaimed = res.Report.SpaceReclaimed
 	}
 
 	return spaceReclaimed, output, nil

cli/command/container/prune_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
-	"github.com/moby/moby/api/types/container"
 	"github.com/moby/moby/client"
 )
 
@@ -16,8 +15,8 @@ func TestContainerPrunePromptTermination(t *testing.T) {
 	t.Cleanup(cancel)
 
 	cli := test.NewFakeCli(&fakeClient{
-		containerPruneFunc: func(ctx context.Context, pruneFilters client.Filters) (container.PruneReport, error) {
-			return container.PruneReport{}, errors.New("fakeClient containerPruneFunc should not be called")
+		containerPruneFunc: func(ctx context.Context, opts client.ContainerPruneOptions) (client.ContainerPruneResult, error) {
+			return client.ContainerPruneResult{}, errors.New("fakeClient containerPruneFunc should not be called")
 		},
 	})
 	cmd := newPruneCommand(cli)

cli/command/image/client_test.go

@@ -19,7 +19,7 @@ type fakeClient struct {
 	imagePushFunc    func(ref string, options client.ImagePushOptions) (io.ReadCloser, error)
 	infoFunc         func() (system.Info, error)
 	imagePullFunc    func(ref string, options client.ImagePullOptions) (client.ImagePullResponse, error)
-	imagesPruneFunc  func(pruneFilter client.Filters) (image.PruneReport, error)
+	imagesPruneFunc  func(options client.ImagePruneOptions) (client.ImagePruneResult, error)
 	imageLoadFunc    func(input io.Reader, options ...client.ImageLoadOption) (client.LoadResponse, error)
 	imageListFunc    func(options client.ImageListOptions) ([]image.Summary, error)
 	imageInspectFunc func(img string) (image.InspectResponse, error)
@@ -72,11 +72,11 @@ func (cli *fakeClient) ImagePull(_ context.Context, ref string, options client.I
 	return client.ImagePullResponse{}, nil
 }
 
-func (cli *fakeClient) ImagesPrune(_ context.Context, pruneFilter client.Filters) (image.PruneReport, error) {
+func (cli *fakeClient) ImagesPrune(_ context.Context, opts client.ImagePruneOptions) (client.ImagePruneResult, error) {
 	if cli.imagesPruneFunc != nil {
-		return cli.imagesPruneFunc(pruneFilter)
+		return cli.imagesPruneFunc(opts)
 	}
-	return image.PruneReport{}, nil
+	return client.ImagePruneResult{}, nil
 }
 
 func (cli *fakeClient) ImageLoad(_ context.Context, input io.Reader, options ...client.ImageLoadOption) (client.LoadResponse, error) {

cli/command/image/prune.go

@@ -13,6 +13,7 @@ import (
 	"github.com/docker/cli/internal/prompt"
 	"github.com/docker/cli/opts"
 	"github.com/docker/go-units"
+	"github.com/moby/moby/client"
 	"github.com/spf13/cobra"
 )
 
@@ -86,15 +87,17 @@ func runPrune(ctx context.Context, dockerCli command.Cli, options pruneOptions)
 		}
 	}
 
-	report, err := dockerCli.Client().ImagesPrune(ctx, pruneFilters)
+	res, err := dockerCli.Client().ImagesPrune(ctx, client.ImagePruneOptions{
+		Filters: pruneFilters,
+	})
 	if err != nil {
 		return 0, "", err
 	}
 
-	if len(report.ImagesDeleted) > 0 {
-		var sb strings.Builder
+	var sb strings.Builder
+	if len(res.Report.ImagesDeleted) > 0 {
 		sb.WriteString("Deleted Images:\n")
-		for _, st := range report.ImagesDeleted {
+		for _, st := range res.Report.ImagesDeleted {
 			if st.Untagged != "" {
 				sb.WriteString("untagged: ")
 				sb.WriteString(st.Untagged)
@@ -105,11 +108,9 @@ func runPrune(ctx context.Context, dockerCli command.Cli, options pruneOptions)
 				sb.WriteByte('\n')
 			}
 		}
-		output = sb.String()
-		spaceReclaimed = report.SpaceReclaimed
 	}
 
-	return spaceReclaimed, output, nil
+	return res.Report.SpaceReclaimed, sb.String(), nil
 }
 
 type cancelledErr struct{ error }

cli/command/image/prune_test.go

@@ -21,7 +21,7 @@ func TestNewPruneCommandErrors(t *testing.T) {
 		name            string
 		args            []string
 		expectedError   string
-		imagesPruneFunc func(pruneFilter client.Filters) (image.PruneReport, error)
+		imagesPruneFunc func(client.ImagePruneOptions) (client.ImagePruneResult, error)
 	}{
 		{
 			name:          "wrong-args",
@@ -32,8 +32,8 @@ func TestNewPruneCommandErrors(t *testing.T) {
 			name:          "prune-error",
 			args:          []string{"--force"},
 			expectedError: "something went wrong",
-			imagesPruneFunc: func(pruneFilter client.Filters) (image.PruneReport, error) {
-				return image.PruneReport{}, errors.New("something went wrong")
+			imagesPruneFunc: func(client.ImagePruneOptions) (client.ImagePruneResult, error) {
+				return client.ImagePruneResult{}, errors.New("something went wrong")
 			},
 		},
 	}
@@ -54,43 +54,47 @@ func TestNewPruneCommandSuccess(t *testing.T) {
 	testCases := []struct {
 		name            string
 		args            []string
-		imagesPruneFunc func(pruneFilter client.Filters) (image.PruneReport, error)
+		imagesPruneFunc func(client.ImagePruneOptions) (client.ImagePruneResult, error)
 	}{
 		{
 			name: "all",
 			args: []string{"--all"},
-			imagesPruneFunc: func(pruneFilter client.Filters) (image.PruneReport, error) {
-				assert.Check(t, pruneFilter["dangling"]["false"])
-				return image.PruneReport{}, nil
+			imagesPruneFunc: func(opts client.ImagePruneOptions) (client.ImagePruneResult, error) {
+				assert.Check(t, opts.Filters["dangling"]["false"])
+				return client.ImagePruneResult{}, nil
 			},
 		},
 		{
 			name: "force-deleted",
 			args: []string{"--force"},
-			imagesPruneFunc: func(pruneFilter client.Filters) (image.PruneReport, error) {
-				assert.Check(t, pruneFilter["dangling"]["true"])
-				return image.PruneReport{
-					ImagesDeleted:  []image.DeleteResponse{{Deleted: "image1"}},
-					SpaceReclaimed: 1,
+			imagesPruneFunc: func(opts client.ImagePruneOptions) (client.ImagePruneResult, error) {
+				assert.Check(t, opts.Filters["dangling"]["true"])
+				return client.ImagePruneResult{
+					Report: image.PruneReport{
+						ImagesDeleted:  []image.DeleteResponse{{Deleted: "image1"}},
+						SpaceReclaimed: 1,
+					},
 				}, nil
 			},
 		},
 		{
 			name: "label-filter",
 			args: []string{"--force", "--filter", "label=foobar"},
-			imagesPruneFunc: func(pruneFilter client.Filters) (image.PruneReport, error) {
-				assert.Check(t, pruneFilter["label"]["foobar"])
-				return image.PruneReport{}, nil
+			imagesPruneFunc: func(opts client.ImagePruneOptions) (client.ImagePruneResult, error) {
+				assert.Check(t, opts.Filters["label"]["foobar"])
+				return client.ImagePruneResult{}, nil
 			},
 		},
 		{
 			name: "force-untagged",
 			args: []string{"--force"},
-			imagesPruneFunc: func(pruneFilter client.Filters) (image.PruneReport, error) {
-				assert.Check(t, pruneFilter["dangling"]["true"])
-				return image.PruneReport{
-					ImagesDeleted:  []image.DeleteResponse{{Untagged: "image1"}},
-					SpaceReclaimed: 2,
+			imagesPruneFunc: func(opts client.ImagePruneOptions) (client.ImagePruneResult, error) {
+				assert.Check(t, opts.Filters["dangling"]["true"])
+				return client.ImagePruneResult{
+					Report: image.PruneReport{
+						ImagesDeleted:  []image.DeleteResponse{{Untagged: "image1"}},
+						SpaceReclaimed: 2,
+					},
 				}, nil
 			},
 		},
@@ -116,8 +120,8 @@ func TestPrunePromptTermination(t *testing.T) {
 	t.Cleanup(cancel)
 
 	cli := test.NewFakeCli(&fakeClient{
-		imagesPruneFunc: func(pruneFilter client.Filters) (image.PruneReport, error) {
-			return image.PruneReport{}, errors.New("fakeClient imagesPruneFunc should not be called")
+		imagesPruneFunc: func(client.ImagePruneOptions) (client.ImagePruneResult, error) {
+			return client.ImagePruneResult{}, errors.New("fakeClient imagesPruneFunc should not be called")
 		},
 	})
 	cmd := newPruneCommand(cli)

cli/command/network/client_test.go

@@ -14,7 +14,7 @@ type fakeClient struct {
 	networkDisconnectFunc func(ctx context.Context, networkID, container string, force bool) error
 	networkRemoveFunc     func(ctx context.Context, networkID string) error
 	networkListFunc       func(ctx context.Context, options client.NetworkListOptions) ([]network.Summary, error)
-	networkPruneFunc      func(ctx context.Context, pruneFilters client.Filters) (network.PruneReport, error)
+	networkPruneFunc      func(ctx context.Context, options client.NetworkPruneOptions) (client.NetworkPruneResult, error)
 	networkInspectFunc    func(ctx context.Context, networkID string, options client.NetworkInspectOptions) (network.Inspect, []byte, error)
 }
 
@@ -60,9 +60,9 @@ func (c *fakeClient) NetworkInspectWithRaw(ctx context.Context, networkID string
 	return network.Inspect{}, nil, nil
 }
 
-func (c *fakeClient) NetworksPrune(ctx context.Context, pruneFilter client.Filters) (network.PruneReport, error) {
+func (c *fakeClient) NetworksPrune(ctx context.Context, opts client.NetworkPruneOptions) (client.NetworkPruneResult, error) {
 	if c.networkPruneFunc != nil {
-		return c.networkPruneFunc(ctx, pruneFilter)
+		return c.networkPruneFunc(ctx, opts)
 	}
-	return network.PruneReport{}, nil
+	return client.NetworkPruneResult{}, nil
 }

cli/command/network/prune.go

@@ -10,6 +10,7 @@ import (
 	"github.com/docker/cli/cli/command/system/pruner"
 	"github.com/docker/cli/internal/prompt"
 	"github.com/docker/cli/opts"
+	"github.com/moby/moby/client"
 	"github.com/spf13/cobra"
 )
 
@@ -70,14 +71,16 @@ func runPrune(ctx context.Context, dockerCli command.Cli, options pruneOptions)
 		}
 	}
 
-	report, err := dockerCli.Client().NetworksPrune(ctx, pruneFilters)
+	res, err := dockerCli.Client().NetworksPrune(ctx, client.NetworkPruneOptions{
+		Filters: pruneFilters,
+	})
 	if err != nil {
 		return "", err
 	}
 
-	if len(report.NetworksDeleted) > 0 {
+	if len(res.Report.NetworksDeleted) > 0 {
 		output = "Deleted Networks:\n"
-		for _, id := range report.NetworksDeleted {
+		for _, id := range res.Report.NetworksDeleted {
 			output += id + "\n"
 		}
 	}

cli/command/network/prune_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/docker/cli/internal/test"
-	"github.com/moby/moby/api/types/network"
 	"github.com/moby/moby/client"
 )
 
@@ -16,8 +15,8 @@ func TestNetworkPrunePromptTermination(t *testing.T) {
 	t.Cleanup(cancel)
 
 	cli := test.NewFakeCli(&fakeClient{
-		networkPruneFunc: func(ctx context.Context, pruneFilters client.Filters) (network.PruneReport, error) {
-			return network.PruneReport{}, errors.New("fakeClient networkPruneFunc should not be called")
+		networkPruneFunc: func(ctx context.Context, opts client.NetworkPruneOptions) (client.NetworkPruneResult, error) {
+			return client.NetworkPruneResult{}, errors.New("fakeClient networkPruneFunc should not be called")
 		},
 	})
 	cmd := newPruneCommand(cli)

cli/command/plugin/client_test.go

@@ -11,54 +11,54 @@ import (
 
 type fakeClient struct {
 	client.Client
-	pluginCreateFunc  func(createContext io.Reader, createOptions client.PluginCreateOptions) error
-	pluginDisableFunc func(name string, disableOptions client.PluginDisableOptions) error
+	pluginCreateFunc  func(createContext io.Reader, options client.PluginCreateOptions) error
+	pluginDisableFunc func(name string, options client.PluginDisableOptions) error
 	pluginEnableFunc  func(name string, options client.PluginEnableOptions) error
 	pluginRemoveFunc  func(name string, options client.PluginRemoveOptions) error
 	pluginInstallFunc func(name string, options client.PluginInstallOptions) (io.ReadCloser, error)
-	pluginListFunc    func(filter client.Filters) (plugin.ListResponse, error)
+	pluginListFunc    func(options client.PluginListOptions) (plugin.ListResponse, error)
 	pluginInspectFunc func(name string) (*plugin.Plugin, []byte, error)
 	pluginUpgradeFunc func(name string, options client.PluginInstallOptions) (io.ReadCloser, error)
 }
 
-func (c *fakeClient) PluginCreate(_ context.Context, createContext io.Reader, createOptions client.PluginCreateOptions) error {
+func (c *fakeClient) PluginCreate(_ context.Context, createContext io.Reader, options client.PluginCreateOptions) error {
 	if c.pluginCreateFunc != nil {
-		return c.pluginCreateFunc(createContext, createOptions)
+		return c.pluginCreateFunc(createContext, options)
 	}
 	return nil
 }
 
-func (c *fakeClient) PluginEnable(_ context.Context, name string, enableOptions client.PluginEnableOptions) error {
+func (c *fakeClient) PluginEnable(_ context.Context, name string, options client.PluginEnableOptions) error {
 	if c.pluginEnableFunc != nil {
-		return c.pluginEnableFunc(name, enableOptions)
+		return c.pluginEnableFunc(name, options)
 	}
 	return nil
 }
 
-func (c *fakeClient) PluginDisable(_ context.Context, name string, disableOptions client.PluginDisableOptions) error {
+func (c *fakeClient) PluginDisable(_ context.Context, name string, options client.PluginDisableOptions) error {
 	if c.pluginDisableFunc != nil {
-		return c.pluginDisableFunc(name, disableOptions)
+		return c.pluginDisableFunc(name, options)
 	}
 	return nil
 }
 
-func (c *fakeClient) PluginRemove(_ context.Context, name string, removeOptions client.PluginRemoveOptions) error {
+func (c *fakeClient) PluginRemove(_ context.Context, name string, options client.PluginRemoveOptions) error {
 	if c.pluginRemoveFunc != nil {
-		return c.pluginRemoveFunc(name, removeOptions)
+		return c.pluginRemoveFunc(name, options)
 	}
 	return nil
 }
 
-func (c *fakeClient) PluginInstall(_ context.Context, name string, installOptions client.PluginInstallOptions) (io.ReadCloser, error) {
+func (c *fakeClient) PluginInstall(_ context.Context, name string, options client.PluginInstallOptions) (io.ReadCloser, error) {
 	if c.pluginInstallFunc != nil {
-		return c.pluginInstallFunc(name, installOptions)
+		return c.pluginInstallFunc(name, options)
 	}
 	return nil, nil
 }
 
-func (c *fakeClient) PluginList(_ context.Context, filter client.Filters) (plugin.ListResponse, error) {
+func (c *fakeClient) PluginList(_ context.Context, options client.PluginListOptions) (plugin.ListResponse, error) {
 	if c.pluginListFunc != nil {
-		return c.pluginListFunc(filter)
+		return c.pluginListFunc(options)
 	}
 
 	return plugin.ListResponse{}, nil

cli/command/plugin/completion.go

@@ -32,7 +32,9 @@ func completeNames(dockerCLI completion.APIClientProvider, state pluginState) co
 			// no filter
 		}
 
-		list, err := dockerCLI.Client().PluginList(cmd.Context(), f)
+		list, err := dockerCLI.Client().PluginList(cmd.Context(), client.PluginListOptions{
+			Filters: f,
+		})
 		if err != nil {
 			return nil, cobra.ShellCompDirectiveError
 		}