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

     1  package integration
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"strings"
     7  
     8  	. "github.com/hanks177/podman/v4/test/utils"
     9  	. "github.com/onsi/ginkgo"
    10  	. "github.com/onsi/gomega"
    11  	. "github.com/onsi/gomega/gexec"
    12  )
    13  
    14  var _ = Describe("Podman stop", func() {
    15  	var (
    16  		tempdir    string
    17  		err        error
    18  		podmanTest *PodmanTestIntegration
    19  	)
    20  
    21  	BeforeEach(func() {
    22  		tempdir, err = CreateTempDirInTempDir()
    23  		if err != nil {
    24  			os.Exit(1)
    25  		}
    26  		podmanTest = PodmanTestCreate(tempdir)
    27  		podmanTest.Setup()
    28  	})
    29  
    30  	AfterEach(func() {
    31  		podmanTest.Cleanup()
    32  		f := CurrentGinkgoTestDescription()
    33  		processTestResult(f)
    34  
    35  	})
    36  
    37  	It("podman stop bogus container", func() {
    38  		session := podmanTest.Podman([]string{"stop", "foobar"})
    39  		session.WaitWithDefaultTimeout()
    40  		Expect(session).Should(Exit(125))
    41  	})
    42  
    43  	It("podman stop --ignore bogus container", func() {
    44  		session := podmanTest.RunTopContainer("")
    45  		session.WaitWithDefaultTimeout()
    46  		Expect(session).Should(Exit(0))
    47  		cid := session.OutputToString()
    48  
    49  		session = podmanTest.Podman([]string{"stop", "--ignore", "foobar", cid})
    50  		session.WaitWithDefaultTimeout()
    51  		Expect(session).Should(Exit(0))
    52  		output := session.OutputToString()
    53  		Expect(output).To(ContainSubstring(cid))
    54  	})
    55  
    56  	It("podman stop container by id", func() {
    57  		session := podmanTest.RunTopContainer("")
    58  		session.WaitWithDefaultTimeout()
    59  		Expect(session).Should(Exit(0))
    60  		cid := session.OutputToString()
    61  		session = podmanTest.Podman([]string{"stop", cid})
    62  		session.WaitWithDefaultTimeout()
    63  		Expect(session).Should(Exit(0))
    64  
    65  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
    66  		finalCtrs.WaitWithDefaultTimeout()
    67  		Expect(finalCtrs).Should(Exit(0))
    68  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
    69  	})
    70  
    71  	It("podman stop container by name", func() {
    72  		session := podmanTest.RunTopContainer("test1")
    73  		session.WaitWithDefaultTimeout()
    74  		Expect(session).Should(Exit(0))
    75  		session = podmanTest.Podman([]string{"stop", "test1"})
    76  		session.WaitWithDefaultTimeout()
    77  		Expect(session).Should(Exit(0))
    78  
    79  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
    80  		finalCtrs.WaitWithDefaultTimeout()
    81  		Expect(finalCtrs).Should(Exit(0))
    82  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
    83  	})
    84  
    85  	It("podman container stop by name", func() {
    86  		session := podmanTest.RunTopContainer("test1")
    87  		session.WaitWithDefaultTimeout()
    88  		Expect(session).Should(Exit(0))
    89  		session = podmanTest.Podman([]string{"container", "stop", "test1"})
    90  		session.WaitWithDefaultTimeout()
    91  		Expect(session).Should(Exit(0))
    92  
    93  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
    94  		finalCtrs.WaitWithDefaultTimeout()
    95  		Expect(finalCtrs).Should(Exit(0))
    96  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
    97  	})
    98  
    99  	It("podman stop stopped container", func() {
   100  		session := podmanTest.RunTopContainer("test1")
   101  		session.WaitWithDefaultTimeout()
   102  		Expect(session).Should(Exit(0))
   103  
   104  		session2 := podmanTest.Podman([]string{"stop", "test1"})
   105  		session2.WaitWithDefaultTimeout()
   106  		Expect(session2).Should(Exit(0))
   107  
   108  		session3 := podmanTest.Podman([]string{"stop", "test1"})
   109  		session3.WaitWithDefaultTimeout()
   110  		Expect(session3).Should(Exit(0))
   111  
   112  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   113  		finalCtrs.WaitWithDefaultTimeout()
   114  		Expect(finalCtrs).Should(Exit(0))
   115  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   116  	})
   117  
   118  	It("podman stop all containers -t", func() {
   119  		session := podmanTest.RunTopContainer("test1")
   120  		session.WaitWithDefaultTimeout()
   121  		Expect(session).Should(Exit(0))
   122  		cid1 := session.OutputToString()
   123  
   124  		session = podmanTest.RunTopContainer("test2")
   125  		session.WaitWithDefaultTimeout()
   126  		Expect(session).Should(Exit(0))
   127  		cid2 := session.OutputToString()
   128  
   129  		session = podmanTest.RunTopContainer("test3")
   130  		session.WaitWithDefaultTimeout()
   131  		Expect(session).Should(Exit(0))
   132  		cid3 := session.OutputToString()
   133  
   134  		session = podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
   135  		session.WaitWithDefaultTimeout()
   136  		Expect(session).Should(Exit(0))
   137  		output := session.OutputToString()
   138  		Expect(output).To(ContainSubstring(cid1))
   139  		Expect(output).To(ContainSubstring(cid2))
   140  		Expect(output).To(ContainSubstring(cid3))
   141  
   142  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   143  		finalCtrs.WaitWithDefaultTimeout()
   144  		Expect(finalCtrs).Should(Exit(0))
   145  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   146  	})
   147  
   148  	It("podman stop container --time", func() {
   149  		session := podmanTest.RunTopContainer("test4")
   150  		session.WaitWithDefaultTimeout()
   151  		Expect(session).Should(Exit(0))
   152  
   153  		session = podmanTest.Podman([]string{"stop", "--time", "0", "test4"})
   154  		session.WaitWithDefaultTimeout()
   155  		Expect(session).Should(Exit(0))
   156  		output := session.OutputToString()
   157  		Expect(output).To(ContainSubstring("test4"))
   158  
   159  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   160  		finalCtrs.WaitWithDefaultTimeout()
   161  		Expect(finalCtrs).Should(Exit(0))
   162  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   163  	})
   164  
   165  	It("podman stop container --timeout", func() {
   166  		session := podmanTest.Podman([]string{"run", "-d", "--name", "test5", ALPINE, "sleep", "100"})
   167  		session.WaitWithDefaultTimeout()
   168  		Expect(session).Should(Exit(0))
   169  		session = podmanTest.Podman([]string{"stop", "--timeout", "0", "test5"})
   170  		// Without timeout container stops in 10 seconds
   171  		// If not stopped in 5 seconds, then --timeout did not work
   172  		session.Wait(5)
   173  		Expect(session).Should(Exit(0))
   174  		output := session.OutputToString()
   175  		Expect(output).To(ContainSubstring("test5"))
   176  
   177  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   178  		finalCtrs.WaitWithDefaultTimeout()
   179  		Expect(finalCtrs).Should(Exit(0))
   180  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   181  	})
   182  
   183  	It("podman stop container --timeout Warning", func() {
   184  		SkipIfRemote("warning will happen only on server side")
   185  		session := podmanTest.Podman([]string{"run", "-d", "--name", "test5", ALPINE, "sleep", "100"})
   186  		session.WaitWithDefaultTimeout()
   187  		Expect(session).Should(Exit(0))
   188  		session = podmanTest.Podman([]string{"stop", "--timeout", "1", "test5"})
   189  		session.WaitWithDefaultTimeout()
   190  		Expect(session).Should(Exit(0))
   191  		warning := session.ErrorToString()
   192  		Expect(warning).To(ContainSubstring("StopSignal SIGTERM failed to stop container test5 in 1 seconds, resorting to SIGKILL"))
   193  	})
   194  
   195  	It("podman stop latest containers", func() {
   196  		SkipIfRemote("--latest flag n/a")
   197  		session := podmanTest.RunTopContainer("test1")
   198  		session.WaitWithDefaultTimeout()
   199  		Expect(session).Should(Exit(0))
   200  		session = podmanTest.Podman([]string{"stop", "-l", "-t", "1"})
   201  		session.WaitWithDefaultTimeout()
   202  		Expect(session).Should(Exit(0))
   203  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   204  		finalCtrs.WaitWithDefaultTimeout()
   205  		Expect(finalCtrs).Should(Exit(0))
   206  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   207  	})
   208  
   209  	It("podman stop all containers with one stopped", func() {
   210  		session := podmanTest.RunTopContainer("test1")
   211  		session.WaitWithDefaultTimeout()
   212  		Expect(session).Should(Exit(0))
   213  		session2 := podmanTest.RunTopContainer("test2")
   214  		session2.WaitWithDefaultTimeout()
   215  		Expect(session2).Should(Exit(0))
   216  		cid := "-l"
   217  		if IsRemote() {
   218  			cid = "test2"
   219  		}
   220  		session3 := podmanTest.Podman([]string{"stop", cid, "-t", "1"})
   221  		session3.WaitWithDefaultTimeout()
   222  		Expect(session3).Should(Exit(0))
   223  		session4 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
   224  		session4.WaitWithDefaultTimeout()
   225  		Expect(session4).Should(Exit(0))
   226  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   227  		finalCtrs.WaitWithDefaultTimeout()
   228  		Expect(finalCtrs).Should(Exit(0))
   229  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   230  	})
   231  
   232  	It("podman stop all containers with one created", func() {
   233  		session := podmanTest.RunTopContainer("test1")
   234  		session.WaitWithDefaultTimeout()
   235  		Expect(session).Should(Exit(0))
   236  		session2 := podmanTest.Podman([]string{"create", ALPINE, "/bin/sh"})
   237  		session2.WaitWithDefaultTimeout()
   238  		Expect(session2).Should(Exit(0))
   239  		session3 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
   240  		session3.WaitWithDefaultTimeout()
   241  		Expect(session3).Should(Exit(0))
   242  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   243  		finalCtrs.WaitWithDefaultTimeout()
   244  		Expect(finalCtrs).Should(Exit(0))
   245  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   246  	})
   247  
   248  	It("podman stop should return silent success on stopping configured containers", func() {
   249  		// following container is not created on OCI runtime
   250  		// so we return success and assume that is is stopped
   251  		session2 := podmanTest.Podman([]string{"create", "--name", "stopctr", ALPINE, "/bin/sh"})
   252  		session2.WaitWithDefaultTimeout()
   253  		Expect(session2).Should(Exit(0))
   254  		session3 := podmanTest.Podman([]string{"stop", "stopctr"})
   255  		session3.WaitWithDefaultTimeout()
   256  		Expect(session3).Should(Exit(0))
   257  	})
   258  
   259  	It("podman stop --cidfile", func() {
   260  
   261  		tmpDir, err := ioutil.TempDir("", "")
   262  		Expect(err).To(BeNil())
   263  		tmpFile := tmpDir + "cid"
   264  
   265  		defer os.RemoveAll(tmpDir)
   266  
   267  		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "top"})
   268  		session.WaitWithDefaultTimeout()
   269  		Expect(session).Should(Exit(0))
   270  		cid := session.OutputToStringArray()[0]
   271  
   272  		session = podmanTest.Podman([]string{"start", cid})
   273  		session.WaitWithDefaultTimeout()
   274  		Expect(session).Should(Exit(0))
   275  
   276  		result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile})
   277  		result.WaitWithDefaultTimeout()
   278  		Expect(result).Should(Exit(0))
   279  		output := result.OutputToString()
   280  		Expect(output).To(ContainSubstring(cid))
   281  	})
   282  
   283  	It("podman stop multiple --cidfile", func() {
   284  
   285  		tmpDir, err := ioutil.TempDir("", "")
   286  		Expect(err).To(BeNil())
   287  		tmpFile1 := tmpDir + "cid-1"
   288  		tmpFile2 := tmpDir + "cid-2"
   289  
   290  		defer os.RemoveAll(tmpDir)
   291  
   292  		session := podmanTest.Podman([]string{"run", "--cidfile", tmpFile1, "-d", ALPINE, "top"})
   293  		session.WaitWithDefaultTimeout()
   294  		Expect(session).Should(Exit(0))
   295  		cid1 := session.OutputToStringArray()[0]
   296  		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
   297  
   298  		session = podmanTest.Podman([]string{"run", "--cidfile", tmpFile2, "-d", ALPINE, "top"})
   299  		session.WaitWithDefaultTimeout()
   300  		Expect(session).Should(Exit(0))
   301  		cid2 := session.OutputToStringArray()[0]
   302  		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
   303  
   304  		result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile1, "--cidfile", tmpFile2})
   305  		result.WaitWithDefaultTimeout()
   306  		Expect(result).Should(Exit(0))
   307  		output := result.OutputToString()
   308  		Expect(output).To(ContainSubstring(cid1))
   309  		Expect(output).To(ContainSubstring(cid2))
   310  		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
   311  	})
   312  
   313  	It("podman stop invalid --latest and --cidfile and --all", func() {
   314  		SkipIfRemote("--latest flag n/a")
   315  
   316  		result := podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--latest"})
   317  		result.WaitWithDefaultTimeout()
   318  		Expect(result).Should(Exit(125))
   319  
   320  		result = podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--all"})
   321  		result.WaitWithDefaultTimeout()
   322  		Expect(result).Should(Exit(125))
   323  
   324  		result = podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--all", "--latest"})
   325  		result.WaitWithDefaultTimeout()
   326  		Expect(result).Should(Exit(125))
   327  
   328  		result = podmanTest.Podman([]string{"stop", "--latest", "--all"})
   329  		result.WaitWithDefaultTimeout()
   330  		Expect(result).Should(Exit(125))
   331  	})
   332  
   333  	It("podman stop --all", func() {
   334  		session := podmanTest.RunTopContainer("")
   335  		session.WaitWithDefaultTimeout()
   336  		Expect(session).Should(Exit(0))
   337  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
   338  
   339  		session = podmanTest.RunTopContainer("")
   340  		session.WaitWithDefaultTimeout()
   341  		Expect(session).Should(Exit(0))
   342  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
   343  
   344  		session = podmanTest.Podman([]string{"stop", "--all"})
   345  		session.WaitWithDefaultTimeout()
   346  		Expect(session).Should(Exit(0))
   347  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
   348  	})
   349  
   350  	It("podman stop --ignore", func() {
   351  		session := podmanTest.RunTopContainer("")
   352  		session.WaitWithDefaultTimeout()
   353  		Expect(session).Should(Exit(0))
   354  		cid := session.OutputToString()
   355  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
   356  
   357  		session = podmanTest.Podman([]string{"stop", "bogus", cid})
   358  		session.WaitWithDefaultTimeout()
   359  		Expect(session).Should(Exit(125))
   360  
   361  		session = podmanTest.Podman([]string{"stop", "--ignore", "bogus", cid})
   362  		session.WaitWithDefaultTimeout()
   363  		Expect(session).Should(Exit(0))
   364  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
   365  	})
   366  })