github.com/jwhonce/docker@v0.6.7-0.20190327063223-da823cf3a5a3/integration-cli/docker_cli_prune_unix_test.go (about)

     1  // +build !windows
     2  
     3  package main
     4  
     5  import (
     6  	"io/ioutil"
     7  	"os"
     8  	"path/filepath"
     9  	"strconv"
    10  	"strings"
    11  	"time"
    12  
    13  	"github.com/docker/docker/integration-cli/checker"
    14  	"github.com/docker/docker/integration-cli/cli"
    15  	"github.com/docker/docker/integration-cli/cli/build"
    16  	"github.com/docker/docker/integration-cli/daemon"
    17  	"github.com/go-check/check"
    18  	"gotest.tools/icmd"
    19  )
    20  
    21  func pruneNetworkAndVerify(c *check.C, d *daemon.Daemon, kept, pruned []string) {
    22  	_, err := d.Cmd("network", "prune", "--force")
    23  	c.Assert(err, checker.IsNil)
    24  
    25  	for _, s := range kept {
    26  		waitAndAssert(c, defaultReconciliationTimeout, func(*check.C) (interface{}, check.CommentInterface) {
    27  			out, err := d.Cmd("network", "ls", "--format", "{{.Name}}")
    28  			c.Assert(err, checker.IsNil)
    29  			return out, nil
    30  		}, checker.Contains, s)
    31  	}
    32  
    33  	for _, s := range pruned {
    34  		waitAndAssert(c, defaultReconciliationTimeout, func(*check.C) (interface{}, check.CommentInterface) {
    35  			out, err := d.Cmd("network", "ls", "--format", "{{.Name}}")
    36  			c.Assert(err, checker.IsNil)
    37  			return out, nil
    38  		}, checker.Not(checker.Contains), s)
    39  	}
    40  }
    41  
    42  func (s *DockerSwarmSuite) TestPruneNetwork(c *check.C) {
    43  	d := s.AddDaemon(c, true, true)
    44  	_, err := d.Cmd("network", "create", "n1") // used by container (testprune)
    45  	c.Assert(err, checker.IsNil)
    46  	_, err = d.Cmd("network", "create", "n2")
    47  	c.Assert(err, checker.IsNil)
    48  	_, err = d.Cmd("network", "create", "n3", "--driver", "overlay") // used by service (testprunesvc)
    49  	c.Assert(err, checker.IsNil)
    50  	_, err = d.Cmd("network", "create", "n4", "--driver", "overlay")
    51  	c.Assert(err, checker.IsNil)
    52  
    53  	cName := "testprune"
    54  	_, err = d.Cmd("run", "-d", "--name", cName, "--net", "n1", "busybox", "top")
    55  	c.Assert(err, checker.IsNil)
    56  
    57  	serviceName := "testprunesvc"
    58  	replicas := 1
    59  	out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image",
    60  		"--name", serviceName,
    61  		"--replicas", strconv.Itoa(replicas),
    62  		"--network", "n3",
    63  		"busybox", "top")
    64  	c.Assert(err, checker.IsNil)
    65  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
    66  	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, replicas+1)
    67  
    68  	// prune and verify
    69  	pruneNetworkAndVerify(c, d, []string{"n1", "n3"}, []string{"n2", "n4"})
    70  
    71  	// remove containers, then prune and verify again
    72  	_, err = d.Cmd("rm", "-f", cName)
    73  	c.Assert(err, checker.IsNil)
    74  	_, err = d.Cmd("service", "rm", serviceName)
    75  	c.Assert(err, checker.IsNil)
    76  	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 0)
    77  
    78  	pruneNetworkAndVerify(c, d, []string{}, []string{"n1", "n3"})
    79  }
    80  
    81  func (s *DockerDaemonSuite) TestPruneImageDangling(c *check.C) {
    82  	s.d.StartWithBusybox(c)
    83  
    84  	result := cli.BuildCmd(c, "test", cli.Daemon(s.d),
    85  		build.WithDockerfile(`FROM busybox
    86                   LABEL foo=bar`),
    87  		cli.WithFlags("-q"),
    88  	)
    89  	result.Assert(c, icmd.Success)
    90  	id := strings.TrimSpace(result.Combined())
    91  
    92  	out, err := s.d.Cmd("images", "-q", "--no-trunc")
    93  	c.Assert(err, checker.IsNil)
    94  	c.Assert(strings.TrimSpace(out), checker.Contains, id)
    95  
    96  	out, err = s.d.Cmd("image", "prune", "--force")
    97  	c.Assert(err, checker.IsNil)
    98  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id)
    99  
   100  	out, err = s.d.Cmd("images", "-q", "--no-trunc")
   101  	c.Assert(err, checker.IsNil)
   102  	c.Assert(strings.TrimSpace(out), checker.Contains, id)
   103  
   104  	out, err = s.d.Cmd("image", "prune", "--force", "--all")
   105  	c.Assert(err, checker.IsNil)
   106  	c.Assert(strings.TrimSpace(out), checker.Contains, id)
   107  
   108  	out, err = s.d.Cmd("images", "-q", "--no-trunc")
   109  	c.Assert(err, checker.IsNil)
   110  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id)
   111  }
   112  
   113  func (s *DockerSuite) TestPruneContainerUntil(c *check.C) {
   114  	out := cli.DockerCmd(c, "run", "-d", "busybox").Combined()
   115  	id1 := strings.TrimSpace(out)
   116  	cli.WaitExited(c, id1, 5*time.Second)
   117  
   118  	until := daemonUnixTime(c)
   119  
   120  	out = cli.DockerCmd(c, "run", "-d", "busybox").Combined()
   121  	id2 := strings.TrimSpace(out)
   122  	cli.WaitExited(c, id2, 5*time.Second)
   123  
   124  	out = cli.DockerCmd(c, "container", "prune", "--force", "--filter", "until="+until).Combined()
   125  	c.Assert(strings.TrimSpace(out), checker.Contains, id1)
   126  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   127  
   128  	out = cli.DockerCmd(c, "ps", "-a", "-q", "--no-trunc").Combined()
   129  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
   130  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   131  }
   132  
   133  func (s *DockerSuite) TestPruneContainerLabel(c *check.C) {
   134  	out := cli.DockerCmd(c, "run", "-d", "--label", "foo", "busybox").Combined()
   135  	id1 := strings.TrimSpace(out)
   136  	cli.WaitExited(c, id1, 5*time.Second)
   137  
   138  	out = cli.DockerCmd(c, "run", "-d", "--label", "bar", "busybox").Combined()
   139  	id2 := strings.TrimSpace(out)
   140  	cli.WaitExited(c, id2, 5*time.Second)
   141  
   142  	out = cli.DockerCmd(c, "run", "-d", "busybox").Combined()
   143  	id3 := strings.TrimSpace(out)
   144  	cli.WaitExited(c, id3, 5*time.Second)
   145  
   146  	out = cli.DockerCmd(c, "run", "-d", "--label", "foobar", "busybox").Combined()
   147  	id4 := strings.TrimSpace(out)
   148  	cli.WaitExited(c, id4, 5*time.Second)
   149  
   150  	// Add a config file of label=foobar, that will have no impact if cli is label!=foobar
   151  	config := `{"pruneFilters": ["label=foobar"]}`
   152  	d, err := ioutil.TempDir("", "integration-cli-")
   153  	c.Assert(err, checker.IsNil)
   154  	defer os.RemoveAll(d)
   155  	err = ioutil.WriteFile(filepath.Join(d, "config.json"), []byte(config), 0644)
   156  	c.Assert(err, checker.IsNil)
   157  
   158  	// With config.json only, prune based on label=foobar
   159  	out = cli.DockerCmd(c, "--config", d, "container", "prune", "--force").Combined()
   160  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
   161  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   162  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id3)
   163  	c.Assert(strings.TrimSpace(out), checker.Contains, id4)
   164  
   165  	out = cli.DockerCmd(c, "container", "prune", "--force", "--filter", "label=foo").Combined()
   166  	c.Assert(strings.TrimSpace(out), checker.Contains, id1)
   167  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   168  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id3)
   169  
   170  	out = cli.DockerCmd(c, "ps", "-a", "-q", "--no-trunc").Combined()
   171  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
   172  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   173  	c.Assert(strings.TrimSpace(out), checker.Contains, id3)
   174  
   175  	out = cli.DockerCmd(c, "container", "prune", "--force", "--filter", "label!=bar").Combined()
   176  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   177  	c.Assert(strings.TrimSpace(out), checker.Contains, id3)
   178  
   179  	out = cli.DockerCmd(c, "ps", "-a", "-q", "--no-trunc").Combined()
   180  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   181  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id3)
   182  
   183  	// With config.json label=foobar and CLI label!=foobar, CLI label!=foobar supersede
   184  	out = cli.DockerCmd(c, "--config", d, "container", "prune", "--force", "--filter", "label!=foobar").Combined()
   185  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   186  
   187  	out = cli.DockerCmd(c, "ps", "-a", "-q", "--no-trunc").Combined()
   188  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   189  }
   190  
   191  func (s *DockerSuite) TestPruneVolumeLabel(c *check.C) {
   192  	out, _ := dockerCmd(c, "volume", "create", "--label", "foo")
   193  	id1 := strings.TrimSpace(out)
   194  	c.Assert(id1, checker.Not(checker.Equals), "")
   195  
   196  	out, _ = dockerCmd(c, "volume", "create", "--label", "bar")
   197  	id2 := strings.TrimSpace(out)
   198  	c.Assert(id2, checker.Not(checker.Equals), "")
   199  
   200  	out, _ = dockerCmd(c, "volume", "create")
   201  	id3 := strings.TrimSpace(out)
   202  	c.Assert(id3, checker.Not(checker.Equals), "")
   203  
   204  	out, _ = dockerCmd(c, "volume", "create", "--label", "foobar")
   205  	id4 := strings.TrimSpace(out)
   206  	c.Assert(id4, checker.Not(checker.Equals), "")
   207  
   208  	// Add a config file of label=foobar, that will have no impact if cli is label!=foobar
   209  	config := `{"pruneFilters": ["label=foobar"]}`
   210  	d, err := ioutil.TempDir("", "integration-cli-")
   211  	c.Assert(err, checker.IsNil)
   212  	defer os.RemoveAll(d)
   213  	err = ioutil.WriteFile(filepath.Join(d, "config.json"), []byte(config), 0644)
   214  	c.Assert(err, checker.IsNil)
   215  
   216  	// With config.json only, prune based on label=foobar
   217  	out, _ = dockerCmd(c, "--config", d, "volume", "prune", "--force")
   218  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
   219  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   220  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id3)
   221  	c.Assert(strings.TrimSpace(out), checker.Contains, id4)
   222  
   223  	out, _ = dockerCmd(c, "volume", "prune", "--force", "--filter", "label=foo")
   224  	c.Assert(strings.TrimSpace(out), checker.Contains, id1)
   225  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   226  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id3)
   227  
   228  	out, _ = dockerCmd(c, "volume", "ls", "--format", "{{.Name}}")
   229  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
   230  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   231  	c.Assert(strings.TrimSpace(out), checker.Contains, id3)
   232  
   233  	out, _ = dockerCmd(c, "volume", "prune", "--force", "--filter", "label!=bar")
   234  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   235  	c.Assert(strings.TrimSpace(out), checker.Contains, id3)
   236  
   237  	out, _ = dockerCmd(c, "volume", "ls", "--format", "{{.Name}}")
   238  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   239  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id3)
   240  
   241  	// With config.json label=foobar and CLI label!=foobar, CLI label!=foobar supersede
   242  	out, _ = dockerCmd(c, "--config", d, "volume", "prune", "--force", "--filter", "label!=foobar")
   243  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   244  
   245  	out, _ = dockerCmd(c, "volume", "ls", "--format", "{{.Name}}")
   246  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   247  }
   248  
   249  func (s *DockerSuite) TestPruneNetworkLabel(c *check.C) {
   250  	dockerCmd(c, "network", "create", "--label", "foo", "n1")
   251  	dockerCmd(c, "network", "create", "--label", "bar", "n2")
   252  	dockerCmd(c, "network", "create", "n3")
   253  
   254  	out, _ := dockerCmd(c, "network", "prune", "--force", "--filter", "label=foo")
   255  	c.Assert(strings.TrimSpace(out), checker.Contains, "n1")
   256  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), "n2")
   257  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), "n3")
   258  
   259  	out, _ = dockerCmd(c, "network", "prune", "--force", "--filter", "label!=bar")
   260  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), "n1")
   261  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), "n2")
   262  	c.Assert(strings.TrimSpace(out), checker.Contains, "n3")
   263  
   264  	out, _ = dockerCmd(c, "network", "prune", "--force")
   265  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), "n1")
   266  	c.Assert(strings.TrimSpace(out), checker.Contains, "n2")
   267  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), "n3")
   268  }
   269  
   270  func (s *DockerDaemonSuite) TestPruneImageLabel(c *check.C) {
   271  	s.d.StartWithBusybox(c)
   272  
   273  	result := cli.BuildCmd(c, "test1", cli.Daemon(s.d),
   274  		build.WithDockerfile(`FROM busybox
   275                   LABEL foo=bar`),
   276  		cli.WithFlags("-q"),
   277  	)
   278  	result.Assert(c, icmd.Success)
   279  	id1 := strings.TrimSpace(result.Combined())
   280  	out, err := s.d.Cmd("images", "-q", "--no-trunc")
   281  	c.Assert(err, checker.IsNil)
   282  	c.Assert(strings.TrimSpace(out), checker.Contains, id1)
   283  
   284  	result = cli.BuildCmd(c, "test2", cli.Daemon(s.d),
   285  		build.WithDockerfile(`FROM busybox
   286                   LABEL bar=foo`),
   287  		cli.WithFlags("-q"),
   288  	)
   289  	result.Assert(c, icmd.Success)
   290  	id2 := strings.TrimSpace(result.Combined())
   291  	out, err = s.d.Cmd("images", "-q", "--no-trunc")
   292  	c.Assert(err, checker.IsNil)
   293  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   294  
   295  	out, err = s.d.Cmd("image", "prune", "--force", "--all", "--filter", "label=foo=bar")
   296  	c.Assert(err, checker.IsNil)
   297  	c.Assert(strings.TrimSpace(out), checker.Contains, id1)
   298  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   299  
   300  	out, err = s.d.Cmd("image", "prune", "--force", "--all", "--filter", "label!=bar=foo")
   301  	c.Assert(err, checker.IsNil)
   302  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
   303  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id2)
   304  
   305  	out, err = s.d.Cmd("image", "prune", "--force", "--all", "--filter", "label=bar=foo")
   306  	c.Assert(err, checker.IsNil)
   307  	c.Assert(strings.TrimSpace(out), checker.Not(checker.Contains), id1)
   308  	c.Assert(strings.TrimSpace(out), checker.Contains, id2)
   309  }