test/e2e: Remove slirp

Signed-off-by: Lokesh Mandvekar <[email protected]>

Author: lsm5

test/e2e/containers_conf_test.go

@@ -384,12 +384,6 @@ var _ = Describe("Verify podman containers.conf usage", func() {
 		Expect(session.OutputToString()).To(Equal("0002"))
 	})
 
-	It("network slirp options to allow host loopback", func() {
-		session := podmanTest.Podman([]string{"run", "--network", "slirp4netns", ALPINE, "ping", "-c1", "10.0.2.2"})
-		session.Wait(30)
-		Expect(session).Should(ExitCleanly())
-	})
-
 	It("podman-remote test localcontainers.conf", func() {
 		SkipIfNotRemote("this test is only for remote")
 
@@ -754,7 +748,7 @@ var _ = Describe("Verify podman containers.conf usage", func() {
 	It("podman default_rootless_network_cmd", func() {
 		SkipIfNotRootless("default_rootless_network_cmd is only used rootless")
 
-		for _, mode := range []string{"pasta", "slirp4netns", "invalid"} {
+		for _, mode := range []string{"pasta", "invalid"} {
 			conffile := filepath.Join(podmanTest.TempDir, "container.conf")
 			content := "[network]\ndefault_rootless_network_cmd=\"" + mode + "\"\n"
 			err := os.WriteFile(conffile, []byte(content), 0o755)

test/e2e/network_connect_disconnect_test.go

@@ -32,23 +32,6 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		Expect(dis).Should(ExitWithError(125, `no container with name or ID "foobar" found: no such container`))
 	})
 
-	It("network disconnect with net mode slirp4netns should result in error", func() {
-		netName := "slirp" + stringid.GenerateRandomID()
-		session := podmanTest.Podman([]string{"network", "create", netName})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-		defer podmanTest.removeNetwork(netName)
-
-		session = podmanTest.Podman([]string{"create", "--name", "test", "--network", "slirp4netns", ALPINE})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-		defer podmanTest.removeNetwork(netName)
-
-		con := podmanTest.Podman([]string{"network", "disconnect", netName, "test"})
-		con.WaitWithDefaultTimeout()
-		Expect(con).Should(ExitWithError(125, `"slirp4netns" is not supported: invalid network mode`))
-	})
-
 	It("podman network disconnect", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})
@@ -121,23 +104,6 @@ var _ = Describe("Podman network connect and disconnect", func() {
 		Expect(dis).Should(ExitWithError(125, `no container with name or ID "foobar" found: no such container`))
 	})
 
-	It("network connect with net mode slirp4netns should result in error", func() {
-		netName := "slirp" + stringid.GenerateRandomID()
-		session := podmanTest.Podman([]string{"network", "create", netName})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-		defer podmanTest.removeNetwork(netName)
-
-		session = podmanTest.Podman([]string{"create", "--name", "test", "--network", "slirp4netns", ALPINE})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-		defer podmanTest.removeNetwork(netName)
-
-		con := podmanTest.Podman([]string{"network", "connect", netName, "test"})
-		con.WaitWithDefaultTimeout()
-		Expect(con).Should(ExitWithError(125, `"slirp4netns" is not supported: invalid network mode`))
-	})
-
 	It("podman connect on a container that already is connected to the network should error after init", func() {
 		netName := "aliasTest" + stringid.GenerateRandomID()
 		session := podmanTest.Podman([]string{"network", "create", netName})

test/e2e/network_create_test.go

@@ -568,7 +568,7 @@ var _ = Describe("Podman network create", func() {
 	})
 
 	It("podman network create with invalid name", func() {
-		for _, name := range []string{"none", "host", "bridge", "private", "slirp4netns", "pasta", "container", "ns", "default"} {
+		for _, name := range []string{"none", "host", "bridge", "private", "pasta", "container", "ns", "default"} {
 			nc := podmanTest.Podman([]string{"network", "create", name})
 			nc.WaitWithDefaultTimeout()
 			Expect(nc).To(ExitWithError(125, fmt.Sprintf("cannot create network with name %q because it conflicts with a valid network mode", name)))

test/e2e/pod_create_test.go

@@ -557,18 +557,6 @@ entrypoint ["/fromimage"]
 		Expect(check2.OutputToString()).To(Equal("/fromcommand:[/fromcommand]"))
 	})
 
-	It("podman create pod with slirp network option", func() {
-		name := "test"
-		session := podmanTest.Podman([]string{"pod", "create", "--name", name, "--network", "slirp4netns:port_handler=slirp4netns", "-p", "8082:8000"})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-
-		check := podmanTest.Podman([]string{"pod", "inspect", "--format", "{{.InfraConfig.NetworkOptions.slirp4netns}}", name})
-		check.WaitWithDefaultTimeout()
-		Expect(check).Should(ExitCleanly())
-		Expect(check.OutputToString()).To(Equal("[port_handler=slirp4netns]"))
-	})
-
 	It("podman pod status test", func() {
 		podName := "testpod"
 		create := podmanTest.Podman([]string{"pod", "create", "--name", podName})

test/e2e/run_networking_test.go

@@ -5,12 +5,9 @@ package integration
 import (
 	"encoding/json"
 	"fmt"
-	"io"
 	"net"
 	"os"
-	"strconv"
 	"strings"
-	"sync"
 	"syscall"
 
 	"github.com/containernetworking/plugins/pkg/ns"
@@ -560,112 +557,6 @@ EXPOSE 2004-2005/tcp`, ALPINE)
 		Expect(inspectOut[0].NetworkSettings.Ports["80/tcp"][0]).To(HaveField("HostIP", "0.0.0.0"))
 	})
 
-	It("podman run slirp4netns verify net.ipv6.conf.default.accept_dad=0", func() {
-		session := podmanTest.Podman([]string{"run", "--network", "slirp4netns:enable_ipv6=true", ALPINE, "ip", "addr"})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-		// check the ipv6 setup id done without delay (https://github.com/containers/podman/issues/11062)
-		Expect(session.OutputToString()).To(ContainSubstring("inet6 fd00::"))
-
-		const ipv6ConfDefaultAcceptDadSysctl = "/proc/sys/net/ipv6/conf/all/accept_dad"
-
-		cat := SystemExec("cat", []string{ipv6ConfDefaultAcceptDadSysctl})
-		cat.WaitWithDefaultTimeout()
-		Expect(cat).Should(ExitCleanly())
-		sysctlValue := cat.OutputToString()
-
-		session = podmanTest.Podman([]string{"run", "--network", "slirp4netns:enable_ipv6=true", ALPINE, "cat", ipv6ConfDefaultAcceptDadSysctl})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-		Expect(session.OutputToString()).To(Equal(sysctlValue))
-	})
-
-	It("podman run network expose host port 8080 to container port 8000 using invalid port handler", func() {
-		session := podmanTest.Podman([]string{"run", "--network", "slirp4netns:port_handler=invalid", "-dt", "-p", "8080:8000", ALPINE, "/bin/sh"})
-		session.WaitWithDefaultTimeout()
-		Expect(session).To(ExitWithError(126, `unknown port_handler for slirp4netns: "invalid"`))
-	})
-
-	It("podman run slirp4netns network with host loopback", func() {
-		session := podmanTest.Podman([]string{"run", "--cap-add", "net_raw", "--network", "slirp4netns:allow_host_loopback=true", ALPINE, "ping", "-c1", "10.0.2.2"})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-	})
-
-	It("podman run slirp4netns network with mtu", func() {
-		session := podmanTest.Podman([]string{"run", "--network", "slirp4netns:mtu=9000", ALPINE, "ip", "addr"})
-		session.Wait(30)
-		Expect(session).Should(ExitCleanly())
-		Expect(session.OutputToString()).To(ContainSubstring("mtu 9000"))
-	})
-
-	It("podman run slirp4netns network with different cidr", func() {
-		slirp4netnsHelp := SystemExec("slirp4netns", []string{"--help"})
-		Expect(slirp4netnsHelp).Should(ExitCleanly())
-
-		networkConfiguration := "slirp4netns:cidr=192.168.0.0/24,allow_host_loopback=true"
-		session := podmanTest.Podman([]string{"run", "--cap-add", "net_raw", "--network", networkConfiguration, ALPINE, "ping", "-c1", "192.168.0.2"})
-		session.Wait(30)
-
-		if strings.Contains(slirp4netnsHelp.OutputToString(), "cidr") {
-			Expect(session).Should(ExitCleanly())
-		} else {
-			Expect(session).To(ExitWithError(125, "cidr not supported"))
-		}
-	})
-
-	for _, local := range []bool{true, false} {
-		testName := "HostIP"
-		if local {
-			testName = "127.0.0.1"
-		}
-		It(fmt.Sprintf("podman run network slirp4netns bind to %s", testName), func() {
-			ip := "127.0.0.1"
-			if !local {
-				// Determine our likeliest outgoing IP address
-				conn, err := net.Dial("udp", "8.8.8.8:80")
-				Expect(err).ToNot(HaveOccurred())
-
-				defer conn.Close()
-				ip = conn.LocalAddr().(*net.UDPAddr).IP.String()
-			}
-			port := strconv.Itoa(GetPort())
-
-			networkConfiguration := fmt.Sprintf("slirp4netns:outbound_addr=%s,allow_host_loopback=true", ip)
-
-			listener, err := net.Listen("tcp", ":"+port)
-			Expect(err).ToNot(HaveOccurred())
-			defer listener.Close()
-
-			msg := RandomString(10)
-			wg := &sync.WaitGroup{}
-			wg.Add(1)
-			// now use a new goroutine to start accepting connection in the background and make the checks there
-			go func() {
-				defer GinkgoRecover()
-				defer wg.Done()
-				conn, err := listener.Accept()
-				Expect(err).ToNot(HaveOccurred(), "accept new connection")
-				defer conn.Close()
-				addr := conn.RemoteAddr()
-				// addr will be in the form ip:port, we don't care about the port as it is random
-				Expect(addr.String()).To(HavePrefix(ip+":"), "remote address")
-				gotBytes, err := io.ReadAll(conn)
-				Expect(err).ToNot(HaveOccurred(), "read from connection")
-				Expect(string(gotBytes)).To(Equal(msg), "received correct message from container")
-			}()
-
-			session := podmanTest.Podman([]string{"run", "--network", networkConfiguration, ALPINE, "sh", "-c", "echo -n " + msg + " | nc -w 30 10.0.2.2 " + port})
-			session.WaitWithDefaultTimeout()
-			Expect(session).Should(ExitCleanly())
-
-			// explicitly close the socket here before we wait to unlock Accept() calls in case of hangs
-			listener.Close()
-			// wait for the checks in the goroutine to be done
-			wg.Wait()
-		})
-	}
-
 	It("podman run network expose ports in image metadata", func() {
 		session := podmanTest.Podman([]string{"create", "--name", "test", "-t", "-P", NGINX_IMAGE})
 		session.WaitWithDefaultTimeout()

test/e2e/stats_test.go

@@ -150,29 +150,6 @@ var _ = Describe("Podman stats", func() {
 		Expect(session).Should(ExitCleanly())
 	})
 
-	It("podman stats on container with forced slirp4netns", func() {
-		// This will force the slirp4netns net mode to be tested as root
-		session := podmanTest.Podman([]string{"run", "-d", "--net", "slirp4netns", ALPINE, "top"})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-		session = podmanTest.Podman([]string{"stats", "--no-stream", "-a"})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-	})
-
-	It("podman reads slirp4netns network stats", func() {
-		session := podmanTest.Podman([]string{"run", "-d", "--network", "slirp4netns", ALPINE, "top"})
-		session.WaitWithDefaultTimeout()
-		Expect(session).Should(ExitCleanly())
-
-		cid := session.OutputToString()
-
-		stats := podmanTest.Podman([]string{"stats", "--format", "'{{.NetIO}}'", "--no-stream", cid})
-		stats.WaitWithDefaultTimeout()
-		Expect(stats).Should(ExitCleanly())
-		Expect(stats.OutputToString()).To(Not(ContainSubstring("-- / --")))
-	})
-
 	// Regression test for #8265
 	It("podman stats with custom memory limits", func() {
 		// Run three containers. One with a memory limit.  Make sure