podman

1
package integration
2

3
import (
4
	"os/exec"
5
	"strings"
6

7
	. "github.com/containers/podman/v5/test/utils"
8
	. "github.com/onsi/ginkgo/v2"
9
	. "github.com/onsi/gomega"
10
)
11

12
var _ = Describe("Podman run ns", func() {
13

14
	It("podman run pidns test", func() {
15
		SkipIfRootlessCgroupsV1("Not supported for rootless + CgroupsV1")
16
		session := podmanTest.Podman([]string{"run", fedoraMinimal, "bash", "-c", "echo $$"})
17
		session.WaitWithDefaultTimeout()
18
		Expect(session).Should(ExitCleanly())
19
		Expect(session.OutputToString()).To(Equal("1"))
20

21
		session = podmanTest.Podman([]string{"run", "--pid=host", fedoraMinimal, "bash", "-c", "echo $$"})
22
		session.WaitWithDefaultTimeout()
23
		Expect(session).Should(ExitCleanly())
24
		Expect(session.OutputToString()).To(Not(Equal("1")))
25

26
		session = podmanTest.Podman([]string{"run", "--pid=badpid", fedoraMinimal, "bash", "-c", "echo $$"})
27
		session.WaitWithDefaultTimeout()
28
		Expect(session).To(ExitWithError())
29
	})
30

31
	It("podman run --cgroup private test", func() {
32
		session := podmanTest.Podman([]string{"run", "--cgroupns=private", fedoraMinimal, "cat", "/proc/self/cgroup"})
33
		session.WaitWithDefaultTimeout()
34
		Expect(session).Should(ExitCleanly())
35

36
		output := session.OutputToString()
37
		Expect(output).ToNot(ContainSubstring("slice"))
38
	})
39

40
	It("podman run ipcns test", func() {
41
		setup := SystemExec("ls", []string{"--inode", "-d", "/dev/shm"})
42
		Expect(setup).Should(ExitCleanly())
43
		hostShm := setup.OutputToString()
44

45
		session := podmanTest.Podman([]string{"run", "--ipc=host", fedoraMinimal, "ls", "--inode", "-d", "/dev/shm"})
46
		session.WaitWithDefaultTimeout()
47
		Expect(session).Should(ExitCleanly())
48
		Expect(session.OutputToString()).To(Equal(hostShm))
49
	})
50

51
	It("podman run ipcns ipcmk host test", func() {
52
		setup := SystemExec("ipcmk", []string{"-M", "1024"})
53
		Expect(setup).Should(ExitCleanly())
54
		output := strings.Split(setup.OutputToString(), " ")
55
		ipc := output[len(output)-1]
56
		session := podmanTest.Podman([]string{"run", "--ipc=host", fedoraMinimal, "ipcs", "-m", "-i", ipc})
57
		session.WaitWithDefaultTimeout()
58
		Expect(session).Should(ExitCleanly())
59

60
		setup = SystemExec("ipcrm", []string{"-m", ipc})
61
		Expect(setup).Should(ExitCleanly())
62
	})
63

64
	It("podman run ipcns ipcmk container test", func() {
65
		setup := podmanTest.Podman([]string{"run", "-d", "--name", "test1", fedoraMinimal, "sleep", "999"})
66
		setup.WaitWithDefaultTimeout()
67
		Expect(setup).Should(ExitCleanly())
68

69
		session := podmanTest.Podman([]string{"exec", "test1", "ipcmk", "-M", "1024"})
70
		session.WaitWithDefaultTimeout()
71
		Expect(session).Should(ExitCleanly())
72
		output := strings.Split(session.OutputToString(), " ")
73
		ipc := output[len(output)-1]
74
		session = podmanTest.Podman([]string{"run", "--ipc=container:test1", fedoraMinimal, "ipcs", "-m", "-i", ipc})
75
		session.WaitWithDefaultTimeout()
76
		Expect(session).Should(ExitCleanly())
77
	})
78

79
	It("podman run bad ipc pid test", func() {
80
		session := podmanTest.Podman([]string{"run", "--ipc=badpid", fedoraMinimal, "bash", "-c", "echo $$"})
81
		session.WaitWithDefaultTimeout()
82
		Expect(session).To(ExitWithError())
83
	})
84

85
	It("podman run mounts fresh cgroup", func() {
86
		session := podmanTest.Podman([]string{"run", fedoraMinimal, "grep", "cgroup", "/proc/self/mountinfo"})
87
		session.WaitWithDefaultTimeout()
88
		Expect(session).Should(ExitCleanly())
89
		output := session.OutputToString()
90
		Expect(output).ToNot(ContainSubstring(".."))
91
	})
92

93
	It("podman run --ipc=host --pid=host", func() {
94
		SkipIfRootlessCgroupsV1("Not supported for rootless + CgroupsV1")
95
		cmd := exec.Command("ls", "-l", "/proc/self/ns/pid")
96
		res, err := cmd.Output()
97
		Expect(err).ToNot(HaveOccurred())
98
		fields := strings.Split(string(res), " ")
99
		hostPidNS := strings.TrimSuffix(fields[len(fields)-1], "\n")
100

101
		cmd = exec.Command("ls", "-l", "/proc/self/ns/ipc")
102
		res, err = cmd.Output()
103
		Expect(err).ToNot(HaveOccurred())
104
		fields = strings.Split(string(res), " ")
105
		hostIpcNS := strings.TrimSuffix(fields[len(fields)-1], "\n")
106

107
		session := podmanTest.Podman([]string{"run", "--ipc=host", "--pid=host", ALPINE, "ls", "-l", "/proc/self/ns/pid"})
108
		session.WaitWithDefaultTimeout()
109
		Expect(session).Should(ExitCleanly())
110
		fields = strings.Split(session.OutputToString(), " ")
111
		ctrPidNS := strings.TrimSuffix(fields[len(fields)-1], "\n")
112

113
		session = podmanTest.Podman([]string{"run", "--ipc=host", "--pid=host", ALPINE, "ls", "-l", "/proc/self/ns/ipc"})
114
		session.WaitWithDefaultTimeout()
115
		Expect(session).Should(ExitCleanly())
116
		fields = strings.Split(session.OutputToString(), " ")
117
		ctrIpcNS := strings.TrimSuffix(fields[len(fields)-1], "\n")
118

119
		Expect(hostPidNS).To(Equal(ctrPidNS))
120
		Expect(hostIpcNS).To(Equal(ctrIpcNS))
121
	})
122

123
})
124