Merge pull request #2241 from selansen/global_add_pool

Global Default Address Pool support

libnetwork/drivers/bridge/bridge_test.go

@@ -10,7 +10,6 @@ import (
 	"testing"
 
 	"github.com/docker/libnetwork/driverapi"
-	"github.com/docker/libnetwork/ipamutils"
 	"github.com/docker/libnetwork/iptables"
 	"github.com/docker/libnetwork/netlabel"
 	"github.com/docker/libnetwork/netutils"
@@ -20,10 +19,6 @@ import (
 	"github.com/vishvananda/netlink"
 )
 
-func init() {
-	ipamutils.InitNetworks(nil)
-}
-
 func TestEndpointMarshalling(t *testing.T) {
 	ip1, _ := types.ParseCIDR("172.22.0.9/16")
 	ip2, _ := types.ParseCIDR("2001:db8::9")

libnetwork/ipam/allocator.go

@@ -46,8 +46,8 @@ func NewAllocator(lcDs, glDs datastore.DataStore) (*Allocator, error) {
 
 	// Load predefined subnet pools
 	a.predefined = map[string][]*net.IPNet{
-		localAddressSpace:  ipamutils.PredefinedBroadNetworks,
-		globalAddressSpace: ipamutils.PredefinedGranularNetworks,
+		localAddressSpace:  ipamutils.PredefinedLocalScopeDefaultNetworks,
+		globalAddressSpace: ipamutils.PredefinedGlobalScopeDefaultNetworks,
 	}
 
 	// Initialize asIndices map

libnetwork/ipam/allocator_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/docker/libnetwork/bitseq"
 	"github.com/docker/libnetwork/datastore"
 	"github.com/docker/libnetwork/ipamapi"
-	"github.com/docker/libnetwork/ipamutils"
 	_ "github.com/docker/libnetwork/testutils"
 	"github.com/docker/libnetwork/types"
 	"gotest.tools/assert"
@@ -57,7 +56,6 @@ func randomLocalStore(needStore bool) (datastore.DataStore, error) {
 }
 
 func getAllocator(store bool) (*Allocator, error) {
-	ipamutils.InitNetworks(nil)
 	ds, err := randomLocalStore(store)
 	if err != nil {
 		return nil, err

libnetwork/ipams/builtin/builtin_unix.go

@@ -35,7 +35,7 @@ func Init(ic ipamapi.Callback, l, g interface{}) error {
 		}
 	}
 
-	ipamutils.InitNetworks(GetDefaultIPAddressPool())
+	ipamutils.ConfigLocalScopeDefaultNetworks(GetDefaultIPAddressPool())
 
 	a, err := ipam.NewAllocator(localDs, globalDs)
 	if err != nil {

libnetwork/ipams/builtin/builtin_windows.go

@@ -37,7 +37,7 @@ func InitDockerDefault(ic ipamapi.Callback, l, g interface{}) error {
 		}
 	}
 
-	ipamutils.InitNetworks(nil)
+	ipamutils.ConfigLocalScopeDefaultNetworks(nil)
 
 	a, err := ipam.NewAllocator(localDs, globalDs)
 	if err != nil {

libnetwork/ipamutils/utils.go

@@ -5,23 +5,20 @@ import (
 	"fmt"
 	"net"
 	"sync"
-
-	"github.com/sirupsen/logrus"
 )
 
 var (
-	// PredefinedBroadNetworks contains a list of 31 IPv4 private networks with host size 16 and 12
-	// (172.17-31.x.x/16, 192.168.x.x/20) which do not overlap with the networks in `PredefinedGranularNetworks`
-	PredefinedBroadNetworks []*net.IPNet
-	// PredefinedGranularNetworks contains a list of 64K IPv4 private networks with host size 8
-	// (10.x.x.x/24) which do not overlap with the networks in `PredefinedBroadNetworks`
-	PredefinedGranularNetworks []*net.IPNet
-	initNetworksOnce           sync.Once
-
-	defaultBroadNetwork = []*NetworkToSplit{{"172.17.0.0/16", 16}, {"172.18.0.0/16", 16}, {"172.19.0.0/16", 16},
+	// PredefinedLocalScopeDefaultNetworks contains a list of 31 IPv4 private networks with host size 16 and 12
+	// (172.17-31.x.x/16, 192.168.x.x/20) which do not overlap with the networks in `PredefinedGlobalScopeDefaultNetworks`
+	PredefinedLocalScopeDefaultNetworks []*net.IPNet
+	// PredefinedGlobalScopeDefaultNetworks contains a list of 64K IPv4 private networks with host size 8
+	// (10.x.x.x/24) which do not overlap with the networks in `PredefinedLocalScopeDefaultNetworks`
+	PredefinedGlobalScopeDefaultNetworks []*net.IPNet
+	mutex                                sync.Mutex
+	localScopeDefaultNetworks            = []*NetworkToSplit{{"172.17.0.0/16", 16}, {"172.18.0.0/16", 16}, {"172.19.0.0/16", 16},
 		{"172.20.0.0/14", 16}, {"172.24.0.0/14", 16}, {"172.28.0.0/14", 16},
 		{"192.168.0.0/16", 20}}
-	defaultGranularNetwork = []*NetworkToSplit{{"10.0.0.0/8", 24}}
+	globalScopeDefaultNetworks = []*NetworkToSplit{{"10.0.0.0/8", 24}}
 )
 
 // NetworkToSplit represent a network that has to be split in chunks with mask length Size.
@@ -34,19 +31,47 @@ type NetworkToSplit struct {
 	Size int    `json:"size"`
 }
 
-// InitNetworks initializes the broad network pool and the granular network pool
-func InitNetworks(defaultAddressPool []*NetworkToSplit) {
-	initNetworksOnce.Do(func() {
-		// error ingnored should never fail
-		PredefinedGranularNetworks, _ = splitNetworks(defaultGranularNetwork)
-		if defaultAddressPool == nil {
-			defaultAddressPool = defaultBroadNetwork
-		}
-		var err error
-		if PredefinedBroadNetworks, err = splitNetworks(defaultAddressPool); err != nil {
-			logrus.WithError(err).Error("InitAddressPools failed to initialize the default address pool")
-		}
-	})
+func init() {
+	var err error
+	if PredefinedGlobalScopeDefaultNetworks, err = splitNetworks(globalScopeDefaultNetworks); err != nil {
+		//we are going to panic in case of error as we should never get into this state
+		panic("InitAddressPools failed to initialize the global scope default address pool")
+	}
+
+	if PredefinedLocalScopeDefaultNetworks, err = splitNetworks(localScopeDefaultNetworks); err != nil {
+		//we are going to panic in case of error as we should never get into this state
+		panic("InitAddressPools failed to initialize the local scope default address pool")
+	}
+}
+
+// configDefaultNetworks configures local as well global default pool based on input
+func configDefaultNetworks(defaultAddressPool []*NetworkToSplit, result *[]*net.IPNet) error {
+	mutex.Lock()
+	defer mutex.Unlock()
+	defaultNetworks, err := splitNetworks(defaultAddressPool)
+	if err != nil {
+		return err
+	}
+	*result = defaultNetworks
+	return nil
+}
+
+// ConfigGlobalScopeDefaultNetworks configures global default pool.
+// Ideally this will be called from SwarmKit as part of swarm init
+func ConfigGlobalScopeDefaultNetworks(defaultAddressPool []*NetworkToSplit) error {
+	if defaultAddressPool == nil {
+		defaultAddressPool = globalScopeDefaultNetworks
+	}
+	return configDefaultNetworks(defaultAddressPool, &PredefinedGlobalScopeDefaultNetworks)
+}
+
+// ConfigLocalScopeDefaultNetworks configures local default pool.
+// Ideally this will be called during libnetwork init
+func ConfigLocalScopeDefaultNetworks(defaultAddressPool []*NetworkToSplit) error {
+	if defaultAddressPool == nil {
+		return nil
+	}
+	return configDefaultNetworks(defaultAddressPool, &PredefinedLocalScopeDefaultNetworks)
 }
 
 // splitNetworks takes a slice of networks, split them accordingly and returns them

libnetwork/ipamutils/utils_test.go

@@ -2,7 +2,6 @@ package ipamutils
 
 import (
 	"net"
-	"sync"
 	"testing"
 
 	_ "github.com/docker/libnetwork/testutils"
@@ -34,15 +33,25 @@ func initGranularPredefinedNetworks() []*net.IPNet {
 	return pl
 }
 
+func initGlobalScopeNetworks() []*net.IPNet {
+	pl := make([]*net.IPNet, 0, 256*256)
+	mask := []byte{255, 255, 255, 0}
+	for i := 0; i < 256; i++ {
+		for j := 0; j < 256; j++ {
+			pl = append(pl, &net.IPNet{IP: []byte{30, byte(i), byte(j), 0}, Mask: mask})
+		}
+	}
+	return pl
+}
+
 func TestDefaultNetwork(t *testing.T) {
-	InitNetworks(nil)
-	for _, nw := range PredefinedGranularNetworks {
+	for _, nw := range PredefinedGlobalScopeDefaultNetworks {
 		if ones, bits := nw.Mask.Size(); bits != 32 || ones != 24 {
 			t.Fatalf("Unexpected size for network in granular list: %v", nw)
 		}
 	}
 
-	for _, nw := range PredefinedBroadNetworks {
+	for _, nw := range PredefinedLocalScopeDefaultNetworks {
 		if ones, bits := nw.Mask.Size(); bits != 32 || (ones != 20 && ones != 16) {
 			t.Fatalf("Unexpected size for network in broad list: %v", nw)
 		}
@@ -53,7 +62,7 @@ func TestDefaultNetwork(t *testing.T) {
 	for _, v := range originalBroadNets {
 		m[v.String()] = true
 	}
-	for _, nw := range PredefinedBroadNetworks {
+	for _, nw := range PredefinedLocalScopeDefaultNetworks {
 		_, ok := m[nw.String()]
 		assert.Check(t, ok)
 		delete(m, nw.String())
@@ -67,7 +76,25 @@ func TestDefaultNetwork(t *testing.T) {
 	for _, v := range originalGranularNets {
 		m[v.String()] = true
 	}
-	for _, nw := range PredefinedGranularNetworks {
+	for _, nw := range PredefinedGlobalScopeDefaultNetworks {
+		_, ok := m[nw.String()]
+		assert.Check(t, ok)
+		delete(m, nw.String())
+	}
+
+	assert.Check(t, is.Len(m, 0))
+}
+
+func TestConfigGlobalScopeDefaultNetworks(t *testing.T) {
+	err := ConfigGlobalScopeDefaultNetworks([]*NetworkToSplit{{"30.0.0.0/8", 24}})
+	assert.NilError(t, err)
+
+	originalGlobalScopeNetworks := initGlobalScopeNetworks()
+	m := make(map[string]bool)
+	for _, v := range originalGlobalScopeNetworks {
+		m[v.String()] = true
+	}
+	for _, nw := range PredefinedGlobalScopeDefaultNetworks {
 		_, ok := m[nw.String()]
 		assert.Check(t, ok)
 		delete(m, nw.String())
@@ -77,15 +104,15 @@ func TestDefaultNetwork(t *testing.T) {
 }
 
 func TestInitAddressPools(t *testing.T) {
-	initNetworksOnce = sync.Once{}
-	InitNetworks([]*NetworkToSplit{{"172.80.0.0/16", 24}, {"172.90.0.0/16", 24}})
-
-	// Check for Random IPAddresses in PredefinedBroadNetworks  ex: first , last and middle
-	assert.Check(t, is.Len(PredefinedBroadNetworks, 512), "Failed to find PredefinedBroadNetworks")
-	assert.Check(t, is.Equal(PredefinedBroadNetworks[0].String(), "172.80.0.0/24"))
-	assert.Check(t, is.Equal(PredefinedBroadNetworks[127].String(), "172.80.127.0/24"))
-	assert.Check(t, is.Equal(PredefinedBroadNetworks[255].String(), "172.80.255.0/24"))
-	assert.Check(t, is.Equal(PredefinedBroadNetworks[256].String(), "172.90.0.0/24"))
-	assert.Check(t, is.Equal(PredefinedBroadNetworks[383].String(), "172.90.127.0/24"))
-	assert.Check(t, is.Equal(PredefinedBroadNetworks[511].String(), "172.90.255.0/24"))
+	err := ConfigLocalScopeDefaultNetworks([]*NetworkToSplit{{"172.80.0.0/16", 24}, {"172.90.0.0/16", 24}})
+	assert.NilError(t, err)
+
+	// Check for Random IPAddresses in PredefinedLocalScopeDefaultNetworks  ex: first , last and middle
+	assert.Check(t, is.Len(PredefinedLocalScopeDefaultNetworks, 512), "Failed to find PredefinedLocalScopeDefaultNetworks")
+	assert.Check(t, is.Equal(PredefinedLocalScopeDefaultNetworks[0].String(), "172.80.0.0/24"))
+	assert.Check(t, is.Equal(PredefinedLocalScopeDefaultNetworks[127].String(), "172.80.127.0/24"))
+	assert.Check(t, is.Equal(PredefinedLocalScopeDefaultNetworks[255].String(), "172.80.255.0/24"))
+	assert.Check(t, is.Equal(PredefinedLocalScopeDefaultNetworks[256].String(), "172.90.0.0/24"))
+	assert.Check(t, is.Equal(PredefinedLocalScopeDefaultNetworks[383].String(), "172.90.127.0/24"))
+	assert.Check(t, is.Equal(PredefinedLocalScopeDefaultNetworks[511].String(), "172.90.255.0/24"))
 }

libnetwork/netutils/utils_linux.go

@@ -94,8 +94,8 @@ func ElectInterfaceAddresses(name string) ([]*net.IPNet, []*net.IPNet, error) {
 	}
 
 	if link == nil || len(v4Nets) == 0 {
-		// Choose from predefined broad networks
-		v4Net, err := FindAvailableNetwork(ipamutils.PredefinedBroadNetworks)
+		// Choose from predefined local scope  networks
+		v4Net, err := FindAvailableNetwork(ipamutils.PredefinedLocalScopeDefaultNetworks)
 		if err != nil {
 			return nil, nil, err
 		}

libnetwork/netutils/utils_test.go

@@ -212,15 +212,14 @@ func TestUtilGenerateRandomMAC(t *testing.T) {
 
 func TestNetworkRequest(t *testing.T) {
 	defer testutils.SetupTestOSContext(t)()
-	ipamutils.InitNetworks(nil)
 
-	nw, err := FindAvailableNetwork(ipamutils.PredefinedBroadNetworks)
+	nw, err := FindAvailableNetwork(ipamutils.PredefinedLocalScopeDefaultNetworks)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	var found bool
-	for _, exp := range ipamutils.PredefinedBroadNetworks {
+	for _, exp := range ipamutils.PredefinedLocalScopeDefaultNetworks {
 		if types.CompareIPNet(exp, nw) {
 			found = true
 			break
@@ -231,13 +230,13 @@ func TestNetworkRequest(t *testing.T) {
 		t.Fatalf("Found unexpected broad network %s", nw)
 	}
 
-	nw, err = FindAvailableNetwork(ipamutils.PredefinedGranularNetworks)
+	nw, err = FindAvailableNetwork(ipamutils.PredefinedGlobalScopeDefaultNetworks)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	found = false
-	for _, exp := range ipamutils.PredefinedGranularNetworks {
+	for _, exp := range ipamutils.PredefinedGlobalScopeDefaultNetworks {
 		if types.CompareIPNet(exp, nw) {
 			found = true
 			break
@@ -255,7 +254,7 @@ func TestNetworkRequest(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	nw, err = FindAvailableNetwork(ipamutils.PredefinedBroadNetworks)
+	nw, err = FindAvailableNetwork(ipamutils.PredefinedLocalScopeDefaultNetworks)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -266,7 +265,6 @@ func TestNetworkRequest(t *testing.T) {
 
 func TestElectInterfaceAddressMultipleAddresses(t *testing.T) {
 	defer testutils.SetupTestOSContext(t)()
-	ipamutils.InitNetworks(nil)
 
 	nws := []string{"172.101.202.254/16", "172.102.202.254/16"}
 	createInterface(t, "test", nws...)
@@ -303,7 +301,6 @@ func TestElectInterfaceAddressMultipleAddresses(t *testing.T) {
 
 func TestElectInterfaceAddress(t *testing.T) {
 	defer testutils.SetupTestOSContext(t)()
-	ipamutils.InitNetworks(nil)
 
 	nws := "172.101.202.254/16"
 	createInterface(t, "test", nws)