github.com/containers/podman/v4@v4.9.4/test/e2e/pod_start_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"strconv"
     7  	"strings"
     8  
     9  	. "github.com/containers/podman/v4/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 pod start", func() {
    16  
    17  	It("podman pod start bogus pod", func() {
    18  		session := podmanTest.Podman([]string{"pod", "start", "123"})
    19  		session.WaitWithDefaultTimeout()
    20  		Expect(session).Should(Exit(125))
    21  	})
    22  
    23  	It("podman pod start single empty pod", func() {
    24  		_, ec, podid := podmanTest.CreatePod(nil)
    25  		Expect(ec).To(Equal(0))
    26  
    27  		session := podmanTest.Podman([]string{"pod", "start", podid})
    28  		session.WaitWithDefaultTimeout()
    29  		Expect(session).Should(Exit(125))
    30  	})
    31  
    32  	It("podman pod start single pod by name", func() {
    33  		_, ec, _ := podmanTest.CreatePod(map[string][]string{"--name": {"foobar99"}})
    34  		Expect(ec).To(Equal(0))
    35  
    36  		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "ls"})
    37  		session.WaitWithDefaultTimeout()
    38  		Expect(session).Should(ExitCleanly())
    39  
    40  		session = podmanTest.Podman([]string{"pod", "start", "foobar99"})
    41  		session.WaitWithDefaultTimeout()
    42  		Expect(session).Should(ExitCleanly())
    43  	})
    44  
    45  	It("podman pod start multiple pods", func() {
    46  		_, ec, podid1 := podmanTest.CreatePod(map[string][]string{"--name": {"foobar99"}})
    47  		Expect(ec).To(Equal(0))
    48  
    49  		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
    50  		session.WaitWithDefaultTimeout()
    51  		Expect(session).Should(ExitCleanly())
    52  
    53  		_, ec2, podid2 := podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
    54  		Expect(ec2).To(Equal(0))
    55  
    56  		session = podmanTest.Podman([]string{"create", "--pod", "foobar100", ALPINE, "top"})
    57  		session.WaitWithDefaultTimeout()
    58  		Expect(session).Should(ExitCleanly())
    59  
    60  		session = podmanTest.Podman([]string{"pod", "start", podid1, podid2})
    61  		session.WaitWithDefaultTimeout()
    62  		Expect(session).Should(ExitCleanly())
    63  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
    64  	})
    65  
    66  	It("multiple pods in conflict", func() {
    67  		podName := []string{"Pod_" + RandomString(10), "Pod_" + RandomString(10)}
    68  
    69  		pod, _, podid1 := podmanTest.CreatePod(map[string][]string{
    70  			"--infra":   {"true"},
    71  			"--name":    {podName[0]},
    72  			"--publish": {"127.0.0.1:8083:80"},
    73  		})
    74  		Expect(pod).To(ExitCleanly())
    75  
    76  		session := podmanTest.Podman([]string{"create", "--pod", podName[0], ALPINE, "top"})
    77  		session.WaitWithDefaultTimeout()
    78  		Expect(session).To(ExitCleanly())
    79  
    80  		pod, _, podid2 := podmanTest.CreatePod(map[string][]string{
    81  			"--infra":   {"true"},
    82  			"--name":    {podName[1]},
    83  			"--publish": {"127.0.0.1:8083:80"},
    84  		})
    85  		Expect(pod).To(ExitCleanly())
    86  
    87  		session = podmanTest.Podman([]string{"create", "--pod", podName[1], ALPINE, "top"})
    88  		session.WaitWithDefaultTimeout()
    89  		Expect(session).To(ExitCleanly())
    90  
    91  		session = podmanTest.Podman([]string{"pod", "start", podid1, podid2})
    92  		session.WaitWithDefaultTimeout()
    93  		Expect(session).To(Exit(125))
    94  	})
    95  
    96  	It("podman pod start all pods", func() {
    97  		_, ec, _ := podmanTest.CreatePod(map[string][]string{"--name": {"foobar99"}})
    98  		Expect(ec).To(Equal(0))
    99  
   100  		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
   101  		session.WaitWithDefaultTimeout()
   102  		Expect(session).Should(ExitCleanly())
   103  
   104  		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
   105  		Expect(ec).To(Equal(0))
   106  
   107  		session = podmanTest.Podman([]string{"create", "--pod", "foobar100", ALPINE, "top"})
   108  		session.WaitWithDefaultTimeout()
   109  		Expect(session).Should(ExitCleanly())
   110  
   111  		session = podmanTest.Podman([]string{"pod", "start", "--all"})
   112  		session.WaitWithDefaultTimeout()
   113  		Expect(session).Should(ExitCleanly())
   114  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
   115  	})
   116  
   117  	It("podman pod start latest pod", func() {
   118  		_, ec, _ := podmanTest.CreatePod(map[string][]string{"--name": {"foobar99"}})
   119  		Expect(ec).To(Equal(0))
   120  
   121  		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
   122  		session.WaitWithDefaultTimeout()
   123  		Expect(session).Should(ExitCleanly())
   124  
   125  		_, ec, _ = podmanTest.CreatePod(map[string][]string{"--name": {"foobar100"}})
   126  		Expect(ec).To(Equal(0))
   127  
   128  		session = podmanTest.Podman([]string{"create", "--pod", "foobar100", ALPINE, "top"})
   129  		session.WaitWithDefaultTimeout()
   130  		Expect(session).Should(ExitCleanly())
   131  
   132  		podid := "--latest"
   133  		if IsRemote() {
   134  			podid = "foobar100"
   135  		}
   136  		session = podmanTest.Podman([]string{"pod", "start", podid})
   137  		session.WaitWithDefaultTimeout()
   138  		Expect(session).Should(ExitCleanly())
   139  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
   140  	})
   141  
   142  	It("podman pod start multiple pods with bogus", func() {
   143  		_, ec, podid := podmanTest.CreatePod(map[string][]string{"--name": {"foobar99"}})
   144  		Expect(ec).To(Equal(0))
   145  
   146  		session := podmanTest.Podman([]string{"create", "--pod", "foobar99", ALPINE, "top"})
   147  		session.WaitWithDefaultTimeout()
   148  		Expect(session).Should(ExitCleanly())
   149  
   150  		session = podmanTest.Podman([]string{"pod", "start", podid, "doesnotexist"})
   151  		session.WaitWithDefaultTimeout()
   152  		Expect(session).Should(Exit(125))
   153  	})
   154  
   155  	It("podman pod start single pod via --pod-id-file", func() {
   156  		tmpDir := GinkgoT().TempDir()
   157  		tmpFile := tmpDir + "podID"
   158  
   159  		podName := "rudolph"
   160  
   161  		// Create a pod with --pod-id-file.
   162  		session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
   163  		session.WaitWithDefaultTimeout()
   164  		Expect(session).Should(ExitCleanly())
   165  
   166  		// Create container inside the pod.
   167  		session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
   168  		session.WaitWithDefaultTimeout()
   169  		Expect(session).Should(ExitCleanly())
   170  
   171  		session = podmanTest.Podman([]string{"pod", "start", "--pod-id-file", tmpFile})
   172  		session.WaitWithDefaultTimeout()
   173  		Expect(session).Should(ExitCleanly())
   174  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2)) // infra+top
   175  	})
   176  
   177  	It("podman pod start multiple pods via --pod-id-file", func() {
   178  		tmpDir := GinkgoT().TempDir()
   179  
   180  		podIDFiles := []string{}
   181  		for _, i := range "0123456789" {
   182  			tmpFile := tmpDir + "cid" + string(i)
   183  			podName := "rudolph" + string(i)
   184  			// Create a pod with --pod-id-file.
   185  			session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--pod-id-file", tmpFile})
   186  			session.WaitWithDefaultTimeout()
   187  			Expect(session).Should(ExitCleanly())
   188  
   189  			// Create container inside the pod.
   190  			session = podmanTest.Podman([]string{"create", "--pod", podName, ALPINE, "top"})
   191  			session.WaitWithDefaultTimeout()
   192  			Expect(session).Should(ExitCleanly())
   193  
   194  			// Append the id files along with the command.
   195  			podIDFiles = append(podIDFiles, "--pod-id-file")
   196  			podIDFiles = append(podIDFiles, tmpFile)
   197  		}
   198  
   199  		cmd := []string{"pod", "start"}
   200  		cmd = append(cmd, podIDFiles...)
   201  		session := podmanTest.Podman(cmd)
   202  		session.WaitWithDefaultTimeout()
   203  		Expect(session).Should(ExitCleanly())
   204  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(20)) // 10*(infra+top)
   205  	})
   206  
   207  	It("podman pod create --infra-conmon-pod create + start", func() {
   208  		tmpDir := GinkgoT().TempDir()
   209  		tmpFile := tmpDir + "podID"
   210  
   211  		podName := "rudolph"
   212  		// Create a pod with --infra-conmon-pid.
   213  		session := podmanTest.Podman([]string{"pod", "create", "--name", podName, "--infra-conmon-pidfile", tmpFile})
   214  		session.WaitWithDefaultTimeout()
   215  		Expect(session).Should(ExitCleanly())
   216  
   217  		session = podmanTest.Podman([]string{"pod", "start", podName})
   218  		session.WaitWithDefaultTimeout()
   219  		Expect(session).Should(ExitCleanly())
   220  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1)) // infra
   221  
   222  		readFirstLine := func(path string) string {
   223  			content, err := os.ReadFile(path)
   224  			Expect(err).ToNot(HaveOccurred())
   225  			return strings.Split(string(content), "\n")[0]
   226  		}
   227  
   228  		// Read the infra-conmon-pidfile and perform some sanity checks
   229  		// on the pid.
   230  		infraConmonPID := readFirstLine(tmpFile)
   231  		_, err = strconv.Atoi(infraConmonPID) // Make sure it's a proper integer
   232  		Expect(err).ToNot(HaveOccurred())
   233  
   234  		cmdline := readFirstLine(fmt.Sprintf("/proc/%s/cmdline", infraConmonPID))
   235  		Expect(cmdline).To(ContainSubstring("/conmon"))
   236  	})
   237  
   238  })