From 2aaef377f31635c1a5247c4964bfbc75672a4534 Mon Sep 17 00:00:00 2001 From: Alessandro Boch Date: Tue, 22 Sep 2015 13:20:55 -0700 Subject: [PATCH] IPAM driver - Add IPAM cotract and remote IPAM hooks - Add ipam registration in controller - Have default IPAM follow ipamapi contract Signed-off-by: Alessandro Boch --- libnetwork/.gitignore | 3 +- libnetwork/bitseq/sequence.go | 4 +- libnetwork/controller.go | 100 +++- libnetwork/drivers.go | 15 + libnetwork/ipam/allocator.go | 891 ++++++++++++++++------------ libnetwork/ipam/allocator_test.go | 725 ++++++++++++++-------- libnetwork/ipam/contract.go | 100 ---- libnetwork/ipam/store.go | 64 +- libnetwork/ipamapi/contract.go | 74 +++ libnetwork/ipams/builtin/builtin.go | 35 ++ libnetwork/ipams/remote/api/api.go | 81 +++ libnetwork/ipams/remote/remote.go | 92 +++ libnetwork/network.go | 14 +- libnetwork/store.go | 38 +- libnetwork/store_test.go | 3 +- libnetwork/types/types.go | 53 +- libnetwork/types/types_test.go | 172 ++++++ 17 files changed, 1635 insertions(+), 829 deletions(-) delete mode 100644 libnetwork/ipam/contract.go create mode 100644 libnetwork/ipamapi/contract.go create mode 100644 libnetwork/ipams/builtin/builtin.go create mode 100644 libnetwork/ipams/remote/api/api.go create mode 100644 libnetwork/ipams/remote/remote.go diff --git a/libnetwork/.gitignore b/libnetwork/.gitignore index 0529bde798..0e0d489204 100644 --- a/libnetwork/.gitignore +++ b/libnetwork/.gitignore @@ -29,7 +29,8 @@ cmd/dnet/dnet *.tmp *.coverprofile -# IDE files +# IDE files and folders .project +.settings/ libnetwork-build.created diff --git a/libnetwork/bitseq/sequence.go b/libnetwork/bitseq/sequence.go index 047f4dbaa7..0d48f54d15 100644 --- a/libnetwork/bitseq/sequence.go +++ b/libnetwork/bitseq/sequence.go @@ -306,8 +306,8 @@ func (h *Handle) validateOrdinal(ordinal uint32) error { } // Destroy removes from the datastore the data belonging to this handle -func (h *Handle) Destroy() { - h.deleteFromStore() +func (h *Handle) Destroy() error { + return h.deleteFromStore() } // ToByteArray converts this handle's data into a byte array diff --git a/libnetwork/controller.go b/libnetwork/controller.go index 9a364c5413..ff560d419c 100644 --- a/libnetwork/controller.go +++ b/libnetwork/controller.go @@ -58,6 +58,7 @@ import ( "github.com/docker/libnetwork/datastore" "github.com/docker/libnetwork/driverapi" "github.com/docker/libnetwork/hostdiscovery" + "github.com/docker/libnetwork/ipamapi" "github.com/docker/libnetwork/osl" "github.com/docker/libnetwork/types" ) @@ -116,7 +117,14 @@ type driverData struct { capability driverapi.Capability } +type ipamData struct { + driver ipamapi.Ipam + // default address spaces are provided by ipam driver at registration time + defaultLocalAddressSpace, defaultGlobalAddressSpace string +} + type driverTable map[string]*driverData +type ipamTable map[string]*ipamData type networkTable map[string]*network type endpointTable map[string]*endpoint type sandboxTable map[string]*sandbox @@ -125,6 +133,7 @@ type controller struct { id string networks networkTable drivers driverTable + ipamDrivers ipamTable sandboxes sandboxTable cfg *config.Config globalStore, localStore datastore.DataStore @@ -145,11 +154,12 @@ func New(cfgOptions ...config.Option) (NetworkController, error) { cfg.ProcessOptions(cfgOptions...) } c := &controller{ - id: stringid.GenerateRandomID(), - cfg: cfg, - networks: networkTable{}, - sandboxes: sandboxTable{}, - drivers: driverTable{}} + id: stringid.GenerateRandomID(), + cfg: cfg, + networks: networkTable{}, + sandboxes: sandboxTable{}, + drivers: driverTable{}, + ipamDrivers: ipamTable{}} if err := initDrivers(c); err != nil { return nil, err } @@ -160,13 +170,26 @@ func New(cfgOptions ...config.Option) (NetworkController, error) { // But it cannot fail creating the Controller log.Debugf("Failed to Initialize Datastore due to %v. Operating in non-clustered mode", err) } + if err := c.initLocalStore(); err != nil { + log.Debugf("Failed to Initialize LocalDatastore due to %v.", err) + } + } + + if err := initIpams(c, c.localStore, c.globalStore); err != nil { + return nil, err + } + + if cfg != nil { + if err := c.restoreFromGlobalStore(); err != nil { + log.Debugf("Failed to restore from global Datastore due to %v", err) + } if err := c.initDiscovery(cfg.Cluster.Watcher); err != nil { // Failing to initalize discovery is a bad situation to be in. // But it cannot fail creating the Controller log.Debugf("Failed to Initialize Discovery : %v", err) } - if err := c.initLocalStore(); err != nil { - log.Debugf("Failed to Initialize LocalDatastore due to %v.", err) + if err := c.restoreFromLocalStore(); err != nil { + log.Debugf("Failed to restore from local Datastore due to %v", err) } } @@ -272,6 +295,28 @@ func (c *controller) RegisterDriver(networkType string, driver driverapi.Driver, return nil } +func (c *controller) RegisterIpamDriver(name string, driver ipamapi.Ipam) error { + if !config.IsValidName(name) { + return ErrInvalidName(name) + } + + c.Lock() + if _, ok := c.ipamDrivers[name]; ok { + c.Unlock() + return driverapi.ErrActiveRegistration(name) + } + l, g, err := driver.GetDefaultAddressSpaces() + if err != nil { + return fmt.Errorf("ipam driver %s failed to return default address spaces: %v", name, err) + } + c.ipamDrivers[name] = &ipamData{driver: driver, defaultLocalAddressSpace: l, defaultGlobalAddressSpace: g} + c.Unlock() + + log.Debugf("Registering ipam provider: %s", name) + + return nil +} + // NewNetwork creates a new network of the specified network type. The options // are network specific and modeled in a generic way. func (c *controller) NewNetwork(networkType, name string, options ...NetworkOption) (Network, error) { @@ -292,6 +337,7 @@ func (c *controller) NewNetwork(networkType, name string, options ...NetworkOpti network := &network{ name: name, networkType: networkType, + ipamType: ipamapi.DefaultIPAM, id: stringid.GenerateRandomID(), ctrlr: c, endpoints: endpointTable{}, @@ -316,7 +362,6 @@ func (c *controller) NewNetwork(networkType, name string, options ...NetworkOpti } func (c *controller) addNetwork(n *network) error { - c.Lock() // Check if a driver for the specified network type is available dd, ok := c.drivers[n.networkType] @@ -534,14 +579,39 @@ func (c *controller) loadDriver(networkType string) (*driverData, error) { return dd, nil } -func (c *controller) getDriver(networkType string) (*driverData, error) { - c.Lock() - defer c.Unlock() - dd, ok := c.drivers[networkType] - if !ok { - return nil, types.NotFoundErrorf("driver %s not found", networkType) +func (c *controller) loadIpamDriver(name string) (*ipamData, error) { + if _, err := plugins.Get(name, ipamapi.PluginEndpointType); err != nil { + if err == plugins.ErrNotFound { + return nil, types.NotFoundErrorf(err.Error()) + } + return nil, err } - return dd, nil + c.Lock() + id, ok := c.ipamDrivers[name] + c.Unlock() + if !ok { + return nil, ErrInvalidNetworkDriver(name) + } + return id, nil +} + +func (c *controller) getIPAM(name string) (id *ipamData, err error) { + var ok bool + c.Lock() + id, ok = c.ipamDrivers[name] + c.Unlock() + if !ok { + id, err = c.loadIpamDriver(name) + } + return id, err +} + +func (c *controller) getIpamDriver(name string) (ipamapi.Ipam, error) { + id, err := c.getIPAM(name) + if err != nil { + return nil, err + } + return id.driver, nil } func (c *controller) Stop() { diff --git a/libnetwork/drivers.go b/libnetwork/drivers.go index 898bcc4ebe..b50d089b09 100644 --- a/libnetwork/drivers.go +++ b/libnetwork/drivers.go @@ -4,6 +4,9 @@ import ( "strings" "github.com/docker/libnetwork/driverapi" + "github.com/docker/libnetwork/ipamapi" + builtinIpam "github.com/docker/libnetwork/ipams/builtin" + remoteIpam "github.com/docker/libnetwork/ipams/remote" "github.com/docker/libnetwork/netlabel" ) @@ -53,3 +56,15 @@ func makeDriverConfig(c *controller, ntype string) map[string]interface{} { return config } + +func initIpams(ic ipamapi.Callback, lDs, gDs interface{}) error { + for _, fn := range [](func(ipamapi.Callback, interface{}, interface{}) error){ + builtinIpam.Init, + remoteIpam.Init, + } { + if err := fn(ic, lDs, gDs); err != nil { + return err + } + } + return nil +} diff --git a/libnetwork/ipam/allocator.go b/libnetwork/ipam/allocator.go index 60c25613c0..85851a0c64 100644 --- a/libnetwork/ipam/allocator.go +++ b/libnetwork/ipam/allocator.go @@ -1,57 +1,58 @@ package ipam import ( + "encoding/json" "fmt" "net" "strings" "sync" log "github.com/Sirupsen/logrus" + "github.com/docker/libkv/store" "github.com/docker/libnetwork/bitseq" "github.com/docker/libnetwork/datastore" + "github.com/docker/libnetwork/ipamapi" + "github.com/docker/libnetwork/netutils" "github.com/docker/libnetwork/types" ) const ( + localAddressSpace = "LocalDefault" + globalAddressSpace = "GlobalDefault" // The biggest configurable host subnets - minNetSize = 8 - minNetSizeV6 = 64 - // The effective network size for v6 + minNetSize = 8 + minNetSizeV6 = 64 minNetSizeV6Eff = 96 - // The size of the host subnet used internally, it's the most granular sequence addresses - defaultInternalHostSize = 16 // datastore keyes for ipam objects - dsConfigKey = "ipam-config" // ipam-config// - dsDataKey = "ipam-data" // ipam-data//// + dsConfigKey = "ipam/" + ipamapi.DefaultIPAM + "/config" + dsDataKey = "ipam/" + ipamapi.DefaultIPAM + "/data" ) // Allocator provides per address space ipv4/ipv6 book keeping type Allocator struct { - // The internal subnets host size - internalHostSize int + // Predefined pools for default address spaces + predefined map[string][]*net.IPNet // Static subnet information - subnets map[subnetKey]*SubnetInfo - // Allocated addresses in each address space's internal subnet - addresses map[subnetKey]*bitseq.Handle + subnets map[SubnetKey]*PoolData + // Allocated addresses in each address space's subnet + addresses map[SubnetKey]*bitseq.Handle // Datastore store datastore.DataStore - App string - ID string dbIndex uint64 dbExists bool sync.Mutex } // NewAllocator returns an instance of libnetwork ipam -func NewAllocator(ds datastore.DataStore) (*Allocator, error) { +func NewAllocator(lcDs, glDs datastore.DataStore) (*Allocator, error) { a := &Allocator{} - a.subnets = make(map[subnetKey]*SubnetInfo) - a.addresses = make(map[subnetKey]*bitseq.Handle) - a.internalHostSize = defaultInternalHostSize - a.store = ds - a.App = "ipam" - a.ID = dsConfigKey + a.subnets = make(map[SubnetKey]*PoolData) + a.addresses = make(map[SubnetKey]*bitseq.Handle) + a.predefined = make(map[string][]*net.IPNet, 2) + a.predefined[localAddressSpace] = initLocalPredefinedPools() + a.predefined[globalAddressSpace] = initGlobalPredefinedPools() + a.store = glDs if a.store == nil { return a, nil @@ -70,18 +71,13 @@ func NewAllocator(ds datastore.DataStore) (*Allocator, error) { } a.subnetConfigFromStore(kvPair) - // Now retrieve the list of small subnets + // Now retrieve the bitmasks for the master pools var inserterList []func() error a.Lock() for k, v := range a.subnets { - inserterList = append(inserterList, - func() error { - subnetList, err := getInternalSubnets(v.Subnet, a.internalHostSize) - if err != nil { - return fmt.Errorf("failed to load address bitmask for configured subnet %s because of %s", v.Subnet.String(), err.Error()) - } - return a.insertAddressMasks(k, subnetList) - }) + if v.Range == nil { + inserterList = append(inserterList, func() error { return a.insertBitMask(k, v.Pool) }) + } } a.Unlock() @@ -98,29 +94,31 @@ func NewAllocator(ds datastore.DataStore) (*Allocator, error) { func (a *Allocator) subnetConfigFromStore(kvPair *store.KVPair) { a.Lock() if a.dbIndex < kvPair.LastIndex { - a.subnets = byteArrayToSubnets(kvPair.Value) + a.SetValue(kvPair.Value) a.dbIndex = kvPair.LastIndex a.dbExists = true } a.Unlock() } -// Pointer to the configured subnets in each address space -type subnetKey struct { - addressSpace AddressSpace - subnet string - childSubnet string +// SubnetKey is the pointer to the configured pools in each address space +type SubnetKey struct { + AddressSpace string + Subnet string + ChildSubnet string } -func (s *subnetKey) String() string { - k := fmt.Sprintf("%s/%s", s.addressSpace, s.subnet) - if s.childSubnet != "" { - k = fmt.Sprintf("%s/%s", k, s.childSubnet) +// String returns the string form of the SubnetKey object +func (s *SubnetKey) String() string { + k := fmt.Sprintf("%s/%s", s.AddressSpace, s.Subnet) + if s.ChildSubnet != "" { + k = fmt.Sprintf("%s/%s", k, s.ChildSubnet) } return k } -func (s *subnetKey) FromString(str string) error { +// FromString populate the SubnetKey object reading it from string +func (s *SubnetKey) FromString(str string) error { if str == "" || !strings.Contains(str, "/") { return fmt.Errorf("invalid string form for subnetkey: %s", str) } @@ -129,26 +127,106 @@ func (s *subnetKey) FromString(str string) error { if len(p) != 3 && len(p) != 5 { return fmt.Errorf("invalid string form for subnetkey: %s", str) } - s.addressSpace = AddressSpace(p[0]) - s.subnet = fmt.Sprintf("%s/%s", p[1], p[2]) + s.AddressSpace = p[0] + s.Subnet = fmt.Sprintf("%s/%s", p[1], p[2]) if len(p) == 5 { - s.childSubnet = fmt.Sprintf("%s/%s", p[1], p[2]) + s.ChildSubnet = fmt.Sprintf("%s/%s", p[3], p[4]) } return nil } -func (s *subnetKey) canonicalSubnet() *net.IPNet { - if _, sub, err := net.ParseCIDR(s.subnet); err == nil { - return sub +// AddressRange specifies first and last ip ordinal which +// identify a range in a a pool of addresses +type AddressRange struct { + Sub *net.IPNet + Start, End uint32 +} + +// String returns the string form of the AddressRange object +func (r *AddressRange) String() string { + return fmt.Sprintf("Sub: %s, range [%d, %d]", r.Sub, r.Start, r.End) +} + +// MarshalJSON returns the JSON encoding of the Range object +func (r *AddressRange) MarshalJSON() ([]byte, error) { + m := map[string]interface{}{ + "Sub": r.Sub.String(), + "Start": r.Start, + "End": r.End, } + return json.Marshal(m) +} + +// UnmarshalJSON decodes data into the Range object +func (r *AddressRange) UnmarshalJSON(data []byte) error { + m := map[string]interface{}{} + err := json.Unmarshal(data, &m) + if err != nil { + return err + } + if r.Sub, err = types.ParseCIDR(m["Sub"].(string)); err != nil { + return err + } + r.Start = uint32(m["Start"].(float64)) + r.End = uint32(m["End"].(float64)) return nil } -func (s *subnetKey) canonicalChildSubnet() *net.IPNet { - if _, sub, err := net.ParseCIDR(s.childSubnet); err == nil { - return sub +// PoolData contains the configured pool data +type PoolData struct { + ParentKey SubnetKey + Pool *net.IPNet + Range *AddressRange `json:",omitempty"` + RefCount int +} + +// String returns the string form of the PoolData object +func (p *PoolData) String() string { + return fmt.Sprintf("ParentKey: %s, Pool: %s, Range: %s, RefCount: %d", + p.ParentKey.String(), p.Pool.String(), p.Range, p.RefCount) +} + +// MarshalJSON returns the JSON encoding of the PoolData object +func (p *PoolData) MarshalJSON() ([]byte, error) { + m := map[string]interface{}{ + "ParentKey": p.ParentKey, + "RefCount": p.RefCount, } + if p.Pool != nil { + m["Pool"] = p.Pool.String() + } + if p.Range != nil { + m["Range"] = p.Range + } + return json.Marshal(m) +} + +// UnmarshalJSON decodes data into the PoolData object +func (p *PoolData) UnmarshalJSON(data []byte) error { + var ( + err error + t struct { + ParentKey SubnetKey + Pool string + Range *AddressRange `json:",omitempty"` + RefCount int + } + ) + + if err = json.Unmarshal(data, &t); err != nil { + return err + } + + p.ParentKey = t.ParentKey + p.Range = t.Range + p.RefCount = t.RefCount + if t.Pool != "" { + if p.Pool, err = types.ParseCIDR(t.Pool); err != nil { + return err + } + } + return nil } @@ -159,88 +237,267 @@ const ( v6 = 6 ) -/******************* - * IPAMConf Contract - ********************/ +// GetDefaultAddressSpaces returns the local and global default address spaces +func (a *Allocator) GetDefaultAddressSpaces() (string, string, error) { + return localAddressSpace, globalAddressSpace, nil +} -// AddSubnet adds a subnet for the specified address space -func (a *Allocator) AddSubnet(addrSpace AddressSpace, subnetInfo *SubnetInfo) error { - // Sanity check - if addrSpace == "" { - return ErrInvalidAddressSpace +// RequestPool returns an address pool along with its unique id. +func (a *Allocator) RequestPool(addressSpace, pool, subPool string, options map[string]string, v6 bool) (string, *net.IPNet, map[string]string, error) { + k, nw, aw, ipr, err := a.parsePoolRequest(addressSpace, pool, subPool, v6) + if err != nil { + return "", nil, nil, ipamapi.ErrInvalidPool } - if subnetInfo == nil || subnetInfo.Subnet == nil { - return ErrInvalidSubnet +retry: + insert, err := a.updatePoolDBOnAdd(*k, nw, ipr) + if err != nil { + return "", nil, nil, err } - // Convert to smaller internal subnets (if needed) - subnetList, err := getInternalSubnets(subnetInfo.Subnet, a.internalHostSize) + if err := a.writeToStore(); err != nil { + if _, ok := err.(types.RetryError); !ok { + return "", nil, nil, types.InternalErrorf("pool configuration failed because of %s", err.Error()) + } + if erru := a.readFromStore(); erru != nil { + return "", nil, nil, fmt.Errorf("failed to get updated pool config from datastore (%v) after (%v)", erru, err) + } + goto retry + } + return k.String(), aw, nil, insert() +} + +// ReleasePool releases the address pool identified by the passed id +func (a *Allocator) ReleasePool(poolID string) error { + k := SubnetKey{} + if err := k.FromString(poolID); err != nil { + return types.BadRequestErrorf("invalid pool id: %s", poolID) + } + +retry: + remove, err := a.updatePoolDBOnRemoval(k) if err != nil { return err } -retry: - if a.contains(addrSpace, subnetInfo) { - return ErrOverlapSubnet - } - - // Store the configured subnet and sync to datatstore - key := subnetKey{addrSpace, subnetInfo.Subnet.String(), ""} - a.Lock() - a.subnets[key] = subnetInfo - a.Unlock() - err = a.writeToStore() - if err != nil { + if err = a.writeToStore(); err != nil { if _, ok := err.(types.RetryError); !ok { - return types.InternalErrorf("subnet configuration failed because of %s", err.Error()) + return types.InternalErrorf("pool (%s) removal failed because of %v", poolID, err) } - // Update to latest if erru := a.readFromStore(); erru != nil { - // Restore and bail out - a.Lock() - delete(a.addresses, key) - a.Unlock() - return fmt.Errorf("failed to get updated subnets config from datastore (%v) after (%v)", erru, err) + return fmt.Errorf("failed to get updated pool config from datastore (%v) after (%v)", erru, err) } goto retry } - // Insert respective bitmasks for this subnet - a.insertAddressMasks(key, subnetList) + return remove() +} + +func (a *Allocator) parsePoolRequest(addressSpace, pool, subPool string, v6 bool) (*SubnetKey, *net.IPNet, *net.IPNet, *AddressRange, error) { + var ( + nw, aw *net.IPNet + ipr *AddressRange + err error + ) + + if addressSpace == "" { + return nil, nil, nil, nil, ipamapi.ErrInvalidAddressSpace + } + + if pool == "" && subPool != "" { + return nil, nil, nil, nil, ipamapi.ErrInvalidSubPool + } + + if pool != "" { + if _, nw, err = net.ParseCIDR(pool); err != nil { + return nil, nil, nil, nil, ipamapi.ErrInvalidPool + } + if subPool != "" { + if ipr, err = getAddressRange(subPool); err != nil { + return nil, nil, nil, nil, err + } + } + } else { + if nw, err = a.getPredefinedPool(addressSpace, v6); err != nil { + return nil, nil, nil, nil, err + } + + } + if aw, err = adjustAndCheckSubnetSize(nw); err != nil { + return nil, nil, nil, nil, err + } + + return &SubnetKey{AddressSpace: addressSpace, Subnet: nw.String(), ChildSubnet: subPool}, nw, aw, ipr, nil +} + +func (a *Allocator) updatePoolDBOnAdd(k SubnetKey, nw *net.IPNet, ipr *AddressRange) (func() error, error) { + a.Lock() + defer a.Unlock() + + // Check if already allocated + if p, ok := a.subnets[k]; ok { + a.incRefCount(p, 1) + return func() error { return nil }, nil + } + + // If master pool, check for overlap + if ipr == nil { + if a.contains(k.AddressSpace, nw) { + return nil, ipamapi.ErrPoolOverlap + } + // This is a new master pool, add it along with corresponding bitmask + a.subnets[k] = &PoolData{Pool: nw, RefCount: 1} + return func() error { return a.insertBitMask(k, nw) }, nil + } + + // This is a new non-master pool + p := &PoolData{ + ParentKey: SubnetKey{AddressSpace: k.AddressSpace, Subnet: k.Subnet}, + Pool: nw, + Range: ipr, + RefCount: 1, + } + a.subnets[k] = p + + // Look for parent pool + pp, ok := a.subnets[p.ParentKey] + if ok { + a.incRefCount(pp, 1) + return func() error { return nil }, nil + } + + // Parent pool does not exist, add it along with corresponding bitmask + a.subnets[p.ParentKey] = &PoolData{Pool: nw, RefCount: 1} + return func() error { return a.insertBitMask(p.ParentKey, nw) }, nil +} + +func (a *Allocator) updatePoolDBOnRemoval(k SubnetKey) (func() error, error) { + a.Lock() + defer a.Unlock() + + p, ok := a.subnets[k] + if !ok { + return nil, ipamapi.ErrBadPool + } + + a.incRefCount(p, -1) + + c := p + for ok { + if c.RefCount == 0 { + delete(a.subnets, k) + if c.Range == nil { + return func() error { + bm, err := a.retrieveBitmask(k, c.Pool) + if err != nil { + return fmt.Errorf("could not find bitmask in datastore for pool %s removal: %v", k.String(), err) + } + return bm.Destroy() + }, nil + } + } + k = c.ParentKey + c, ok = a.subnets[k] + } + + return func() error { return nil }, nil +} + +func (a *Allocator) incRefCount(p *PoolData, delta int) { + c := p + ok := true + for ok { + c.RefCount += delta + c, ok = a.subnets[c.ParentKey] + } +} + +func (a *Allocator) insertBitMask(key SubnetKey, pool *net.IPNet) error { + log.Debugf("Inserting bitmask (%s, %s)", key.String(), pool.String()) + ipVer := getAddressVersion(pool.IP) + ones, bits := pool.Mask.Size() + numAddresses := uint32(1 << uint(bits-ones)) + + if ipVer == v4 { + // Do not let broadcast address be reserved + numAddresses-- + } + + // Generate the new address masks. AddressMask content may come from datastore + h, err := bitseq.NewHandle(dsDataKey, a.store, key.String(), numAddresses) + if err != nil { + return err + } + + if ipVer == v4 { + // Do not let network identifier address be reserved + h.Set(0) + } + + a.Lock() + a.addresses[key] = h + a.Unlock() return nil } -// Create and insert the internal subnet(s) addresses masks into the address database. Mask data may come from the bitseq datastore. -func (a *Allocator) insertAddressMasks(parentKey subnetKey, internalSubnetList []*net.IPNet) error { - ipVer := getAddressVersion(internalSubnetList[0].IP) - num := len(internalSubnetList) - ones, bits := internalSubnetList[0].Mask.Size() - numAddresses := 1 << uint(bits-ones) - - for i := 0; i < num; i++ { - smallKey := subnetKey{parentKey.addressSpace, parentKey.subnet, internalSubnetList[i].String()} - limit := uint32(numAddresses) - - if ipVer == v4 && i == num-1 { - // Do not let broadcast address be reserved - limit-- +func (a *Allocator) retrieveBitmask(k SubnetKey, n *net.IPNet) (*bitseq.Handle, error) { + a.Lock() + bm, ok := a.addresses[k] + a.Unlock() + if !ok { + log.Debugf("Retrieving bitmask (%s, %s)", k.String(), n.String()) + if err := a.insertBitMask(k, n); err != nil { + return nil, fmt.Errorf("could not find bitmask in datastore for %s", k.String()) } - - // Generate the new address masks. AddressMask content may come from datastore - h, err := bitseq.NewHandle(dsDataKey, a.getStore(), smallKey.String(), limit) - if err != nil { - return err - } - - if ipVer == v4 && i == 0 { - // Do not let network identifier address be reserved - h.Set(0) - } - a.Lock() - a.addresses[smallKey] = h + bm = a.addresses[k] a.Unlock() } - return nil + return bm, nil +} + +func (a *Allocator) getPredefineds(as string) []*net.IPNet { + a.Lock() + defer a.Unlock() + l := make([]*net.IPNet, 0, len(a.predefined[as])) + for _, pool := range a.predefined[as] { + l = append(l, pool) + } + return l +} + +func (a *Allocator) getPredefinedPool(as string, ipV6 bool) (*net.IPNet, error) { + var v ipVersion + v = v4 + if ipV6 { + v = v6 + } + + if as != localAddressSpace && as != globalAddressSpace { + return nil, fmt.Errorf("no default pool availbale for non-default addresss spaces") + } + + for _, nw := range a.getPredefineds(as) { + if v != getAddressVersion(nw.IP) { + continue + } + a.Lock() + _, ok := a.subnets[SubnetKey{AddressSpace: as, Subnet: nw.String()}] + a.Unlock() + if ok { + continue + } + + if !a.contains(as, nw) { + if as == localAddressSpace { + if err := netutils.CheckRouteOverlaps(nw); err == nil { + return nw, nil + } + continue + } + return nw, nil + } + } + + return nil, types.NotFoundErrorf("could not find an available predefined network") } // Check subnets size. In case configured subnet is v6 and host size is @@ -249,7 +506,7 @@ func adjustAndCheckSubnetSize(subnet *net.IPNet) (*net.IPNet, error) { ones, bits := subnet.Mask.Size() if v6 == getAddressVersion(subnet.IP) { if ones < minNetSizeV6 { - return nil, ErrInvalidSubnet + return nil, ipamapi.ErrInvalidPool } if ones < minNetSizeV6Eff { newMask := net.CIDRMask(minNetSizeV6Eff, bits) @@ -257,20 +514,17 @@ func adjustAndCheckSubnetSize(subnet *net.IPNet) (*net.IPNet, error) { } } else { if ones < minNetSize { - return nil, ErrInvalidSubnet + return nil, ipamapi.ErrInvalidPool } } return subnet, nil } // Checks whether the passed subnet is a superset or subset of any of the subset in the db -func (a *Allocator) contains(space AddressSpace, subInfo *SubnetInfo) bool { - a.Lock() - defer a.Unlock() +func (a *Allocator) contains(space string, nw *net.IPNet) bool { for k, v := range a.subnets { - if space == k.addressSpace { - if subInfo.Subnet.Contains(v.Subnet.IP) || - v.Subnet.Contains(subInfo.Subnet.IP) { + if space == k.AddressSpace && k.ChildSubnet == "" { + if nw.Contains(v.Pool.IP) || v.Pool.Contains(nw.IP) { return true } } @@ -278,272 +532,107 @@ func (a *Allocator) contains(space AddressSpace, subInfo *SubnetInfo) bool { return false } -// Splits the passed subnet into N internal subnets with host size equal to internalHostSize. -// If the subnet's host size is equal to or smaller than internalHostSize, there won't be any -// split and the return list will contain only the passed subnet. -func getInternalSubnets(inSubnet *net.IPNet, internalHostSize int) ([]*net.IPNet, error) { - var subnetList []*net.IPNet - - // Sanity check and size adjustment for v6 - subnet, err := adjustAndCheckSubnetSize(inSubnet) - if err != nil { - return subnetList, err +// RequestAddress returns an address from the specified pool ID +func (a *Allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[string]string) (*net.IPNet, map[string]string, error) { + k := SubnetKey{} + if err := k.FromString(poolID); err != nil { + return nil, nil, types.BadRequestErrorf("invalid pool id: %s", poolID) } - // Get network/host subnet information - netBits, bits := subnet.Mask.Size() - hostBits := bits - netBits - - extraBits := hostBits - internalHostSize - if extraBits <= 0 { - subnetList = make([]*net.IPNet, 1) - subnetList[0] = subnet - } else { - // Split in smaller internal subnets - numIntSubs := 1 << uint(extraBits) - subnetList = make([]*net.IPNet, numIntSubs) - - // Construct one copy of the internal subnets's mask - intNetBits := bits - internalHostSize - intMask := net.CIDRMask(intNetBits, bits) - - // Construct the prefix portion for each internal subnet - for i := 0; i < numIntSubs; i++ { - intIP := make([]byte, len(subnet.IP)) - copy(intIP, subnet.IP) // IPv6 is too big, just work on the extra portion - addIntToIP(intIP, uint32(i< len(a.predefined[as])-1-atLeast { + return 0, nil, fmt.Errorf("Not enough non-overlapping networks to run the test") + } + return i, a.predefined[as][i], nil +} + func TestAdjustAndCheckSubnet(t *testing.T) { _, sub6, _ := net.ParseCIDR("1003:1:2:300::/63") _, err := adjustAndCheckSubnetSize(sub6) @@ -172,13 +444,13 @@ func TestAdjustAndCheckSubnet(t *testing.T) { } func TestRemoveSubnet(t *testing.T) { - a, err := NewAllocator(nil) + a, err := NewAllocator(nil, nil) if err != nil { t.Fatal(err) } input := []struct { - addrSpace AddressSpace + addrSpace string subnet string }{ {"default", "192.168.0.0/16"}, @@ -191,119 +463,116 @@ func TestRemoveSubnet(t *testing.T) { {"splane", "2002:1:2:3:4:5:ffff::/112"}, } - for _, i := range input { - _, sub, err := net.ParseCIDR(i.subnet) - if err != nil { - t.Fatalf("Wrong input, Can't proceed: %s", err.Error()) - } - err = a.AddSubnet(i.addrSpace, &SubnetInfo{Subnet: sub}) - if err != nil { + poolIDs := make([]string, len(input)) + + for ind, i := range input { + if poolIDs[ind], _, _, err = a.RequestPool(i.addrSpace, i.subnet, "", nil, false); err != nil { t.Fatalf("Failed to apply input. Can't proceed: %s", err.Error()) } } - _, sub, _ := net.ParseCIDR("172.17.0.0/16") - a.RemoveSubnet("default", sub) - if len(a.subnets) != 7 { - t.Fatalf("Failed to remove subnet info") - } - list := a.getSubnetList("default", v4) - if len(list) != 257 { - t.Fatalf("Failed to effectively remove subnet address space") - } - - _, sub, _ = net.ParseCIDR("2002:1:2:3:4:5:ffff::/112") - a.RemoveSubnet("default", sub) - if len(a.subnets) != 6 { - t.Fatalf("Failed to remove subnet info") - } - list = a.getSubnetList("default", v6) - if len(list) != 0 { - t.Fatalf("Failed to effectively remove subnet address space") - } - - _, sub, _ = net.ParseCIDR("2002:1:2:3:4:5:6::/112") - a.RemoveSubnet("splane", sub) - if len(a.subnets) != 5 { - t.Fatalf("Failed to remove subnet info") - } - list = a.getSubnetList("splane", v6) - if len(list) != 1 { - t.Fatalf("Failed to effectively remove subnet address space") - } -} - -func TestGetInternalSubnets(t *testing.T) { - // This function tests the splitting of a parent subnet in small host subnets. - // The splitting is controlled by the max host size, which is the first parameter - // passed to the function. It basically says if the parent subnet host size is - // greater than the max host size, split the parent subnet into N internal small - // subnets with host size = max host size to cover the same address space. - - input := []struct { - internalHostSize int - parentSubnet string - firstIntSubnet string - lastIntSubnet string - }{ - // Test 8 bits prefix network - {24, "10.0.0.0/8", "10.0.0.0/8", "10.0.0.0/8"}, - {16, "10.0.0.0/8", "10.0.0.0/16", "10.255.0.0/16"}, - {8, "10.0.0.0/8", "10.0.0.0/24", "10.255.255.0/24"}, - // Test 16 bits prefix network - {16, "192.168.0.0/16", "192.168.0.0/16", "192.168.0.0/16"}, - {8, "192.168.0.0/16", "192.168.0.0/24", "192.168.255.0/24"}, - // Test 24 bits prefix network - {16, "192.168.57.0/24", "192.168.57.0/24", "192.168.57.0/24"}, - {8, "192.168.57.0/24", "192.168.57.0/24", "192.168.57.0/24"}, - // Test non byte multiple host size - {24, "10.0.0.0/8", "10.0.0.0/8", "10.0.0.0/8"}, - {20, "10.0.0.0/12", "10.0.0.0/12", "10.0.0.0/12"}, - {20, "10.128.0.0/12", "10.128.0.0/12", "10.128.0.0/12"}, - {12, "10.16.0.0/16", "10.16.0.0/20", "10.16.240.0/20"}, - {13, "10.0.0.0/8", "10.0.0.0/19", "10.255.224.0/19"}, - {15, "10.0.0.0/8", "10.0.0.0/17", "10.255.128.0/17"}, - // Test v6 network - {16, "2002:1:2:3:4:5:6000::/110", "2002:1:2:3:4:5:6000:0/112", "2002:1:2:3:4:5:6003:0/112"}, - {16, "2002:1:2:3:4:5:ff00::/104", "2002:1:2:3:4:5:ff00:0/112", "2002:1:2:3:4:5:ffff:0/112"}, - {12, "2002:1:2:3:4:5:ffff::/112", "2002:1:2:3:4:5:ffff:0/116", "2002:1:2:3:4:5:ffff:f000/116"}, - {11, "2002:1:2:3:4:5:ffff::/112", "2002:1:2:3:4:5:ffff:0/117", "2002:1:2:3:4:5:ffff:f800/117"}, - } - - for _, d := range input { - assertInternalSubnet(t, d.internalHostSize, d.parentSubnet, d.firstIntSubnet, d.lastIntSubnet) + for ind, id := range poolIDs { + if err := a.ReleasePool(id); err != nil { + t.Fatalf("Failed to release poolID %s (%d)", id, ind) + } } } func TestGetSameAddress(t *testing.T) { - a, err := NewAllocator(nil) + a, err := NewAllocator(nil, nil) if err != nil { t.Fatal(err) } - addSpace := AddressSpace("giallo") - _, subnet, _ := net.ParseCIDR("192.168.100.0/24") - if err := a.AddSubnet(addSpace, &SubnetInfo{Subnet: subnet}); err != nil { + pid, _, _, err := a.RequestPool("giallo", "192.168.100.0/24", "", nil, false) + if err != nil { t.Fatal(err) } ip := net.ParseIP("192.168.100.250") - req := &AddressRequest{Subnet: *subnet, Address: ip} - - _, err = a.Request(addSpace, req) + _, _, err = a.RequestAddress(pid, ip, nil) if err != nil { t.Fatal(err) } - _, err = a.Request(addSpace, req) + _, _, err = a.RequestAddress(pid, ip, nil) if err == nil { t.Fatal(err) } } +func TestRequestReleaseAddressFromSubPool(t *testing.T) { + a, err := NewAllocator(nil, nil) + if err != nil { + t.Fatal(err) + } + + poolID, _, _, err := a.RequestPool("rosso", "172.28.0.0/16", "172.28.30.0/24", nil, false) + if err != nil { + t.Fatal(err) + } + + var ip *net.IPNet + expected := &net.IPNet{IP: net.IP{172, 28, 30, 255}, Mask: net.IPMask{255, 255, 0, 0}} + for err == nil { + var c *net.IPNet + if c, _, err = a.RequestAddress(poolID, nil, nil); err == nil { + ip = c + } + } + if err != ipamapi.ErrNoAvailableIPs { + t.Fatal(err) + } + if !types.CompareIPNet(expected, ip) { + t.Fatalf("Unexpected last IP from subpool. Expected: %s. Got: %v.", expected, ip) + } + rp := &net.IPNet{IP: net.IP{172, 28, 30, 97}, Mask: net.IPMask{255, 255, 0, 0}} + if err = a.ReleaseAddress(poolID, rp.IP); err != nil { + t.Fatal(err) + } + if ip, _, err = a.RequestAddress(poolID, nil, nil); err != nil { + t.Fatal(err) + } + if !types.CompareIPNet(rp, ip) { + t.Fatalf("Unexpected IP from subpool. Expected: %s. Got: %v.", rp, ip) + } + + _, _, _, err = a.RequestPool("rosso", "10.0.0.0/8", "10.0.0.0/16", nil, false) + if err != nil { + t.Fatal(err) + } + poolID, _, _, err = a.RequestPool("rosso", "10.0.0.0/16", "10.0.0.0/24", nil, false) + if err != nil { + t.Fatal(err) + } + expected = &net.IPNet{IP: net.IP{10, 0, 0, 255}, Mask: net.IPMask{255, 255, 0, 0}} + for err == nil { + var c *net.IPNet + if c, _, err = a.RequestAddress(poolID, nil, nil); err == nil { + ip = c + } + } + if err != ipamapi.ErrNoAvailableIPs { + t.Fatal(err) + } + if !types.CompareIPNet(expected, ip) { + t.Fatalf("Unexpected last IP from subpool. Expected: %s. Got: %v.", expected, ip) + } + rp = &net.IPNet{IP: net.IP{10, 0, 0, 79}, Mask: net.IPMask{255, 255, 0, 0}} + if err = a.ReleaseAddress(poolID, rp.IP); err != nil { + t.Fatal(err) + } + if ip, _, err = a.RequestAddress(poolID, nil, nil); err != nil { + t.Fatal(err) + } + if !types.CompareIPNet(rp, ip) { + t.Fatalf("Unexpected IP from subpool. Expected: %s. Got: %v.", rp, ip) + } +} + func TestGetAddress(t *testing.T) { input := []string{ - /*"10.0.0.0/8", "10.0.0.0/9", */ "10.0.0.0/10", "10.0.0.0/11", "10.0.0.0/12", "10.0.0.0/13", "10.0.0.0/14", + /*"10.0.0.0/8", "10.0.0.0/9", "10.0.0.0/10",*/ "10.0.0.0/11", "10.0.0.0/12", "10.0.0.0/13", "10.0.0.0/14", "10.0.0.0/15", "10.0.0.0/16", "10.0.0.0/17", "10.0.0.0/18", "10.0.0.0/19", "10.0.0.0/20", "10.0.0.0/21", "10.0.0.0/22", "10.0.0.0/23", "10.0.0.0/24", "10.0.0.0/25", "10.0.0.0/26", "10.0.0.0/27", "10.0.0.0/28", "10.0.0.0/29", "10.0.0.0/30", "10.0.0.0/31"} @@ -313,90 +582,65 @@ func TestGetAddress(t *testing.T) { } } -func TestGetSubnetList(t *testing.T) { - a, err := NewAllocator(nil) - if err != nil { - t.Fatal(err) - } - input := []struct { - addrSpace AddressSpace - subnet string - }{ - {"default", "192.168.0.0/16"}, - {"default", "172.17.0.0/16"}, - {"default", "10.0.0.0/8"}, - {"default", "2002:1:2:3:4:5:6::/112"}, - {"default", "2002:1:2:3:4:5:ffff::/112"}, - {"splane", "172.17.0.0/16"}, - {"splane", "10.0.0.0/8"}, - {"splane", "2002:1:2:3:4:5:ff00::/104"}, - } - - for _, i := range input { - _, sub, err := net.ParseCIDR(i.subnet) - if err != nil { - t.Fatalf("Wrong input, Can't proceed: %s", err.Error()) - } - err = a.AddSubnet(i.addrSpace, &SubnetInfo{Subnet: sub}) - if err != nil { - t.Fatalf("Failed to apply input. Can't proceed: %s", err.Error()) - } - } - - list := a.getSubnetList("default", v4) - if len(list) != 258 { - t.Fatalf("Incorrect number of internal subnets for ipv4 version. Expected 258. Got %d.", len(list)) - } - list = a.getSubnetList("splane", v4) - if len(list) != 257 { - t.Fatalf("Incorrect number of internal subnets for ipv4 version. Expected 257. Got %d.", len(list)) - } - - list = a.getSubnetList("default", v6) - if len(list) != 2 { - t.Fatalf("Incorrect number of internal subnets for ipv6 version. Expected 2. Got %d.", len(list)) - } - list = a.getSubnetList("splane", v6) - if len(list) != 256 { - t.Fatalf("Incorrect number of internal subnets for ipv6 version. Expected 256. Got %d.", len(list)) - } - -} - func TestRequestSyntaxCheck(t *testing.T) { var ( - subnet = "192.168.0.0/16" - addSpace = AddressSpace("green") + pool = "192.168.0.0/16" + subPool = "192.168.0.0/24" + addrSpace = "green" ) - a, err := NewAllocator(nil) - if err != nil { - t.Fatal(err) - } + a, _ := NewAllocator(nil, nil) - // Add subnet and create base request - _, sub, _ := net.ParseCIDR(subnet) - a.AddSubnet(addSpace, &SubnetInfo{Subnet: sub}) - req := &AddressRequest{Subnet: *sub} - - // Empty address space request - _, err = a.Request("", req) + _, _, _, err := a.RequestPool("", pool, "", nil, false) if err == nil { t.Fatalf("Failed to detect wrong request: empty address space") } - // Preferred address from different subnet in request - req.Address = net.ParseIP("172.17.0.23") - _, err = a.Request(addSpace, req) + _, _, _, err = a.RequestPool("", pool, subPool, nil, false) + if err == nil { + t.Fatalf("Failed to detect wrong request: empty address space") + } + + _, _, _, err = a.RequestPool(addrSpace, "", subPool, nil, false) + if err == nil { + t.Fatalf("Failed to detect wrong request: subPool specified and no pool") + } + + pid, _, _, err := a.RequestPool(addrSpace, pool, subPool, nil, false) + if err != nil { + t.Fatalf("Unexpected failure: %v", err) + } + + _, _, err = a.RequestAddress("", nil, nil) + if err == nil { + t.Fatalf("Failed to detect wrong request: no pool id specified") + } + + ip := net.ParseIP("172.17.0.23") + _, _, err = a.RequestAddress(pid, ip, nil) if err == nil { t.Fatalf("Failed to detect wrong request: preferred IP from different subnet") } - // Preferred address specified and nil subnet - req = &AddressRequest{Address: net.ParseIP("172.17.0.23")} - _, err = a.Request(addSpace, req) + ip = net.ParseIP("192.168.0.50") + _, _, err = a.RequestAddress(pid, ip, nil) + if err != nil { + t.Fatalf("Unexpected failure: %v", err) + } + + err = a.ReleaseAddress("", ip) if err == nil { - t.Fatalf("Failed to detect wrong request: subnet not specified but preferred address specified") + t.Fatalf("Failed to detect wrong request: no pool id specified") + } + + err = a.ReleaseAddress(pid, nil) + if err == nil { + t.Fatalf("Failed to detect wrong request: no pool id specified") + } + + err = a.ReleaseAddress(pid, ip) + if err != nil { + t.Fatalf("Unexpected failure: %v", err) } } @@ -433,18 +677,15 @@ func TestRequest(t *testing.T) { func TestRelease(t *testing.T) { var ( err error - req *AddressRequest subnet = "192.168.0.0/16" ) - _, sub, _ := net.ParseCIDR(subnet) - a := getAllocator(t, sub) - req = &AddressRequest{Subnet: *sub} - bm := a.addresses[subnetKey{"default", subnet, subnet}] + a, pid := getAllocator(t, subnet) + bm := a.addresses[SubnetKey{"default", subnet, ""}] // Allocate all addresses - for err != ErrNoAvailableIPs { - _, err = a.Request("default", req) + for err != ipamapi.ErrNoAvailableIPs { + _, _, err = a.RequestAddress(pid, nil, nil) } toRelease := []struct { @@ -475,45 +716,24 @@ func TestRelease(t *testing.T) { } // One by one, relase the address and request again. We should get the same IP - req = &AddressRequest{Subnet: *sub} for i, inp := range toRelease { - address := net.ParseIP(inp.address) - a.Release("default", address) + ip0 := net.ParseIP(inp.address) + a.ReleaseAddress(pid, ip0) if bm.Unselected() != 1 { t.Fatalf("Failed to update free address count after release. Expected %d, Found: %d", i+1, bm.Unselected()) } - rsp, err := a.Request("default", req) + nw, _, err := a.RequestAddress(pid, nil, nil) if err != nil { t.Fatalf("Failed to obtain the address: %s", err.Error()) } - if !address.Equal(rsp.Address) { - t.Fatalf("Failed to obtain the same address. Expected: %s, Got: %s", address, rsp.Address) + ip := nw.IP + if !ip0.Equal(ip) { + t.Fatalf("Failed to obtain the same address. Expected: %s, Got: %s", ip0, ip) } } } -func assertInternalSubnet(t *testing.T, hostSize int, bigSubnet, firstSmall, lastSmall string) { - _, subnet, _ := net.ParseCIDR(bigSubnet) - list, _ := getInternalSubnets(subnet, hostSize) - count := 1 - ones, bits := subnet.Mask.Size() - diff := bits - ones - int(hostSize) - if diff > 0 { - count <<= uint(diff) - } - - if len(list) != count { - t.Fatalf("Wrong small subnets number. Expected: %d, Got: %d", count, len(list)) - } - if firstSmall != list[0].String() { - t.Fatalf("Wrong first small subent. Expected: %v, Got: %v", firstSmall, list[0]) - } - if lastSmall != list[count-1].String() { - t.Fatalf("Wrong last small subent. Expected: %v, Got: %v", lastSmall, list[count-1]) - } -} - func assertGetAddress(t *testing.T, subnet string) { var ( err error @@ -526,15 +746,15 @@ func assertGetAddress(t *testing.T, subnet string) { zeroes := bits - ones numAddresses := 1 << uint(zeroes) - bm, err := bitseq.NewHandle("ipam_test", nil, "default/192.168.0.0/24", uint32(numAddresses)) + bm, err := bitseq.NewHandle("ipam_test", nil, "default/"+subnet, uint32(numAddresses)) if err != nil { t.Fatal(err) } start := time.Now() run := 0 - for err != ErrNoAvailableIPs { - _, err = a.getAddress(sub, bm, nil, v4) + for err != ipamapi.ErrNoAvailableIPs { + _, err = a.getAddress(sub, bm, nil, nil) run++ } if printTime { @@ -554,59 +774,52 @@ func assertGetAddress(t *testing.T, subnet string) { func assertNRequests(t *testing.T, subnet string, numReq int, lastExpectedIP string) { var ( err error - req *AddressRequest - rsp *AddressResponse + nw *net.IPNet printTime = false ) - _, sub, _ := net.ParseCIDR(subnet) lastIP := net.ParseIP(lastExpectedIP) - - a := getAllocator(t, sub) - req = &AddressRequest{Subnet: *sub} + a, pid := getAllocator(t, subnet) i := 0 start := time.Now() for ; i < numReq; i++ { - rsp, err = a.Request("default", req) + nw, _, err = a.RequestAddress(pid, nil, nil) } if printTime { fmt.Printf("\nTaken %v, to allocate %d addresses on %s\n", time.Since(start), numReq, subnet) } - if !lastIP.Equal(rsp.Address) { - t.Fatalf("Wrong last IP. Expected %s. Got: %s (err: %v, ind: %d)", lastExpectedIP, rsp.Address.String(), err, i) + if !lastIP.Equal(nw.IP) { + t.Fatalf("Wrong last IP. Expected %s. Got: %s (err: %v, ind: %d)", lastExpectedIP, nw.IP.String(), err, i) } } -func benchmarkRequest(subnet *net.IPNet) { +func benchmarkRequest(subnet string) { var err error - a, _ := NewAllocator(nil) - a.internalHostSize = 20 - a.AddSubnet("default", &SubnetInfo{Subnet: subnet}) - - req := &AddressRequest{Subnet: *subnet} - for err != ErrNoAvailableIPs { - _, err = a.Request("default", req) + a, _ := NewAllocator(nil, nil) + pid, _, _, _ := a.RequestPool("default", subnet, "", nil, false) + for err != ipamapi.ErrNoAvailableIPs { + _, _, err = a.RequestAddress(pid, nil, nil) } } -func benchMarkRequest(subnet *net.IPNet, b *testing.B) { +func benchMarkRequest(subnet string, b *testing.B) { for n := 0; n < b.N; n++ { benchmarkRequest(subnet) } } func BenchmarkRequest_24(b *testing.B) { - benchmarkRequest(&net.IPNet{IP: []byte{10, 0, 0, 0}, Mask: []byte{255, 255, 255, 0}}) + benchmarkRequest("10.0.0.0/24") } func BenchmarkRequest_16(b *testing.B) { - benchmarkRequest(&net.IPNet{IP: []byte{10, 0, 0, 0}, Mask: []byte{255, 255, 0, 0}}) + benchmarkRequest("10.0.0.0/16") } func BenchmarkRequest_8(b *testing.B) { - benchmarkRequest(&net.IPNet{IP: []byte{10, 0, 0, 0}, Mask: []byte{255, 0xfc, 0, 0}}) + benchmarkRequest("10.0.0.0/8") } diff --git a/libnetwork/ipam/contract.go b/libnetwork/ipam/contract.go deleted file mode 100644 index 618ada2c52..0000000000 --- a/libnetwork/ipam/contract.go +++ /dev/null @@ -1,100 +0,0 @@ -// Package ipam that specifies the contract the IPAM plugin need to satisfy, -// decoupling IPAM interface and implementation. -package ipam - -import ( - "errors" - "net" -) - -/************** - * IPAM Errors - **************/ - -// ErrIpamNotAvailable is returned when the plugin prviding the IPAM service is not available -var ( - ErrInvalidIpamService = errors.New("Invalid IPAM Service") - ErrInvalidIpamConfigService = errors.New("Invalid IPAM Config Service") - ErrIpamNotAvailable = errors.New("IPAM Service not available") - ErrIpamInternalError = errors.New("IPAM Internal Error") - ErrInvalidAddressSpace = errors.New("Invalid Address Space") - ErrInvalidSubnet = errors.New("Invalid Subnet") - ErrInvalidRequest = errors.New("Invalid Request") - ErrSubnetNotFound = errors.New("Subnet not found") - ErrOverlapSubnet = errors.New("Subnet overlaps with existing subnet on this address space") - ErrNoAvailableSubnet = errors.New("No available subnet") - ErrNoAvailableIPs = errors.New("No available addresses on subnet") - ErrIPAlreadyAllocated = errors.New("Address already in use") - ErrIPOutOfRange = errors.New("Requested address is out of range") - ErrSubnetAlreadyRegistered = errors.New("Subnet already registered on this address space") - ErrBadSubnet = errors.New("Address space does not contain specified subnet") -) - -// AddressSpace identifies a unique pool of network addresses -type AddressSpace string - -/******************************* - * IPAM Configuration Interface - *******************************/ - -// Config represents the interface the IPAM service plugins must implement -// in order to allow injection/modification of IPAM database. -// Common key is a addressspace -type Config interface { - // AddSubnet adds a subnet to the specified address space - AddSubnet(AddressSpace, *SubnetInfo) error - // RemoveSubnet removes a subnet from the specified address space - RemoveSubnet(AddressSpace, *net.IPNet) error - // AddVendorInfo adds Vendor specific data - AddVendorInfo([]byte) error -} - -// SubnetInfo contains the information subnet hosts need in order to communicate -type SubnetInfo struct { - Subnet *net.IPNet - Gateway net.IP - OpaqueData []byte // Vendor specific -} - -/************************* - * IPAM Service Interface - *************************/ - -// IPAM defines the interface that needs to be implemented by IPAM service plugin -// Common key is a unique address space identifier -type IPAM interface { - // Request address from the specified address space - Request(AddressSpace, *AddressRequest) (*AddressResponse, error) - // Separate API for IPv6 - RequestV6(AddressSpace, *AddressRequest) (*AddressResponse, error) - // Release the address from the specified address space - Release(AddressSpace, net.IP) -} - -// AddressRequest encloses the information a client -// needs to pass to IPAM when requesting an address -type AddressRequest struct { - Subnet net.IPNet // Preferred subnet pool (Optional) - Address net.IP // Preferred address (Optional) - Endpoint string // For static IP mapping (Optional) - OpaqueData []byte // Vendor specific request data -} - -// Validate runs syntactic validation on this AddressRequest object -func (req *AddressRequest) Validate() error { - var byteArray []byte = req.Address - - // Check preferred address - if byteArray != nil && (&req.Subnet == nil || !req.Subnet.Contains(req.Address)) { - return ErrInvalidRequest - } - - return nil -} - -// AddressResponse represents the IPAM service's -// response to an address request -type AddressResponse struct { - Address net.IP - Subnet SubnetInfo -} diff --git a/libnetwork/ipam/store.go b/libnetwork/ipam/store.go index 8794a3d194..e3d327f1f9 100644 --- a/libnetwork/ipam/store.go +++ b/libnetwork/ipam/store.go @@ -2,7 +2,6 @@ package ipam import ( "encoding/json" - "net" log "github.com/Sirupsen/logrus" "github.com/docker/libnetwork/datastore" @@ -13,14 +12,14 @@ import ( func (a *Allocator) Key() []string { a.Lock() defer a.Unlock() - return []string{a.App, a.ID} + return []string{dsConfigKey} } // KeyPrefix returns the immediate parent key that can be used for tree walk func (a *Allocator) KeyPrefix() []string { a.Lock() defer a.Unlock() - return []string{a.App} + return []string{dsConfigKey} } // Value marshals the data to be stored in the KV store @@ -31,9 +30,14 @@ func (a *Allocator) Value() []byte { if a.subnets == nil { return []byte{} } + m := map[string]interface{}{} + for k, v := range a.subnets { + m[k.String()] = v + } - b, err := subnetsToByteArray(a.subnets) + b, err := json.Marshal(m) if err != nil { + log.Warnf("Failed to marshal ipam configured subnets") return nil } return b @@ -41,52 +45,19 @@ func (a *Allocator) Value() []byte { // SetValue unmarshalls the data from the KV store. func (a *Allocator) SetValue(value []byte) error { - a.subnets = byteArrayToSubnets(value) - return nil -} - -func subnetsToByteArray(m map[subnetKey]*SubnetInfo) ([]byte, error) { - if m == nil { - return nil, nil - } - - mm := make(map[string]string, len(m)) - for k, v := range m { - mm[k.String()] = v.Subnet.String() - } - - return json.Marshal(mm) -} - -func byteArrayToSubnets(ba []byte) map[subnetKey]*SubnetInfo { - m := map[subnetKey]*SubnetInfo{} - - if ba == nil || len(ba) == 0 { - return m - } - - var mm map[string]string - err := json.Unmarshal(ba, &mm) + var m map[string]*PoolData + err := json.Unmarshal(value, &m) if err != nil { - log.Warnf("Failed to decode subnets byte array: %v", err) - return m + return err } - for ks, vs := range mm { - sk := subnetKey{} - if err := sk.FromString(ks); err != nil { - log.Warnf("Failed to decode subnets map entry: (%s, %s)", ks, vs) - continue + for ks, d := range m { + k := SubnetKey{} + if err := k.FromString(ks); err != nil { + return err } - si := &SubnetInfo{} - _, nw, err := net.ParseCIDR(vs) - if err != nil { - log.Warnf("Failed to decode subnets map entry value: (%s, %s)", ks, vs) - continue - } - si.Subnet = nw - m[sk] = si + a.subnets[k] = d } - return m + return nil } // Index returns the latest DB Index as seen by this object @@ -130,7 +101,6 @@ func (a *Allocator) watchForChanges() error { select { case kvPair := <-kvpChan: if kvPair != nil { - log.Debugf("Got notification for key %v: %v", kvPair.Key, kvPair.Value) a.subnetConfigFromStore(kvPair) } } diff --git a/libnetwork/ipamapi/contract.go b/libnetwork/ipamapi/contract.go new file mode 100644 index 0000000000..47396093b1 --- /dev/null +++ b/libnetwork/ipamapi/contract.go @@ -0,0 +1,74 @@ +// Package ipamapi specifies the contract the IPAM service (built-in or remote) needs to satisfy. +package ipamapi + +import ( + "errors" + "net" +) + +/******************** + * IPAM plugin types + ********************/ + +const ( + // DefaultIPAM is the name of the built-in default ipam driver + DefaultIPAM = "default" + // PluginEndpointType represents the Endpoint Type used by Plugin system + PluginEndpointType = "IPAM" + // Gateway is the key for the gateway option + Gateway = "gateway" +) + +// Callback provides a Callback interface for registering an IPAM instance into LibNetwork +type Callback interface { + // RegisterDriver provides a way for Remote drivers to dynamically register new NetworkType and associate with a ipam instance + RegisterIpamDriver(name string, driver Ipam) error +} + +/************** + * IPAM Errors + **************/ + +// Weel-known errors returned by IPAM +var ( + ErrInvalidIpamService = errors.New("Invalid IPAM Service") + ErrInvalidIpamConfigService = errors.New("Invalid IPAM Config Service") + ErrIpamNotAvailable = errors.New("IPAM Service not available") + ErrIpamInternalError = errors.New("IPAM Internal Error") + ErrInvalidAddressSpace = errors.New("Invalid Address Space") + ErrInvalidPool = errors.New("Invalid Address Pool") + ErrInvalidSubPool = errors.New("Invalid Address SubPool") + ErrInvalidRequest = errors.New("Invalid Request") + ErrPoolNotFound = errors.New("Address Pool not found") + ErrOverlapPool = errors.New("Address pool overlaps with existing pool on this address space") + ErrNoAvailablePool = errors.New("No available pool") + ErrNoAvailableIPs = errors.New("No available addresses on this pool") + ErrIPAlreadyAllocated = errors.New("Address already in use") + ErrIPOutOfRange = errors.New("Requested address is out of range") + ErrPoolOverlap = errors.New("Pool overlaps with other one on this address space") + ErrBadPool = errors.New("Address space does not contain specified address pool") +) + +/******************************* + * IPAM Service Interface + *******************************/ + +// Ipam represents the interface the IPAM service plugins must implement +// in order to allow injection/modification of IPAM database. +type Ipam interface { + // GetDefaultAddressSpaces returns the default local and global address spaces for this ipam + GetDefaultAddressSpaces() (string, string, error) + // RequestPool returns an address pool along with its unique id. Address space is a mandatory field + // which denotes a set of non-overlapping pools. pool describes the pool of addrresses in CIDR notation. + // subpool indicates a smaller range of addresses from the pool, for now it is specified in CIDR notation. + // Both pool and subpool are non mandatory fields. When they are not specified, Ipam driver may choose to + // return a self chosen pool for this request. In such case the v6 flag needs to be set appropriately so + // that the driver would return the expected ip version pool. + RequestPool(addressSpace, pool, subPool string, options map[string]string, v6 bool) (string, *net.IPNet, map[string]string, error) + // ReleasePool releases the address pool identified by the passed id + ReleasePool(poolID string) error + // Request address from the specified pool ID. Input options or preferred IP can be passed. + RequestAddress(string, net.IP, map[string]string) (*net.IPNet, map[string]string, error) + // Release the address from the specified pool ID + ReleaseAddress(string, net.IP) error +} diff --git a/libnetwork/ipams/builtin/builtin.go b/libnetwork/ipams/builtin/builtin.go new file mode 100644 index 0000000000..707e001f73 --- /dev/null +++ b/libnetwork/ipams/builtin/builtin.go @@ -0,0 +1,35 @@ +package builtin + +import ( + "fmt" + + "github.com/docker/libnetwork/datastore" + "github.com/docker/libnetwork/ipam" + "github.com/docker/libnetwork/ipamapi" +) + +// Init registers the built-in ipam service with libnetwork +func Init(ic ipamapi.Callback, l, g interface{}) error { + var ( + ok bool + localDs, globalDs datastore.DataStore + ) + + if l != nil { + if localDs, ok = l.(datastore.DataStore); !ok { + return fmt.Errorf("incorrect local datastore passed to built-in ipam init") + } + } + + if g != nil { + if globalDs, ok = g.(datastore.DataStore); !ok { + return fmt.Errorf("incorrect global datastore passed to built-in ipam init") + } + } + a, err := ipam.NewAllocator(localDs, globalDs) + if err != nil { + return err + } + + return ic.RegisterIpamDriver(ipamapi.DefaultIPAM, a) +} diff --git a/libnetwork/ipams/remote/api/api.go b/libnetwork/ipams/remote/api/api.go new file mode 100644 index 0000000000..7d60eb311d --- /dev/null +++ b/libnetwork/ipams/remote/api/api.go @@ -0,0 +1,81 @@ +// Package api defines the data structure to be used in the request/response +// messages between libnetwork and the remote ipam plugin +package api + +import ( + "net" +) + +// Response is the basic response structure used in all responses +type Response struct { + Error string +} + +// IsSuccess returns wheter the plugin response is successful +func (r *Response) IsSuccess() bool { + return r.Error == "" +} + +// GetError returns the error from the response, if any. +func (r *Response) GetError() string { + return r.Error +} + +// GetAddressSpacesResponse is the response to the ``get default address spaces`` request message +type GetAddressSpacesResponse struct { + Response + LocalDefaultAddressSpace string + GlobalDefaultAddressSpace string +} + +// RequestPoolRequest represents the expected data in a ``request address pool`` request message +type RequestPoolRequest struct { + AddressSpace string + Pool string + SubPool string + Options map[string]string + V6 bool +} + +// RequestPoolResponse represents the response message to a ``request address pool`` request +type RequestPoolResponse struct { + Response + PoolID string + Pool *net.IPNet + Data map[string]string +} + +// ReleasePoolRequest represents the expected data in a ``release address pool`` request message +type ReleasePoolRequest struct { + PoolID string +} + +// ReleasePoolResponse represents the response message to a ``release address pool`` request +type ReleasePoolResponse struct { + Response +} + +// RequestAddressRequest represents the expected data in a ``request address`` request message +type RequestAddressRequest struct { + PoolID string + Address net.IP + Options map[string]string +} + +// RequestAddressResponse represents the expected data in the response message to a ``request address`` request +type RequestAddressResponse struct { + Response + Address *net.IPNet + Data map[string]string +} + +// ReleaseAddressRequest represents the expected data in a ``release address`` request message +type ReleaseAddressRequest struct { + PoolID string + Address net.IP +} + +// ReleaseAddressResponse represents the response message to a ``release address`` request +type ReleaseAddressResponse struct { + Response +} diff --git a/libnetwork/ipams/remote/remote.go b/libnetwork/ipams/remote/remote.go new file mode 100644 index 0000000000..f5ddbd4764 --- /dev/null +++ b/libnetwork/ipams/remote/remote.go @@ -0,0 +1,92 @@ +package remote + +import ( + "fmt" + "net" + + log "github.com/Sirupsen/logrus" + "github.com/docker/docker/pkg/plugins" + "github.com/docker/libnetwork/ipamapi" + "github.com/docker/libnetwork/ipams/remote/api" +) + +type allocator struct { + endpoint *plugins.Client + name string +} + +// PluginResponse is the interface for the plugin request responses +type PluginResponse interface { + IsSuccess() bool + GetError() string +} + +func newAllocator(name string, client *plugins.Client) ipamapi.Ipam { + a := &allocator{name: name, endpoint: client} + return a +} + +// Init registers a remote ipam when its plugin is activated +func Init(cb ipamapi.Callback, l, g interface{}) error { + plugins.Handle(ipamapi.PluginEndpointType, func(name string, client *plugins.Client) { + if err := cb.RegisterIpamDriver(name, newAllocator(name, client)); err != nil { + log.Errorf("error registering remote ipam %s due to %v", name, err) + } + }) + return nil +} + +func (a *allocator) call(methodName string, arg interface{}, retVal PluginResponse) error { + method := ipamapi.PluginEndpointType + "." + methodName + err := a.endpoint.Call(method, arg, retVal) + if err != nil { + return err + } + if !retVal.IsSuccess() { + return fmt.Errorf("remote: %s", retVal.GetError()) + } + return nil +} + +// GetDefaultAddressSpaces returns the local and global default address spaces +func (a *allocator) GetDefaultAddressSpaces() (string, string, error) { + res := &api.GetAddressSpacesResponse{} + if err := a.call("GetDefaultAddressSpaces", nil, res); err != nil { + return "", "", err + } + return res.LocalDefaultAddressSpace, res.GlobalDefaultAddressSpace, nil +} + +// RequestPool requests an address pool in the specified address space +func (a *allocator) RequestPool(addressSpace, pool, subPool string, options map[string]string, v6 bool) (string, *net.IPNet, map[string]string, error) { + req := &api.RequestPoolRequest{AddressSpace: addressSpace, Pool: pool, SubPool: subPool, Options: options, V6: v6} + res := &api.RequestPoolResponse{} + if err := a.call("RequestPool", req, res); err != nil { + return "", nil, nil, err + } + return res.PoolID, res.Pool, res.Data, nil +} + +// ReleasePool removes an address pool from the specified address space +func (a *allocator) ReleasePool(poolID string) error { + req := &api.ReleasePoolRequest{PoolID: poolID} + res := &api.ReleasePoolResponse{} + return a.call("ReleasePool", req, res) +} + +// RequestAddress requests an address from the address pool +func (a *allocator) RequestAddress(poolID string, address net.IP, options map[string]string) (*net.IPNet, map[string]string, error) { + req := &api.RequestAddressRequest{PoolID: poolID, Address: address, Options: options} + res := &api.RequestAddressResponse{} + if err := a.call("RequestAddress", req, res); err != nil { + return nil, nil, err + } + return res.Address, res.Data, nil +} + +// ReleaseAddress releases the address from the specified address pool +func (a *allocator) ReleaseAddress(poolID string, address net.IP) error { + req := &api.ReleaseAddressRequest{PoolID: poolID, Address: address} + res := &api.ReleaseAddressResponse{} + return a.call("ReleaseAddress", req, res) +} diff --git a/libnetwork/network.go b/libnetwork/network.go index ea7d4ea600..51164a4c2d 100644 --- a/libnetwork/network.go +++ b/libnetwork/network.go @@ -60,6 +60,7 @@ type network struct { name string networkType string id string + ipamType string driver driverapi.Driver enableIPv6 bool endpointCnt uint64 @@ -178,6 +179,7 @@ func (n *network) MarshalJSON() ([]byte, error) { netMap["name"] = n.name netMap["id"] = n.id netMap["networkType"] = n.networkType + netMap["ipamType"] = n.ipamType netMap["endpointCnt"] = n.endpointCnt netMap["enableIPv6"] = n.enableIPv6 netMap["generic"] = n.generic @@ -193,6 +195,7 @@ func (n *network) UnmarshalJSON(b []byte) (err error) { } n.name = netMap["name"].(string) n.id = netMap["id"].(string) + n.ipamType = netMap["ipamType"].(string) n.networkType = netMap["networkType"].(string) n.endpointCnt = uint64(netMap["endpointCnt"].(float64)) n.enableIPv6 = netMap["enableIPv6"].(bool) @@ -239,9 +242,7 @@ func (n *network) processOptions(options ...NetworkOption) { func (n *network) Delete() error { var err error - n.Lock() - ctrlr := n.ctrlr - n.Unlock() + ctrlr := n.getController() ctrlr.Lock() _, ok := ctrlr.networks[n.id] @@ -338,15 +339,12 @@ func (n *network) CreateEndpoint(name string, options ...EndpointOption) (Endpoi return nil, types.ForbiddenErrorf("service endpoint with name %s already exists", name) } - ep := &endpoint{name: name, - generic: make(map[string]interface{})} + ep := &endpoint{name: name, generic: make(map[string]interface{})} ep.id = stringid.GenerateRandomID() ep.network = n ep.processOptions(options...) - n.Lock() - ctrlr := n.ctrlr - n.Unlock() + ctrlr := n.getController() n.IncEndpointCnt() if err = ctrlr.updateToStore(n); err != nil { diff --git a/libnetwork/store.go b/libnetwork/store.go index 1b70cc22be..9cbbfc5a73 100644 --- a/libnetwork/store.go +++ b/libnetwork/store.go @@ -45,14 +45,7 @@ func (c *controller) initGlobalStore() error { c.Lock() c.globalStore = store c.Unlock() - - nws, err := c.getNetworksFromStore(true) - if err == nil { - c.processNetworkUpdate(nws, nil) - } else if err != datastore.ErrKeyNotFound { - log.Warnf("failed to read networks from globalstore during init : %v", err) - } - return c.watchNetworks() + return nil } func (c *controller) initLocalStore() error { @@ -66,14 +59,37 @@ func (c *controller) initLocalStore() error { c.Lock() c.localStore = localStore c.Unlock() + return nil +} - nws, err := c.getNetworksFromStore(false) +func (c *controller) restoreFromGlobalStore() error { + c.Lock() + s := c.globalStore + c.Unlock() + if s == nil { + return nil + } + c.restore("global") + return c.watchNetworks() +} + +func (c *controller) restoreFromLocalStore() error { + c.Lock() + s := c.localStore + c.Unlock() + if s != nil { + c.restore("local") + } + return nil +} + +func (c *controller) restore(store string) { + nws, err := c.getNetworksFromStore(store == "global") if err == nil { c.processNetworkUpdate(nws, nil) } else if err != datastore.ErrKeyNotFound { - log.Warnf("failed to read networks from localstore during init : %v", err) + log.Warnf("failed to read networks from %s store during init : %v", store, err) } - return nil } func (c *controller) getNetworksFromStore(global bool) ([]*store.KVPair, error) { diff --git a/libnetwork/store_test.go b/libnetwork/store_test.go index ec1da287ba..63777c001e 100644 --- a/libnetwork/store_test.go +++ b/libnetwork/store_test.go @@ -52,7 +52,6 @@ func testLocalBackend(t *testing.T, provider, url string, storeConfig *store.Con genericOption[netlabel.GenericData] = driverOptions cfgOptions = append(cfgOptions, config.OptionDriverConfig("host", genericOption)) - fmt.Printf("URL : %s\n", url) ctrl, err := New(cfgOptions...) if err != nil { t.Fatalf("Error new controller: %v", err) @@ -139,7 +138,7 @@ func TestLocalStoreLockTimeout(t *testing.T) { } defer ctrl1.Stop() // Use the same boltdb file without closing the previous controller - ctrl2, _ := New(cfgOptions...) + ctrl2, err := New(cfgOptions...) if err != nil { t.Fatalf("Error new controller: %v", err) } diff --git a/libnetwork/types/types.go b/libnetwork/types/types.go index 9df1af50b1..bd6e4c89ef 100644 --- a/libnetwork/types/types.go +++ b/libnetwork/types/types.go @@ -222,23 +222,32 @@ func GetMinimalIPNet(nw *net.IPNet) *net.IPNet { var v4inV6MaskPrefix = []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} -// GetHostPartIP returns the host portion of the ip address identified by the mask. -// IP address representation is not modified. If address and mask are not compatible -// an error is returned. -func GetHostPartIP(ip net.IP, mask net.IPMask) (net.IP, error) { +// compareIPMask checks if the passed ip and mask are semantically compatible. +// It returns the byte indexes for the address and mask so that caller can +// do bitwise operations without modifying address representation. +func compareIPMask(ip net.IP, mask net.IPMask) (is int, ms int, err error) { // Find the effective starting of address and mask - is := 0 - ms := 0 if len(ip) == net.IPv6len && ip.To4() != nil { is = 12 } if len(ip[is:]) == net.IPv4len && len(mask) == net.IPv6len && bytes.Equal(mask[:12], v4inV6MaskPrefix) { ms = 12 } - // Check if address and mask are semantically compatible if len(ip[is:]) != len(mask[ms:]) { - return nil, fmt.Errorf("cannot compute host portion ip address as ip and mask are not compatible: (%#v, %#v)", ip, mask) + err = fmt.Errorf("ip and mask are not compatible: (%#v, %#v)", ip, mask) + } + return +} + +// GetHostPartIP returns the host portion of the ip address identified by the mask. +// IP address representation is not modified. If address and mask are not compatible +// an error is returned. +func GetHostPartIP(ip net.IP, mask net.IPMask) (net.IP, error) { + // Find the effective starting of address and mask + is, ms, err := compareIPMask(ip, mask) + if err != nil { + return nil, fmt.Errorf("cannot compute host portion ip address because %s", err) } // Compute host portion @@ -250,6 +259,34 @@ func GetHostPartIP(ip net.IP, mask net.IPMask) (net.IP, error) { return out, nil } +// GetBroadcastIP returns the broadcast ip address for the passed network (ip and mask). +// IP address representation is not modified. If address and mask are not compatible +// an error is returned. +func GetBroadcastIP(ip net.IP, mask net.IPMask) (net.IP, error) { + // Find the effective starting of address and mask + is, ms, err := compareIPMask(ip, mask) + if err != nil { + return nil, fmt.Errorf("cannot compute broadcast ip address because %s", err) + } + + // Compute broadcast address + out := GetIPCopy(ip) + for i := 0; i < len(mask[ms:]); i++ { + out[is+i] |= ^mask[ms+i] + } + + return out, nil +} + +// ParseCIDR returns the *net.IPNet represented by the passed CIDR notation +func ParseCIDR(cidr string) (n *net.IPNet, e error) { + var i net.IP + if i, n, e = net.ParseCIDR(cidr); e == nil { + n.IP = i + } + return +} + const ( // NEXTHOP indicates a StaticRoute with an IP next hop. NEXTHOP = iota diff --git a/libnetwork/types/types_test.go b/libnetwork/types/types_test.go index ed90915b01..e5a94d22c2 100644 --- a/libnetwork/types/types_test.go +++ b/libnetwork/types/types_test.go @@ -111,6 +111,75 @@ func TestErrorConstructors(t *testing.T) { } } +func TestCompareIPMask(t *testing.T) { + input := []struct { + ip net.IP + mask net.IPMask + is int + ms int + isErr bool + }{ + { // ip in v4Inv6 representation, mask in v4 representation + ip: net.IPv4(172, 28, 30, 1), + mask: []byte{0xff, 0xff, 0xff, 0}, + is: 12, + ms: 0, + }, + { // ip and mask in v4Inv6 representation + ip: net.IPv4(172, 28, 30, 2), + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0}, + is: 12, + ms: 12, + }, + { // ip in v4 representation, mask in v4Inv6 representation + ip: net.IPv4(172, 28, 30, 3)[12:], + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0}, + is: 0, + ms: 12, + }, + { // ip and mask in v4 representation + ip: net.IPv4(172, 28, 30, 4)[12:], + mask: []byte{0xff, 0xff, 0xff, 0}, + is: 0, + ms: 0, + }, + { // ip and mask as v6 + ip: net.ParseIP("2005:2004:2002:2001:FFFF:ABCD:EEAB:00CD"), + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0}, + is: 0, + ms: 0, + }, + { + ip: net.ParseIP("2005:2004:2002:2001:FFFF:ABCD:EEAB:00CD"), + mask: []byte{0xff, 0xff, 0xff, 0}, + isErr: true, + }, + { + ip: net.ParseIP("173.32.4.5"), + mask: []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0}, + isErr: true, + }, + { + ip: net.ParseIP("173.32.4.5"), + mask: []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0}, + isErr: true, + }, + } + + for ind, i := range input { + is, ms, err := compareIPMask(i.ip, i.mask) + if i.isErr { + if err == nil { + t.Fatalf("Incorrect error condition for element %d. is: %d, ms: %d, err: %v", ind, is, ms, err) + } + } else { + if i.is != is || i.ms != ms { + t.Fatalf("expected is: %d, ms: %d. Got is: %d, ms: %d for element %d", i.is, i.ms, is, ms, ind) + } + } + } +} + func TestUtilGetHostPortionIP(t *testing.T) { input := []struct { ip net.IP @@ -168,3 +237,106 @@ func TestUtilGetHostPortionIP(t *testing.T) { t.Fatalf("Unexpected success") } } + +func TestUtilGetBroadcastIP(t *testing.T) { + input := []struct { + ip net.IP + mask net.IPMask + bcast net.IP + err error + }{ + // ip in v4Inv6 representation, mask in v4 representation + { + ip: net.IPv4(172, 28, 30, 1), + mask: []byte{0xff, 0xff, 0xff, 0}, + bcast: net.IPv4(172, 28, 30, 255), + }, + { + ip: net.IPv4(10, 28, 30, 1), + mask: []byte{0xff, 0, 0, 0}, + bcast: net.IPv4(10, 255, 255, 255), + }, + // ip and mask in v4Inv6 representation + { + ip: net.IPv4(172, 28, 30, 2), + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0}, + bcast: net.IPv4(172, 28, 30, 255), + }, + { + ip: net.IPv4(172, 28, 30, 2), + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0}, + bcast: net.IPv4(172, 28, 255, 255), + }, + // ip in v4 representation, mask in v4Inv6 representation + { + ip: net.IPv4(172, 28, 30, 3)[12:], + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0}, + bcast: net.IPv4(172, 28, 30, 255)[12:], + }, + { + ip: net.IPv4(172, 28, 30, 3)[12:], + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0}, + bcast: net.IPv4(172, 255, 255, 255)[12:], + }, + // ip and mask in v4 representation + { + ip: net.IPv4(172, 28, 30, 4)[12:], + mask: []byte{0xff, 0xff, 0xff, 0}, + bcast: net.IPv4(172, 28, 30, 255)[12:], + }, + { + ip: net.IPv4(172, 28, 30, 4)[12:], + mask: []byte{0xff, 0xff, 0, 0}, + bcast: net.IPv4(172, 28, 255, 255)[12:], + }, + { // ip and mask as v6 + ip: net.ParseIP("2005:2004:2002:2001:FFFF:ABCD:EEAB:00CD"), + mask: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0}, + bcast: net.ParseIP("2005:2004:2002:2001:FFFF:ABCD:EEFF:FFFF"), + }, + } + + for _, i := range input { + h, err := GetBroadcastIP(i.ip, i.mask) + if err != nil { + t.Fatal(err) + } + if !i.bcast.Equal(h) { + t.Fatalf("Failed to return expected host ip. Expected: %s. Got: %s", i.bcast, h) + } + } + + // ip as v6 and mask as v4 are not compatible + if _, err := GetBroadcastIP(net.ParseIP("2005:2004:2002:2001:FFFF:ABCD:EEAB:00CD"), []byte{0xff, 0xff, 0xff, 0}); err == nil { + t.Fatalf("Unexpected success") + } + // ip as v4 and non conventional mask + if _, err := GetBroadcastIP(net.ParseIP("173.32.4.5"), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0}); err == nil { + t.Fatalf("Unexpected success") + } + // ip as v4 and non conventional mask + if _, err := GetBroadcastIP(net.ParseIP("173.32.4.5"), []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0}); err == nil { + t.Fatalf("Unexpected success") + } +} + +func TestParseCIDR(t *testing.T) { + input := []struct { + cidr string + ipnw *net.IPNet + }{ + {"192.168.22.44/16", &net.IPNet{IP: net.IP{192, 168, 22, 44}, Mask: net.IPMask{255, 255, 0, 0}}}, + {"10.10.2.0/24", &net.IPNet{IP: net.IP{10, 10, 2, 0}, Mask: net.IPMask{255, 255, 255, 0}}}, + {"10.0.0.100/17", &net.IPNet{IP: net.IP{10, 0, 0, 100}, Mask: net.IPMask{255, 255, 128, 0}}}, + } + + for _, i := range input { + nw, err := ParseCIDR(i.cidr) + if err != nil { + t.Fatal(err) + } + if !CompareIPNet(nw, i.ipnw) { + t.Fatalf("network differ. Expected %v. Got: %v", i.ipnw, nw) + } + } +}