github.com/uriddle/docker@v0.0.0-20210926094723-4072e6aeb013/integration-cli/docker_cli_restart_test.go (about)

     1  package main
     2  
     3  import (
     4  	"os"
     5  	"strconv"
     6  	"strings"
     7  	"time"
     8  
     9  	"github.com/docker/docker/pkg/integration/checker"
    10  	"github.com/go-check/check"
    11  )
    12  
    13  func (s *DockerSuite) TestRestartStoppedContainer(c *check.C) {
    14  	testRequires(c, DaemonIsLinux)
    15  	out, _ := dockerCmd(c, "run", "-d", "busybox", "echo", "foobar")
    16  
    17  	cleanedContainerID := strings.TrimSpace(out)
    18  	dockerCmd(c, "wait", cleanedContainerID)
    19  
    20  	out, _ = dockerCmd(c, "logs", cleanedContainerID)
    21  	c.Assert(out, checker.Equals, "foobar\n")
    22  
    23  	dockerCmd(c, "restart", cleanedContainerID)
    24  
    25  	out, _ = dockerCmd(c, "logs", cleanedContainerID)
    26  	c.Assert(out, checker.Equals, "foobar\nfoobar\n")
    27  }
    28  
    29  func (s *DockerSuite) TestRestartRunningContainer(c *check.C) {
    30  	testRequires(c, DaemonIsLinux)
    31  	out, _ := dockerCmd(c, "run", "-d", "busybox", "sh", "-c", "echo foobar && sleep 30 && echo 'should not print this'")
    32  
    33  	cleanedContainerID := strings.TrimSpace(out)
    34  
    35  	c.Assert(waitRun(cleanedContainerID), checker.IsNil)
    36  
    37  	out, _ = dockerCmd(c, "logs", cleanedContainerID)
    38  	c.Assert(out, checker.Equals, "foobar\n")
    39  
    40  	dockerCmd(c, "restart", "-t", "1", cleanedContainerID)
    41  
    42  	out, _ = dockerCmd(c, "logs", cleanedContainerID)
    43  
    44  	c.Assert(waitRun(cleanedContainerID), checker.IsNil)
    45  
    46  	c.Assert(out, checker.Equals, "foobar\nfoobar\n")
    47  }
    48  
    49  // Test that restarting a container with a volume does not create a new volume on restart. Regression test for #819.
    50  func (s *DockerSuite) TestRestartWithVolumes(c *check.C) {
    51  	testRequires(c, DaemonIsLinux)
    52  	out, _ := dockerCmd(c, "run", "-d", "-v", "/test", "busybox", "top")
    53  
    54  	cleanedContainerID := strings.TrimSpace(out)
    55  	out, _ = dockerCmd(c, "inspect", "--format", "{{ len .Mounts }}", cleanedContainerID)
    56  	out = strings.Trim(out, " \n\r")
    57  	c.Assert(out, checker.Equals, "1")
    58  
    59  	source, err := inspectMountSourceField(cleanedContainerID, "/test")
    60  	c.Assert(err, checker.IsNil)
    61  
    62  	dockerCmd(c, "restart", cleanedContainerID)
    63  
    64  	out, _ = dockerCmd(c, "inspect", "--format", "{{ len .Mounts }}", cleanedContainerID)
    65  	out = strings.Trim(out, " \n\r")
    66  	c.Assert(out, checker.Equals, "1")
    67  
    68  	sourceAfterRestart, err := inspectMountSourceField(cleanedContainerID, "/test")
    69  	c.Assert(err, checker.IsNil)
    70  	c.Assert(source, checker.Equals, sourceAfterRestart)
    71  }
    72  
    73  func (s *DockerSuite) TestRestartPolicyNO(c *check.C) {
    74  	testRequires(c, DaemonIsLinux)
    75  	out, _ := dockerCmd(c, "run", "-d", "--restart=no", "busybox", "false")
    76  
    77  	id := strings.TrimSpace(string(out))
    78  	name, err := inspectField(id, "HostConfig.RestartPolicy.Name")
    79  	c.Assert(err, checker.IsNil)
    80  	c.Assert(name, checker.Equals, "no")
    81  }
    82  
    83  func (s *DockerSuite) TestRestartPolicyAlways(c *check.C) {
    84  	testRequires(c, DaemonIsLinux)
    85  	out, _ := dockerCmd(c, "run", "-d", "--restart=always", "busybox", "false")
    86  
    87  	id := strings.TrimSpace(string(out))
    88  	name, err := inspectField(id, "HostConfig.RestartPolicy.Name")
    89  	c.Assert(err, checker.IsNil)
    90  	c.Assert(name, checker.Equals, "always")
    91  
    92  	MaximumRetryCount, err := inspectField(id, "HostConfig.RestartPolicy.MaximumRetryCount")
    93  	c.Assert(err, checker.IsNil)
    94  
    95  	// MaximumRetryCount=0 if the restart policy is always
    96  	c.Assert(MaximumRetryCount, checker.Equals, "0")
    97  }
    98  
    99  func (s *DockerSuite) TestRestartPolicyOnFailure(c *check.C) {
   100  	testRequires(c, DaemonIsLinux)
   101  	out, _ := dockerCmd(c, "run", "-d", "--restart=on-failure:1", "busybox", "false")
   102  
   103  	id := strings.TrimSpace(string(out))
   104  	name, err := inspectField(id, "HostConfig.RestartPolicy.Name")
   105  	c.Assert(err, checker.IsNil)
   106  	c.Assert(name, checker.Equals, "on-failure")
   107  
   108  }
   109  
   110  // a good container with --restart=on-failure:3
   111  // MaximumRetryCount!=0; RestartCount=0
   112  func (s *DockerSuite) TestContainerRestartwithGoodContainer(c *check.C) {
   113  	testRequires(c, DaemonIsLinux)
   114  	out, _ := dockerCmd(c, "run", "-d", "--restart=on-failure:3", "busybox", "true")
   115  
   116  	id := strings.TrimSpace(string(out))
   117  	err := waitInspect(id, "{{ .State.Restarting }} {{ .State.Running }}", "false false", 5*time.Second)
   118  	c.Assert(err, checker.IsNil)
   119  
   120  	count, err := inspectField(id, "RestartCount")
   121  	c.Assert(err, checker.IsNil)
   122  	c.Assert(count, checker.Equals, "0")
   123  
   124  	MaximumRetryCount, err := inspectField(id, "HostConfig.RestartPolicy.MaximumRetryCount")
   125  	c.Assert(err, checker.IsNil)
   126  	c.Assert(MaximumRetryCount, checker.Equals, "3")
   127  
   128  }
   129  
   130  func (s *DockerSuite) TestContainerRestartSuccess(c *check.C) {
   131  	testRequires(c, DaemonIsLinux, SameHostDaemon)
   132  
   133  	out, _ := dockerCmd(c, "run", "-d", "--restart=always", "busybox", "top")
   134  	id := strings.TrimSpace(out)
   135  	c.Assert(waitRun(id), check.IsNil)
   136  
   137  	pidStr, err := inspectField(id, "State.Pid")
   138  	c.Assert(err, check.IsNil)
   139  
   140  	pid, err := strconv.Atoi(pidStr)
   141  	c.Assert(err, check.IsNil)
   142  
   143  	p, err := os.FindProcess(pid)
   144  	c.Assert(err, check.IsNil)
   145  	c.Assert(p, check.NotNil)
   146  
   147  	err = p.Kill()
   148  	c.Assert(err, check.IsNil)
   149  
   150  	err = waitInspect(id, "{{.RestartCount}}", "1", 5*time.Second)
   151  	c.Assert(err, check.IsNil)
   152  
   153  	err = waitInspect(id, "{{.State.Status}}", "running", 5*time.Second)
   154  	c.Assert(err, check.IsNil)
   155  }
   156  
   157  func (s *DockerSuite) TestUserDefinedNetworkWithRestartPolicy(c *check.C) {
   158  	testRequires(c, DaemonIsLinux, SameHostDaemon, NotUserNamespace)
   159  	dockerCmd(c, "network", "create", "-d", "bridge", "udNet")
   160  
   161  	dockerCmd(c, "run", "-d", "--net=udNet", "--name=first", "busybox", "top")
   162  	c.Assert(waitRun("first"), check.IsNil)
   163  
   164  	dockerCmd(c, "run", "-d", "--restart=always", "--net=udNet", "--name=second",
   165  		"--link=first:foo", "busybox", "top")
   166  	c.Assert(waitRun("second"), check.IsNil)
   167  
   168  	// ping to first and its alias foo must succeed
   169  	_, _, err := dockerCmdWithError("exec", "second", "ping", "-c", "1", "first")
   170  	c.Assert(err, check.IsNil)
   171  	_, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "foo")
   172  	c.Assert(err, check.IsNil)
   173  
   174  	// Now kill the second container and let the restart policy kick in
   175  	pidStr, err := inspectField("second", "State.Pid")
   176  	c.Assert(err, check.IsNil)
   177  
   178  	pid, err := strconv.Atoi(pidStr)
   179  	c.Assert(err, check.IsNil)
   180  
   181  	p, err := os.FindProcess(pid)
   182  	c.Assert(err, check.IsNil)
   183  	c.Assert(p, check.NotNil)
   184  
   185  	err = p.Kill()
   186  	c.Assert(err, check.IsNil)
   187  
   188  	err = waitInspect("second", "{{.RestartCount}}", "1", 5*time.Second)
   189  	c.Assert(err, check.IsNil)
   190  
   191  	err = waitInspect("second", "{{.State.Status}}", "running", 5*time.Second)
   192  
   193  	// ping to first and its alias foo must still succeed
   194  	_, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "first")
   195  	c.Assert(err, check.IsNil)
   196  	_, _, err = dockerCmdWithError("exec", "second", "ping", "-c", "1", "foo")
   197  	c.Assert(err, check.IsNil)
   198  }