github.com/containers/podman/v4@v4.9.4/test/e2e/pod_infra_container_test.go (about) 1 package integration 2 3 import ( 4 "strconv" 5 6 . "github.com/containers/podman/v4/test/utils" 7 . "github.com/onsi/ginkgo/v2" 8 . "github.com/onsi/gomega" 9 ) 10 11 var _ = Describe("Podman pod create", func() { 12 13 It("podman create infra container", func() { 14 session := podmanTest.Podman([]string{"pod", "create"}) 15 session.WaitWithDefaultTimeout() 16 Expect(session).Should(ExitCleanly()) 17 podID := session.OutputToString() 18 19 check := podmanTest.Podman([]string{"pod", "ps", "-q", "--no-trunc"}) 20 check.WaitWithDefaultTimeout() 21 Expect(check.OutputToString()).To(ContainSubstring(podID)) 22 Expect(check.OutputToStringArray()).To(HaveLen(1)) 23 24 check = podmanTest.Podman([]string{"ps", "-qa", "--no-trunc"}) 25 check.WaitWithDefaultTimeout() 26 Expect(check.OutputToStringArray()).To(HaveLen(1)) 27 }) 28 29 It("podman start infra container", func() { 30 session := podmanTest.Podman([]string{"pod", "create"}) 31 session.WaitWithDefaultTimeout() 32 Expect(session).Should(ExitCleanly()) 33 podID := session.OutputToString() 34 35 session = podmanTest.Podman([]string{"pod", "start", podID}) 36 session.WaitWithDefaultTimeout() 37 Expect(session).Should(ExitCleanly()) 38 39 check := podmanTest.Podman([]string{"ps", "-qa", "--no-trunc", "--filter", "status=running"}) 40 check.WaitWithDefaultTimeout() 41 Expect(session).Should(ExitCleanly()) 42 Expect(check.OutputToStringArray()).To(HaveLen(1)) 43 }) 44 45 It("podman start infra container different image", func() { 46 session := podmanTest.Podman([]string{"pod", "create", "--infra-image", BB}) 47 session.WaitWithDefaultTimeout() 48 Expect(session).Should(ExitCleanly()) 49 podID := session.OutputToString() 50 51 session = podmanTest.Podman([]string{"pod", "start", podID}) 52 session.WaitWithDefaultTimeout() 53 // If we use the default entry point, we should exit with no error 54 Expect(session).Should(ExitCleanly()) 55 }) 56 57 It("podman infra container namespaces", func() { 58 session := podmanTest.Podman([]string{"pod", "create"}) 59 session.WaitWithDefaultTimeout() 60 Expect(session).Should(ExitCleanly()) 61 podID := session.OutputToString() 62 63 session = podmanTest.Podman([]string{"pod", "start", podID}) 64 session.WaitWithDefaultTimeout() 65 Expect(session).Should(ExitCleanly()) 66 67 session = podmanTest.RunTopContainerInPod("", podID) 68 session.WaitWithDefaultTimeout() 69 Expect(session).Should(ExitCleanly()) 70 71 check := podmanTest.Podman([]string{"ps", "-a", "--no-trunc", "--ns", "--format", "{{.Namespaces.IPC}} {{.Namespaces.NET}}"}) 72 check.WaitWithDefaultTimeout() 73 Expect(session).Should(ExitCleanly()) 74 Expect(check.OutputToStringArray()).To(HaveLen(2)) 75 Expect(check.OutputToStringArray()[0]).To(Equal(check.OutputToStringArray()[1])) 76 77 check = podmanTest.Podman([]string{"ps", "-a", "--no-trunc", "--ns", "--format", "{{.IPC}} {{.NET}}"}) 78 check.WaitWithDefaultTimeout() 79 Expect(session).Should(ExitCleanly()) 80 Expect(check.OutputToStringArray()).To(HaveLen(2)) 81 Expect(check.OutputToStringArray()[0]).To(Equal(check.OutputToStringArray()[1])) 82 }) 83 84 It("podman pod correctly sets up NetNS", func() { 85 session := podmanTest.Podman([]string{"pod", "create", "--share", "net"}) 86 session.WaitWithDefaultTimeout() 87 Expect(session).Should(ExitCleanly()) 88 podID := session.OutputToString() 89 90 session = podmanTest.Podman([]string{"pod", "start", podID}) 91 session.WaitWithDefaultTimeout() 92 Expect(session).Should(ExitCleanly()) 93 94 session = podmanTest.Podman([]string{"run", "-d", "--pod", podID, NGINX_IMAGE}) 95 session.WaitWithDefaultTimeout() 96 Expect(session).Should(ExitCleanly()) 97 98 session = podmanTest.Podman([]string{"run", "--pod", podID, fedoraMinimal, "curl", "-s", "--retry", "2", "--retry-connrefused", "-f", "localhost:80"}) 99 session.WaitWithDefaultTimeout() 100 Expect(session).Should(ExitCleanly()) 101 102 session = podmanTest.Podman([]string{"run", fedoraMinimal, "curl", "-f", "localhost"}) 103 session.WaitWithDefaultTimeout() 104 Expect(session).To(ExitWithError()) 105 106 session = podmanTest.Podman([]string{"pod", "create", "--network", "host"}) 107 session.WaitWithDefaultTimeout() 108 Expect(session).Should(ExitCleanly()) 109 110 session = podmanTest.Podman([]string{"run", "--name", "hostCtr", "--pod", session.OutputToString(), ALPINE, "readlink", "/proc/self/ns/net"}) 111 session.WaitWithDefaultTimeout() 112 Expect(session).Should(ExitCleanly()) 113 114 ns := SystemExec("readlink", []string{"/proc/self/ns/net"}) 115 ns.WaitWithDefaultTimeout() 116 Expect(ns).Should(ExitCleanly()) 117 netns := ns.OutputToString() 118 Expect(netns).ToNot(BeEmpty()) 119 120 Expect(session.OutputToString()).To(Equal(netns)) 121 122 // Sanity Check for podman inspect 123 session = podmanTest.Podman([]string{"inspect", "--format", "'{{.NetworkSettings.SandboxKey}}'", "hostCtr"}) 124 session.WaitWithDefaultTimeout() 125 Expect(session).Should(ExitCleanly()) 126 Expect(session.OutputToString()).Should(Equal("''")) // no network path... host 127 128 }) 129 130 It("podman pod correctly sets up IPCNS", func() { 131 session := podmanTest.Podman([]string{"pod", "create", "--share", "ipc"}) 132 session.WaitWithDefaultTimeout() 133 Expect(session).Should(ExitCleanly()) 134 podID := session.OutputToString() 135 136 session = podmanTest.Podman([]string{"pod", "start", podID}) 137 session.WaitWithDefaultTimeout() 138 Expect(session).Should(ExitCleanly()) 139 140 session = podmanTest.Podman([]string{"run", "--pod", podID, fedoraMinimal, "/bin/sh", "-c", "'touch /dev/shm/hi'"}) 141 session.WaitWithDefaultTimeout() 142 if session.ExitCode() != 0 { 143 Skip("ShmDir not initialized, skipping...") 144 } 145 Expect(session).Should(ExitCleanly()) 146 147 session = podmanTest.Podman([]string{"run", "--pod", podID, fedoraMinimal, "/bin/sh", "-c", "'ls /dev/shm'"}) 148 session.WaitWithDefaultTimeout() 149 Expect(session).Should(ExitCleanly()) 150 Expect(session.OutputToString()).To(Equal("hi")) 151 }) 152 153 It("podman pod correctly sets up PIDNS", func() { 154 session := podmanTest.Podman([]string{"pod", "create", "--share", "pid", "--name", "test-pod"}) 155 session.WaitWithDefaultTimeout() 156 Expect(session).Should(ExitCleanly()) 157 podID := session.OutputToString() 158 159 session = podmanTest.Podman([]string{"pod", "start", podID}) 160 session.WaitWithDefaultTimeout() 161 Expect(session).Should(ExitCleanly()) 162 163 session = podmanTest.RunTopContainerInPod("test-ctr", podID) 164 session.WaitWithDefaultTimeout() 165 Expect(session).Should(ExitCleanly()) 166 167 check := podmanTest.Podman([]string{"top", "test-ctr", "pid"}) 168 check.WaitWithDefaultTimeout() 169 Expect(check).Should(ExitCleanly()) 170 PIDs := check.OutputToStringArray() 171 Expect(PIDs).To(HaveLen(3)) 172 173 ctrPID, _ := strconv.Atoi(PIDs[1]) 174 infraPID, _ := strconv.Atoi(PIDs[2]) 175 Expect(ctrPID).To(BeNumerically("<", infraPID)) 176 }) 177 178 It("podman pod doesn't share PIDNS if requested to not", func() { 179 session := podmanTest.Podman([]string{"pod", "create", "--share", "net", "--name", "test-pod"}) 180 session.WaitWithDefaultTimeout() 181 Expect(session).Should(ExitCleanly()) 182 podID := session.OutputToString() 183 184 session = podmanTest.Podman([]string{"pod", "start", podID}) 185 session.WaitWithDefaultTimeout() 186 Expect(session).Should(ExitCleanly()) 187 188 session = podmanTest.RunTopContainerInPod("test-ctr", podID) 189 session.WaitWithDefaultTimeout() 190 Expect(session).Should(ExitCleanly()) 191 192 check := podmanTest.Podman([]string{"top", "test-ctr", "pid"}) 193 check.WaitWithDefaultTimeout() 194 Expect(check).Should(ExitCleanly()) 195 ctrTop := check.OutputToStringArray() 196 197 check = podmanTest.Podman([]string{"top", podID[:12] + "-infra", "pid"}) 198 check.WaitWithDefaultTimeout() 199 Expect(check).Should(ExitCleanly()) 200 infraTop := check.OutputToStringArray() 201 202 ctrPID, _ := strconv.Atoi(ctrTop[1]) 203 infraPID, _ := strconv.Atoi(infraTop[1]) 204 Expect(ctrPID).To(Equal(infraPID)) 205 }) 206 207 It("podman pod container can override pod net NS", func() { 208 session := podmanTest.Podman([]string{"pod", "create", "--share", "net"}) 209 session.WaitWithDefaultTimeout() 210 Expect(session).Should(ExitCleanly()) 211 podID := session.OutputToString() 212 213 session = podmanTest.Podman([]string{"pod", "start", podID}) 214 session.WaitWithDefaultTimeout() 215 Expect(session).Should(ExitCleanly()) 216 217 session = podmanTest.Podman([]string{"run", "-d", "--pod", podID, NGINX_IMAGE}) 218 session.WaitWithDefaultTimeout() 219 Expect(session).Should(ExitCleanly()) 220 221 session = podmanTest.Podman([]string{"run", "--pod", podID, "--network", "bridge", NGINX_IMAGE, "curl", "-f", "localhost"}) 222 session.WaitWithDefaultTimeout() 223 Expect(session).To(ExitWithError()) 224 }) 225 226 It("podman pod container can override pod pid NS", func() { 227 SkipIfRootlessCgroupsV1("Not supported for rootless + CgroupsV1") 228 session := podmanTest.Podman([]string{"pod", "create", "--share", "pid"}) 229 session.WaitWithDefaultTimeout() 230 Expect(session).Should(ExitCleanly()) 231 podID := session.OutputToString() 232 233 session = podmanTest.Podman([]string{"pod", "start", podID}) 234 session.WaitWithDefaultTimeout() 235 Expect(session).Should(ExitCleanly()) 236 237 session = podmanTest.Podman([]string{"run", "--pod", podID, "--pid", "host", "-d", ALPINE, "top"}) 238 session.WaitWithDefaultTimeout() 239 Expect(session).Should(ExitCleanly()) 240 241 check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.Namespaces.PIDNS}}"}) 242 check.WaitWithDefaultTimeout() 243 Expect(check).Should(ExitCleanly()) 244 outputArray := check.OutputToStringArray() 245 Expect(outputArray).To(HaveLen(2)) 246 247 check = podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.PIDNS}}"}) 248 check.WaitWithDefaultTimeout() 249 Expect(check).Should(ExitCleanly()) 250 outputArray = check.OutputToStringArray() 251 Expect(outputArray).To(HaveLen(2)) 252 253 PID1 := outputArray[0] 254 PID2 := outputArray[1] 255 Expect(PID1).To(Not(Equal(PID2))) 256 }) 257 258 It("podman pod container can override pod not sharing pid", func() { 259 session := podmanTest.Podman([]string{"pod", "create", "--share", "net"}) 260 session.WaitWithDefaultTimeout() 261 Expect(session).Should(ExitCleanly()) 262 podID := session.OutputToString() 263 264 session = podmanTest.Podman([]string{"pod", "start", podID}) 265 session.WaitWithDefaultTimeout() 266 Expect(session).Should(ExitCleanly()) 267 268 session = podmanTest.Podman([]string{"run", "--pod", podID, "--pid", "pod", "-d", ALPINE, "top"}) 269 session.WaitWithDefaultTimeout() 270 Expect(session).Should(ExitCleanly()) 271 272 check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.PIDNS}}"}) 273 check.WaitWithDefaultTimeout() 274 Expect(check).Should(ExitCleanly()) 275 outputArray := check.OutputToStringArray() 276 Expect(outputArray).To(HaveLen(2)) 277 278 PID1 := outputArray[0] 279 PID2 := outputArray[1] 280 Expect(PID1).To(Equal(PID2)) 281 }) 282 283 It("podman pod container can override pod ipc NS", func() { 284 session := podmanTest.Podman([]string{"pod", "create", "--share", "ipc"}) 285 session.WaitWithDefaultTimeout() 286 Expect(session).Should(ExitCleanly()) 287 podID := session.OutputToString() 288 289 session = podmanTest.Podman([]string{"pod", "start", podID}) 290 session.WaitWithDefaultTimeout() 291 Expect(session).Should(ExitCleanly()) 292 293 session = podmanTest.Podman([]string{"run", "--pod", podID, "--ipc", "host", "-d", ALPINE, "top"}) 294 session.WaitWithDefaultTimeout() 295 Expect(session).Should(ExitCleanly()) 296 297 check := podmanTest.Podman([]string{"ps", "-a", "--ns", "--format", "{{.IPC}}"}) 298 check.WaitWithDefaultTimeout() 299 Expect(check).Should(ExitCleanly()) 300 outputArray := check.OutputToStringArray() 301 Expect(outputArray).To(HaveLen(2)) 302 303 PID1 := outputArray[0] 304 PID2 := outputArray[1] 305 Expect(PID1).To(Not(Equal(PID2))) 306 }) 307 308 It("podman pod infra container deletion", func() { 309 session := podmanTest.Podman([]string{"pod", "create", "--share", "ipc"}) 310 session.WaitWithDefaultTimeout() 311 Expect(session).Should(ExitCleanly()) 312 podID := session.OutputToString() 313 314 session = podmanTest.Podman([]string{"ps", "-aq"}) 315 session.WaitWithDefaultTimeout() 316 Expect(session).Should(ExitCleanly()) 317 infraID := session.OutputToString() 318 319 session = podmanTest.Podman([]string{"rm", infraID}) 320 session.WaitWithDefaultTimeout() 321 Expect(session).To(ExitWithError()) 322 323 session = podmanTest.Podman([]string{"pod", "rm", podID}) 324 session.WaitWithDefaultTimeout() 325 Expect(session).Should(ExitCleanly()) 326 }) 327 328 It("podman run in pod starts infra", func() { 329 session := podmanTest.Podman([]string{"pod", "create"}) 330 session.WaitWithDefaultTimeout() 331 Expect(session).Should(ExitCleanly()) 332 podID := session.OutputToString() 333 334 result := podmanTest.Podman([]string{"ps", "-aq"}) 335 result.WaitWithDefaultTimeout() 336 Expect(result).Should(ExitCleanly()) 337 infraID := result.OutputToString() 338 339 result = podmanTest.Podman([]string{"run", "--pod", podID, "-d", ALPINE, "top"}) 340 result.WaitWithDefaultTimeout() 341 Expect(result).Should(ExitCleanly()) 342 343 result = podmanTest.Podman([]string{"ps", "-aq"}) 344 result.WaitWithDefaultTimeout() 345 Expect(result).Should(ExitCleanly()) 346 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 347 348 Expect(result.OutputToString()).To(ContainSubstring(infraID)) 349 }) 350 351 It("podman start in pod starts infra", func() { 352 session := podmanTest.Podman([]string{"pod", "create"}) 353 session.WaitWithDefaultTimeout() 354 Expect(session).Should(ExitCleanly()) 355 podID := session.OutputToString() 356 357 result := podmanTest.Podman([]string{"ps", "-aq"}) 358 result.WaitWithDefaultTimeout() 359 Expect(result).Should(ExitCleanly()) 360 infraID := result.OutputToString() 361 362 result = podmanTest.Podman([]string{"create", "--pod", podID, ALPINE, "ls"}) 363 result.WaitWithDefaultTimeout() 364 Expect(result).Should(ExitCleanly()) 365 ctrID := result.OutputToString() 366 367 result = podmanTest.Podman([]string{"start", ctrID}) 368 result.WaitWithDefaultTimeout() 369 Expect(result).Should(ExitCleanly()) 370 371 result = podmanTest.Podman([]string{"ps", "-aq"}) 372 result.WaitWithDefaultTimeout() 373 Expect(result).Should(ExitCleanly()) 374 Expect(result.OutputToStringArray()).ShouldNot(BeEmpty()) 375 376 Expect(result.OutputToString()).To(ContainSubstring(infraID)) 377 }) 378 379 It("podman run --add-host in pod should fail", func() { 380 session := podmanTest.Podman([]string{"pod", "create", "--add-host", "host1:127.0.0.1"}) 381 session.WaitWithDefaultTimeout() 382 Expect(session).Should(ExitCleanly()) 383 podID := session.OutputToString() 384 385 session = podmanTest.Podman([]string{"create", "--pod", podID, "--add-host", "foobar:127.0.0.1", ALPINE, "ping", "-c", "1", "foobar"}) 386 session.WaitWithDefaultTimeout() 387 Expect(session).Should(ExitWithError()) 388 Expect(session.ErrorToString()).To(ContainSubstring("extra host entries must be specified on the pod: network cannot be configured when it is shared with a pod")) 389 390 // verify we can see the pods hosts 391 session = podmanTest.Podman([]string{"run", "--cap-add", "net_raw", "--pod", podID, ALPINE, "ping", "-c", "1", "host1"}) 392 session.WaitWithDefaultTimeout() 393 Expect(session).Should(ExitCleanly()) 394 }) 395 396 It("podman run hostname is shared", func() { 397 session := podmanTest.Podman([]string{"pod", "create"}) 398 session.WaitWithDefaultTimeout() 399 Expect(session).Should(ExitCleanly()) 400 podID := session.OutputToString() 401 402 // verify we can add a host to the infra's /etc/hosts 403 session = podmanTest.Podman([]string{"run", "--pod", podID, ALPINE, "hostname"}) 404 session.WaitWithDefaultTimeout() 405 Expect(session).Should(ExitCleanly()) 406 hostname := session.OutputToString() 407 408 infraName := podID[:12] + "-infra" 409 // verify we can see the other hosts of infra's /etc/hosts 410 session = podmanTest.Podman([]string{"inspect", infraName}) 411 session.WaitWithDefaultTimeout() 412 Expect(session).Should(ExitCleanly()) 413 Expect(session.OutputToString()).To(ContainSubstring(hostname)) 414 }) 415 416 tests := []string{"", "none"} 417 for _, test := range tests { 418 test := test 419 It("podman pod create --share="+test+" should not create an infra ctr", func() { 420 session := podmanTest.Podman([]string{"pod", "create", "--share", test}) 421 session.WaitWithDefaultTimeout() 422 Expect(session).Should(ExitCleanly()) 423 424 session = podmanTest.Podman([]string{"pod", "inspect", "--format", "{{.NumContainers}}", session.OutputToString()}) 425 session.WaitWithDefaultTimeout() 426 Expect(session).Should(ExitCleanly()) 427 Expect(session.OutputToString()).Should(Equal("0")) 428 }) 429 } 430 431 })