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  })