Merge pull request #27 from arangodb-helper/custom-network-namespace

Custom network namespace

Author: ewoutp

README.md

@@ -259,16 +259,23 @@ of the process in the Docker container.
 `endpoint` is the URL used to reach the docker host. This is needed to run 
 the executable in docker. The default value is "unix:///var/run/docker.sock".
 
-* `--dockerNetHost bool`
+* `--dockerNetworkMode mode`
 
-If `dockerNetHost` is set, all docker container will be started 
-with the `--net=host` option.
+If `dockerNetworkMode` is set, all docker container will be started 
+with the `--net=<mode>` option.
 
 * `--dockerPrivileged bool`
 
 If `dockerPrivileged` is set, all docker container will be started 
 with the `--privileged` option turned on.
 
+* `--dockerNetHost bool` (deprecated)
+
+If `dockerNetHost` is set, all docker container will be started 
+with the `--net=host` option.
+
+This option is deprecated, use `--dockerNetworkMode=host` instead.
+
 HTTP API
 --------
 

main.go

@@ -59,7 +59,8 @@ var (
 	dockerUser           string
 	dockerContainer      string
 	dockerGCDelay        time.Duration
-	dockerNetHost        bool
+	dockerNetHost        bool // Deprecated
+	dockerNetworkMode    string
 	dockerPrivileged     bool
 )
 
@@ -83,7 +84,8 @@ func init() {
 	f.StringVar(&dockerUser, "dockerUser", "", "use the given name as user to run the Docker container")
 	f.StringVar(&dockerContainer, "dockerContainer", "", "name of the docker container that is running this process")
 	f.DurationVar(&dockerGCDelay, "dockerGCDelay", defaultDockerGCDelay, "Delay before stopped containers are garbage collected")
-	f.BoolVar(&dockerNetHost, "dockerNetHost", false, "Run containers with --net=host")
+	f.BoolVar(&dockerNetHost, "dockerNetHost", false, "Run containers with --net=host. (deprecated, use --dockerNetworkMode=host instead)")
+	f.StringVar(&dockerNetworkMode, "dockerNetworkMode", "", "Run containers with --net=<value>")
 	f.BoolVar(&dockerPrivileged, "dockerPrivileged", false, "Run containers with --privileged")
 	f.BoolVar(&allPortOffsetsUnique, "uniquePortOffsets", false, "If set, all peers will get a unique port offset. If false (default) only portOffset+peerAddress pairs will be unique.")
 	f.StringVar(&jwtSecretFile, "jwtSecretFile", "", "name of a plain text file containing a JWT secret used for server authentication")
@@ -192,6 +194,13 @@ func cmdMainRun(cmd *cobra.Command, args []string) {
 	if dockerImage != "" && rrPath != "" {
 		log.Fatal("Error: using --dockerImage and --rr is not possible.")
 	}
+	if dockerNetHost {
+		if dockerNetworkMode == "" {
+			dockerNetworkMode = "host"
+		} else if dockerNetworkMode != "host" {
+			log.Fatal("Error: cannot set --dockerNetHost and --dockerNetworkMode at the same time")
+		}
+	}
 	log.Debugf("Using %s as default arangod executable.", arangodExecutable)
 	log.Debugf("Using %s as default JS dir.", arangodJSstartup)
 
@@ -269,7 +278,7 @@ func cmdMainRun(cmd *cobra.Command, args []string) {
 		DockerImage:          dockerImage,
 		DockerUser:           dockerUser,
 		DockerGCDelay:        dockerGCDelay,
-		DockerNetHost:        dockerNetHost,
+		DockerNetworkMode:    dockerNetworkMode,
 		DockerPrivileged:     dockerPrivileged,
 		ProjectVersion:       projectVersion,
 		ProjectBuild:         projectBuild,

service/arangodb.go

@@ -39,14 +39,14 @@ type ServiceConfig struct {
 	SslKeyFile           string // Path containing an x509 certificate + private key to be used by the servers.
 	SslCAFile            string // Path containing an x509 CA certificate used to authenticate clients.
 
-	DockerContainer  string // Name of the container running this process
-	DockerEndpoint   string // Where to reach the docker daemon
-	DockerImage      string // Name of Arangodb docker image
-	DockerUser       string
-	DockerGCDelay    time.Duration
-	DockerNetHost    bool
-	DockerPrivileged bool
-	RunningInDocker  bool
+	DockerContainer   string // Name of the container running this process
+	DockerEndpoint    string // Where to reach the docker daemon
+	DockerImage       string // Name of Arangodb docker image
+	DockerUser        string
+	DockerGCDelay     time.Duration
+	DockerNetworkMode string
+	DockerPrivileged  bool
+	RunningInDocker   bool
 
 	ProjectVersion string
 	ProjectBuild   string
@@ -565,11 +565,15 @@ func (s *Service) Run(rootCtx context.Context) {
 		if s.OwnAddress == "" {
 			s.log.Fatal("OwnAddress must be specified")
 		}
-		hostPort, isNetHost, err := findDockerExposedAddress(s.DockerEndpoint, s.DockerContainer, s.MasterPort)
+		hostPort, isNetHost, networkMode, err := findDockerExposedAddress(s.DockerEndpoint, s.DockerContainer, s.MasterPort)
 		if err != nil {
 			s.log.Fatalf("Failed to detect port mapping: %#v", err)
 			return
 		}
+		if s.DockerNetworkMode == "" && networkMode != "" && networkMode != "default" {
+			s.log.Infof("Auto detected network mode: %s", networkMode)
+			s.DockerNetworkMode = networkMode
+		}
 		s.announcePort = hostPort
 		s.isNetHost = isNetHost
 	} else {
@@ -581,7 +585,7 @@ func (s *Service) Run(rootCtx context.Context) {
 	var runner Runner
 	if s.DockerEndpoint != "" && s.DockerImage != "" {
 		var err error
-		runner, err = NewDockerRunner(s.log, s.DockerEndpoint, s.DockerImage, s.DockerUser, s.DockerContainer, s.DockerGCDelay, s.DockerNetHost, s.DockerPrivileged)
+		runner, err = NewDockerRunner(s.log, s.DockerEndpoint, s.DockerImage, s.DockerUser, s.DockerContainer, s.DockerGCDelay, s.DockerNetworkMode, s.DockerPrivileged)
 		if err != nil {
 			s.log.Fatalf("Failed to create docker runner: %#v", err)
 		}

service/docker.go

@@ -3,34 +3,36 @@ package service
 import (
 	"fmt"
 	"strconv"
+	"strings"
 
 	docker "github.com/fsouza/go-dockerclient"
 )
 
 // findDockerExposedAddress looks up the external port number to which the given
 // port is mapped onto for the given container.
-func findDockerExposedAddress(dockerEndpoint, containerName string, port int) (hostPort int, isNetHost bool, err error) {
+func findDockerExposedAddress(dockerEndpoint, containerName string, port int) (hostPort int, isNetHost bool, networkMode string, err error) {
 	client, err := docker.NewClient(dockerEndpoint)
 	if err != nil {
-		return 0, false, maskAny(err)
+		return 0, false, "", maskAny(err)
 	}
 	container, err := client.InspectContainer(containerName)
 	if err != nil {
-		return 0, false, maskAny(err)
+		return 0, false, "", maskAny(err)
 	}
-	isNetHost = container.HostConfig.NetworkMode == "host"
+	networkMode = container.HostConfig.NetworkMode
+	isNetHost = networkMode == "host" || strings.HasPrefix(networkMode, "container:")
 	if isNetHost {
 		// There is no port mapping for `--net=host`
-		return port, isNetHost, nil
+		return port, isNetHost, networkMode, nil
 	}
 	dockerPort := docker.Port(fmt.Sprintf("%d/tcp", port))
 	bindings, ok := container.NetworkSettings.Ports[dockerPort]
 	if !ok || len(bindings) == 0 {
-		return 0, isNetHost, maskAny(fmt.Errorf("Cannot find port binding for TCP port %d", port))
+		return 0, isNetHost, networkMode, maskAny(fmt.Errorf("Cannot find port binding for TCP port %d", port))
 	}
 	hostPort, err = strconv.Atoi(bindings[0].HostPort)
 	if err != nil {
-		return 0, isNetHost, maskAny(err)
+		return 0, isNetHost, networkMode, maskAny(err)
 	}
-	return hostPort, isNetHost, nil
+	return hostPort, isNetHost, networkMode, nil
 }

service/runner_docker.go

@@ -22,7 +22,7 @@ const (
 )
 
 // NewDockerRunner creates a runner that starts processes on the local OS.
-func NewDockerRunner(log *logging.Logger, endpoint, image, user, volumesFrom string, gcDelay time.Duration, netHost, privileged bool) (Runner, error) {
+func NewDockerRunner(log *logging.Logger, endpoint, image, user, volumesFrom string, gcDelay time.Duration, networkMode string, privileged bool) (Runner, error) {
 	client, err := docker.NewClient(endpoint)
 	if err != nil {
 		return nil, maskAny(err)
@@ -35,7 +35,7 @@ func NewDockerRunner(log *logging.Logger, endpoint, image, user, volumesFrom str
 		volumesFrom:  volumesFrom,
 		containerIDs: make(map[string]time.Time),
 		gcDelay:      gcDelay,
-		netHost:      netHost,
+		networkMode:  networkMode,
 		privileged:   privileged,
 	}, nil
 }
@@ -51,7 +51,7 @@ type dockerRunner struct {
 	containerIDs map[string]time.Time
 	gcOnce       sync.Once
 	gcDelay      time.Duration
-	netHost      bool
+	networkMode  string
 	privileged   bool
 }
 
@@ -173,8 +173,8 @@ func (r *dockerRunner) start(command string, args []string, volumes []Volume, po
 			opts.HostConfig.Binds = append(opts.HostConfig.Binds, bind)
 		}
 	}
-	if r.netHost {
-		opts.HostConfig.NetworkMode = "host"
+	if r.networkMode != "" && r.networkMode != "default" {
+		opts.HostConfig.NetworkMode = r.networkMode
 	} else {
 		for _, p := range ports {
 			dockerPort := docker.Port(fmt.Sprintf("%d/tcp", p))
@@ -248,9 +248,15 @@ func (r *dockerRunner) CreateStartArangodbCommand(index int, masterIP string, ma
 		masterPortI, _ := strconv.Atoi(masterPort)
 		hostPort = masterPortI + (portOffsetIncrement * (index - 1))
 	}
+	var netArgs string
+	if r.networkMode == "" || r.networkMode == "default" {
+		netArgs = fmt.Sprintf("-p %d:4000", hostPort)
+	} else {
+		netArgs = fmt.Sprintf("--net=%s", r.networkMode)
+	}
 	lines := []string{
 		fmt.Sprintf("docker volume create arangodb%d &&", index),
-		fmt.Sprintf("docker run -it --name=adb%d --rm -p %d:4000 -v arangodb%d:/data -v /var/run/docker.sock:/var/run/docker.sock arangodb/arangodb-starter", index, hostPort, index),
+		fmt.Sprintf("docker run -it --name=adb%d --rm %s -v arangodb%d:/data -v /var/run/docker.sock:/var/run/docker.sock arangodb/arangodb-starter", index, netArgs, index),
 		fmt.Sprintf("--dockerContainer=adb%d --ownAddress=%s --join=%s", index, masterIP, addr),
 	}
 	return strings.Join(lines, " \\\n    ")