@@ -16,8 +16,6 @@ type DiscoveryType int

 const (

 	// NodeDiscovery represents Node join/leave events provided by discovery

 	NodeDiscovery = iota + 1

-	// DatastoreConfig represents an add/remove datastore event

-	DatastoreConfig

 	// EncryptionKeysConfig represents the initial key(s) for performing datapath encryption

 	EncryptionKeysConfig

 	// EncryptionKeysUpdate represents an update to the datapath encryption key(s)

@@ -319,7 +319,6 @@ func (d *driver) pushLocalEndpointEvent(action, nid, eid string) {

 // DiscoverNew is a notification for a new discovery event, such as a new node joining a cluster

 func (d *driver) DiscoverNew(dType discoverapi.DiscoveryType, data interface{}) error {

-	var err error

 	switch dType {

 	case discoverapi.NodeDiscovery:

 		nodeData, ok := data.(discoverapi.NodeDiscoveryData)

@@ -327,18 +326,6 @@ func (d *driver) DiscoverNew(dType discoverapi.DiscoveryType, data interface{})

 			return fmt.Errorf("invalid discovery data")

 		}

 		d.nodeJoin(nodeData.Address, nodeData.BindAddress, nodeData.Self)

-	case discoverapi.DatastoreConfig:

-		if d.store != nil {

-			return types.ForbiddenErrorf("cannot accept datastore configuration: Overlay driver has a datastore configured already")

-		}

-		dsc, ok := data.(discoverapi.DatastoreConfigData)

-		if !ok {

-			return types.InternalErrorf("incorrect data in datastore configuration: %v", data)

-		}

-		d.store, err = datastore.NewDataStoreFromConfig(dsc)

-		if err != nil {

-			return types.InternalErrorf("failed to initialize data store: %v", err)

-		}

 	case discoverapi.EncryptionKeysConfig:

 		encrData, ok := data.(discoverapi.DriverEncryptionConfig)

 		if !ok {

@@ -7,8 +7,6 @@ import (

 	"sync"

 	"github.com/docker/docker/libnetwork/bitseq"

-	"github.com/docker/docker/libnetwork/datastore"

-	"github.com/docker/docker/libnetwork/discoverapi"

 	"github.com/docker/docker/libnetwork/ipamapi"

 	"github.com/docker/docker/libnetwork/types"

 	"github.com/sirupsen/logrus"

@@ -17,9 +15,6 @@ import (

 const (

 	localAddressSpace  = "LocalDefault"

 	globalAddressSpace = "GlobalDefault"

-	// datastore keyes for ipam objects

-	dsConfigKey = "ipam/" + ipamapi.DefaultIPAM + "/config"

-	dsDataKey   = "ipam/" + ipamapi.DefaultIPAM + "/data"

 )

 // Allocator provides per address space ipv4/ipv6 book keeping

@@ -28,168 +23,37 @@ type Allocator struct {

 	// Separate from the addrSpace because they should not be serialized

 	predefined             map[string][]*net.IPNet

 	predefinedStartIndices map[string]int

-	// The (potentially serialized) address spaces

+	// The address spaces

 	addrSpaces map[string]*addrSpace

-	// stores        []datastore.Datastore

 	// Allocated addresses in each address space's subnet

 	addresses map[SubnetKey]*bitseq.Handle

 	sync.Mutex

 }

 // NewAllocator returns an instance of libnetwork ipam

-func NewAllocator(lcDs, glDs datastore.DataStore, lcAs, glAs []*net.IPNet) (*Allocator, error) {

-	a := &Allocator{}

-

-	// Load predefined subnet pools

-

-	a.predefined = map[string][]*net.IPNet{

-		localAddressSpace:  lcAs,

-		globalAddressSpace: glAs,

+func NewAllocator(lcAs, glAs []*net.IPNet) (*Allocator, error) {

+	a := &Allocator{

+		predefined: map[string][]*net.IPNet{

+			localAddressSpace:  lcAs,

+			globalAddressSpace: glAs,

+		},

+		predefinedStartIndices: map[string]int{},

+		addresses:              map[SubnetKey]*bitseq.Handle{},

 	}

-	// Initialize asIndices map

-	a.predefinedStartIndices = make(map[string]int)

-

-	// Initialize bitseq map

-	a.addresses = make(map[SubnetKey]*bitseq.Handle)

-

-	// Initialize address spaces

-	a.addrSpaces = make(map[string]*addrSpace)

-	for _, aspc := range []struct {

-		as string

-		ds datastore.DataStore

-	}{

-		{localAddressSpace, lcDs},

-		{globalAddressSpace, glDs},

-	} {

-		a.initializeAddressSpace(aspc.as, aspc.ds)

+	a.addrSpaces = map[string]*addrSpace{

+		localAddressSpace:  a.newAddressSpace(),

+		globalAddressSpace: a.newAddressSpace(),

 	}

 	return a, nil

 }

-func (a *Allocator) refresh(as string) error {

-	aSpace, err := a.getAddressSpaceFromStore(as)

-	if err != nil {

-		return types.InternalErrorf("error getting pools config from store: %v", err)

-	}

-

-	if aSpace == nil {

-		return nil

-	}

-

-	a.Lock()

-	a.addrSpaces[as] = aSpace

-	a.Unlock()

-

-	return nil

-}

-

-func (a *Allocator) updateBitMasks(aSpace *addrSpace) error {

-	var inserterList []func() error

-

-	aSpace.Lock()

-	for k, v := range aSpace.subnets {

-		if v.Range == nil {

-			kk := k

-			vv := v

-			inserterList = append(inserterList, func() error { return a.insertBitMask(kk, vv.Pool) })

-		}

-	}

-	aSpace.Unlock()

-

-	// Add the bitmasks (data could come from datastore)

-	for _, f := range inserterList {

-		if err := f(); err != nil {

-			return err

-		}

-	}

-

-	return nil

-}

-

-// Checks for and fixes damaged bitmask.

-func (a *Allocator) checkConsistency(as string) {

-	var sKeyList []SubnetKey

-

-	// Retrieve this address space's configuration and bitmasks from the datastore

-	a.refresh(as)

-	a.Lock()

-	aSpace, ok := a.addrSpaces[as]

-	a.Unlock()

-	if !ok {

-		return

-	}

-	a.updateBitMasks(aSpace)

-

-	aSpace.Lock()

-	for sk, pd := range aSpace.subnets {

-		if pd.Range != nil {

-			continue

-		}

-		sKeyList = append(sKeyList, sk)

-	}

-	aSpace.Unlock()

-

-	for _, sk := range sKeyList {

-		a.Lock()

-		bm := a.addresses[sk]

-		a.Unlock()

-		if err := bm.CheckConsistency(); err != nil {

-			logrus.Warnf("Error while running consistency check for %s: %v", sk, err)

-		}

-	}

-}

-

-func (a *Allocator) initializeAddressSpace(as string, ds datastore.DataStore) error {

-	scope := ""

-	if ds != nil {

-		scope = ds.Scope()

-	}

-

-	a.Lock()

-	if currAS, ok := a.addrSpaces[as]; ok {

-		if currAS.ds != nil {

-			a.Unlock()

-			return types.ForbiddenErrorf("a datastore is already configured for the address space %s", as)

-		}

-	}

-	a.addrSpaces[as] = &addrSpace{

+func (a *Allocator) newAddressSpace() *addrSpace {

+	return &addrSpace{

 		subnets: map[SubnetKey]*PoolData{},

-		id:      dsConfigKey + "/" + as,

-		scope:   scope,

-		ds:      ds,

 		alloc:   a,

 	}

-	a.Unlock()

-

-	a.checkConsistency(as)

-

-	return nil

-}

-

-// DiscoverNew informs the allocator about a new global scope datastore

-func (a *Allocator) DiscoverNew(dType discoverapi.DiscoveryType, data interface{}) error {

-	if dType != discoverapi.DatastoreConfig {

-		return nil

-	}

-

-	dsc, ok := data.(discoverapi.DatastoreConfigData)

-	if !ok {

-		return types.InternalErrorf("incorrect data in datastore update notification: %v", data)

-	}

-

-	ds, err := datastore.NewDataStoreFromConfig(dsc)

-	if err != nil {

-		return err

-	}

-

-	return a.initializeAddressSpace(globalAddressSpace, ds)

-}

-

-// DiscoverDelete is a notification of no interest for the allocator

-func (a *Allocator) DiscoverDelete(dType discoverapi.DiscoveryType, data interface{}) error {

-	return nil

 }

 // GetDefaultAddressSpaces returns the local and global default address spaces

@@ -220,10 +84,6 @@ retry:

 		k = &SubnetKey{AddressSpace: addressSpace, Subnet: nw.String()}

 	}

-	if err := a.refresh(addressSpace); err != nil {

-		return "", nil, nil, err

-	}

-

 	aSpace, err := a.getAddrSpace(addressSpace)

 	if err != nil {

 		return "", nil, nil, err

@@ -238,14 +98,6 @@ retry:

 		return "", nil, nil, err

 	}

-	if err := a.writeToStore(aSpace); err != nil {

-		if _, ok := err.(types.RetryError); !ok {

-			return "", nil, nil, types.InternalErrorf("pool configuration failed because of %s", err.Error())

-		}

-

-		goto retry

-	}

-

 	return k.String(), nw, nil, insert()

 }

@@ -257,11 +109,6 @@ func (a *Allocator) ReleasePool(poolID string) error {

 		return types.BadRequestErrorf("invalid pool id: %s", poolID)

 	}

-retry:

-	if err := a.refresh(k.AddressSpace); err != nil {

-		return err

-	}

-

 	aSpace, err := a.getAddrSpace(k.AddressSpace)

 	if err != nil {

 		return err

@@ -272,13 +119,6 @@ retry:

 		return err

 	}

-	if err = a.writeToStore(aSpace); err != nil {

-		if _, ok := err.(types.RetryError); !ok {

-			return types.InternalErrorf("pool (%s) removal failed because of %v", poolID, err)

-		}

-		goto retry

-	}

-

 	return remove()

 }

@@ -289,7 +129,7 @@ func (a *Allocator) getAddrSpace(as string) (*addrSpace, error) {

 	defer a.Unlock()

 	aSpace, ok := a.addrSpaces[as]

 	if !ok {

-		return nil, types.BadRequestErrorf("cannot find address space %s (most likely the backing datastore is not configured)", as)

+		return nil, types.BadRequestErrorf("cannot find address space %s", as)

 	}

 	return aSpace, nil

 }

@@ -331,7 +171,6 @@ func (a *Allocator) parsePoolRequest(addressSpace, pool, subPool string, v6 bool

 func (a *Allocator) insertBitMask(key SubnetKey, pool *net.IPNet) error {

 	//logrus.Debugf("Inserting bitmask (%s, %s)", key.String(), pool.String())

-	store := a.getStore(key.AddressSpace)

 	ipVer := getAddressVersion(pool.IP)

 	ones, bits := pool.Mask.Size()

 	numAddresses := uint64(1 << uint(bits-ones))

@@ -341,8 +180,8 @@ func (a *Allocator) insertBitMask(key SubnetKey, pool *net.IPNet) error {

 		numAddresses--

 	}

-	// Generate the new address masks. AddressMask content may come from datastore

-	h, err := bitseq.NewHandle(dsDataKey, store, key.String(), numAddresses)

+	// Generate the new address masks.

+	h, err := bitseq.NewHandle("", nil, "", numAddresses)

 	if err != nil {

 		return err

 	}

@@ -372,7 +211,7 @@ func (a *Allocator) retrieveBitmask(k SubnetKey, n *net.IPNet) (*bitseq.Handle,

 	if !ok {

 		logrus.Debugf("Retrieving bitmask (%s, %s)", k.String(), n.String())

 		if err := a.insertBitMask(k, n); err != nil {

-			return nil, types.InternalErrorf("could not find bitmask in datastore for %s", k.String())

+			return nil, types.InternalErrorf("could not find bitmask for %s", k.String())

 		}

 		a.Lock()

 		bm = a.addresses[k]

@@ -452,10 +291,6 @@ func (a *Allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[s

 		return nil, nil, types.BadRequestErrorf("invalid pool id: %s", poolID)

 	}

-	if err := a.refresh(k.AddressSpace); err != nil {

-		return nil, nil, err

-	}

-

 	aSpace, err := a.getAddrSpace(k.AddressSpace)

 	if err != nil {

 		return nil, nil, err

@@ -482,7 +317,7 @@ func (a *Allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[s

 	bm, err := a.retrieveBitmask(k, c.Pool)

 	if err != nil {

-		return nil, nil, types.InternalErrorf("could not find bitmask in datastore for %s on address %v request from pool %s: %v",

+		return nil, nil, types.InternalErrorf("could not find bitmask for %s on address %v request from pool %s: %v",

 			k.String(), prefAddress, poolID, err)

 	}

 	// In order to request for a serial ip address allocation, callers can pass in the option to request

@@ -509,10 +344,6 @@ func (a *Allocator) ReleaseAddress(poolID string, address net.IP) error {

 		return types.BadRequestErrorf("invalid pool id: %s", poolID)

 	}

-	if err := a.refresh(k.AddressSpace); err != nil {

-		return err

-	}

-

 	aSpace, err := a.getAddrSpace(k.AddressSpace)

 	if err != nil {

 		return err

@@ -551,7 +382,7 @@ func (a *Allocator) ReleaseAddress(poolID string, address net.IP) error {

 	bm, err := a.retrieveBitmask(k, c.Pool)

 	if err != nil {

-		return types.InternalErrorf("could not find bitmask in datastore for %s on address %v release from pool %s: %v",

+		return types.InternalErrorf("could not find bitmask for %s on address %v release from pool %s: %v",

 			k.String(), address, poolID, err)

 	}

 	defer logrus.Debugf("Released address PoolID:%s, Address:%v Sequence:%s", poolID, address, bm.String())

@@ -1,70 +1,24 @@

 package ipam

 import (

-	"encoding/json"

 	"flag"

 	"fmt"

 	"math/rand"

 	"net"

-	"os"

-	"path/filepath"

 	"strconv"

 	"sync"

 	"testing"

 	"time"

 	"github.com/docker/docker/libnetwork/bitseq"

-	"github.com/docker/docker/libnetwork/datastore"

 	"github.com/docker/docker/libnetwork/ipamapi"

 	"github.com/docker/docker/libnetwork/ipamutils"

 	"github.com/docker/docker/libnetwork/types"

-	"github.com/docker/libkv/store"

-	"github.com/docker/libkv/store/boltdb"

 	"golang.org/x/sync/errgroup"

 	"gotest.tools/v3/assert"

 	is "gotest.tools/v3/assert/cmp"

 )

-var (

-	defaultPrefix = filepath.Join(os.TempDir(), "libnetwork", "test", "ipam")

-)

-

-func init() {

-	boltdb.Register()

-}

-

-// OptionBoltdbWithRandomDBFile function returns a random dir for local store backend

-func randomLocalStore(needStore bool) (datastore.DataStore, error) {

-	if !needStore {

-		return nil, nil

-	}

-	tmp, err := os.CreateTemp("", "libnetwork-")

-	if err != nil {

-		return nil, fmt.Errorf("Error creating temp file: %v", err)

-	}

-	if err := tmp.Close(); err != nil {

-		return nil, fmt.Errorf("Error closing temp file: %v", err)

-	}

-	return datastore.NewDataStore(datastore.ScopeCfg{

-		Client: datastore.ScopeClientCfg{

-			Provider: "boltdb",

-			Address:  filepath.Join(defaultPrefix, filepath.Base(tmp.Name())),

-			Config: &store.Config{

-				Bucket:            "libnetwork",

-				ConnectionTimeout: 3 * time.Second,

-			},

-		},

-	})

-}

-

-func getAllocator(store bool) (*Allocator, error) {

-	ds, err := randomLocalStore(store)

-	if err != nil {

-		return nil, err

-	}

-	return NewAllocator(ds, nil, ipamutils.GetLocalScopeDefaultNetworks(), ipamutils.GetGlobalScopeDefaultNetworks())

-}

-

 func TestInt2IP2IntConversion(t *testing.T) {

 	for i := uint64(0); i < 256*256*256; i++ {

 		var array [4]byte // new array at each cycle

@@ -122,741 +76,611 @@ func TestKeyString(t *testing.T) {

 	}

 }

-func TestPoolDataMarshal(t *testing.T) {

-	_, nw, err := net.ParseCIDR("172.28.30.1/24")

+func TestAddSubnets(t *testing.T) {

+	a, err := NewAllocator(ipamutils.GetLocalScopeDefaultNetworks(), ipamutils.GetGlobalScopeDefaultNetworks())

 	if err != nil {

 		t.Fatal(err)

 	}

+	a.addrSpaces["abc"] = a.addrSpaces[localAddressSpace]

-	p := &PoolData{

-		ParentKey: SubnetKey{AddressSpace: "Blue", Subnet: "172.28.0.0/16"},

-		Pool:      nw,

-		Range:     &AddressRange{Sub: &net.IPNet{IP: net.IP{172, 28, 20, 0}, Mask: net.IPMask{255, 255, 255, 0}}, Start: 0, End: 255},

-		RefCount:  4,

+	pid0, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

+	if err != nil {

+		t.Fatal("Unexpected failure in adding subnet")

 	}

-	ba, err := json.Marshal(p)

+	pid1, _, _, err := a.RequestPool("abc", "10.0.0.0/8", "", nil, false)

 	if err != nil {

-		t.Fatal(err)

+		t.Fatalf("Unexpected failure in adding overlapping subnets to different address spaces: %v", err)

 	}

-	var q PoolData

-	err = json.Unmarshal(ba, &q)

-	if err != nil {

-		t.Fatal(err)

+

+	if pid0 == pid1 {

+		t.Fatal("returned same pool id for same subnets in different namespaces")

 	}

-	if p.ParentKey != q.ParentKey || !types.CompareIPNet(p.Range.Sub, q.Range.Sub) ||

-		p.Range.Start != q.Range.Start || p.Range.End != q.Range.End || p.RefCount != q.RefCount ||

-		!types.CompareIPNet(p.Pool, q.Pool) {

-		t.Fatalf("\n%#v\n%#v", p, &q)

+	_, _, _, err = a.RequestPool("abc", "10.0.0.0/8", "", nil, false)

+	if err == nil {

+		t.Fatalf("Expected failure requesting existing subnet")

 	}

-	p = &PoolData{

-		ParentKey: SubnetKey{AddressSpace: "Blue", Subnet: "172.28.0.0/16"},

-		Pool:      nw,

-		RefCount:  4,

+	_, _, _, err = a.RequestPool("abc", "10.128.0.0/9", "", nil, false)

+	if err == nil {

+		t.Fatal("Expected failure on adding overlapping base subnet")

 	}

-	ba, err = json.Marshal(p)

+	_, _, _, err = a.RequestPool("abc", "10.0.0.0/8", "10.128.0.0/9", nil, false)

 	if err != nil {

-		t.Fatal(err)

+		t.Fatalf("Unexpected failure on adding sub pool: %v", err)

 	}

-	err = json.Unmarshal(ba, &q)

-	if err != nil {

-		t.Fatal(err)

+	_, _, _, err = a.RequestPool("abc", "10.0.0.0/8", "10.128.0.0/9", nil, false)

+	if err == nil {

+		t.Fatalf("Expected failure on adding overlapping sub pool")

 	}

-	if q.Range != nil {

-		t.Fatal("Unexpected Range")

+	_, _, _, err = a.RequestPool(localAddressSpace, "10.20.2.0/24", "", nil, false)

+	if err == nil {

+		t.Fatal("Failed to detect overlapping subnets")

 	}

-}

-

-func TestSubnetsMarshal(t *testing.T) {

-	for _, store := range []bool{false, true} {

-		a, err := getAllocator(store)

-		if err != nil {

-			t.Fatal(err)

-		}

-		pid0, _, _, err := a.RequestPool(localAddressSpace, "192.168.0.0/16", "", nil, false)

-		if err != nil {

-			t.Fatal(err)

-		}

-		pid1, _, _, err := a.RequestPool(localAddressSpace, "192.169.0.0/16", "", nil, false)

-		if err != nil {

-			t.Fatal(err)

-		}

-		_, _, err = a.RequestAddress(pid0, nil, nil)

-		if err != nil {

-			t.Fatal(err)

-		}

-

-		cfg, err := a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

-

-		ba := cfg.Value()

-		if err := cfg.SetValue(ba); err != nil {

-			t.Fatal(err)

-		}

-		expIP := &net.IPNet{IP: net.IP{192, 168, 0, 2}, Mask: net.IPMask{255, 255, 0, 0}}

-		ip, _, err := a.RequestAddress(pid0, nil, nil)

-		if err != nil {

-			t.Fatal(err)

-		}

-		if !types.CompareIPNet(expIP, ip) {

-			t.Fatalf("Got unexpected ip after pool config restore: %s", ip)

-		}

-

-		expIP = &net.IPNet{IP: net.IP{192, 169, 0, 1}, Mask: net.IPMask{255, 255, 0, 0}}

-		ip, _, err = a.RequestAddress(pid1, nil, nil)

-		if err != nil {

-			t.Fatal(err)

-		}

-		if !types.CompareIPNet(expIP, ip) {

-			t.Fatalf("Got unexpected ip after pool config restore: %s", ip)

-		}

+	_, _, _, err = a.RequestPool(localAddressSpace, "10.128.0.0/9", "", nil, false)

+	if err == nil {

+		t.Fatal("Failed to detect overlapping subnets")

 	}

-}

-

-func TestAddSubnets(t *testing.T) {

-	for _, store := range []bool{false, true} {

-		a, err := getAllocator(store)

-		if err != nil {

-			t.Fatal(err)

-		}

-		a.addrSpaces["abc"] = a.addrSpaces[localAddressSpace]

-

-		pid0, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

-		if err != nil {

-			t.Fatal("Unexpected failure in adding subnet")

-		}

-

-		pid1, _, _, err := a.RequestPool("abc", "10.0.0.0/8", "", nil, false)

-		if err != nil {

-			t.Fatalf("Unexpected failure in adding overlapping subnets to different address spaces: %v", err)

-		}

-		if pid0 == pid1 {

-			t.Fatal("returned same pool id for same subnets in different namespaces")

-		}

-

-		_, _, _, err = a.RequestPool("abc", "10.0.0.0/8", "", nil, false)

-		if err == nil {

-			t.Fatalf("Expected failure requesting existing subnet")

-		}

-

-		_, _, _, err = a.RequestPool("abc", "10.128.0.0/9", "", nil, false)

-		if err == nil {

-			t.Fatal("Expected failure on adding overlapping base subnet")

-		}

-

-		_, _, _, err = a.RequestPool("abc", "10.0.0.0/8", "10.128.0.0/9", nil, false)

-		if err != nil {

-			t.Fatalf("Unexpected failure on adding sub pool: %v", err)

-		}

-		_, _, _, err = a.RequestPool("abc", "10.0.0.0/8", "10.128.0.0/9", nil, false)

-		if err == nil {

-			t.Fatalf("Expected failure on adding overlapping sub pool")

-		}

-

-		_, _, _, err = a.RequestPool(localAddressSpace, "10.20.2.0/24", "", nil, false)

-		if err == nil {

-			t.Fatal("Failed to detect overlapping subnets")

-		}

-

-		_, _, _, err = a.RequestPool(localAddressSpace, "10.128.0.0/9", "", nil, false)

-		if err == nil {

-			t.Fatal("Failed to detect overlapping subnets")

-		}

-

-		_, _, _, err = a.RequestPool(localAddressSpace, "1003:1:2:3:4:5:6::/112", "", nil, false)

-		if err != nil {

-			t.Fatalf("Failed to add v6 subnet: %s", err.Error())

-		}

+	_, _, _, err = a.RequestPool(localAddressSpace, "1003:1:2:3:4:5:6::/112", "", nil, false)

+	if err != nil {

+		t.Fatalf("Failed to add v6 subnet: %s", err.Error())

+	}

-		_, _, _, err = a.RequestPool(localAddressSpace, "1003:1:2:3::/64", "", nil, false)

-		if err == nil {

-			t.Fatal("Failed to detect overlapping v6 subnet")

-		}

+	_, _, _, err = a.RequestPool(localAddressSpace, "1003:1:2:3::/64", "", nil, false)

+	if err == nil {

+		t.Fatal("Failed to detect overlapping v6 subnet")

 	}

 }

 // TestDoublePoolRelease tests that releasing a pool which has already

 // been released raises an error.

 func TestDoublePoolRelease(t *testing.T) {

-	for _, store := range []bool{false, true} {

-		a, err := getAllocator(store)

-		assert.NilError(t, err)

+	a, err := NewAllocator(ipamutils.GetLocalScopeDefaultNetworks(), ipamutils.GetGlobalScopeDefaultNetworks())

+	assert.NilError(t, err)

-		pid0, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

-		assert.NilError(t, err)

+	pid0, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

+	assert.NilError(t, err)

-		err = a.ReleasePool(pid0)

-		assert.NilError(t, err)

+	err = a.ReleasePool(pid0)

+	assert.NilError(t, err)

-		err = a.ReleasePool(pid0)

-		assert.Check(t, is.ErrorContains(err, ""))

-	}

+	err = a.ReleasePool(pid0)

+	assert.Check(t, is.ErrorContains(err, ""))

 }

 func TestAddReleasePoolID(t *testing.T) {

-	for _, store := range []bool{false, true} {

-		a, err := getAllocator(store)

-		assert.NilError(t, err)

+	a, err := NewAllocator(ipamutils.GetLocalScopeDefaultNetworks(), ipamutils.GetGlobalScopeDefaultNetworks())

+	assert.NilError(t, err)

-		var k0, k1 SubnetKey

-		_, err = a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

+	var k0, k1 SubnetKey

+	_, err = a.getAddrSpace(localAddressSpace)

+	if err != nil {

+		t.Fatal(err)

+	}

-		pid0, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

-		if err != nil {

-			t.Fatal("Unexpected failure in adding pool")

-		}

-		if err := k0.FromString(pid0); err != nil {

-			t.Fatal(err)

-		}

+	pid0, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

+	if err != nil {

+		t.Fatal("Unexpected failure in adding pool")

+	}

+	if err := k0.FromString(pid0); err != nil {

+		t.Fatal(err)

+	}

-		aSpace, err := a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

+	aSpace, err := a.getAddrSpace(localAddressSpace)

+	if err != nil {

+		t.Fatal(err)

+	}

-		subnets := aSpace.subnets

+	subnets := aSpace.subnets

-		if subnets[k0].RefCount != 1 {

-			t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

-		}

+	if subnets[k0].RefCount != 1 {

+		t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

+	}

-		pid1, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "10.0.0.0/16", nil, false)

-		if err != nil {

-			t.Fatal("Unexpected failure in adding sub pool")

-		}

-		if err := k1.FromString(pid1); err != nil {

-			t.Fatal(err)

-		}

+	pid1, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "10.0.0.0/16", nil, false)

+	if err != nil {

+		t.Fatal("Unexpected failure in adding sub pool")

+	}

+	if err := k1.FromString(pid1); err != nil {

+		t.Fatal(err)

+	}

-		if pid0 == pid1 {

-			t.Fatalf("Incorrect poolIDs returned %s, %s", pid0, pid1)

-		}

+	if pid0 == pid1 {

+		t.Fatalf("Incorrect poolIDs returned %s, %s", pid0, pid1)

+	}

-		aSpace, err = a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

+	aSpace, err = a.getAddrSpace(localAddressSpace)

+	if err != nil {

+		t.Fatal(err)

+	}

-		subnets = aSpace.subnets

-		if subnets[k1].RefCount != 1 {

-			t.Fatalf("Unexpected ref count for %s: %d", k1, subnets[k1].RefCount)

-		}

+	subnets = aSpace.subnets

+	if subnets[k1].RefCount != 1 {

+		t.Fatalf("Unexpected ref count for %s: %d", k1, subnets[k1].RefCount)

+	}

-		_, _, _, err = a.RequestPool(localAddressSpace, "10.0.0.0/8", "10.0.0.0/16", nil, false)

-		if err == nil {

-			t.Fatal("Expected failure in adding sub pool")

-		}

+	_, _, _, err = a.RequestPool(localAddressSpace, "10.0.0.0/8", "10.0.0.0/16", nil, false)

+	if err == nil {

+		t.Fatal("Expected failure in adding sub pool")

+	}

-		aSpace, err = a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

+	aSpace, err = a.getAddrSpace(localAddressSpace)

+	if err != nil {

+		t.Fatal(err)

+	}

-		subnets = aSpace.subnets

+	subnets = aSpace.subnets

-		if subnets[k0].RefCount != 2 {

-			t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

-		}

+	if subnets[k0].RefCount != 2 {

+		t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

+	}

-		if err := a.ReleasePool(pid1); err != nil {

-			t.Fatal(err)

-		}

+	if err := a.ReleasePool(pid1); err != nil {

+		t.Fatal(err)

+	}

-		aSpace, err = a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

+	aSpace, err = a.getAddrSpace(localAddressSpace)

+	if err != nil {

+		t.Fatal(err)

+	}

-		subnets = aSpace.subnets

-		if subnets[k0].RefCount != 1 {

-			t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

-		}

-		if err := a.ReleasePool(pid0); err != nil {

-			t.Fatal(err)

-		}

+	subnets = aSpace.subnets

+	if subnets[k0].RefCount != 1 {

+		t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

+	}

+	if err := a.ReleasePool(pid0); err != nil {

+		t.Fatal(err)

+	}

-		pid00, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

-		if err != nil {

-			t.Fatal("Unexpected failure in adding pool")

-		}

-		if pid00 != pid0 {

-			t.Fatal("main pool should still exist")

-		}

+	pid00, _, _, err := a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

+	if err != nil {

+		t.Fatal("Unexpected failure in adding pool")

+	}

+	if pid00 != pid0 {

+		t.Fatal("main pool should still exist")

+	}

-		aSpace, err = a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

+	aSpace, err = a.getAddrSpace(localAddressSpace)

+	if err != nil {

+		t.Fatal(err)

+	}

-		subnets = aSpace.subnets

-		if subnets[k0].RefCount != 1 {

-			t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

-		}

+	subnets = aSpace.subnets

+	if subnets[k0].RefCount != 1 {

+		t.Fatalf("Unexpected ref count for %s: %d", k0, subnets[k0].RefCount)

+	}

-		if err := a.ReleasePool(pid00); err != nil {

-			t.Fatal(err)

-		}

+	if err := a.ReleasePool(pid00); err != nil {

+		t.Fatal(err)

+	}

-		aSpace, err = a.getAddrSpace(localAddressSpace)

-		if err != nil {

-			t.Fatal(err)

-		}

+	aSpace, err = a.getAddrSpace(localAddressSpace)

+	if err != nil {

+		t.Fatal(err)

+	}

-		subnets = aSpace.subnets

-		if bp, ok := subnets[k0]; ok {

-			t.Fatalf("Base pool %s is still present: %v", k0, bp)

-		}

+	subnets = aSpace.subnets

+	if bp, ok := subnets[k0]; ok {

+		t.Fatalf("Base pool %s is still present: %v", k0, bp)

+	}

-		_, _, _, err = a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

-		if err != nil {

-			t.Fatal("Unexpected failure in adding pool")

-		}

+	_, _, _, err = a.RequestPool(localAddressSpace, "10.0.0.0/8", "", nil, false)

+	if err != nil {

+		t.Fatal("Unexpected failure in adding pool")

+	}