github.com/containers/podman/v5@v5.1.0-rc1/test/e2e/pod_start_test.go (about)

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