GitList

Browse code

Add `--filter until=<timestamp>` for `docker container/image prune`

This fix is a follow up for comment
https://github.com/docker/docker/pull/28535#issuecomment-263215225

This fix provides `--filter until=<timestamp>` for `docker container/image prune`.

This fix adds `--filter until=<timestamp>` to `docker container/image prune`
so that it is possible to specify a timestamp and prune those containers/images
that are earlier than the timestamp.

Related docs has been updated

Several integration tests have been added to cover changes.

This fix fixes #28497.

This fix is related to #28535.

Signed-off-by: Yong Tang <yong.tang.github@outlook.com>

Yong Tang authored on 2016/12/08 07:02:13
Showing 16 changed files

api/server/router/network/network_routes.go index 2390aac..3e45c14 100644
api/swagger.yaml index 6f4e180..c1c6338 100644
cli/command/container/prune.go index 0aad66e..ca50e2e 100644
cli/command/image/prune.go index 82c28fc..f17aed7 100644
cli/command/network/prune.go index 9f1979e..c5c5359 100644
cli/command/prune/prune.go index a022487..6314718 100644
cli/command/system/prune.go index 92dddbd..46e4316 100644
client/container_prune_test.go index 0000000..5f06ea0
client/image_prune_test.go index 0000000..61cf18e
client/network_prune_test.go index 0000000..07a5d41
daemon/prune.go index a693beb..b0663b9 100644
docs/reference/commandline/container_prune.md index 4315640..f50e75f 100644
docs/reference/commandline/image_prune.md index a80b8d3..e6450d3 100644
docs/reference/commandline/network_prune.md index 5b65465..a3878c2 100644
docs/reference/commandline/system_prune.md index 46f8c43..b6764a7 100644
integration-cli/docker_cli_prune_unix_test.go index 842a18c..79d7d3c 100644

@@ -312,7 +312,12 @@ func (n *networkRouter) postNetworksPrune(ctx context.Context, w http.ResponseWr
                      		return err
+                     	}
                     -	pruneReport, err := n.backend.NetworksPrune(filters.Args{})
                     +	pruneFilters, err := filters.FromParam(r.Form.Get("filters"))
                     +	if err != nil {
                     +		return err
                     +	}
+                    +
                     +	pruneReport, err := n.backend.NetworksPrune(pruneFilters)
                      	if err != nil {
                      		return err
+                     	}

@@ -4191,6 +4191,7 @@ paths:
                                  Filters to process on the prune list, encoded as JSON (a `map[string][]string`).
                                  Available filters:
                     +            - `until=<timestamp>` Prune containers created before this timestamp. The `<timestamp>` can be Unix timestamps, date formatted timestamps, or Go duration strings (e.g. `10m`, `1h30m`) computed relative to the daemon machine’s time.
                                type: "string"
                            responses:
 :
@@ -4866,6 +4867,7 @@ paths:
                                  - `dangling=<boolean>` When set to `true` (or `1`), prune only
                                     unused *and* untagged images. When set to `false`
                                     (or `0`), all unused images are pruned.
                     +            - `until=<string>` Prune images created before this timestamp. The `<timestamp>` can be Unix timestamps, date formatted timestamps, or Go duration strings (e.g. `10m`, `1h30m`) computed relative to the daemon machine’s time.
                                type: "string"
                            responses:
 :
@@ -6295,8 +6297,6 @@ paths:
                        /networks/prune:
                          post:
                            summary: "Delete unused networks"
                     -      consumes:
                     -        - "application/json"
                            produces:
                              - "application/json"
                            operationId: "NetworkPrune"
@@ -6307,6 +6307,7 @@ paths:
                                  Filters to process on the prune list, encoded as JSON (a `map[string][]string`).
                                  Available filters:
                     +            - `until=<timestamp>` Prune networks created before this timestamp. The `<timestamp>` can be Unix timestamps, date formatted timestamps, or Go duration strings (e.g. `10m`, `1h30m`) computed relative to the daemon machine’s time.
                                type: "string"
                            responses:
 :

@@ -3,21 +3,22 @@ package container
                      import (
                      	"fmt"
                     -	"github.com/docker/docker/api/types/filters"
                      	"github.com/docker/docker/cli"
                      	"github.com/docker/docker/cli/command"
                     +	"github.com/docker/docker/opts"
                      	units "github.com/docker/go-units"
                      	"github.com/spf13/cobra"
                      	"golang.org/x/net/context"
+                     )
                      type pruneOptions struct {
                     -	force bool
                     +	force  bool
                     +	filter opts.FilterOpt
+                     }
                      // NewPruneCommand returns a new cobra prune command for containers
                      func NewPruneCommand(dockerCli *command.DockerCli) *cobra.Command {
                     -	var opts pruneOptions
                     +	opts := pruneOptions{filter: opts.NewFilterOpt()}
                      	cmd := &cobra.Command{
                      		Use:   "prune [OPTIONS]",
@@ -39,6 +40,7 @@ func NewPruneCommand(dockerCli *command.DockerCli) *cobra.Command {
                      	flags := cmd.Flags()
                      	flags.BoolVarP(&opts.force, "force", "f", false, "Do not prompt for confirmation")
                     +	flags.Var(&opts.filter, "filter", "Provide filter values (e.g. 'until=<timestamp>')")
                      	return cmd
+                     }
@@ -47,11 +49,13 @@ const warning = `WARNING! This will remove all stopped containers.
                      Are you sure you want to continue?`
                      func runPrune(dockerCli *command.DockerCli, opts pruneOptions) (spaceReclaimed uint64, output string, err error) {
                     +	pruneFilters := opts.filter.Value()
+                    +
                      	if !opts.force && !command.PromptForConfirmation(dockerCli.In(), dockerCli.Out(), warning) {
                      		return
+                     	}
                     -	report, err := dockerCli.Client().ContainersPrune(context.Background(), filters.Args{})
                     +	report, err := dockerCli.Client().ContainersPrune(context.Background(), pruneFilters)
                      	if err != nil {
                      		return
+                     	}
@@ -69,6 +73,6 @@ func runPrune(dockerCli *command.DockerCli, opts pruneOptions) (spaceReclaimed u
                      // RunPrune calls the Container Prune API
                      // This returns the amount of space reclaimed and a detailed output string
                     -func RunPrune(dockerCli *command.DockerCli) (uint64, string, error) {
                     -	return runPrune(dockerCli, pruneOptions{force: true})
                     +func RunPrune(dockerCli *command.DockerCli, filter opts.FilterOpt) (uint64, string, error) {
                     +	return runPrune(dockerCli, pruneOptions{force: true, filter: filter})
+                     }

@@ -6,6 +6,7 @@ import (
                      	"github.com/docker/docker/cli/command/image"
                      	"github.com/docker/docker/cli/command/network"
                      	"github.com/docker/docker/cli/command/volume"
                     +	"github.com/docker/docker/opts"
                      	"github.com/spf13/cobra"
+                     )
@@ -30,21 +31,21 @@ func NewNetworkPruneCommand(dockerCli *command.DockerCli) *cobra.Command {
+                     }
                      // RunContainerPrune executes a prune command for containers
                     -func RunContainerPrune(dockerCli *command.DockerCli) (uint64, string, error) {
                     -	return container.RunPrune(dockerCli)
                     +func RunContainerPrune(dockerCli *command.DockerCli, filter opts.FilterOpt) (uint64, string, error) {
                     +	return container.RunPrune(dockerCli, filter)
+                     }
                      // RunVolumePrune executes a prune command for volumes
                     -func RunVolumePrune(dockerCli *command.DockerCli) (uint64, string, error) {
                     +func RunVolumePrune(dockerCli *command.DockerCli, filter opts.FilterOpt) (uint64, string, error) {
                      	return volume.RunPrune(dockerCli)
+                     }
                      // RunImagePrune executes a prune command for images
                     -func RunImagePrune(dockerCli *command.DockerCli, all bool) (uint64, string, error) {
                     -	return image.RunPrune(dockerCli, all)
                     +func RunImagePrune(dockerCli *command.DockerCli, all bool, filter opts.FilterOpt) (uint64, string, error) {
                     +	return image.RunPrune(dockerCli, all, filter)
+                     }
                      // RunNetworkPrune executes a prune command for networks
                     -func RunNetworkPrune(dockerCli *command.DockerCli) (uint64, string, error) {
                     -	return network.RunPrune(dockerCli)
                     +func RunNetworkPrune(dockerCli *command.DockerCli, filter opts.FilterOpt) (uint64, string, error) {
                     +	return network.RunPrune(dockerCli, filter)
+                     }

                     new file mode 100644
@@ -0,0 +1,111 @@
                     +package client
+                    +
                     +import (
                     +	"bytes"
                     +	"encoding/json"
                     +	"fmt"
                     +	"io/ioutil"
                     +	"net/http"
                     +	"strings"
                     +	"testing"
+                    +
                     +	"github.com/docker/docker/api/types"
                     +	"github.com/docker/docker/api/types/filters"
                     +	"github.com/docker/docker/pkg/testutil/assert"
                     +	"golang.org/x/net/context"
                     +)
+                    +
                     +func TestContainersPruneError(t *testing.T) {
                     +	client := &Client{
                     +		client:  newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
                     +		version: "1.25",
                     +	}
+                    +
                     +	filters := filters.NewArgs()
+                    +
                     +	_, err := client.ContainersPrune(context.Background(), filters)
                     +	assert.Error(t, err, "Error response from daemon: Server error")
                     +}
+                    +
                     +func TestContainersPrune(t *testing.T) {
                     +	expectedURL := "/v1.25/containers/prune"
+                    +
                     +	danglingFilters := filters.NewArgs()
                     +	danglingFilters.Add("dangling", "true")
+                    +
                     +	noDanglingFilters := filters.NewArgs()
                     +	noDanglingFilters.Add("dangling", "false")
+                    +
                     +	danglingUntilFilters := filters.NewArgs()
                     +	danglingUntilFilters.Add("dangling", "true")
                     +	danglingUntilFilters.Add("until", "2016-12-15T14:00")
+                    +
                     +	listCases := []struct {
                     +		filters             filters.Args
                     +		expectedQueryParams map[string]string
                     +	}{
                     +		{
                     +			filters: filters.Args{},
                     +			expectedQueryParams: map[string]string{
                     +				"until":   "",
                     +				"filter":  "",
                     +				"filters": "",
                     +			},
                     +		},
                     +		{
                     +			filters: danglingFilters,
                     +			expectedQueryParams: map[string]string{
                     +				"until":   "",
                     +				"filter":  "",
                     +				"filters": `{"dangling":{"true":true}}`,
                     +			},
                     +		},
                     +		{
                     +			filters: danglingUntilFilters,
                     +			expectedQueryParams: map[string]string{
                     +				"until":   "",
                     +				"filter":  "",
                     +				"filters": `{"dangling":{"true":true},"until":{"2016-12-15T14:00":true}}`,
                     +			},
                     +		},
                     +		{
                     +			filters: noDanglingFilters,
                     +			expectedQueryParams: map[string]string{
                     +				"until":   "",
                     +				"filter":  "",
                     +				"filters": `{"dangling":{"false":true}}`,
                     +			},
                     +		},
                     +	}
                     +	for _, listCase := range listCases {
                     +		client := &Client{
                     +			client: newMockClient(func(req *http.Request) (*http.Response, error) {
                     +				if !strings.HasPrefix(req.URL.Path, expectedURL) {
                     +					return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
                     +				}
                     +				query := req.URL.Query()
                     +				for key, expected := range listCase.expectedQueryParams {
                     +					actual := query.Get(key)
                     +					assert.Equal(t, actual, expected)
                     +				}
                     +				content, err := json.Marshal(types.ContainersPruneReport{
                     +					ContainersDeleted: []string{"container_id1", "container_id2"},
                     +					SpaceReclaimed:    9999,
                     +				})
                     +				if err != nil {
                     +					return nil, err
                     +				}
                     +				return &http.Response{
                     +					StatusCode: http.StatusOK,
                     +					Body:       ioutil.NopCloser(bytes.NewReader(content)),
                     +				}, nil
                     +			}),
                     +			version: "1.25",
                     +		}
+                    +
                     +		report, err := client.ContainersPrune(context.Background(), listCase.filters)
                     +		assert.NilError(t, err)
                     +		assert.Equal(t, len(report.ContainersDeleted), 2)
                     +		assert.Equal(t, report.SpaceReclaimed, uint64(9999))
                     +	}
                     +}

@@ -3,11 +3,13 @@ package daemon
                      import (
                      	"fmt"
                      	"regexp"
                     +	"time"
                      	"github.com/Sirupsen/logrus"
                      	"github.com/docker/distribution/digest"
                      	"github.com/docker/docker/api/types"
                      	"github.com/docker/docker/api/types/filters"
                     +	timetypes "github.com/docker/docker/api/types/time"
                      	"github.com/docker/docker/image"
                      	"github.com/docker/docker/layer"
                      	"github.com/docker/docker/pkg/directory"
@@ -21,9 +23,17 @@ import (
                      func (daemon *Daemon) ContainersPrune(pruneFilters filters.Args) (*types.ContainersPruneReport, error) {
                      	rep := &types.ContainersPruneReport{}
                     +	until, err := getUntilFromPruneFilters(pruneFilters)
                     +	if err != nil {
                     +		return nil, err
                     +	}
+                    +
                      	allContainers := daemon.List()
                      	for _, c := range allContainers {
                      		if !c.IsRunning() {
                     +			if !until.IsZero() && c.Created.After(until) {
                     +				continue
                     +			}
                      			cSize, _ := daemon.getSize(c)
                      			// TODO: sets RmLink to true?
                      			err := daemon.ContainerRm(c.ID, &types.ContainerRmConfig{})
@@ -84,6 +94,11 @@ func (daemon *Daemon) ImagesPrune(pruneFilters filters.Args) (*types.ImagesPrune
+                     		}
+                     	}
                     +	until, err := getUntilFromPruneFilters(pruneFilters)
                     +	if err != nil {
                     +		return nil, err
                     +	}
+                    +
                      	var allImages map[image.ID]*image.Image
                      	if danglingOnly {
                      		allImages = daemon.imageStore.Heads()
@@ -104,6 +119,9 @@ func (daemon *Daemon) ImagesPrune(pruneFilters filters.Args) (*types.ImagesPrune
                      		if len(daemon.referenceStore.References(dgst)) == 0 && len(daemon.imageStore.Children(id)) != 0 {
                      			continue
+                     		}
                     +		if !until.IsZero() && img.Created.After(until) {
                     +			continue
                     +		}
                      		topImages[id] = img
+                     	}
@@ -169,9 +187,17 @@ func (daemon *Daemon) ImagesPrune(pruneFilters filters.Args) (*types.ImagesPrune
                      // localNetworksPrune removes unused local networks
                      func (daemon *Daemon) localNetworksPrune(pruneFilters filters.Args) (*types.NetworksPruneReport, error) {
                      	rep := &types.NetworksPruneReport{}
                     -	var err error
+                    +
                     +	until, err := getUntilFromPruneFilters(pruneFilters)
                     +	if err != nil {
                     +		return rep, err
                     +	}
+                    +
                      	// When the function returns true, the walk will stop.
                      	l := func(nw libnetwork.Network) bool {
                     +		if !until.IsZero() && nw.Info().Created().After(until) {
                     +			return false
                     +		}
                      		nwName := nw.Name()
                      		predefined := runconfig.IsPreDefinedNetwork(nwName)
                      		if !predefined && len(nw.Endpoints()) == 0 {
@@ -190,6 +216,12 @@ func (daemon *Daemon) localNetworksPrune(pruneFilters filters.Args) (*types.Netw
                      // clusterNetworksPrune removes unused cluster networks
                      func (daemon *Daemon) clusterNetworksPrune(pruneFilters filters.Args) (*types.NetworksPruneReport, error) {
                      	rep := &types.NetworksPruneReport{}
+                    +
                     +	until, err := getUntilFromPruneFilters(pruneFilters)
                     +	if err != nil {
                     +		return nil, err
                     +	}
+                    +
                      	cluster := daemon.GetCluster()
                      	networks, err := cluster.GetNetworks()
                      	if err != nil {
@@ -200,6 +232,9 @@ func (daemon *Daemon) clusterNetworksPrune(pruneFilters filters.Args) (*types.Ne
                      		if nw.Name == "ingress" {
                      			continue
+                     		}
                     +		if !until.IsZero() && nw.Created.After(until) {
                     +			continue
                     +		}
                      		// https://github.com/docker/docker/issues/24186
                      		// `docker network inspect` unfortunately displays ONLY those containers that are local to that node.
                      		// So we try to remove it anyway and check the error
@@ -234,3 +269,24 @@ func (daemon *Daemon) NetworksPrune(pruneFilters filters.Args) (*types.NetworksP
+                     	}
                      	return rep, err
+                     }
+                    +
                     +func getUntilFromPruneFilters(pruneFilters filters.Args) (time.Time, error) {
                     +	until := time.Time{}
                     +	if !pruneFilters.Include("until") {
                     +		return until, nil
                     +	}
                     +	untilFilters := pruneFilters.Get("until")
                     +	if len(untilFilters) > 1 {
                     +		return until, fmt.Errorf("more than one until filter specified")
                     +	}
                     +	ts, err := timetypes.GetTimestamp(untilFilters[0], time.Now())
                     +	if err != nil {
                     +		return until, err
                     +	}
                     +	seconds, nanoseconds, err := timetypes.ParseTimestamps(ts, 0)
                     +	if err != nil {
                     +		return until, err
                     +	}
                     +	until = time.Unix(seconds, nanoseconds)
                     +	return until, nil
                     +}

@@ -21,8 +21,10 @@ Usage:	docker container prune [OPTIONS]
                      Remove all stopped containers
                      Options:
                     -  -f, --force   Do not prompt for confirmation
                     -      --help    Print usage
                     +Options:
                     +      --filter filter   Provide filter values (e.g. 'until=<timestamp>')
                     +  -f, --force           Do not prompt for confirmation
                     +      --help            Print usage
                      ```
                      ## Examples
@@ -38,6 +40,63 @@ f98f9c2aa1eaf727e4ec9c0283bc7d4aa4762fbdba7f26191f26c97f64090360
                      Total reclaimed space: 212 B
                      ```
                     +## Filtering
+                    +
                     +The filtering flag (`-f` or `--filter`) format is of "key=value". If there is more
                     +than one filter, then pass multiple flags (e.g., `--filter "foo=bar" --filter "bif=baz"`)
+                    +
                     +The currently supported filters are:
+                    +
                     +* until (`<timestamp>`) - only remove containers created before given timestamp
+                    +
                     +The `until` filter can be Unix timestamps, date formatted
                     +timestamps, or Go duration strings (e.g. `10m`, `1h30m`) computed
                     +relative to the daemon machine’s time. Supported formats for date
                     +formatted time stamps include RFC3339Nano, RFC3339, `2006-01-02T15:04:05`,
                     +`2006-01-02T15:04:05.999999999`, `2006-01-02Z07:00`, and `2006-01-02`. The local
                     +timezone on the daemon will be used if you do not provide either a `Z` or a
                     +`+-00:00` timezone offset at the end of the timestamp.  When providing Unix
                     +timestamps enter seconds[.nanoseconds], where seconds is the number of seconds
                     +that have elapsed since January 1, 1970 (midnight UTC/GMT), not counting leap
                     +seconds (aka Unix epoch or Unix time), and the optional .nanoseconds field is a
                     +fraction of a second no more than nine digits long.
+                    +
                     +The following removes containers created more than 5 minutes ago:
                     +```bash
                     +$ docker ps -a --format 'table {{.ID}}\t{{.Image}}\t{{.Command}}\t{{.CreatedAt}}\t{{.Status}}'
                     +CONTAINER ID        IMAGE               COMMAND             CREATED AT                      STATUS
                     +61b9efa71024        busybox             "sh"                2017-01-04 13:23:33 -0800 PST   Exited (0) 41 seconds ago
                     +53a9bc23a516        busybox             "sh"                2017-01-04 13:11:59 -0800 PST   Exited (0) 12 minutes ago
+                    +
                     +$ docker container prune --force --filter "until=5m"
                     +Deleted Containers:
                     +53a9bc23a5168b6caa2bfbefddf1b30f93c7ad57f3dec271fd32707497cb9369
+                    +
                     +Total reclaimed space: 25 B
+                    +
                     +$ docker ps -a --format 'table {{.ID}}\t{{.Image}}\t{{.Command}}\t{{.CreatedAt}}\t{{.Status}}'
                     +CONTAINER ID        IMAGE               COMMAND             CREATED AT                      STATUS
                     +61b9efa71024        busybox             "sh"                2017-01-04 13:23:33 -0800 PST   Exited (0) 44 seconds ago
                     +```
+                    +
                     +The following removes containers created before `2017-01-04T13:10:00`:
                     +```bash
                     +$ docker ps -a --format 'table {{.ID}}\t{{.Image}}\t{{.Command}}\t{{.CreatedAt}}\t{{.Status}}'
                     +CONTAINER ID        IMAGE               COMMAND             CREATED AT                      STATUS
                     +53a9bc23a516        busybox             "sh"                2017-01-04 13:11:59 -0800 PST   Exited (0) 7 minutes ago
                     +4a75091a6d61        busybox             "sh"                2017-01-04 13:09:53 -0800 PST   Exited (0) 9 minutes ago
+                    +
                     +$ docker container prune --force --filter "until=2017-01-04T13:10:00"
                     +Deleted Containers:
                     +4a75091a6d618526fcd8b33ccd6e5928ca2a64415466f768a6180004b0c72c6c
+                    +
                     +Total reclaimed space: 27 B
+                    +
                     +$ docker ps -a --format 'table {{.ID}}\t{{.Image}}\t{{.Command}}\t{{.CreatedAt}}\t{{.Status}}'
                     +CONTAINER ID        IMAGE               COMMAND             CREATED AT                      STATUS
                     +53a9bc23a516        busybox             "sh"                2017-01-04 13:11:59 -0800 PST   Exited (0) 9 minutes ago
                     +```
+                    +
                      ## Related information
                      * [system df](system_df.md)

@@ -5,6 +5,7 @@ package main
                      import (
                      	"strconv"
                      	"strings"
                     +	"time"
                      	"github.com/docker/docker/integration-cli/checker"
                      	"github.com/docker/docker/integration-cli/daemon"
@@ -90,3 +91,23 @@ func (s *DockerDaemonSuite) TestPruneImageDangling(c *check.C) {
                      	c.Assert(err, checker.IsNil)
                      	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id)
+                     }
+                    +
                     +func (s *DockerSuite) TestPruneContainerUntil(c *check.C) {
                     +	out, _ := dockerCmd(c, "run", "-d", "busybox")
                     +	id1 := strings.TrimSpace(out)
                     +	c.Assert(waitExited(id1, 5*time.Second), checker.IsNil)
+                    +
                     +	until := daemonUnixTime(c)
+                    +
                     +	out, _ = dockerCmd(c, "run", "-d", "busybox")
                     +	id2 := strings.TrimSpace(out)
                     +	c.Assert(waitExited(id2, 5*time.Second), checker.IsNil)
+                    +
                     +	out, _ = dockerCmd(c, "container", "prune", "--force", "--filter", "until="+until)
                     +	c.Assert(strings.TrimSpace(out), checker.Contains, id1)
                     +	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
+                    +
                     +	out, _ = dockerCmd(c, "ps", "-a", "-q", "--no-trunc")
                     +	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
                     +	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
                     +}