kotovalexarian-likes-github
/
moby--moby
mirror of https://github.com/moby/moby.git
1
0
Fork 0
Code Releases Activity

Merge pull request #560 from mavenugo/adb 

Flip the default for the flag AllowNonDefaultBridge in bridge driver
This commit is contained in:
Jana Radhakrishnan 2015-09-24 18:02:12 -07:00
parent ffb13d6e8d a42e5f0663
commit 51699b91aa
12 changed files with 80 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libnetwork/api/api.go
View File

@ -291,9 +291,6 @@ func processCreateDefaults(c libnetwork.NetworkController, nc *networkCreate) {
if _, ok := gData["BridgeName"]; !ok {
gData["BridgeName"] = nc.Name
}
if _, ok := gData["AllowNonDefaultBridge"]; !ok {
gData["AllowNonDefaultBridge"] = "true"
}
nc.Options[netlabel.GenericData] = genericData
}
}

34
libnetwork/api/api_test.go
View File

@ -96,8 +96,7 @@ func createTestNetwork(t *testing.T, network string) (libnetwork.NetworkControll
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": network,
"AllowNonDefaultBridge": true,
"BridgeName": network,
},
}
netGeneric := libnetwork.NetworkOptionGeneric(netOption)
@ -212,10 +211,9 @@ func TestCreateDeleteNetwork(t *testing.T) {
ops := options.Generic{
netlabel.EnableIPv6: true,
netlabel.GenericData: map[string]string{
"BridgeName": "abc",
"AllowNonDefaultBridge": "true",
"FixedCIDRv6": "fe80::1/64",
"AddressIP": "172.28.30.254/24",
"BridgeName": "abc",
"FixedCIDRv6": "fe80::1/64",
"AddressIP": "172.28.30.254/24",
},
}
nc := networkCreate{Name: "network_1", NetworkType: bridgeNetType, Options: ops}
@ -259,8 +257,7 @@ func TestGetNetworksAndEndpoints(t *testing.T) {
ops := options.Generic{
netlabel.GenericData: map[string]string{
"BridgeName": "api_test_nw",
"AllowNonDefaultBridge": "true",
"BridgeName": "api_test_nw",
},
}
@ -531,8 +528,7 @@ func TestProcGetServices(t *testing.T) {
netName1 := "production"
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": netName1,
"AllowNonDefaultBridge": true,
"BridgeName": netName1,
},
}
nw1, err := c.NewNetwork(bridgeNetType, netName1, libnetwork.NetworkOptionGeneric(netOption))
@ -543,8 +539,7 @@ func TestProcGetServices(t *testing.T) {
netName2 := "work-dev"
netOption = options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": netName2,
"AllowNonDefaultBridge": true,
"BridgeName": netName2,
},
}
nw2, err := c.NewNetwork(bridgeNetType, netName2, libnetwork.NetworkOptionGeneric(netOption))
@ -1781,14 +1776,13 @@ func TestEndToEnd(t *testing.T) {
ops := options.Generic{
netlabel.EnableIPv6: true,
netlabel.GenericData: map[string]string{
"BridgeName": "cdef",
"FixedCIDRv6": "fe80:2000::1/64",
"EnableIPv6": "true",
"Mtu": "1460",
"EnableIPTables": "true",
"AddressIP": "172.28.30.254/16",
"EnableUserlandProxy": "true",
"AllowNonDefaultBridge": "true",
"BridgeName": "cdef",
"FixedCIDRv6": "fe80:2000::1/64",
"EnableIPv6": "true",
"Mtu": "1460",
"EnableIPTables": "true",
"AddressIP": "172.28.30.254/16",
"EnableUserlandProxy": "true",
},
}

3
libnetwork/cmd/dnet/dnet.go
View File

@ -117,8 +117,7 @@ func createDefaultNetwork(c libnetwork.NetworkController) {
// Bridge driver is special due to legacy reasons
if d == "bridge" {
genericOption[netlabel.GenericData] = map[string]interface{}{
"BridgeName": nw,
"AllowNonDefaultBridge": "true",
"BridgeName": nw,
}
networkOption := libnetwork.NetworkOptionGeneric(genericOption)
createOptions = append(createOptions, networkOption)

7
libnetwork/default_gateway.go
View File

@ -94,10 +94,9 @@ func (sb *sandbox) clearDefaultGW() error {
func (c *controller) createGWNetwork() (Network, error) {
netOption := options.Generic{
"BridgeName": libnGWNetwork,
"EnableICC": false,
"AllowNonDefaultBridge": true,
"EnableIPMasquerade": true,
"BridgeName": libnGWNetwork,
"EnableICC": false,
"EnableIPMasquerade": true,
}
n, err := c.NewNetwork("bridge", libnGWNetwork,

10
libnetwork/drivers/bridge/bridge.go
View File

@ -59,7 +59,7 @@ type networkConfiguration struct {
DefaultGatewayIPv4 net.IP
DefaultGatewayIPv6 net.IP
DefaultBindingIP net.IP
AllowNonDefaultBridge bool
DisableBridgeCreation bool
}
// endpointConfiguration represents the user specified configuration for the sandbox endpoint
@ -249,13 +249,13 @@ func (c *networkConfiguration) fromMap(data map[string]interface{}) error {
}
}
if i, ok := data["AllowNonDefaultBridge"]; ok && i != nil {
if i, ok := data["DisableBridgeCreation"]; ok && i != nil {
if s, ok := i.(string); ok {
if c.AllowNonDefaultBridge, err = strconv.ParseBool(s); err != nil {
return types.BadRequestErrorf("failed to parse AllowNonDefaultBridge value: %s", err.Error())
if c.DisableBridgeCreation, err = strconv.ParseBool(s); err != nil {
return types.BadRequestErrorf("failed to parse DisableBridgeCreation value: %s", err.Error())
}
} else {
return types.BadRequestErrorf("invalid type for AllowNonDefaultBridge value")
return types.BadRequestErrorf("invalid type for DisableBridgeCreation value")
}
}

10
libnetwork/drivers/bridge/bridge_test.go
View File

@ -123,7 +123,7 @@ func TestCreateFail(t *testing.T) {
t.Fatalf("Failed to setup driver config: %v", err)
}
netconfig := &networkConfiguration{BridgeName: "dummy0"}
netconfig := &networkConfiguration{BridgeName: "dummy0", DisableBridgeCreation: true}
genericOption := make(map[string]interface{})
genericOption[netlabel.GenericData] = netconfig
@ -146,20 +146,20 @@ func TestCreateMultipleNetworks(t *testing.T) {
t.Fatalf("Failed to setup driver config: %v", err)
}
config1 := &networkConfiguration{BridgeName: "net_test_1", AllowNonDefaultBridge: true}
config1 := &networkConfiguration{BridgeName: "net_test_1"}
genericOption = make(map[string]interface{})
genericOption[netlabel.GenericData] = config1
if err := d.CreateNetwork("1", genericOption); err != nil {
t.Fatalf("Failed to create bridge: %v", err)
}
config2 := &networkConfiguration{BridgeName: "net_test_2", AllowNonDefaultBridge: true}
config2 := &networkConfiguration{BridgeName: "net_test_2"}
genericOption[netlabel.GenericData] = config2
if err := d.CreateNetwork("2", genericOption); err != nil {
t.Fatalf("Failed to create bridge: %v", err)
}
config3 := &networkConfiguration{BridgeName: "net_test_3", AllowNonDefaultBridge: true}
config3 := &networkConfiguration{BridgeName: "net_test_3"}
genericOption[netlabel.GenericData] = config3
if err := d.CreateNetwork("3", genericOption); err != nil {
t.Fatalf("Failed to create bridge: %v", err)
@ -168,7 +168,7 @@ func TestCreateMultipleNetworks(t *testing.T) {
// Verify the network isolation rules are installed, each network subnet should appear 4 times
verifyV4INCEntries(d.networks, 4, t)
config4 := &networkConfiguration{BridgeName: "net_test_4", AllowNonDefaultBridge: true}
config4 := &networkConfiguration{BridgeName: "net_test_4"}
genericOption[netlabel.GenericData] = config4
if err := d.CreateNetwork("4", genericOption); err != nil {
t.Fatalf("Failed to create bridge: %v", err)

11
libnetwork/drivers/bridge/errors.go
View File

@ -211,6 +211,17 @@ func (ndbee NonDefaultBridgeExistError) Error() string {
// Forbidden denotes the type of this error
func (ndbee NonDefaultBridgeExistError) Forbidden() {}
// NonDefaultBridgeNeedsIPError is returned when a non-default
// bridge config is passed but it has no ip configured
type NonDefaultBridgeNeedsIPError string
func (ndbee NonDefaultBridgeNeedsIPError) Error() string {
return fmt.Sprintf("bridge device with non default name %s must have a valid IP address", string(ndbee))
}
// Forbidden denotes the type of this error
func (ndbee NonDefaultBridgeNeedsIPError) Forbidden() {}
// FixedCIDRv4Error is returned when fixed-cidrv4 configuration
// failed.
type FixedCIDRv4Error struct {

2
libnetwork/drivers/bridge/setup_device.go
View File

@ -15,7 +15,7 @@ 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 {
if config.BridgeName != DefaultBridgeName && config.DisableBridgeCreation {
return NonDefaultBridgeExistError(config.BridgeName)
}

2
libnetwork/drivers/bridge/setup_device_test.go
View File

@ -33,7 +33,7 @@ func TestSetupNewBridge(t *testing.T) {
func TestSetupNewNonDefaultBridge(t *testing.T) {
defer testutils.SetupTestOSContext(t)()
config := &networkConfiguration{BridgeName: "test0"}
config := &networkConfiguration{BridgeName: "test0", DisableBridgeCreation: true}
br := &bridgeInterface{}
err := setupDevice(config, br)

4
libnetwork/drivers/bridge/setup_ipv4.go
View File

@ -53,8 +53,8 @@ func setupBridgeIPv4(config *networkConfiguration, i *bridgeInterface) error {
// Do not try to configure IPv4 on a non-default bridge unless you are
// specifically asked to do so.
if config.BridgeName != DefaultBridgeName && !config.AllowNonDefaultBridge {
return NonDefaultBridgeExistError(config.BridgeName)
if config.BridgeName != DefaultBridgeName && config.DisableBridgeCreation {
return NonDefaultBridgeNeedsIPError(config.BridgeName)
}
bridgeIPv4, err := electBridgeIPv4(config)

91
libnetwork/libnetwork_test.go
View File

@ -290,14 +290,13 @@ func TestBridge(t *testing.T) {
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AddressIPv4": subnet,
"FixedCIDR": cidr,
"FixedCIDRv6": cidrv6,
"EnableIPv6": true,
"EnableICC": true,
"AllowNonDefaultBridge": true,
"EnableIPMasquerade": true,
"BridgeName": "testnetwork",
"AddressIPv4": subnet,
"FixedCIDR": cidr,
"FixedCIDRv6": cidrv6,
"EnableIPv6": true,
"EnableICC": true,
"EnableIPMasquerade": true,
},
}
@ -391,8 +390,7 @@ func TestNetworkName(t *testing.T) {
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
}
@ -428,8 +426,7 @@ func TestNetworkType(t *testing.T) {
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
}
@ -455,8 +452,7 @@ func TestNetworkID(t *testing.T) {
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
}
@ -481,8 +477,8 @@ func TestDeleteNetworkWithActiveEndpoints(t *testing.T) {
}
netOption := options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true}
"BridgeName": "testnetwork",
}
option := options.Generic{
netlabel.GenericData: netOption,
}
@ -522,8 +518,8 @@ func TestUnknownNetwork(t *testing.T) {
}
netOption := options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true}
"BridgeName": "testnetwork",
}
option := options.Generic{
netlabel.GenericData: netOption,
}
@ -560,9 +556,9 @@ func TestUnknownEndpoint(t *testing.T) {
subnet.IP = ip
netOption := options.Generic{
"BridgeName": "testnetwork",
"AddressIPv4": subnet,
"AllowNonDefaultBridge": true}
"BridgeName": "testnetwork",
"AddressIPv4": subnet,
}
option := options.Generic{
netlabel.GenericData: netOption,
}
@ -604,8 +600,7 @@ func TestNetworkEndpointsWalkers(t *testing.T) {
// Create network 1 and add 2 endpoint: ep11, ep12
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "network1",
"AllowNonDefaultBridge": true,
"BridgeName": "network1",
},
}
@ -677,8 +672,7 @@ func TestNetworkEndpointsWalkers(t *testing.T) {
// Create network 2
netOption = options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "network2",
"AllowNonDefaultBridge": true,
"BridgeName": "network2",
},
}
@ -735,8 +729,7 @@ func TestDuplicateEndpoint(t *testing.T) {
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
}
n, err := createTestNetwork(bridgeNetType, "testnetwork", netOption)
@ -786,8 +779,7 @@ func TestControllerQuery(t *testing.T) {
// Create network 1
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "network1",
"AllowNonDefaultBridge": true,
"BridgeName": "network1",
},
}
net1, err := createTestNetwork(bridgeNetType, "network1", netOption)
@ -803,8 +795,7 @@ func TestControllerQuery(t *testing.T) {
// Create network 2
netOption = options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "network2",
"AllowNonDefaultBridge": true,
"BridgeName": "network2",
},
}
net2, err := createTestNetwork(bridgeNetType, "network2", netOption)
@ -890,8 +881,7 @@ func TestNetworkQuery(t *testing.T) {
// Create network 1 and add 2 endpoint: ep11, ep12
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "network1",
"AllowNonDefaultBridge": true,
"BridgeName": "network1",
},
}
net1, err := createTestNetwork(bridgeNetType, "network1", netOption)
@ -1012,8 +1002,7 @@ func TestEndpointJoin(t *testing.T) {
// Create network 1 and add 2 endpoint: ep11, ep12
n1, err := createTestNetwork(bridgeNetType, "testnetwork1", options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork1",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork1",
},
})
if err != nil {
@ -1123,8 +1112,7 @@ func TestEndpointJoin(t *testing.T) {
n2, err := createTestNetwork(bridgeNetType, "testnetwork2",
options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork2",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork2",
},
})
if err != nil {
@ -1215,8 +1203,7 @@ func externalKeyTest(t *testing.T, reexec bool) {
n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
})
if err != nil {
@ -1365,8 +1352,7 @@ func TestEndpointDeleteWithActiveContainer(t *testing.T) {
n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
})
if err != nil {
@ -1429,8 +1415,7 @@ func TestEndpointMultipleJoins(t *testing.T) {
n, err := createTestNetwork(bridgeNetType, "testmultiple", options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testmultiple",
"AllowNonDefaultBridge": true,
"BridgeName": "testmultiple",
},
})
if err != nil {
@ -1501,8 +1486,7 @@ func TestLeaveAll(t *testing.T) {
n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
})
if err != nil {
@ -1565,8 +1549,7 @@ func TestontainerInvalidLeave(t *testing.T) {
n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
})
if err != nil {
@ -1632,8 +1615,7 @@ func TestEndpointUpdateParent(t *testing.T) {
n, err := createTestNetwork("bridge", "testnetwork", options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
})
if err != nil {
@ -1738,9 +1720,8 @@ func TestEnableIPv6(t *testing.T) {
netOption := options.Generic{
netlabel.EnableIPv6: true,
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"FixedCIDRv6": cidrv6,
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
"FixedCIDRv6": cidrv6,
},
}
@ -1911,8 +1892,7 @@ func TestResolvConf(t *testing.T) {
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "testnetwork",
"AllowNonDefaultBridge": true,
"BridgeName": "testnetwork",
},
}
n, err := createTestNetwork("bridge", "testnetwork", netOption)
@ -2181,8 +2161,7 @@ func createGlobalInstance(t *testing.T) {
netOption := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": "network",
"AllowNonDefaultBridge": true,
"BridgeName": "network",
},
}

6
libnetwork/sandbox_test.go
View File

@ -35,8 +35,7 @@ func getTestEnv(t *testing.T) (NetworkController, Network, Network) {
name1 := "test_nw_1"
netOption1 := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": name1,
"AllowNonDefaultBridge": true,
"BridgeName": name1,
},
}
n1, err := c.NewNetwork(netType, name1, NetworkOptionGeneric(netOption1))
@ -47,8 +46,7 @@ func getTestEnv(t *testing.T) (NetworkController, Network, Network) {
name2 := "test_nw_2"
netOption2 := options.Generic{
netlabel.GenericData: options.Generic{
"BridgeName": name2,
"AllowNonDefaultBridge": true,
"BridgeName": name2,
},
}
n2, err := c.NewNetwork(netType, name2, NetworkOptionGeneric(netOption2))