kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

Moved most of the driver configuration to network configuration.

Browse source 
Signed-off-by: Jana Radhakrishnan <mrjana@docker.com>
This commit is contained in:
Jana Radhakrishnan 2015-05-06 05:51:26 +00:00
parent c9b54861e7
commit 94a9f12280
25 changed files with 184 additions and 181 deletions

102
libnetwork/drivers/bridge/bridge.go
View file

@ -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 {

76
libnetwork/drivers/bridge/bridge_test.go
View file

@ -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
config := &NetworkConfiguration{BridgeName: DefaultBridgeName}
netOptions := make(map[string]interface{})
netOptions[netlabel.GenericData] = config
if err := d.Config(driverOptions); err != nil {
t.Fatalf("Failed to setup driver config: %v", err)
}
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)
}

10
libnetwork/drivers/bridge/error.go
View file

@ -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 {

2
libnetwork/drivers/bridge/interface.go
View file

@ -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.

4
libnetwork/drivers/bridge/interface_test.go
View file

@ -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)

30
libnetwork/drivers/bridge/network_test.go
View file

@ -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)
}

12
libnetwork/drivers/bridge/port_mapping_test.go
View file

@ -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)
}

6
libnetwork/drivers/bridge/setup.go
View file

@ -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}
}

4
libnetwork/drivers/bridge/setup_device.go
View file

@ -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

6
libnetwork/drivers/bridge/setup_device_test.go
View file

@ -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 {

2
libnetwork/drivers/bridge/setup_fixedcidrv4.go
View file

@ -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

4
libnetwork/drivers/bridge/setup_fixedcidrv4_test.go
View file

@ -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)}}

2
libnetwork/drivers/bridge/setup_fixedcidrv6.go
View file

@ -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}

2
libnetwork/drivers/bridge/setup_fixedcidrv6_test.go
View file

@ -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")

4
libnetwork/drivers/bridge/setup_ip_forwarding.go
View file

@ -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

10
libnetwork/drivers/bridge/setup_ip_forwarding_test.go
View file

@ -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)
}
}

2
libnetwork/drivers/bridge/setup_ip_tables.go
View file

@ -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)

8
libnetwork/drivers/bridge/setup_ip_tables_test.go
View file

@ -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 {

8
libnetwork/drivers/bridge/setup_ipv4.go
View file

@ -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
}

6
libnetwork/drivers/bridge/setup_ipv4_test.go
View file

@ -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}

4
libnetwork/drivers/bridge/setup_ipv6.go
View file

@ -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
}

2
libnetwork/drivers/bridge/setup_ipv6_test.go
View file

@ -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}

2
libnetwork/drivers/bridge/setup_verify.go
View file

@ -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 {

10
libnetwork/drivers/bridge/setup_verify_test.go
View file

@ -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

47
libnetwork/libnetwork_test.go
View file

@ -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)
}