Merge pull request #12165 from icecrime/optional_userland_proxy

Optional userland proxy
Upstream-commit: 74bfa3675353aaf10ca760e82a79d758bea0ff6b
Component: engine

components/engine/integration-cli/docker_cli_nat_test.go

@@ -4,14 +4,26 @@ import (
 	"fmt"
 	"net"
 	"os/exec"
+	"strconv"
 	"strings"
 
 	"github.com/go-check/check"
 )
 
-func (s *DockerSuite) TestNetworkNat(c *check.C) {
-	testRequires(c, SameHostDaemon, NativeExecDriver)
+func startServerContainer(c *check.C, proto string, port int) string {
+	cmd := []string{"-d", "-p", fmt.Sprintf("%d:%d", port, port), "busybox", "nc", "-lp", strconv.Itoa(port)}
+	if proto == "udp" {
+		cmd = append(cmd, "-u")
+	}
 
+	name := "server"
+	if err := waitForContainer(name, cmd...); err != nil {
+		c.Fatalf("Failed to launch server container: %v", err)
+	}
+	return name
+}
+
+func getExternalAddress(c *check.C) net.IP {
 	iface, err := net.InterfaceByName("eth0")
 	if err != nil {
 		c.Skip(fmt.Sprintf("Test not running with `make test`. Interface eth0 not found: %v", err))
@@ -27,35 +39,65 @@ func (s *DockerSuite) TestNetworkNat(c *check.C) {
 		c.Fatalf("Error retrieving the up for eth0: %s", err)
 	}
 
-	runCmd := exec.Command(dockerBinary, "run", "-dt", "-p", "8080:8080", "busybox", "nc", "-lp", "8080")
+	return ifaceIP
+}
+
+func getContainerLogs(c *check.C, containerID string) string {
+	runCmd := exec.Command(dockerBinary, "logs", containerID)
 	out, _, err := runCommandWithOutput(runCmd)
 	if err != nil {
 		c.Fatal(out, err)
 	}
+	return strings.Trim(out, "\r\n")
+}
 
-	cleanedContainerID := strings.TrimSpace(out)
-
-	runCmd = exec.Command(dockerBinary, "run", "busybox", "sh", "-c", fmt.Sprintf("echo hello world | nc -w 30 %s 8080", ifaceIP))
-	out, _, err = runCommandWithOutput(runCmd)
+func getContainerStatus(c *check.C, containerID string) string {
+	runCmd := exec.Command(dockerBinary, "inspect", "-f", "{{.State.Running}}", containerID)
+	out, _, err := runCommandWithOutput(runCmd)
 	if err != nil {
 		c.Fatal(out, err)
 	}
+	return strings.Trim(out, "\r\n")
+}
 
-	runCmd = exec.Command(dockerBinary, "logs", cleanedContainerID)
-	out, _, err = runCommandWithOutput(runCmd)
-	if err != nil {
-		c.Fatalf("failed to retrieve logs for container: %s, %v", out, err)
+func (s *DockerSuite) TestNetworkNat(c *check.C) {
+	testRequires(c, SameHostDaemon, NativeExecDriver)
+	defer deleteAllContainers()
+
+	srv := startServerContainer(c, "tcp", 8080)
+
+	// Spawn a new container which connects to the server through the
+	// interface address.
+	endpoint := getExternalAddress(c)
+	runCmd := exec.Command(dockerBinary, "run", "busybox", "sh", "-c", fmt.Sprintf("echo hello world | nc -w 30 %s 8080", endpoint))
+	if out, _, err := runCommandWithOutput(runCmd); err != nil {
+		c.Fatalf("Failed to connect to server: %v (output: %q)", err, string(out))
+	}
+
+	result := getContainerLogs(c, srv)
+	if expected := "hello world"; result != expected {
+		c.Fatalf("Unexpected output. Expected: %q, received: %q", expected, result)
 	}
+}
 
-	out = strings.Trim(out, "\r\n")
+func (s *DockerSuite) TestNetworkLocalhostTCPNat(c *check.C) {
+	testRequires(c, SameHostDaemon, NativeExecDriver)
+	defer deleteAllContainers()
 
-	if expected := "hello world"; out != expected {
-		c.Fatalf("Unexpected output. Expected: %q, received: %q for iface %s", expected, out, ifaceIP)
+	srv := startServerContainer(c, "tcp", 8081)
+
+	// Attempt to connect from the host to the listening container.
+	conn, err := net.Dial("tcp", "localhost:8081")
+	if err != nil {
+		c.Fatalf("Failed to connect to container (%v)", err)
 	}
+	if _, err := conn.Write([]byte("hello world\n")); err != nil {
+		c.Fatal(err)
+	}
+	conn.Close()
 
-	killCmd := exec.Command(dockerBinary, "kill", cleanedContainerID)
-	if out, _, err = runCommandWithOutput(killCmd); err != nil {
-		c.Fatalf("failed to kill container: %s, %v", out, err)
+	result := getContainerLogs(c, srv)
+	if expected := "hello world"; result != expected {
+		c.Fatalf("Unexpected output. Expected: %q, received: %q", expected, result)
 	}
-
 }

components/engine/integration-cli/docker_cli_run_test.go

@@ -2197,49 +2197,19 @@ func (s *DockerSuite) TestRunPortInUse(c *check.C) {
 	testRequires(c, SameHostDaemon)
 
 	port := "1234"
-	l, err := net.Listen("tcp", ":"+port)
-	if err != nil {
-		c.Fatal(err)
-	}
-	defer l.Close()
 	cmd := exec.Command(dockerBinary, "run", "-d", "-p", port+":80", "busybox", "top")
 	out, _, err := runCommandWithOutput(cmd)
+	if err != nil {
+		c.Fatalf("Fail to run listening container")
+	}
+
+	cmd = exec.Command(dockerBinary, "run", "-d", "-p", port+":80", "busybox", "top")
+	out, _, err = runCommandWithOutput(cmd)
 	if err == nil {
 		c.Fatalf("Binding on used port must fail")
 	}
-	if !strings.Contains(out, "address already in use") {
-		c.Fatalf("Out must be about \"address already in use\", got %s", out)
-	}
-}
-
-// https://github.com/docker/docker/issues/8428
-func (s *DockerSuite) TestRunPortProxy(c *check.C) {
-	testRequires(c, SameHostDaemon)
-
-	port := "12345"
-	cmd := exec.Command(dockerBinary, "run", "-d", "-p", port+":80", "busybox", "top")
-
-	out, _, err := runCommandWithOutput(cmd)
-	if err != nil {
-		c.Fatalf("Failed to run and bind port %s, output: %s, error: %s", port, out, err)
-	}
-
-	// connett for 10 times here. This will trigger 10 EPIPES in the child
-	// process and kill it when it writes to a closed stdout/stderr
-	for i := 0; i < 10; i++ {
-		net.Dial("tcp", fmt.Sprintf("0.0.0.0:%s", port))
-	}
-
-	listPs := exec.Command("sh", "-c", "ps ax | grep docker")
-	out, _, err = runCommandWithOutput(listPs)
-	if err != nil {
-		c.Errorf("list docker process failed with output %s, error %s", out, err)
-	}
-	if strings.Contains(out, "docker <defunct>") {
-		c.Errorf("Unexpected defunct docker process")
-	}
-	if !strings.Contains(out, "docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 12345") {
-		c.Errorf("Failed to find docker-proxy process, got %s", out)
+	if !strings.Contains(out, "port is already allocated") {
+		c.Fatalf("Out must be about \"port is already allocated\", got %s", out)
 	}
 }
 

components/engine/integration-cli/docker_utils.go

@@ -37,6 +37,16 @@ type Daemon struct {
 	storageDriver  string
 	execDriver     string
 	wait           chan error
+	userlandProxy  bool
+}
+
+func enableUserlandProxy() bool {
+	if env := os.Getenv("DOCKER_USERLANDPROXY"); env != "" {
+		if val, err := strconv.ParseBool(env); err != nil {
+			return val
+		}
+	}
+	return true
 }
 
 // NewDaemon returns a Daemon instance to be used for testing.
@@ -58,11 +68,19 @@ func NewDaemon(c *check.C) *Daemon {
 		c.Fatalf("Could not create %s/graph directory", daemonFolder)
 	}
 
+	userlandProxy := true
+	if env := os.Getenv("DOCKER_USERLANDPROXY"); env != "" {
+		if val, err := strconv.ParseBool(env); err != nil {
+			userlandProxy = val
+		}
+	}
+
 	return &Daemon{
 		c:             c,
 		folder:        daemonFolder,
 		storageDriver: os.Getenv("DOCKER_GRAPHDRIVER"),
 		execDriver:    os.Getenv("DOCKER_EXECDRIVER"),
+		userlandProxy: userlandProxy,
 	}
 }
 
@@ -79,6 +97,7 @@ func (d *Daemon) Start(arg ...string) error {
 		"--daemon",
 		"--graph", fmt.Sprintf("%s/graph", d.folder),
 		"--pidfile", fmt.Sprintf("%s/docker.pid", d.folder),
+		fmt.Sprintf("--userland-proxy=%t", d.userlandProxy),
 	}
 
 	// If we don't explicitly set the log-level or debug flag(-D) then