Moved most of the driver configuration to network configuration.

Signed-off-by: Jana Radhakrishnan <mrjana@docker.com>

libnetwork/drivers/bridge/bridge.go

@@ -31,6 +31,11 @@ var (
 
 // Configuration info for the "bridge" driver.
 type Configuration struct {
+	EnableIPForwarding bool
+}
+
+// NetworkConfiguration for network specific configuration
+type NetworkConfiguration struct {
 	BridgeName            string
 	AddressIPv4           *net.IPNet
 	FixedCIDR             *net.IPNet
@@ -39,12 +44,11 @@ type Configuration struct {
 	EnableIPTables        bool
 	EnableIPMasquerade    bool
 	EnableICC             bool
-	EnableIPForwarding    bool
-	AllowNonDefaultBridge bool
 	Mtu                   int
 	DefaultGatewayIPv4    net.IP
 	DefaultGatewayIPv6    net.IP
 	DefaultBindingIP      net.IP
+	AllowNonDefaultBridge bool
 }
 
 // EndpointConfiguration represents the user specified configuration for the sandbox endpoint
@@ -71,7 +75,8 @@ type bridgeEndpoint struct {
 
 type bridgeNetwork struct {
 	id        types.UUID
-	bridge    *bridgeInterface               // The bridge's L3 interface
+	bridge    *bridgeInterface // The bridge's L3 interface
+	config    *NetworkConfiguration
 	endpoints map[types.UUID]*bridgeEndpoint // key: endpoint id
 	sync.Mutex
 }
@@ -92,9 +97,9 @@ func New() (string, driverapi.Driver) {
 	return networkType, &driver{}
 }
 
-// Validate performs a static validation on the configuration parameters.
+// Validate performs a static validation on the network configuration parameters.
 // Whatever can be assessed a priori before attempting any programming.
-func (c *Configuration) Validate() error {
+func (c *NetworkConfiguration) Validate() error {
 	if c.Mtu < 0 {
 		return ErrInvalidMtu
 	}
@@ -172,12 +177,13 @@ func (d *driver) Config(option map[string]interface{}) error {
 			return ErrInvalidDriverConfig
 		}
 
-		if err := config.Validate(); err != nil {
-			return err
-		}
 		d.config = config
 	}
 
+	if config.EnableIPForwarding {
+		return setupIPForwarding(config)
+	}
+
 	return nil
 }
 
@@ -189,17 +195,40 @@ func (d *driver) getNetwork(id types.UUID) (*bridgeNetwork, error) {
 	return d.network, nil
 }
 
+func parseNetworkOptions(option options.Generic) (*NetworkConfiguration, error) {
+	var config *NetworkConfiguration
+
+	genericData := option[netlabel.GenericData]
+	if genericData != nil {
+		switch opt := genericData.(type) {
+		case options.Generic:
+			opaqueConfig, err := options.GenerateFromModel(opt, &NetworkConfiguration{})
+			if err != nil {
+				return nil, err
+			}
+			config = opaqueConfig.(*NetworkConfiguration)
+		case *NetworkConfiguration:
+			config = opt
+		default:
+			return nil, ErrInvalidNetworkConfig
+		}
+
+		if err := config.Validate(); err != nil {
+			return nil, err
+		}
+	} else {
+		config = &NetworkConfiguration{}
+	}
+
+	return config, nil
+}
+
 // Create a new network using bridge plugin
 func (d *driver) CreateNetwork(id types.UUID, option map[string]interface{}) error {
 	var err error
 
 	// Driver must be configured
 	d.Lock()
-	if d.config == nil {
-		d.Unlock()
-		return ErrInvalidNetworkConfig
-	}
-	config := d.config
 
 	// Sanity checks
 	if d.network != nil {
@@ -209,6 +238,7 @@ func (d *driver) CreateNetwork(id types.UUID, option map[string]interface{}) err
 
 	// Create and set network handler in driver
 	d.network = &bridgeNetwork{id: id, endpoints: make(map[types.UUID]*bridgeEndpoint)}
+	network := d.network
 	d.Unlock()
 
 	// On failure make sure to reset driver network handler to nil
@@ -220,9 +250,15 @@ func (d *driver) CreateNetwork(id types.UUID, option map[string]interface{}) err
 		}
 	}()
 
+	config, err := parseNetworkOptions(option)
+	if err != nil {
+		return err
+	}
+	network.config = config
+
 	// Create or retrieve the bridge L3 interface
 	bridgeIface := newInterface(config)
-	d.network.bridge = bridgeIface
+	network.bridge = bridgeIface
 
 	// Prepare the bridge setup configuration
 	bridgeSetup := newBridgeSetup(config, bridgeIface)
@@ -263,9 +299,6 @@ func (d *driver) CreateNetwork(id types.UUID, option map[string]interface{}) err
 		// Setup IPTables.
 		{config.EnableIPTables, setupIPTables},
 
-		// Setup IP forwarding.
-		{config.EnableIPForwarding, setupIPForwarding},
-
 		// Setup DefaultGatewayIPv4
 		{config.DefaultGatewayIPv4 != nil, setupGatewayIPv4},
 
@@ -336,7 +369,7 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf
 	// Get the network handler and make sure it exists
 	d.Lock()
 	n := d.network
-	config := d.config
+	config := n.config
 	d.Unlock()
 	if n == nil {
 		return nil, driverapi.ErrNoNetwork
@@ -517,7 +550,7 @@ func (d *driver) DeleteEndpoint(nid, eid types.UUID) error {
 	// Get the network handler and make sure it exists
 	d.Lock()
 	n := d.network
-	config := d.config
+	config := n.config
 	d.Unlock()
 	if n == nil {
 		return driverapi.ErrNoNetwork
@@ -630,23 +663,29 @@ func (d *driver) EndpointInfo(nid, eid types.UUID) (map[string]interface{}, erro
 
 // Join method is invoked when a Sandbox is attached to an endpoint.
 func (d *driver) Join(nid, eid types.UUID, sboxKey string, options map[string]interface{}) (*driverapi.JoinInfo, error) {
-	d.Lock()
-	config := d.config
-	d.Unlock()
-	if !config.EnableICC {
+	network, err := d.getNetwork(nid)
+	if err != nil {
+		return nil, err
+	}
+
+	if !network.config.EnableICC {
 		return nil, d.link(nid, eid, options, true)
 	}
+
 	return nil, nil
 }
 
 // Leave method is invoked when a Sandbox detaches from an endpoint.
 func (d *driver) Leave(nid, eid types.UUID, options map[string]interface{}) error {
-	d.Lock()
-	config := d.config
-	d.Unlock()
-	if !config.EnableICC {
+	network, err := d.getNetwork(nid)
+	if err != nil {
+		return err
+	}
+
+	if !network.config.EnableICC {
 		return d.link(nid, eid, options, false)
 	}
+
 	return nil
 }
 
@@ -691,11 +730,9 @@ func (d *driver) link(nid, eid types.UUID, options map[string]interface{}, enabl
 				return err
 			}
 
-			d.Lock()
 			l := newLink(parentEndpoint.intf.Address.IP.String(),
 				endpoint.intf.Address.IP.String(),
-				endpoint.config.ExposedPorts, d.config.BridgeName)
-			d.Unlock()
+				endpoint.config.ExposedPorts, network.config.BridgeName)
 			if enable {
 				err = l.Enable()
 				if err != nil {
@@ -725,11 +762,10 @@ func (d *driver) link(nid, eid types.UUID, options map[string]interface{}, enabl
 		if childEndpoint.config == nil || childEndpoint.config.ExposedPorts == nil {
 			continue
 		}
-		d.Lock()
+
 		l := newLink(endpoint.intf.Address.IP.String(),
 			childEndpoint.intf.Address.IP.String(),
-			childEndpoint.config.ExposedPorts, d.config.BridgeName)
-		d.Unlock()
+			childEndpoint.config.ExposedPorts, network.config.BridgeName)
 		if enable {
 			err = l.Enable()
 			if err != nil {

libnetwork/drivers/bridge/bridge_test.go

@@ -18,13 +18,16 @@ func TestCreateFullOptions(t *testing.T) {
 	_, d := New()
 
 	config := &Configuration{
-		BridgeName:         DefaultBridgeName,
-		EnableIPv6:         true,
-		FixedCIDR:          bridgeNetworks[0],
-		EnableIPTables:     true,
 		EnableIPForwarding: true,
 	}
-	_, config.FixedCIDRv6, _ = net.ParseCIDR("2001:db8::/48")
+
+	netConfig := &NetworkConfiguration{
+		BridgeName:     DefaultBridgeName,
+		EnableIPv6:     true,
+		FixedCIDR:      bridgeNetworks[0],
+		EnableIPTables: true,
+	}
+	_, netConfig.FixedCIDRv6, _ = net.ParseCIDR("2001:db8::/48")
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
@@ -32,7 +35,10 @@ func TestCreateFullOptions(t *testing.T) {
 		t.Fatalf("Failed to setup driver config: %v", err)
 	}
 
-	err := d.CreateNetwork("dummy", nil)
+	netOption := make(map[string]interface{})
+	netOption[netlabel.GenericData] = netConfig
+
+	err := d.CreateNetwork("dummy", netOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
@@ -42,15 +48,11 @@ func TestCreate(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 	_, d := New()
 
-	config := &Configuration{BridgeName: DefaultBridgeName}
+	config := &NetworkConfiguration{BridgeName: DefaultBridgeName}
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	if err := d.CreateNetwork("dummy", nil); err != nil {
+	if err := d.CreateNetwork("dummy", genericOption); err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
 }
@@ -59,15 +61,11 @@ func TestCreateFail(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 	_, d := New()
 
-	config := &Configuration{BridgeName: "dummy0"}
+	config := &NetworkConfiguration{BridgeName: "dummy0"}
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	if err := d.CreateNetwork("dummy", nil); err == nil {
+	if err := d.CreateNetwork("dummy", genericOption); err == nil {
 		t.Fatal("Bridge creation was expected to fail")
 	}
 }
@@ -77,7 +75,7 @@ func TestQueryEndpointInfo(t *testing.T) {
 
 	_, d := New()
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName:     DefaultBridgeName,
 		EnableIPTables: true,
 		EnableICC:      false,
@@ -85,11 +83,7 @@ func TestQueryEndpointInfo(t *testing.T) {
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	err := d.CreateNetwork("net1", nil)
+	err := d.CreateNetwork("net1", genericOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
@@ -138,15 +132,11 @@ func TestCreateLinkWithOptions(t *testing.T) {
 
 	_, d := New()
 
-	config := &Configuration{BridgeName: DefaultBridgeName}
-	driverOptions := make(map[string]interface{})
-	driverOptions[netlabel.GenericData] = config
-
-	if err := d.Config(driverOptions); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
+	config := &NetworkConfiguration{BridgeName: DefaultBridgeName}
+	netOptions := make(map[string]interface{})
+	netOptions[netlabel.GenericData] = config
 
-	err := d.CreateNetwork("net1", nil)
+	err := d.CreateNetwork("net1", netOptions)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
@@ -192,7 +182,7 @@ func TestLinkContainers(t *testing.T) {
 
 	_, d := New()
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName:     DefaultBridgeName,
 		EnableIPTables: true,
 		EnableICC:      false,
@@ -200,11 +190,7 @@ func TestLinkContainers(t *testing.T) {
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	err := d.CreateNetwork("net1", nil)
+	err := d.CreateNetwork("net1", genericOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
@@ -311,7 +297,7 @@ func TestLinkContainers(t *testing.T) {
 func TestValidateConfig(t *testing.T) {
 
 	// Test mtu
-	c := Configuration{Mtu: -2}
+	c := NetworkConfiguration{Mtu: -2}
 	err := c.Validate()
 	if err == nil {
 		t.Fatalf("Failed to detect invalid MTU number")
@@ -328,7 +314,7 @@ func TestValidateConfig(t *testing.T) {
 
 	// Test FixedCIDR
 	_, containerSubnet, _ := net.ParseCIDR("172.27.0.0/16")
-	c = Configuration{
+	c = NetworkConfiguration{
 		AddressIPv4: network,
 		FixedCIDR:   containerSubnet,
 	}
@@ -374,7 +360,7 @@ func TestValidateConfig(t *testing.T) {
 
 	// Test v6 gw
 	_, containerSubnet, _ = net.ParseCIDR("2001:1234:ae:b004::/64")
-	c = Configuration{
+	c = NetworkConfiguration{
 		EnableIPv6:         true,
 		FixedCIDRv6:        containerSubnet,
 		DefaultGatewayIPv6: net.ParseIP("2001:1234:ac:b004::bad:a55"),
@@ -406,7 +392,7 @@ func TestSetDefaultGw(t *testing.T) {
 	gw4[3] = 254
 	gw6 := net.ParseIP("2001:db8:ea9:9abc:b0c4::254")
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName:         DefaultBridgeName,
 		EnableIPv6:         true,
 		FixedCIDRv6:        subnetv6,
@@ -417,11 +403,7 @@ func TestSetDefaultGw(t *testing.T) {
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	err := d.CreateNetwork("dummy", nil)
+	err := d.CreateNetwork("dummy", genericOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}

libnetwork/drivers/bridge/error.go

@@ -39,6 +39,10 @@ var (
 
 	// ErrInvalidMtu is returned when the user provided MTU is not valid.
 	ErrInvalidMtu = errors.New("invalid MTU number")
+
+	// ErrIPFwdCfg is returned when ip forwarding setup is invoked when the configuration
+	// not enabled.
+	ErrIPFwdCfg = errors.New("unexpected request to enable IP Forwarding")
 )
 
 // ErrInvalidPort is returned when the container or host port specified in the port binding is not valid.
@@ -133,12 +137,6 @@ func (fcv6 *FixedCIDRv6Error) Error() string {
 	return fmt.Sprintf("setup FixedCIDRv6 failed for subnet %s in %s: %v", fcv6.net, fcv6.net, fcv6.err)
 }
 
-type ipForwardCfgError bridgeInterface
-
-func (i *ipForwardCfgError) Error() string {
-	return fmt.Sprintf("unexpected request to enable IP Forwarding for: %v", *i)
-}
-
 type ipTableCfgError string
 
 func (name ipTableCfgError) Error() string {

libnetwork/drivers/bridge/interface.go

@@ -25,7 +25,7 @@ type bridgeInterface struct {
 // an already existing device identified by the Configuration BridgeName field,
 // or the default bridge name when unspecified), but doesn't attempt to create
 // one when missing
-func newInterface(config *Configuration) *bridgeInterface {
+func newInterface(config *NetworkConfiguration) *bridgeInterface {
 	i := &bridgeInterface{}
 
 	// Initialize the bridge name to the default if unspecified.

libnetwork/drivers/bridge/interface_test.go

@@ -10,7 +10,7 @@ import (
 func TestInterfaceDefaultName(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	config := &Configuration{}
+	config := &NetworkConfiguration{}
 	if _ = newInterface(config); config.BridgeName != DefaultBridgeName {
 		t.Fatalf("Expected default interface name %q, got %q", DefaultBridgeName, config.BridgeName)
 	}
@@ -19,7 +19,7 @@ func TestInterfaceDefaultName(t *testing.T) {
 func TestAddressesEmptyInterface(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	inf := newInterface(&Configuration{})
+	inf := newInterface(&NetworkConfiguration{})
 	addrv4, addrsv6, err := inf.addresses()
 	if err != nil {
 		t.Fatalf("Failed to get addresses of default interface: %v", err)

libnetwork/drivers/bridge/network_test.go

@@ -15,18 +15,15 @@ func TestLinkCreate(t *testing.T) {
 	dr := d.(*driver)
 
 	mtu := 1490
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName: DefaultBridgeName,
 		Mtu:        mtu,
 		EnableIPv6: true,
 	}
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
 
-	err := d.CreateNetwork("dummy", nil)
+	err := d.CreateNetwork("dummy", genericOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
@@ -102,16 +99,13 @@ func TestLinkCreateTwo(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 	_, d := New()
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName: DefaultBridgeName,
 		EnableIPv6: true}
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
 
-	err := d.CreateNetwork("dummy", nil)
+	err := d.CreateNetwork("dummy", genericOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
@@ -135,16 +129,12 @@ func TestLinkCreateNoEnableIPv6(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 	_, d := New()
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName: DefaultBridgeName}
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	err := d.CreateNetwork("dummy", nil)
+	err := d.CreateNetwork("dummy", genericOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
@@ -168,17 +158,13 @@ func TestLinkDelete(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 	_, d := New()
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName: DefaultBridgeName,
 		EnableIPv6: true}
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = config
 
-	if err := d.Config(genericOption); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	err := d.CreateNetwork("dummy", nil)
+	err := d.CreateNetwork("dummy", genericOption)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}

libnetwork/drivers/bridge/port_mapping_test.go

@@ -27,18 +27,14 @@ func TestPortMappingConfig(t *testing.T) {
 	epOptions := make(map[string]interface{})
 	epOptions[netlabel.PortMap] = portBindings
 
-	driverConfig := &Configuration{
+	netConfig := &NetworkConfiguration{
 		BridgeName:     DefaultBridgeName,
 		EnableIPTables: true,
 	}
-	driverOptions := make(map[string]interface{})
-	driverOptions[netlabel.GenericData] = driverConfig
+	netOptions := make(map[string]interface{})
+	netOptions[netlabel.GenericData] = netConfig
 
-	if err := d.Config(driverOptions); err != nil {
-		t.Fatalf("Failed to setup driver config: %v", err)
-	}
-
-	err := d.CreateNetwork("dummy", nil)
+	err := d.CreateNetwork("dummy", netOptions)
 	if err != nil {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}

libnetwork/drivers/bridge/setup.go

@@ -1,14 +1,14 @@
 package bridge
 
-type setupStep func(*Configuration, *bridgeInterface) error
+type setupStep func(*NetworkConfiguration, *bridgeInterface) error
 
 type bridgeSetup struct {
-	config *Configuration
+	config *NetworkConfiguration
 	bridge *bridgeInterface
 	steps  []setupStep
 }
 
-func newBridgeSetup(c *Configuration, i *bridgeInterface) *bridgeSetup {
+func newBridgeSetup(c *NetworkConfiguration, i *bridgeInterface) *bridgeSetup {
 	return &bridgeSetup{config: c, bridge: i}
 }
 

libnetwork/drivers/bridge/setup_device.go

@@ -8,7 +8,7 @@ import (
 )
 
 // SetupDevice create a new bridge interface/
-func setupDevice(config *Configuration, i *bridgeInterface) error {
+func setupDevice(config *NetworkConfiguration, i *bridgeInterface) error {
 	// We only attempt to create the bridge when the requested device name is
 	// the default one.
 	if config.BridgeName != DefaultBridgeName && !config.AllowNonDefaultBridge {
@@ -35,7 +35,7 @@ func setupDevice(config *Configuration, i *bridgeInterface) error {
 }
 
 // SetupDeviceUp ups the given bridge interface.
-func setupDeviceUp(config *Configuration, i *bridgeInterface) error {
+func setupDeviceUp(config *NetworkConfiguration, i *bridgeInterface) error {
 	err := netlink.LinkSetUp(i.Link)
 	if err != nil {
 		return err

libnetwork/drivers/bridge/setup_device_test.go

@@ -12,7 +12,7 @@ import (
 func TestSetupNewBridge(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	config := &Configuration{BridgeName: DefaultBridgeName}
+	config := &NetworkConfiguration{BridgeName: DefaultBridgeName}
 	br := &bridgeInterface{}
 
 	if err := setupDevice(config, br); err != nil {
@@ -32,7 +32,7 @@ func TestSetupNewBridge(t *testing.T) {
 func TestSetupNewNonDefaultBridge(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	config := &Configuration{BridgeName: "test0"}
+	config := &NetworkConfiguration{BridgeName: "test0"}
 	br := &bridgeInterface{}
 
 	err := setupDevice(config, br)
@@ -48,7 +48,7 @@ func TestSetupNewNonDefaultBridge(t *testing.T) {
 func TestSetupDeviceUp(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	config := &Configuration{BridgeName: DefaultBridgeName}
+	config := &NetworkConfiguration{BridgeName: DefaultBridgeName}
 	br := &bridgeInterface{}
 
 	if err := setupDevice(config, br); err != nil {

libnetwork/drivers/bridge/setup_fixedcidrv4.go

@@ -2,7 +2,7 @@ package bridge
 
 import log "github.com/Sirupsen/logrus"
 
-func setupFixedCIDRv4(config *Configuration, i *bridgeInterface) error {
+func setupFixedCIDRv4(config *NetworkConfiguration, i *bridgeInterface) error {
 	addrv4, _, err := i.addresses()
 	if err != nil {
 		return err

libnetwork/drivers/bridge/setup_fixedcidrv4_test.go

@@ -10,7 +10,7 @@ import (
 func TestSetupFixedCIDRv4(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName:  DefaultBridgeName,
 		AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(16, 32)},
 		FixedCIDR:   &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)}}
@@ -37,7 +37,7 @@ func TestSetupFixedCIDRv4(t *testing.T) {
 func TestSetupBadFixedCIDRv4(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName:  DefaultBridgeName,
 		AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(24, 32)},
 		FixedCIDR:   &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)}}

libnetwork/drivers/bridge/setup_fixedcidrv6.go

@@ -2,7 +2,7 @@ package bridge
 
 import log "github.com/Sirupsen/logrus"
 
-func setupFixedCIDRv6(config *Configuration, i *bridgeInterface) error {
+func setupFixedCIDRv6(config *NetworkConfiguration, i *bridgeInterface) error {
 	log.Debugf("Using IPv6 subnet: %v", config.FixedCIDRv6)
 	if err := ipAllocator.RegisterSubnet(config.FixedCIDRv6, config.FixedCIDRv6); err != nil {
 		return &FixedCIDRv6Error{net: config.FixedCIDRv6, err: err}

libnetwork/drivers/bridge/setup_fixedcidrv6_test.go

@@ -10,7 +10,7 @@ import (
 func TestSetupFixedCIDRv6(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	config := &Configuration{}
+	config := &NetworkConfiguration{}
 	br := newInterface(config)
 
 	_, config.FixedCIDRv6, _ = net.ParseCIDR("2002:db8::/48")

libnetwork/drivers/bridge/setup_ip_forwarding.go

@@ -10,10 +10,10 @@ const (
 	ipv4ForwardConfPerm = 0644
 )
 
-func setupIPForwarding(config *Configuration, i *bridgeInterface) error {
+func setupIPForwarding(config *Configuration) error {
 	// Sanity Check
 	if config.EnableIPForwarding == false {
-		return (*ipForwardCfgError)(i)
+		return ErrIPFwdCfg
 	}
 
 	// Enable IPv4 forwarding

libnetwork/drivers/bridge/setup_ip_forwarding_test.go

@@ -18,12 +18,10 @@ func TestSetupIPForwarding(t *testing.T) {
 
 	// Create test interface with ip forwarding setting enabled
 	config := &Configuration{
-		BridgeName:         DefaultBridgeName,
 		EnableIPForwarding: true}
-	br := &bridgeInterface{}
 
 	// Set IP Forwarding
-	if err := setupIPForwarding(config, br); err != nil {
+	if err := setupIPForwarding(config); err != nil {
 		t.Fatalf("Failed to setup IP forwarding: %v", err)
 	}
 
@@ -41,17 +39,15 @@ func TestUnexpectedSetupIPForwarding(t *testing.T) {
 
 	// Create test interface without ip forwarding setting enabled
 	config := &Configuration{
-		BridgeName:         DefaultBridgeName,
 		EnableIPForwarding: false}
-	br := &bridgeInterface{}
 
 	// Attempt Set IP Forwarding
-	err := setupIPForwarding(config, br)
+	err := setupIPForwarding(config)
 	if err == nil {
 		t.Fatal("Setup IP forwarding was expected to fail")
 	}
 
-	if _, ok := err.(*ipForwardCfgError); !ok {
+	if err != ErrIPFwdCfg {
 		t.Fatalf("Setup IP forwarding failed with unexpected error: %v", err)
 	}
 }

libnetwork/drivers/bridge/setup_ip_tables.go

@@ -13,7 +13,7 @@ const (
 	DockerChain = "DOCKER"
 )
 
-func setupIPTables(config *Configuration, i *bridgeInterface) error {
+func setupIPTables(config *NetworkConfiguration, i *bridgeInterface) error {
 	// Sanity check.
 	if config.EnableIPTables == false {
 		return ipTableCfgError(config.BridgeName)

libnetwork/drivers/bridge/setup_ip_tables_test.go

@@ -58,14 +58,14 @@ func TestSetupIPTables(t *testing.T) {
 	assertBridgeConfig(config, br, t)
 }
 
-func getBasicTestConfig() *Configuration {
-	config := &Configuration{
+func getBasicTestConfig() *NetworkConfiguration {
+	config := &NetworkConfiguration{
 		BridgeName:  DefaultBridgeName,
 		AddressIPv4: &net.IPNet{IP: net.ParseIP(iptablesTestBridgeIP), Mask: net.CIDRMask(16, 32)}}
 	return config
 }
 
-func createTestBridge(config *Configuration, br *bridgeInterface, t *testing.T) {
+func createTestBridge(config *NetworkConfiguration, br *bridgeInterface, t *testing.T) {
 	if err := setupDevice(config, br); err != nil {
 		t.Fatalf("Failed to create the testing Bridge: %s", err.Error())
 	}
@@ -94,7 +94,7 @@ func assertIPTableChainProgramming(rule iptRule, descr string, t *testing.T) {
 }
 
 // Assert function which pushes chains based on bridge config parameters.
-func assertBridgeConfig(config *Configuration, br *bridgeInterface, t *testing.T) {
+func assertBridgeConfig(config *NetworkConfiguration, br *bridgeInterface, t *testing.T) {
 	// Attempt programming of ip tables.
 	err := setupIPTables(config, br)
 	if err != nil {

libnetwork/drivers/bridge/setup_ipv4.go

@@ -40,7 +40,7 @@ func init() {
 	}
 }
 
-func setupBridgeIPv4(config *Configuration, i *bridgeInterface) error {
+func setupBridgeIPv4(config *NetworkConfiguration, i *bridgeInterface) error {
 	addrv4, _, err := i.addresses()
 	if err != nil {
 		return err
@@ -77,12 +77,12 @@ func setupBridgeIPv4(config *Configuration, i *bridgeInterface) error {
 	return nil
 }
 
-func allocateBridgeIP(config *Configuration, i *bridgeInterface) error {
+func allocateBridgeIP(config *NetworkConfiguration, i *bridgeInterface) error {
 	ipAllocator.RequestIP(i.bridgeIPv4, i.bridgeIPv4.IP)
 	return nil
 }
 
-func electBridgeIPv4(config *Configuration) (*net.IPNet, error) {
+func electBridgeIPv4(config *NetworkConfiguration) (*net.IPNet, error) {
 	// Use the requested IPv4 CIDR when available.
 	if config.AddressIPv4 != nil {
 		return config.AddressIPv4, nil
@@ -108,7 +108,7 @@ func electBridgeIPv4(config *Configuration) (*net.IPNet, error) {
 	return nil, IPv4AddrRangeError(config.BridgeName)
 }
 
-func setupGatewayIPv4(config *Configuration, i *bridgeInterface) error {
+func setupGatewayIPv4(config *NetworkConfiguration, i *bridgeInterface) error {
 	if !i.bridgeIPv4.Contains(config.DefaultGatewayIPv4) {
 		return ErrInvalidGateway
 	}

libnetwork/drivers/bridge/setup_ipv4_test.go

@@ -8,8 +8,8 @@ import (
 	"github.com/vishvananda/netlink"
 )
 
-func setupTestInterface(t *testing.T) (*Configuration, *bridgeInterface) {
-	config := &Configuration{
+func setupTestInterface(t *testing.T) (*NetworkConfiguration, *bridgeInterface) {
+	config := &NetworkConfiguration{
 		BridgeName: DefaultBridgeName}
 	br := &bridgeInterface{}
 
@@ -84,7 +84,7 @@ func TestSetupGatewayIPv4(t *testing.T) {
 	nw.IP = ip
 	gw := net.ParseIP("192.168.0.254")
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName:         DefaultBridgeName,
 		DefaultGatewayIPv4: gw}
 

libnetwork/drivers/bridge/setup_ipv6.go

@@ -22,7 +22,7 @@ func init() {
 	}
 }
 
-func setupBridgeIPv6(config *Configuration, i *bridgeInterface) error {
+func setupBridgeIPv6(config *NetworkConfiguration, i *bridgeInterface) error {
 	// Enable IPv6 on the bridge
 	procFile := "/proc/sys/net/ipv6/conf/" + config.BridgeName + "/disable_ipv6"
 	if err := ioutil.WriteFile(procFile, []byte{'0', '\n'}, 0644); err != nil {
@@ -47,7 +47,7 @@ func setupBridgeIPv6(config *Configuration, i *bridgeInterface) error {
 	return nil
 }
 
-func setupGatewayIPv6(config *Configuration, i *bridgeInterface) error {
+func setupGatewayIPv6(config *NetworkConfiguration, i *bridgeInterface) error {
 	if config.FixedCIDRv6 == nil {
 		return ErrInvalidContainerSubnet
 	}

libnetwork/drivers/bridge/setup_ipv6_test.go

@@ -53,7 +53,7 @@ func TestSetupGatewayIPv6(t *testing.T) {
 	_, nw, _ := net.ParseCIDR("2001:db8:ea9:9abc:ffff::/80")
 	gw := net.ParseIP("2001:db8:ea9:9abc:ffff::254")
 
-	config := &Configuration{
+	config := &NetworkConfiguration{
 		BridgeName:         DefaultBridgeName,
 		FixedCIDRv6:        nw,
 		DefaultGatewayIPv6: gw}

libnetwork/drivers/bridge/setup_verify.go

@@ -2,7 +2,7 @@ package bridge
 
 import "github.com/vishvananda/netlink"
 
-func setupVerifyAndReconcile(config *Configuration, i *bridgeInterface) error {
+func setupVerifyAndReconcile(config *NetworkConfiguration, i *bridgeInterface) error {
 	// Fetch a single IPv4 and a slice of IPv6 addresses from the bridge.
 	addrv4, addrsv6, err := i.addresses()
 	if err != nil {

libnetwork/drivers/bridge/setup_verify_test.go

@@ -27,7 +27,7 @@ func TestSetupVerify(t *testing.T) {
 
 	addrv4 := net.IPv4(192, 168, 1, 1)
 	inf := setupVerifyTest(t)
-	config := &Configuration{}
+	config := &NetworkConfiguration{}
 	config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()}
 
 	if err := netlink.AddrAdd(inf.Link, &netlink.Addr{IPNet: config.AddressIPv4}); err != nil {
@@ -44,7 +44,7 @@ func TestSetupVerifyBad(t *testing.T) {
 
 	addrv4 := net.IPv4(192, 168, 1, 1)
 	inf := setupVerifyTest(t)
-	config := &Configuration{}
+	config := &NetworkConfiguration{}
 	config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()}
 
 	ipnet := &net.IPNet{IP: net.IPv4(192, 168, 1, 2), Mask: addrv4.DefaultMask()}
@@ -62,7 +62,7 @@ func TestSetupVerifyMissing(t *testing.T) {
 
 	addrv4 := net.IPv4(192, 168, 1, 1)
 	inf := setupVerifyTest(t)
-	config := &Configuration{}
+	config := &NetworkConfiguration{}
 	config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()}
 
 	if err := setupVerifyAndReconcile(config, inf); err == nil {
@@ -75,7 +75,7 @@ func TestSetupVerifyIPv6(t *testing.T) {
 
 	addrv4 := net.IPv4(192, 168, 1, 1)
 	inf := setupVerifyTest(t)
-	config := &Configuration{}
+	config := &NetworkConfiguration{}
 	config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()}
 	config.EnableIPv6 = true
 
@@ -96,7 +96,7 @@ func TestSetupVerifyIPv6Missing(t *testing.T) {
 
 	addrv4 := net.IPv4(192, 168, 1, 1)
 	inf := setupVerifyTest(t)
-	config := &Configuration{}
+	config := &NetworkConfiguration{}
 	config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()}
 	config.EnableIPv6 = true
 

libnetwork/libnetwork_test.go

@@ -25,17 +25,21 @@ func TestMain(m *testing.M) {
 	os.Exit(m.Run())
 }
 
-func createTestNetwork(networkType, networkName string, option options.Generic) (libnetwork.Network, error) {
+func createTestNetwork(networkType, networkName string, option options.Generic, netOption options.Generic) (libnetwork.Network, error) {
 	controller := libnetwork.New()
 	genericOption := make(map[string]interface{})
 	genericOption[netlabel.GenericData] = option
 
+	genericNetOption := make(map[string]interface{})
+	genericNetOption[netlabel.GenericData] = netOption
+
 	err := controller.ConfigureNetworkDriver(networkType, genericOption)
 	if err != nil {
 		return nil, err
 	}
 
-	network, err := controller.NewNetwork(networkType, networkName)
+	network, err := controller.NewNetwork(networkType, networkName,
+		libnetwork.NetworkOptionGeneric(genericNetOption))
 	if err != nil {
 		return nil, err
 	}
@@ -58,7 +62,8 @@ func getPortMapping() []netutils.PortBinding {
 }
 
 func TestNull(t *testing.T) {
-	network, err := createTestNetwork("null", "testnetwork", options.Generic{})
+	network, err := createTestNetwork("null", "testnetwork", options.Generic{},
+		options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -91,7 +96,7 @@ func TestNull(t *testing.T) {
 }
 
 func TestHost(t *testing.T) {
-	network, err := createTestNetwork("host", "testnetwork", options.Generic{})
+	network, err := createTestNetwork("host", "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -146,6 +151,10 @@ func TestBridge(t *testing.T) {
 
 	log.Debug("Adding a bridge")
 	option := options.Generic{
+		"EnableIPForwarding": true,
+	}
+
+	netOption := options.Generic{
 		"BridgeName":            bridgeName,
 		"AddressIPv4":           subnet,
 		"FixedCIDR":             cidr,
@@ -154,10 +163,9 @@ func TestBridge(t *testing.T) {
 		"EnableIPTables":        true,
 		"EnableIPMasquerade":    true,
 		"EnableICC":             true,
-		"EnableIPForwarding":    true,
 		"AllowNonDefaultBridge": true}
 
-	network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
+	network, err := createTestNetwork(bridgeNetType, "testnetwork", option, netOption)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -195,7 +203,7 @@ func TestBridge(t *testing.T) {
 func TestUnknownDriver(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	_, err := createTestNetwork("unknowndriver", "testnetwork", options.Generic{})
+	_, err := createTestNetwork("unknowndriver", "testnetwork", options.Generic{}, options.Generic{})
 	if err == nil {
 		t.Fatal("Expected to fail. But instead succeeded")
 	}
@@ -245,7 +253,8 @@ func TestDuplicateNetwork(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = controller.NewNetwork(bridgeNetType, "testnetwork", nil)
+	_, err = controller.NewNetwork(bridgeNetType, "testnetwork",
+		libnetwork.NetworkOptionGeneric(genericOption))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -264,7 +273,7 @@ func TestNetworkName(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 	networkName := "testnetwork"
 
-	n, err := createTestNetwork(bridgeNetType, networkName, options.Generic{})
+	n, err := createTestNetwork(bridgeNetType, networkName, options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -276,7 +285,7 @@ func TestNetworkName(t *testing.T) {
 
 func TestNetworkType(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
-	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
+	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -289,7 +298,7 @@ func TestNetworkType(t *testing.T) {
 func TestNetworkID(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
+	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -305,7 +314,7 @@ func TestDeleteNetworkWithActiveEndpoints(t *testing.T) {
 		"BridgeName":            bridgeName,
 		"AllowNonDefaultBridge": true}
 
-	network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
+	network, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, option)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -340,7 +349,7 @@ func TestUnknownNetwork(t *testing.T) {
 		"BridgeName":            bridgeName,
 		"AllowNonDefaultBridge": true}
 
-	network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
+	network, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, option)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -373,7 +382,7 @@ func TestUnknownEndpoint(t *testing.T) {
 		"AddressIPv4":           subnet,
 		"AllowNonDefaultBridge": true}
 
-	network, err := createTestNetwork(bridgeNetType, "testnetwork", option)
+	network, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, option)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -580,7 +589,7 @@ const containerID = "valid_container"
 func TestEndpointJoin(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
+	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -607,7 +616,7 @@ func TestEndpointJoin(t *testing.T) {
 func TestEndpointJoinInvalidContainerId(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
+	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -630,7 +639,7 @@ func TestEndpointJoinInvalidContainerId(t *testing.T) {
 func TestEndpointMultipleJoins(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
+	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -667,7 +676,7 @@ func TestEndpointMultipleJoins(t *testing.T) {
 func TestEndpointInvalidLeave(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{})
+	n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -722,7 +731,7 @@ func TestEndpointInvalidLeave(t *testing.T) {
 func TestEndpointUpdateParent(t *testing.T) {
 	defer netutils.SetupTestNetNS(t)()
 
-	n, err := createTestNetwork("bridge", "testnetwork", options.Generic{})
+	n, err := createTestNetwork("bridge", "testnetwork", options.Generic{}, options.Generic{})
 	if err != nil {
 		t.Fatal(err)
 	}