Remove jobs from daemon/networkdriver/bridge

Signed-off-by: Tibor Vass <[email protected]>

api/client/port.go

@@ -1,10 +1,10 @@
 package client
 
 import (
+	"encoding/json"
 	"fmt"
 	"strings"
 
-	"github.com/docker/docker/engine"
 	"github.com/docker/docker/nat"
 	flag "github.com/docker/docker/pkg/mflag"
 )
@@ -23,12 +23,13 @@ func (cli *DockerCli) CmdPort(args ...string) error {
 		return err
 	}
 
-	env := engine.Env{}
-	if err := env.Decode(stream); err != nil {
-		return err
+	var c struct {
+		NetworkSettings struct {
+			Ports nat.PortMap
+		}
 	}
-	ports := nat.PortMap{}
-	if err := env.GetSubEnv("NetworkSettings").GetJson("Ports", &ports); err != nil {
+
+	if err := json.NewDecoder(stream).Decode(&c); err != nil {
 		return err
 	}
 
@@ -44,7 +45,7 @@ func (cli *DockerCli) CmdPort(args ...string) error {
 			proto = parts[1]
 		}
 		natPort := port + "/" + proto
-		if frontends, exists := ports[nat.Port(port+"/"+proto)]; exists && frontends != nil {
+		if frontends, exists := c.NetworkSettings.Ports[nat.Port(port+"/"+proto)]; exists && frontends != nil {
 			for _, frontend := range frontends {
 				fmt.Fprintf(cli.out, "%s:%s\n", frontend.HostIp, frontend.HostPort)
 			}
@@ -53,7 +54,7 @@ func (cli *DockerCli) CmdPort(args ...string) error {
 		return fmt.Errorf("Error: No public port '%s' published for %s", natPort, cmd.Arg(0))
 	}
 
-	for from, frontends := range ports {
+	for from, frontends := range c.NetworkSettings.Ports {
 		for _, frontend := range frontends {
 			fmt.Fprintf(cli.out, "%s -> %s:%s\n", from, frontend.HostIp, frontend.HostPort)
 		}

builtins/builtins.go

@@ -6,15 +6,11 @@ import (
 	"github.com/docker/docker/api"
 	apiserver "github.com/docker/docker/api/server"
 	"github.com/docker/docker/autogen/dockerversion"
-	"github.com/docker/docker/daemon/networkdriver/bridge"
 	"github.com/docker/docker/engine"
 	"github.com/docker/docker/pkg/parsers/kernel"
 )
 
 func Register(eng *engine.Engine) error {
-	if err := daemon(eng); err != nil {
-		return err
-	}
 	if err := remote(eng); err != nil {
 		return err
 	}
@@ -33,25 +29,6 @@ func remote(eng *engine.Engine) error {
 	return eng.Register("acceptconnections", apiserver.AcceptConnections)
 }
 
-// daemon: a default execution and storage backend for Docker on Linux,
-// with the following underlying components:
-//
-// * Pluggable storage drivers including aufs, vfs, lvm and btrfs.
-// * Pluggable execution drivers including lxc and chroot.
-//
-// In practice `daemon` still includes most core Docker components, including:
-//
-// * The reference registry client implementation
-// * Image management
-// * The build facility
-// * Logging
-//
-// These components should be broken off into plugins of their own.
-//
-func daemon(eng *engine.Engine) error {
-	return eng.Register("init_networkdriver", bridge.InitDriver)
-}
-
 // builtins jobs independent of any subsystem
 func dockerVersion(job *engine.Job) error {
 	v := &engine.Env{}

daemon/config.go

@@ -1,9 +1,8 @@
 package daemon
 
 import (
-	"net"
-
 	"github.com/docker/docker/daemon/networkdriver"
+	"github.com/docker/docker/daemon/networkdriver/bridge"
 	"github.com/docker/docker/opts"
 	flag "github.com/docker/docker/pkg/mflag"
 	"github.com/docker/docker/pkg/ulimit"
@@ -20,35 +19,27 @@ const (
 // to the docker daemon when you launch it with say: `docker -d -e lxc`
 // FIXME: separate runtime configuration from http api configuration
 type Config struct {
-	Pidfile                     string
-	Root                        string
-	AutoRestart                 bool
-	Dns                         []string
-	DnsSearch                   []string
-	EnableIPv6                  bool
-	EnableIptables              bool
-	EnableIpForward             bool
-	EnableIpMasq                bool
-	DefaultIp                   net.IP
-	BridgeIface                 string
-	BridgeIP                    string
-	FixedCIDR                   string
-	FixedCIDRv6                 string
-	InterContainerCommunication bool
-	GraphDriver                 string
-	GraphOptions                []string
-	ExecDriver                  string
-	Mtu                         int
-	SocketGroup                 string
-	EnableCors                  bool
-	CorsHeaders                 string
-	DisableNetwork              bool
-	EnableSelinuxSupport        bool
-	Context                     map[string][]string
-	TrustKeyPath                string
-	Labels                      []string
-	Ulimits                     map[string]*ulimit.Ulimit
-	LogConfig                   runconfig.LogConfig
+	Bridge bridge.Config
+
+	Pidfile              string
+	Root                 string
+	AutoRestart          bool
+	Dns                  []string
+	DnsSearch            []string
+	GraphDriver          string
+	GraphOptions         []string
+	ExecDriver           string
+	Mtu                  int
+	SocketGroup          string
+	EnableCors           bool
+	CorsHeaders          string
+	DisableNetwork       bool
+	EnableSelinuxSupport bool
+	Context              map[string][]string
+	TrustKeyPath         string
+	Labels               []string
+	Ulimits              map[string]*ulimit.Ulimit
+	LogConfig            runconfig.LogConfig
 }
 
 // InstallFlags adds command-line options to the top-level flag parser for
@@ -59,23 +50,23 @@ func (config *Config) InstallFlags() {
 	flag.StringVar(&config.Pidfile, []string{"p", "-pidfile"}, "/var/run/docker.pid", "Path to use for daemon PID file")
 	flag.StringVar(&config.Root, []string{"g", "-graph"}, "/var/lib/docker", "Root of the Docker runtime")
 	flag.BoolVar(&config.AutoRestart, []string{"#r", "#-restart"}, true, "--restart on the daemon has been deprecated in favor of --restart policies on docker run")
-	flag.BoolVar(&config.EnableIptables, []string{"#iptables", "-iptables"}, true, "Enable addition of iptables rules")
-	flag.BoolVar(&config.EnableIpForward, []string{"#ip-forward", "-ip-forward"}, true, "Enable net.ipv4.ip_forward")
-	flag.BoolVar(&config.EnableIpMasq, []string{"-ip-masq"}, true, "Enable IP masquerading")
-	flag.BoolVar(&config.EnableIPv6, []string{"-ipv6"}, false, "Enable IPv6 networking")
-	flag.StringVar(&config.BridgeIP, []string{"#bip", "-bip"}, "", "Specify network bridge IP")
-	flag.StringVar(&config.BridgeIface, []string{"b", "-bridge"}, "", "Attach containers to a network bridge")
-	flag.StringVar(&config.FixedCIDR, []string{"-fixed-cidr"}, "", "IPv4 subnet for fixed IPs")
-	flag.StringVar(&config.FixedCIDRv6, []string{"-fixed-cidr-v6"}, "", "IPv6 subnet for fixed IPs")
-	flag.BoolVar(&config.InterContainerCommunication, []string{"#icc", "-icc"}, true, "Enable inter-container communication")
+	flag.BoolVar(&config.Bridge.EnableIptables, []string{"#iptables", "-iptables"}, true, "Enable addition of iptables rules")
+	flag.BoolVar(&config.Bridge.EnableIpForward, []string{"#ip-forward", "-ip-forward"}, true, "Enable net.ipv4.ip_forward")
+	flag.BoolVar(&config.Bridge.EnableIpMasq, []string{"-ip-masq"}, true, "Enable IP masquerading")
+	flag.BoolVar(&config.Bridge.EnableIPv6, []string{"-ipv6"}, false, "Enable IPv6 networking")
+	flag.StringVar(&config.Bridge.IP, []string{"#bip", "-bip"}, "", "Specify network bridge IP")
+	flag.StringVar(&config.Bridge.Iface, []string{"b", "-bridge"}, "", "Attach containers to a network bridge")
+	flag.StringVar(&config.Bridge.FixedCIDR, []string{"-fixed-cidr"}, "", "IPv4 subnet for fixed IPs")
+	flag.StringVar(&config.Bridge.FixedCIDRv6, []string{"-fixed-cidr-v6"}, "", "IPv6 subnet for fixed IPs")
+	flag.BoolVar(&config.Bridge.InterContainerCommunication, []string{"#icc", "-icc"}, true, "Enable inter-container communication")
 	flag.StringVar(&config.GraphDriver, []string{"s", "-storage-driver"}, "", "Storage driver to use")
 	flag.StringVar(&config.ExecDriver, []string{"e", "-exec-driver"}, "native", "Exec driver to use")
 	flag.BoolVar(&config.EnableSelinuxSupport, []string{"-selinux-enabled"}, false, "Enable selinux support")
 	flag.IntVar(&config.Mtu, []string{"#mtu", "-mtu"}, 0, "Set the containers network MTU")
 	flag.StringVar(&config.SocketGroup, []string{"G", "-group"}, "docker", "Group for the unix socket")
 	flag.BoolVar(&config.EnableCors, []string{"#api-enable-cors", "#-api-enable-cors"}, false, "Enable CORS headers in the remote API, this is deprecated by --api-cors-header")
 	flag.StringVar(&config.CorsHeaders, []string{"-api-cors-header"}, "", "Set CORS headers in the remote API")
-	opts.IPVar(&config.DefaultIp, []string{"#ip", "-ip"}, "0.0.0.0", "Default IP when binding container ports")
+	opts.IPVar(&config.Bridge.DefaultIp, []string{"#ip", "-ip"}, "0.0.0.0", "Default IP when binding container ports")
 	opts.ListVar(&config.GraphOptions, []string{"-storage-opt"}, "Set storage driver options")
 	// FIXME: why the inconsistency between "hosts" and "sockets"?
 	opts.IPListVar(&config.Dns, []string{"#dns", "-dns"}, "DNS server to use")

daemon/container.go

@@ -24,6 +24,8 @@ import (
 	"github.com/docker/docker/daemon/logger"
 	"github.com/docker/docker/daemon/logger/jsonfilelog"
 	"github.com/docker/docker/daemon/logger/syslog"
+	"github.com/docker/docker/daemon/network"
+	"github.com/docker/docker/daemon/networkdriver/bridge"
 	"github.com/docker/docker/engine"
 	"github.com/docker/docker/image"
 	"github.com/docker/docker/links"
@@ -73,7 +75,7 @@ type Container struct {
 	Config  *runconfig.Config
 	ImageID string `json:"Image"`
 
-	NetworkSettings *NetworkSettings
+	NetworkSettings *network.Settings
 
 	ResolvConfPath string
 	HostnamePath   string
@@ -571,17 +573,12 @@ func (container *Container) AllocateNetwork() error {
 	}
 
 	var (
-		env *engine.Env
 		err error
 		eng = container.daemon.eng
 	)
 
-	job := eng.Job("allocate_interface", container.ID)
-	job.Setenv("RequestedMac", container.Config.MacAddress)
-	if env, err = job.Stdout.AddEnv(); err != nil {
-		return err
-	}
-	if err = job.Run(); err != nil {
+	networkSettings, err := bridge.Allocate(container.ID, container.Config.MacAddress, "", "")
+	if err != nil {
 		return err
 	}
 
@@ -591,12 +588,12 @@ func (container *Container) AllocateNetwork() error {
 
 	if container.Config.PortSpecs != nil {
 		if err = migratePortMappings(container.Config, container.hostConfig); err != nil {
-			eng.Job("release_interface", container.ID).Run()
+			bridge.Release(container.ID)
 			return err
 		}
 		container.Config.PortSpecs = nil
 		if err = container.WriteHostConfig(); err != nil {
-			eng.Job("release_interface", container.ID).Run()
+			bridge.Release(container.ID)
 			return err
 		}
 	}
@@ -626,23 +623,14 @@ func (container *Container) AllocateNetwork() error {
 
 	for port := range portSpecs {
 		if err = container.allocatePort(eng, port, bindings); err != nil {
-			eng.Job("release_interface", container.ID).Run()
+			bridge.Release(container.ID)
 			return err
 		}
 	}
 	container.WriteHostConfig()
 
-	container.NetworkSettings.Ports = bindings
-	container.NetworkSettings.Bridge = env.Get("Bridge")
-	container.NetworkSettings.IPAddress = env.Get("IP")
-	container.NetworkSettings.IPPrefixLen = env.GetInt("IPPrefixLen")
-	container.NetworkSettings.MacAddress = env.Get("MacAddress")
-	container.NetworkSettings.Gateway = env.Get("Gateway")
-	container.NetworkSettings.LinkLocalIPv6Address = env.Get("LinkLocalIPv6")
-	container.NetworkSettings.LinkLocalIPv6PrefixLen = 64
-	container.NetworkSettings.GlobalIPv6Address = env.Get("GlobalIPv6")
-	container.NetworkSettings.GlobalIPv6PrefixLen = env.GetInt("GlobalIPv6PrefixLen")
-	container.NetworkSettings.IPv6Gateway = env.Get("IPv6Gateway")
+	networkSettings.Ports = bindings
+	container.NetworkSettings = networkSettings
 
 	return nil
 }
@@ -651,12 +639,10 @@ func (container *Container) ReleaseNetwork() {
 	if container.Config.NetworkDisabled || !container.hostConfig.NetworkMode.IsPrivate() {
 		return
 	}
-	eng := container.daemon.eng
 
-	job := eng.Job("release_interface", container.ID)
-	job.SetenvBool("overrideShutdown", true)
-	job.Run()
-	container.NetworkSettings = &NetworkSettings{}
+	bridge.Release(container.ID)
+
+	container.NetworkSettings = &network.Settings{}
 }
 
 func (container *Container) isNetworkAllocated() bool {
@@ -675,10 +661,7 @@ func (container *Container) RestoreNetwork() error {
 	eng := container.daemon.eng
 
 	// Re-allocate the interface with the same IP and MAC address.
-	job := eng.Job("allocate_interface", container.ID)
-	job.Setenv("RequestedIP", container.NetworkSettings.IPAddress)
-	job.Setenv("RequestedMac", container.NetworkSettings.MacAddress)
-	if err := job.Run(); err != nil {
+	if _, err := bridge.Allocate(container.ID, container.NetworkSettings.MacAddress, container.NetworkSettings.IPAddress, ""); err != nil {
 		return err
 	}
 
@@ -1077,7 +1060,7 @@ func (container *Container) setupContainerDns() error {
 			latestResolvConf, latestHash := resolvconf.GetLastModified()
 
 			// clean container resolv.conf re: localhost nameservers and IPv6 NS (if IPv6 disabled)
-			updatedResolvConf, modified := resolvconf.FilterResolvDns(latestResolvConf, container.daemon.config.EnableIPv6)
+			updatedResolvConf, modified := resolvconf.FilterResolvDns(latestResolvConf, container.daemon.config.Bridge.EnableIPv6)
 			if modified {
 				// changes have occurred during resolv.conf localhost cleanup: generate an updated hash
 				newHash, err := utils.HashData(bytes.NewReader(updatedResolvConf))
@@ -1131,7 +1114,7 @@ func (container *Container) setupContainerDns() error {
 		}
 
 		// replace any localhost/127.*, and remove IPv6 nameservers if IPv6 disabled in daemon
-		resolvConf, _ = resolvconf.FilterResolvDns(resolvConf, daemon.config.EnableIPv6)
+		resolvConf, _ = resolvconf.FilterResolvDns(resolvConf, daemon.config.Bridge.EnableIPv6)
 	}
 	//get a sha256 hash of the resolv conf at this point so we can check
 	//for changes when the host resolv.conf changes (e.g. network update)
@@ -1481,24 +1464,10 @@ func (container *Container) allocatePort(eng *engine.Engine, port nat.Port, bind
 	}
 
 	for i := 0; i < len(binding); i++ {
-		b := binding[i]
-
-		job := eng.Job("allocate_port", container.ID)
-		job.Setenv("HostIP", b.HostIp)
-		job.Setenv("HostPort", b.HostPort)
-		job.Setenv("Proto", port.Proto())
-		job.Setenv("ContainerPort", port.Port())
-
-		portEnv, err := job.Stdout.AddEnv()
+		b, err := bridge.AllocatePort(container.ID, port, binding[i])
 		if err != nil {
 			return err
 		}
-		if err := job.Run(); err != nil {
-			return err
-		}
-		b.HostIp = portEnv.Get("HostIP")
-		b.HostPort = portEnv.Get("HostPort")
-
 		binding[i] = b
 	}
 	bindings[port] = binding