podman

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
	. "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
		cidFile := filepath.Join(tempdir, "cid")
325

326
		session := podmanTest.Podman([]string{"create", "--cidfile", cidFile, ALPINE, "top"})
327
		session.WaitWithDefaultTimeout()
328
		Expect(session).Should(ExitCleanly())
329
		cid := session.OutputToStringArray()[0]
330

331
		session = podmanTest.Podman([]string{"start", cid})
332
		session.WaitWithDefaultTimeout()
333
		Expect(session).Should(ExitCleanly())
334

335
		result := podmanTest.Podman([]string{"pause", "--cidfile", cidFile})
336
		result.WaitWithDefaultTimeout()
337
		Expect(result).Should(ExitCleanly())
338
		output := result.OutputToString()
339
		Expect(output).To(ContainSubstring(cid))
340

341
		result = podmanTest.Podman([]string{"unpause", "--cidfile", cidFile})
342
		result.WaitWithDefaultTimeout()
343
		Expect(result).Should(ExitCleanly())
344
		output = result.OutputToString()
345
		Expect(output).To(ContainSubstring(cid))
346
	})
347

348
	It("podman pause multiple --cidfile", func() {
349
		cidFile1 := filepath.Join(tempdir, "cid-1")
350
		cidFile2 := filepath.Join(tempdir, "cid-2")
351

352
		session := podmanTest.Podman([]string{"run", "--cidfile", cidFile1, "-d", ALPINE, "top"})
353
		session.WaitWithDefaultTimeout()
354
		Expect(session).Should(ExitCleanly())
355
		cid1 := session.OutputToStringArray()[0]
356
		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
357

358
		session = podmanTest.Podman([]string{"run", "--cidfile", cidFile2, "-d", ALPINE, "top"})
359
		session.WaitWithDefaultTimeout()
360
		Expect(session).Should(ExitCleanly())
361
		cid2 := session.OutputToStringArray()[0]
362
		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
363

364
		result := podmanTest.Podman([]string{"pause", "--cidfile", cidFile1, "--cidfile", cidFile2})
365
		result.WaitWithDefaultTimeout()
366
		Expect(result).Should(ExitCleanly())
367
		output := result.OutputToString()
368
		Expect(output).To(ContainSubstring(cid1))
369
		Expect(output).To(ContainSubstring(cid2))
370
		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
371

372
		result = podmanTest.Podman([]string{"unpause", "--cidfile", cidFile1, "--cidfile", cidFile2})
373
		result.WaitWithDefaultTimeout()
374
		Expect(result).Should(ExitCleanly())
375
		output = result.OutputToString()
376
		Expect(output).To(ContainSubstring(cid1))
377
		Expect(output).To(ContainSubstring(cid2))
378
		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
379
	})
380

381
	It("podman pause invalid --latest and --cidfile and --all", func() {
382
		SkipIfRemote("--latest flag n/a")
383
		result := podmanTest.Podman([]string{"pause", "--cidfile", "foobar", "--latest"})
384
		result.WaitWithDefaultTimeout()
385
		Expect(result).Should(Exit(125))
386
		Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together"))
387
		result = podmanTest.Podman([]string{"pause", "--cidfile", "foobar", "--all"})
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", "--latest"})
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", "--latest", "--all"})
396
		result.WaitWithDefaultTimeout()
397
		Expect(result).Should(Exit(125))
398
		Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together"))
399
	})
400

401
	It("podman unpause invalid --latest and --cidfile and --all", func() {
402
		SkipIfRemote("--latest flag n/a")
403
		result := podmanTest.Podman([]string{"unpause", "--cidfile", "foobar", "--latest"})
404
		result.WaitWithDefaultTimeout()
405
		Expect(result).Should(Exit(125))
406
		Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together"))
407
		result = podmanTest.Podman([]string{"unpause", "--cidfile", "foobar", "--all"})
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", "--latest"})
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", "--latest", "--all"})
416
		result.WaitWithDefaultTimeout()
417
		Expect(result).Should(Exit(125))
418
		Expect(result.ErrorToString()).To(ContainSubstring("cannot be used together"))
419
	})
420

421
	It("podman pause --filter", func() {
422
		session1 := podmanTest.RunTopContainer("")
423
		session1.WaitWithDefaultTimeout()
424
		Expect(session1).Should(ExitCleanly())
425
		cid1 := session1.OutputToString()
426

427
		session1 = podmanTest.RunTopContainer("")
428
		session1.WaitWithDefaultTimeout()
429
		Expect(session1).Should(ExitCleanly())
430
		cid2 := session1.OutputToString()
431

432
		session1 = podmanTest.RunTopContainerWithArgs("", []string{"--label", "test=with,comma"})
433
		session1.WaitWithDefaultTimeout()
434
		Expect(session1).Should(ExitCleanly())
435
		cid3 := session1.OutputToString()
436
		shortCid3 := cid3[0:5]
437

438
		session1 = podmanTest.Podman([]string{"pause", cid1, "-f", "status=test"})
439
		session1.WaitWithDefaultTimeout()
440
		Expect(session1).Should(Exit(125))
441

442
		session1 = podmanTest.Podman([]string{"unpause", cid1, "-f", "status=paused"})
443
		session1.WaitWithDefaultTimeout()
444
		Expect(session1).Should(Exit(125))
445

446
		session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", "label=test=with,comma"})
447
		session1.WaitWithDefaultTimeout()
448
		Expect(session1).Should(ExitCleanly())
449
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
450

451
		session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", "label=test=with,comma"})
452
		session1.WaitWithDefaultTimeout()
453
		Expect(session1).Should(ExitCleanly())
454
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
455

456
		session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
457
		session1.WaitWithDefaultTimeout()
458
		Expect(session1).Should(ExitCleanly())
459
		Expect(session1.OutputToString()).To(BeEmpty())
460

461
		session1 = podmanTest.Podman([]string{"pause", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)})
462
		session1.WaitWithDefaultTimeout()
463
		Expect(session1).Should(ExitCleanly())
464
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
465

466
		session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
467
		session1.WaitWithDefaultTimeout()
468
		Expect(session1).Should(ExitCleanly())
469
		Expect(session1.OutputToString()).To(BeEmpty())
470

471
		session1 = podmanTest.Podman([]string{"unpause", "-a", "--filter", fmt.Sprintf("id=%s", shortCid3)})
472
		session1.WaitWithDefaultTimeout()
473
		Expect(session1).Should(ExitCleanly())
474
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
475

476
		session1 = podmanTest.Podman([]string{"pause", "-f", fmt.Sprintf("id=%s", cid2)})
477
		session1.WaitWithDefaultTimeout()
478
		Expect(session1).Should(ExitCleanly())
479
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
480

481
		session1 = podmanTest.Podman([]string{"unpause", "-f", fmt.Sprintf("id=%s", cid2)})
482
		session1.WaitWithDefaultTimeout()
483
		Expect(session1).Should(ExitCleanly())
484
		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
485
	})
486
})
487