github.com/containers/podman/v4@v4.9.4/test/e2e/pause_test.go (about) 1 package integration 2 3 import ( 4 "fmt" 5 "os" 6 "path/filepath" 7 "strings" 8 9 . "github.com/containers/podman/v4/test/utils" 10 . "github.com/onsi/ginkgo/v2" 11 . "github.com/onsi/gomega" 12 . "github.com/onsi/gomega/gexec" 13 ) 14 15 var _ = Describe("Podman pause", func() { 16 pausedState := "paused" 17 createdState := "created" 18 19 BeforeEach(func() { 20 SkipIfRootlessCgroupsV1("Pause is not supported in cgroups v1") 21 22 if CGROUPSV2 { 23 b, err := os.ReadFile("/proc/self/cgroup") 24 if err != nil { 25 Skip("cannot read self cgroup") 26 } 27 28 path := filepath.Join("/sys/fs/cgroup", strings.TrimSuffix(strings.Replace(string(b), "0::", "", 1), "\n"), "cgroup.freeze") 29 _, err = os.Stat(path) 30 if err != nil { 31 Skip("freezer controller not available on the current kernel") 32 } 33 } 34 35 }) 36 37 It("podman pause bogus container", func() { 38 session := podmanTest.Podman([]string{"pause", "foobar"}) 39 session.WaitWithDefaultTimeout() 40 Expect(session).To(ExitWithError()) 41 }) 42 43 It("podman unpause bogus container", func() { 44 session := podmanTest.Podman([]string{"unpause", "foobar"}) 45 session.WaitWithDefaultTimeout() 46 Expect(session).To(ExitWithError()) 47 }) 48 49 It("podman pause a created container by id", func() { 50 session := podmanTest.Podman([]string{"create", ALPINE, "ls"}) 51 session.WaitWithDefaultTimeout() 52 Expect(session).Should(ExitCleanly()) 53 cid := session.OutputToString() 54 55 result := podmanTest.Podman([]string{"pause", cid}) 56 result.WaitWithDefaultTimeout() 57 58 Expect(result).To(ExitWithError()) 59 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 60 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(createdState)) 61 62 // check we can read stats for a paused container 63 result = podmanTest.Podman([]string{"stats", "--no-stream", cid}) 64 result.WaitWithDefaultTimeout() 65 Expect(result).Should(ExitCleanly()) 66 }) 67 68 It("podman pause a running container by id", func() { 69 session := podmanTest.RunTopContainer("") 70 session.WaitWithDefaultTimeout() 71 Expect(session).Should(ExitCleanly()) 72 cid := session.OutputToString() 73 result := podmanTest.Podman([]string{"pause", cid}) 74 result.WaitWithDefaultTimeout() 75 76 Expect(result).Should(ExitCleanly()) 77 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 78 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 79 80 result = podmanTest.Podman([]string{"unpause", cid}) 81 result.WaitWithDefaultTimeout() 82 }) 83 84 It("podman container pause a running container by id", func() { 85 session := podmanTest.RunTopContainer("") 86 session.WaitWithDefaultTimeout() 87 Expect(session).Should(ExitCleanly()) 88 cid := session.OutputToString() 89 90 result := podmanTest.Podman([]string{"container", "pause", cid}) 91 result.WaitWithDefaultTimeout() 92 93 Expect(result).Should(ExitCleanly()) 94 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 95 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 96 97 result = podmanTest.Podman([]string{"container", "unpause", cid}) 98 result.WaitWithDefaultTimeout() 99 }) 100 101 It("podman unpause a running container by id", func() { 102 session := podmanTest.RunTopContainer("") 103 session.WaitWithDefaultTimeout() 104 Expect(session).Should(ExitCleanly()) 105 cid := session.OutputToString() 106 107 result := podmanTest.Podman([]string{"unpause", cid}) 108 result.WaitWithDefaultTimeout() 109 110 Expect(result).Should(Exit(125)) 111 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) 112 113 }) 114 115 It("podman remove a paused container by id without force", func() { 116 session := podmanTest.RunTopContainer("") 117 session.WaitWithDefaultTimeout() 118 Expect(session).Should(ExitCleanly()) 119 cid := session.OutputToString() 120 121 result := podmanTest.Podman([]string{"pause", cid}) 122 result.WaitWithDefaultTimeout() 123 124 Expect(result).Should(ExitCleanly()) 125 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 126 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 127 128 result = podmanTest.Podman([]string{"rm", cid}) 129 result.WaitWithDefaultTimeout() 130 131 Expect(result).Should(Exit(2)) 132 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 133 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 134 135 // unpause so that the cleanup can stop the container, 136 // otherwise it fails with container state improper 137 session = podmanTest.Podman([]string{"unpause", cid}) 138 session.WaitWithDefaultTimeout() 139 Expect(session).Should(ExitCleanly()) 140 }) 141 142 It("podman remove a paused container by id with force", func() { 143 session := podmanTest.RunTopContainer("") 144 session.WaitWithDefaultTimeout() 145 Expect(session).Should(ExitCleanly()) 146 cid := session.OutputToString() 147 148 result := podmanTest.Podman([]string{"pause", cid}) 149 result.WaitWithDefaultTimeout() 150 151 Expect(result).Should(ExitCleanly()) 152 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 153 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 154 155 result = podmanTest.Podman([]string{"rm", "-t", "0", "--force", cid}) 156 result.WaitWithDefaultTimeout() 157 158 Expect(result).Should(ExitCleanly()) 159 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 160 }) 161 162 It("podman stop a paused container by id", func() { 163 session := podmanTest.RunTopContainer("") 164 session.WaitWithDefaultTimeout() 165 Expect(session).Should(ExitCleanly()) 166 cid := session.OutputToString() 167 168 result := podmanTest.Podman([]string{"pause", cid}) 169 result.WaitWithDefaultTimeout() 170 171 Expect(result).Should(ExitCleanly()) 172 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 173 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 174 175 result = podmanTest.Podman([]string{"stop", cid}) 176 result.WaitWithDefaultTimeout() 177 178 Expect(result).Should(Exit(125)) 179 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 180 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 181 182 result = podmanTest.Podman([]string{"unpause", cid}) 183 result.WaitWithDefaultTimeout() 184 Expect(result).Should(ExitCleanly()) 185 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) 186 187 result = podmanTest.Podman([]string{"rm", cid}) 188 result.WaitWithDefaultTimeout() 189 Expect(result).Should(Exit(2)) 190 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) 191 192 result = podmanTest.Podman([]string{"rm", "-t", "0", "-f", cid}) 193 result.WaitWithDefaultTimeout() 194 Expect(result).Should(ExitCleanly()) 195 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 196 197 }) 198 199 It("podman pause a running container by name", func() { 200 session := podmanTest.RunTopContainer("test1") 201 session.WaitWithDefaultTimeout() 202 Expect(session).Should(ExitCleanly()) 203 204 result := podmanTest.Podman([]string{"pause", "test1"}) 205 result.WaitWithDefaultTimeout() 206 207 Expect(result).Should(ExitCleanly()) 208 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 209 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(Equal(pausedState)) 210 211 result = podmanTest.Podman([]string{"unpause", "test1"}) 212 result.WaitWithDefaultTimeout() 213 }) 214 215 It("podman pause a running container by id and another by name", func() { 216 session1 := podmanTest.RunTopContainer("test1") 217 session1.WaitWithDefaultTimeout() 218 Expect(session1).Should(ExitCleanly()) 219 220 session2 := podmanTest.RunTopContainer("") 221 session2.WaitWithDefaultTimeout() 222 Expect(session2).Should(ExitCleanly()) 223 cid2 := session2.OutputToString() 224 225 result := podmanTest.Podman([]string{"pause", cid2}) 226 result.WaitWithDefaultTimeout() 227 228 Expect(result).Should(ExitCleanly()) 229 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) 230 231 result = podmanTest.Podman([]string{"pause", "test1"}) 232 result.WaitWithDefaultTimeout() 233 234 Expect(result).Should(ExitCleanly()) 235 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 236 237 result = podmanTest.Podman([]string{"unpause", "test1"}) 238 result.WaitWithDefaultTimeout() 239 result = podmanTest.Podman([]string{"unpause", cid2}) 240 result.WaitWithDefaultTimeout() 241 }) 242 243 It("Pause all containers (no containers exist)", func() { 244 result := podmanTest.Podman([]string{"pause", "--all"}) 245 result.WaitWithDefaultTimeout() 246 Expect(result).Should(ExitCleanly()) 247 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 248 249 }) 250 251 It("Unpause all containers (no paused containers exist)", func() { 252 result := podmanTest.Podman([]string{"unpause", "--all"}) 253 result.WaitWithDefaultTimeout() 254 Expect(result).Should(ExitCleanly()) 255 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 256 }) 257 258 It("Pause a bunch of running containers", func() { 259 for i := 0; i < 3; i++ { 260 name := fmt.Sprintf("test%d", i) 261 run := podmanTest.Podman([]string{"run", "-dt", "--name", name, NGINX_IMAGE}) 262 run.WaitWithDefaultTimeout() 263 Expect(run).Should(ExitCleanly()) 264 265 } 266 running := podmanTest.Podman([]string{"ps", "-q"}) 267 running.WaitWithDefaultTimeout() 268 Expect(running).Should(ExitCleanly()) 269 Expect(running.OutputToStringArray()).To(HaveLen(3)) 270 271 pause := podmanTest.Podman([]string{"pause", "--all"}) 272 pause.WaitWithDefaultTimeout() 273 Expect(pause).Should(ExitCleanly()) 274 275 running = podmanTest.Podman([]string{"ps", "-q"}) 276 running.WaitWithDefaultTimeout() 277 Expect(running).Should(ExitCleanly()) 278 Expect(running.OutputToStringArray()).To(BeEmpty()) 279 280 unpause := podmanTest.Podman([]string{"unpause", "--all"}) 281 unpause.WaitWithDefaultTimeout() 282 Expect(unpause).Should(ExitCleanly()) 283 }) 284 285 It("Unpause a bunch of running containers", func() { 286 for i := 0; i < 3; i++ { 287 name := fmt.Sprintf("test%d", i) 288 run := podmanTest.Podman([]string{"run", "-dt", "--name", name, NGINX_IMAGE}) 289 run.WaitWithDefaultTimeout() 290 Expect(run).Should(ExitCleanly()) 291 292 } 293 pause := podmanTest.Podman([]string{"pause", "--all"}) 294 pause.WaitWithDefaultTimeout() 295 Expect(pause).Should(ExitCleanly()) 296 297 unpause := podmanTest.Podman([]string{"unpause", "--all"}) 298 unpause.WaitWithDefaultTimeout() 299 Expect(unpause).Should(ExitCleanly()) 300 301 running := podmanTest.Podman([]string{"ps", "-q"}) 302 running.WaitWithDefaultTimeout() 303 Expect(running).Should(ExitCleanly()) 304 Expect(running.OutputToStringArray()).To(HaveLen(3)) 305 }) 306 307 It("podman pause --latest", func() { 308 SkipIfRemote("--latest flag n/a") 309 session := podmanTest.RunTopContainer("") 310 session.WaitWithDefaultTimeout() 311 Expect(session).Should(ExitCleanly()) 312 result := podmanTest.Podman([]string{"pause", "-l"}) 313 result.WaitWithDefaultTimeout() 314 315 Expect(session).Should(ExitCleanly()) 316 Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0)) 317 Expect(strings.ToLower(podmanTest.GetContainerStatus())).To(ContainSubstring(pausedState)) 318 319 result = podmanTest.Podman([]string{"unpause", "-l"}) 320 result.WaitWithDefaultTimeout() 321 }) 322 323 It("podman pause --cidfile", func() { 324 tmpDir := GinkgoT().TempDir() 325 tmpFile := tmpDir + "cid" 326 327 session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "top"}) 328 session.WaitWithDefaultTimeout() 329 Expect(session).Should(ExitCleanly()) 330 cid := session.OutputToStringArray()[0] 331 332 session = podmanTest.Podman([]string{"start", cid}) 333 session.WaitWithDefaultTimeout() 334 Expect(session).Should(ExitCleanly()) 335 336 result := podmanTest.Podman([]string{"pause", "--cidfile", tmpFile}) 337 result.WaitWithDefaultTimeout() 338 Expect(result).Should(ExitCleanly()) 339 output := result.OutputToString() 340 Expect(output).To(ContainSubstring(cid)) 341 342 result = podmanTest.Podman([]string{"unpause", "--cidfile", tmpFile}) 343 result.WaitWithDefaultTimeout() 344 Expect(result).Should(ExitCleanly()) 345 output = result.OutputToString() 346 Expect(output).To(ContainSubstring(cid)) 347 }) 348 349 It("podman pause multiple --cidfile", func() { 350 tmpDir := GinkgoT().TempDir() 351 tmpFile1 := tmpDir + "cid-1" 352 tmpFile2 := tmpDir + "cid-2" 353 354 defer os.RemoveAll(tmpDir) 355 356 session := podmanTest.Podman([]string{"run", "--cidfile", tmpFile1, "-d", ALPINE, "top"}) 357 session.WaitWithDefaultTimeout() 358 Expect(session).Should(ExitCleanly()) 359 cid1 := session.OutputToStringArray()[0] 360 Expect(podmanTest.NumberOfContainers()).To(Equal(1)) 361 362 session = podmanTest.Podman([]string{"run", "--cidfile", tmpFile2, "-d", ALPINE, "top"}) 363 session.WaitWithDefaultTimeout() 364 Expect(session).Should(ExitCleanly()) 365 cid2 := session.OutputToStringArray()[0] 366 Expect(podmanTest.NumberOfContainers()).To(Equal(2)) 367 368 result := podmanTest.Podman([]string{"pause", "--cidfile", tmpFile1, "--cidfile", tmpFile2}) 369 result.WaitWithDefaultTimeout() 370 Expect(result).Should(ExitCleanly()) 371 output := result.OutputToString() 372 Expect(output).To(ContainSubstring(cid1)) 373 Expect(output).To(ContainSubstring(cid2)) 374 Expect(podmanTest.NumberOfContainers()).To(Equal(2)) 375 376 result = podmanTest.Podman([]string{"unpause", "--cidfile", tmpFile1, "--cidfile", tmpFile2}) 377 result.WaitWithDefaultTimeout() 378 Expect(result).Should(ExitCleanly()) 379 output = result.OutputToString() 380 Expect(output).To(ContainSubstring(cid1)) 381 Expect(output).To(ContainSubstring(cid2)) 382 Expect(podmanTest.NumberOfContainers()).To(Equal(2)) 383 }) 384 385 It("podman pause invalid --latest and --cidfile and --all", func() { 386 SkipIfRemote("--latest flag n/a") 387 result := podmanTest.Podman([]string{"pause", "--cidfile", "foobar", "--latest"}) 388 result.WaitWithDefaultTimeout() 389 Expect(result).Should(Exit(125)) 390 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 391 result = podmanTest.Podman([]string{"pause", "--cidfile", "foobar", "--all"}) 392 result.WaitWithDefaultTimeout() 393 Expect(result).Should(Exit(125)) 394 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 395 result = podmanTest.Podman([]string{"pause", "--cidfile", "foobar", "--all", "--latest"}) 396 result.WaitWithDefaultTimeout() 397 Expect(result).Should(Exit(125)) 398 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 399 result = podmanTest.Podman([]string{"pause", "--latest", "--all"}) 400 result.WaitWithDefaultTimeout() 401 Expect(result).Should(Exit(125)) 402 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 403 }) 404 405 It("podman unpause invalid --latest and --cidfile and --all", func() { 406 SkipIfRemote("--latest flag n/a") 407 result := podmanTest.Podman([]string{"unpause", "--cidfile", "foobar", "--latest"}) 408 result.WaitWithDefaultTimeout() 409 Expect(result).Should(Exit(125)) 410 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 411 result = podmanTest.Podman([]string{"unpause", "--cidfile", "foobar", "--all"}) 412 result.WaitWithDefaultTimeout() 413 Expect(result).Should(Exit(125)) 414 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 415 result = podmanTest.Podman([]string{"unpause", "--cidfile", "foobar", "--all", "--latest"}) 416 result.WaitWithDefaultTimeout() 417 Expect(result).Should(Exit(125)) 418 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 419 result = podmanTest.Podman([]string{"unpause", "--latest", "--all"}) 420 result.WaitWithDefaultTimeout() 421 Expect(result).Should(Exit(125)) 422 Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together")) 423 }) 424 425 It("podman pause --filter", func() { 426 session1 := podmanTest.RunTopContainer("") 427 session1.WaitWithDefaultTimeout() 428 Expect(session1).Should(ExitCleanly()) 429 cid1 := session1.OutputToString() 430 431 session1 = podmanTest.RunTopContainer("") 432 session1.WaitWithDefaultTimeout() 433 Expect(session1).Should(ExitCleanly()) 434 cid2 := session1.OutputToString() 435 436 session1 = podmanTest.RunTopContainerWithArgs("", []string{"--label", "test=with,comma"}) 437 session1.WaitWithDefaultTimeout() 438 Expect(session1).Should(ExitCleanly()) 439 cid3 := session1.OutputToString() 440 shortCid3 := cid3[0:5] 441 442 session1 = podmanTest.Podman([]string{"pause", cid1, "-f", "status=test"}) 443 session1.WaitWithDefaultTimeout() 444 Expect(session1).Should(Exit(125)) 445 446 session1 = podmanTest.Podman([]string{"unpause", cid1, "-f", "status=paused"}) 447 session1.WaitWithDefaultTimeout() 448 Expect(session1).Should(Exit(125)) 449 450 session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", "label=test=with,comma"}) 451 session1.WaitWithDefaultTimeout() 452 Expect(session1).Should(ExitCleanly()) 453 Expect(session1.OutputToString()).To(BeEquivalentTo(cid3)) 454 455 session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", "label=test=with,comma"}) 456 session1.WaitWithDefaultTimeout() 457 Expect(session1).Should(ExitCleanly()) 458 Expect(session1.OutputToString()).To(BeEquivalentTo(cid3)) 459 460 session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)}) 461 session1.WaitWithDefaultTimeout() 462 Expect(session1).Should(ExitCleanly()) 463 Expect(session1.OutputToString()).To(BeEmpty()) 464 465 session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)}) 466 session1.WaitWithDefaultTimeout() 467 Expect(session1).Should(ExitCleanly()) 468 Expect(session1.OutputToString()).To(BeEquivalentTo(cid3)) 469 470 session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)}) 471 session1.WaitWithDefaultTimeout() 472 Expect(session1).Should(ExitCleanly()) 473 Expect(session1.OutputToString()).To(BeEmpty()) 474 475 session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)}) 476 session1.WaitWithDefaultTimeout() 477 Expect(session1).Should(ExitCleanly()) 478 Expect(session1.OutputToString()).To(BeEquivalentTo(cid3)) 479 480 session1 = podmanTest.Podman([]string{"pause", "-f", fmt.Sprintf("id=%s", cid2)}) 481 session1.WaitWithDefaultTimeout() 482 Expect(session1).Should(ExitCleanly()) 483 Expect(session1.OutputToString()).To(BeEquivalentTo(cid2)) 484 485 session1 = podmanTest.Podman([]string{"unpause", "-f", fmt.Sprintf("id=%s", cid2)}) 486 session1.WaitWithDefaultTimeout() 487 Expect(session1).Should(ExitCleanly()) 488 Expect(session1.OutputToString()).To(BeEquivalentTo(cid2)) 489 }) 490 })