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