github.com/hanks177/podman/v4@v4.1.3-0.20220613032544-16d90015bc83/test/e2e/restart_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"os"
     5  	"time"
     6  
     7  	. "github.com/hanks177/podman/v4/test/utils"
     8  	. "github.com/onsi/ginkgo"
     9  	. "github.com/onsi/gomega"
    10  	. "github.com/onsi/gomega/gexec"
    11  )
    12  
    13  var _ = Describe("Podman restart", func() {
    14  	var (
    15  		tempdir    string
    16  		err        error
    17  		podmanTest *PodmanTestIntegration
    18  	)
    19  
    20  	BeforeEach(func() {
    21  		tempdir, err = CreateTempDirInTempDir()
    22  		if err != nil {
    23  			os.Exit(1)
    24  		}
    25  		podmanTest = PodmanTestCreate(tempdir)
    26  		podmanTest.Setup()
    27  	})
    28  
    29  	AfterEach(func() {
    30  		podmanTest.Cleanup()
    31  		f := CurrentGinkgoTestDescription()
    32  		processTestResult(f)
    33  
    34  	})
    35  
    36  	It("Podman restart bogus container", func() {
    37  		session := podmanTest.Podman([]string{"start", "123"})
    38  		session.WaitWithDefaultTimeout()
    39  		Expect(session).Should(Exit(125))
    40  	})
    41  
    42  	It("Podman restart stopped container by name", func() {
    43  		_, exitCode, _ := podmanTest.RunLsContainer("test1")
    44  		Expect(exitCode).To(Equal(0))
    45  		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1"})
    46  		startTime.WaitWithDefaultTimeout()
    47  
    48  		session := podmanTest.Podman([]string{"restart", "test1"})
    49  		session.WaitWithDefaultTimeout()
    50  		Expect(session).Should(Exit(0))
    51  		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1"})
    52  		restartTime.WaitWithDefaultTimeout()
    53  		Expect(restartTime.OutputToString()).To(Not(Equal(startTime.OutputToString())))
    54  	})
    55  
    56  	It("Podman restart stopped container by ID", func() {
    57  		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    58  		session.WaitWithDefaultTimeout()
    59  		Expect(session).Should(Exit(0))
    60  		cid := session.OutputToString()
    61  		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", cid})
    62  		startTime.WaitWithDefaultTimeout()
    63  
    64  		startSession := podmanTest.Podman([]string{"start", cid})
    65  		startSession.WaitWithDefaultTimeout()
    66  		Expect(startSession).Should(Exit(0))
    67  
    68  		session2 := podmanTest.Podman([]string{"restart", cid})
    69  		session2.WaitWithDefaultTimeout()
    70  		Expect(session2).Should(Exit(0))
    71  		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", cid})
    72  		restartTime.WaitWithDefaultTimeout()
    73  		Expect(restartTime.OutputToString()).To(Not(Equal(startTime.OutputToString())))
    74  	})
    75  
    76  	It("Podman restart running container", func() {
    77  		_ = podmanTest.RunTopContainer("test1")
    78  		ok := WaitForContainer(podmanTest)
    79  		Expect(ok).To(BeTrue())
    80  		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1"})
    81  		startTime.WaitWithDefaultTimeout()
    82  
    83  		session := podmanTest.Podman([]string{"restart", "test1"})
    84  		session.WaitWithDefaultTimeout()
    85  		Expect(session).Should(Exit(0))
    86  		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1"})
    87  		restartTime.WaitWithDefaultTimeout()
    88  		Expect(restartTime.OutputToString()).To(Not(Equal(startTime.OutputToString())))
    89  	})
    90  
    91  	It("Podman container restart running container", func() {
    92  		_ = podmanTest.RunTopContainer("test1")
    93  		ok := WaitForContainer(podmanTest)
    94  		Expect(ok).To(BeTrue())
    95  		startTime := podmanTest.Podman([]string{"container", "inspect", "--format='{{.State.StartedAt}}'", "test1"})
    96  		startTime.WaitWithDefaultTimeout()
    97  
    98  		session := podmanTest.Podman([]string{"container", "restart", "test1"})
    99  		session.WaitWithDefaultTimeout()
   100  		Expect(session).Should(Exit(0))
   101  		restartTime := podmanTest.Podman([]string{"container", "inspect", "--format='{{.State.StartedAt}}'", "test1"})
   102  		restartTime.WaitWithDefaultTimeout()
   103  		Expect(restartTime.OutputToString()).To(Not(Equal(startTime.OutputToString())))
   104  	})
   105  
   106  	It("Podman restart multiple containers", func() {
   107  		_, exitCode, _ := podmanTest.RunLsContainer("test1")
   108  		Expect(exitCode).To(Equal(0))
   109  
   110  		_, exitCode, _ = podmanTest.RunLsContainer("test2")
   111  		Expect(exitCode).To(Equal(0))
   112  		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   113  		startTime.WaitWithDefaultTimeout()
   114  
   115  		session := podmanTest.Podman([]string{"restart", "test1", "test2"})
   116  		session.WaitWithDefaultTimeout()
   117  		Expect(session).Should(Exit(0))
   118  		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   119  		restartTime.WaitWithDefaultTimeout()
   120  		Expect(restartTime.OutputToStringArray()[0]).To(Not(Equal(startTime.OutputToStringArray()[0])))
   121  		Expect(restartTime.OutputToStringArray()[1]).To(Not(Equal(startTime.OutputToStringArray()[1])))
   122  	})
   123  
   124  	It("Podman restart the latest container", func() {
   125  		_, exitCode, _ := podmanTest.RunLsContainer("test1")
   126  		Expect(exitCode).To(Equal(0))
   127  
   128  		_, exitCode, _ = podmanTest.RunLsContainer("test2")
   129  		Expect(exitCode).To(Equal(0))
   130  
   131  		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   132  		startTime.WaitWithDefaultTimeout()
   133  
   134  		cid := "-l"
   135  		if IsRemote() {
   136  			cid = "test2"
   137  		}
   138  		session := podmanTest.Podman([]string{"restart", cid})
   139  		session.WaitWithDefaultTimeout()
   140  		Expect(session).Should(Exit(0))
   141  		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   142  		restartTime.WaitWithDefaultTimeout()
   143  		Expect(restartTime.OutputToStringArray()[0]).To(Equal(startTime.OutputToStringArray()[0]))
   144  		Expect(restartTime.OutputToStringArray()[1]).To(Not(Equal(startTime.OutputToStringArray()[1])))
   145  	})
   146  
   147  	It("Podman restart non-stop container with short timeout", func() {
   148  		session := podmanTest.Podman([]string{"run", "-d", "--name", "test1", "--env", "STOPSIGNAL=SIGKILL", ALPINE, "sleep", "999"})
   149  		session.WaitWithDefaultTimeout()
   150  		Expect(session).Should(Exit(0))
   151  		startTime := time.Now()
   152  		session = podmanTest.Podman([]string{"restart", "-t", "2", "test1"})
   153  		session.WaitWithDefaultTimeout()
   154  		Expect(session).Should(Exit(0))
   155  		timeSince := time.Since(startTime)
   156  		Expect(timeSince).To(BeNumerically("<", 10*time.Second))
   157  		Expect(timeSince).To(BeNumerically(">", 2*time.Second))
   158  	})
   159  
   160  	It("Podman restart --all", func() {
   161  		_, exitCode, _ := podmanTest.RunLsContainer("test1")
   162  		Expect(exitCode).To(Equal(0))
   163  
   164  		test2 := podmanTest.RunTopContainer("test2")
   165  		test2.WaitWithDefaultTimeout()
   166  		Expect(test2).Should(Exit(0))
   167  
   168  		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   169  		startTime.WaitWithDefaultTimeout()
   170  
   171  		session := podmanTest.Podman([]string{"restart", "--all"})
   172  		session.WaitWithDefaultTimeout()
   173  		Expect(session).Should(Exit(0))
   174  		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   175  		restartTime.WaitWithDefaultTimeout()
   176  		Expect(restartTime.OutputToStringArray()[0]).To(Not(Equal(startTime.OutputToStringArray()[0])))
   177  		Expect(restartTime.OutputToStringArray()[1]).To(Not(Equal(startTime.OutputToStringArray()[1])))
   178  	})
   179  
   180  	It("Podman restart --all --running", func() {
   181  		_, exitCode, _ := podmanTest.RunLsContainer("test1")
   182  		Expect(exitCode).To(Equal(0))
   183  
   184  		test2 := podmanTest.RunTopContainer("test2")
   185  		test2.WaitWithDefaultTimeout()
   186  		Expect(test2).Should(Exit(0))
   187  
   188  		startTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   189  		startTime.WaitWithDefaultTimeout()
   190  
   191  		session := podmanTest.Podman([]string{"restart", "-a", "--running"})
   192  		session.WaitWithDefaultTimeout()
   193  		Expect(session).Should(Exit(0))
   194  		restartTime := podmanTest.Podman([]string{"inspect", "--format='{{.State.StartedAt}}'", "test1", "test2"})
   195  		restartTime.WaitWithDefaultTimeout()
   196  		Expect(restartTime.OutputToStringArray()[0]).To(Equal(startTime.OutputToStringArray()[0]))
   197  		Expect(restartTime.OutputToStringArray()[1]).To(Not(Equal(startTime.OutputToStringArray()[1])))
   198  	})
   199  
   200  	It("Podman restart a container in a pod and hosts should not duplicated", func() {
   201  		// Fixes: https://github.com/containers/podman/issues/8921
   202  
   203  		_, ec, _ := podmanTest.CreatePod(map[string][]string{"--name": {"foobar99"}})
   204  		Expect(ec).To(Equal(0))
   205  
   206  		session := podmanTest.RunTopContainerInPod("host-restart-test", "foobar99")
   207  		session.WaitWithDefaultTimeout()
   208  		Expect(session).Should(Exit(0))
   209  
   210  		testCmd := []string{"exec", "host-restart-test", "sh", "-c", "wc -l < /etc/hosts"}
   211  
   212  		// before restart
   213  		beforeRestart := podmanTest.Podman(testCmd)
   214  		beforeRestart.WaitWithDefaultTimeout()
   215  		Expect(beforeRestart).Should(Exit(0))
   216  
   217  		session = podmanTest.Podman([]string{"restart", "host-restart-test"})
   218  		session.WaitWithDefaultTimeout()
   219  		Expect(session).Should(Exit(0))
   220  
   221  		afterRestart := podmanTest.Podman(testCmd)
   222  		afterRestart.WaitWithDefaultTimeout()
   223  		Expect(afterRestart).Should(Exit(0))
   224  
   225  		// line count should be equal
   226  		Expect(beforeRestart.OutputToString()).To(Equal(afterRestart.OutputToString()))
   227  	})
   228  
   229  	It("podman restart --all", func() {
   230  		session := podmanTest.RunTopContainer("")
   231  		session.WaitWithDefaultTimeout()
   232  		Expect(session).Should(Exit(0))
   233  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
   234  
   235  		session = podmanTest.RunTopContainer("")
   236  		session.WaitWithDefaultTimeout()
   237  		Expect(session).Should(Exit(0))
   238  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
   239  
   240  		session = podmanTest.Podman([]string{"stop", "--all"})
   241  		session.WaitWithDefaultTimeout()
   242  		Expect(session).Should(Exit(0))
   243  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
   244  
   245  		session = podmanTest.Podman([]string{"restart", "--all"})
   246  		session.WaitWithDefaultTimeout()
   247  		Expect(session).Should(Exit(0))
   248  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
   249  	})
   250  })