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