Add DNS options to RequestAddress API

dvavili · dvavili · commit e609da12cfbc · 2016-03-02T13:53:32.000-08:00
diff --git a/endpoint.go b/endpoint.go
@@ -400,6 +400,12 @@ func (ep *endpoint) sbJoin(sbox Sandbox, options ...EndpointOption) error {
 		}
 	}()
 
+	sb.config.dnsList = append(sb.config.dnsList, ep.iface.dnsServers...)
+	sb.config.dnsSearchList = append(sb.config.dnsSearchList, ep.iface.dnsSearchDomains...)
+	if err = sb.setupResolutionFiles(); err != nil {
+		log.Errorf("Error in setting up resolution files: err %+v", err)
+	}
+
 	network.Lock()
 	nid := network.id
 	network.Unlock()
@@ -859,13 +865,17 @@ func (ep *endpoint) assignAddress(ipam ipamapi.Ipam, assignIPv4, assignIPv6 bool
 
 func (ep *endpoint) assignAddressVersion(ipVer int, ipam ipamapi.Ipam) error {
 	var (
-		poolID  *string
-		address **net.IPNet
-		prefAdd net.IP
-		progAdd net.IP
+		poolID           *string
+		address          **net.IPNet
+		dnsServers       *[]string
+		dnsSearchDomains *[]string
+		prefAdd          net.IP
+		progAdd          net.IP
 	)
 
 	n := ep.getNetwork()
+	dnsServers = &ep.iface.dnsServers
+	dnsSearchDomains = &ep.iface.dnsSearchDomains
 	switch ipVer {
 	case 4:
 		poolID = &ep.iface.v4PoolID
@@ -898,10 +908,12 @@ func (ep *endpoint) assignAddressVersion(ipVer int, ipam ipamapi.Ipam) error {
 		if progAdd != nil && !d.Pool.Contains(progAdd) {
 			continue
 		}
-		addr, _, err := ipam.RequestAddress(d.PoolID, progAdd, ep.ipamOptions)
+		addr, dnsServerList, dnsSearchList, _, err := ipam.RequestAddress(d.PoolID, progAdd, ep.ipamOptions)
 		if err == nil {
 			ep.Lock()
 			*address = addr
+			*dnsServers = dnsServerList
+			*dnsSearchDomains = dnsSearchList
 			*poolID = d.PoolID
 			ep.Unlock()
 			return nil
diff --git a/endpoint_info.go b/endpoint_info.go
@@ -46,14 +46,16 @@ type InterfaceInfo interface {
 }
 
 type endpointInterface struct {
-	mac       net.HardwareAddr
-	addr      *net.IPNet
-	addrv6    *net.IPNet
-	srcName   string
-	dstPrefix string
-	routes    []*net.IPNet
-	v4PoolID  string
-	v6PoolID  string
+	mac              net.HardwareAddr
+	addr             *net.IPNet
+	addrv6           *net.IPNet
+	dnsServers       []string
+	dnsSearchDomains []string
+	srcName          string
+	dstPrefix        string
+	routes           []*net.IPNet
+	v4PoolID         string
+	v6PoolID         string
 }
 
 func (epi *endpointInterface) MarshalJSON() ([]byte, error) {
@@ -67,6 +69,8 @@ func (epi *endpointInterface) MarshalJSON() ([]byte, error) {
 	if epi.addrv6 != nil {
 		epMap["addrv6"] = epi.addrv6.String()
 	}
+	epMap["dnsServers"] = epi.dnsServers
+	epMap["dnsSearchDomains"] = epi.dnsSearchDomains
 	epMap["srcName"] = epi.srcName
 	epMap["dstPrefix"] = epi.dstPrefix
 	var routes []string
@@ -103,6 +107,16 @@ func (epi *endpointInterface) UnmarshalJSON(b []byte) error {
 		}
 	}
 
+	ds, _ := json.Marshal(epMap["dnsServers"])
+	var dnsServers []string
+	json.Unmarshal(ds, &dnsServers)
+	epi.dnsServers = dnsServers
+
+	dsl, _ := json.Marshal(epMap["dnsSearchDomains"])
+	var dnsSearchDomains []string
+	json.Unmarshal(dsl, &dnsSearchDomains)
+	epi.dnsSearchDomains = dnsSearchDomains
+
 	epi.srcName = epMap["srcName"].(string)
 	epi.dstPrefix = epMap["dstPrefix"].(string)
 
@@ -127,6 +141,15 @@ func (epi *endpointInterface) CopyTo(dstEpi *endpointInterface) error {
 	dstEpi.mac = types.GetMacCopy(epi.mac)
 	dstEpi.addr = types.GetIPNetCopy(epi.addr)
 	dstEpi.addrv6 = types.GetIPNetCopy(epi.addrv6)
+
+	dstEpi.dnsServers = make([]string, len(epi.dnsServers))
+	copy(dstEpi.dnsServers, epi.dnsServers)
+	dstEpi.dnsServers = epi.dnsServers
+
+	dstEpi.dnsSearchDomains = make([]string, len(epi.dnsSearchDomains))
+	copy(dstEpi.dnsSearchDomains, epi.dnsSearchDomains)
+	dstEpi.dnsSearchDomains = epi.dnsSearchDomains
+
 	dstEpi.srcName = epi.srcName
 	dstEpi.dstPrefix = epi.dstPrefix
 	dstEpi.v4PoolID = epi.v4PoolID
diff --git a/ipam/allocator.go b/ipam/allocator.go
@@ -416,32 +416,32 @@ func (a *Allocator) getPredefinedPool(as string, ipV6 bool) (*net.IPNet, error)
 }
 
 // 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) {
+func (a *Allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[string]string) (*net.IPNet, []string, []string, map[string]string, error) {
 	log.Debugf("RequestAddress(%s, %v, %v)", poolID, prefAddress, opts)
 	k := SubnetKey{}
 	if err := k.FromString(poolID); err != nil {
-		return nil, nil, types.BadRequestErrorf("invalid pool id: %s", poolID)
+		return nil, nil, nil, nil, types.BadRequestErrorf("invalid pool id: %s", poolID)
 	}
 
 	if err := a.refresh(k.AddressSpace); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, nil, err
 	}
 
 	aSpace, err := a.getAddrSpace(k.AddressSpace)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, nil, err
 	}
 
 	aSpace.Lock()
 	p, ok := aSpace.subnets[k]
 	if !ok {
 		aSpace.Unlock()
-		return nil, nil, types.NotFoundErrorf("cannot find address pool for poolID:%s", poolID)
+		return nil, nil, nil, nil, types.NotFoundErrorf("cannot find address pool for poolID:%s", poolID)
 	}
 
 	if prefAddress != nil && !p.Pool.Contains(prefAddress) {
 		aSpace.Unlock()
-		return nil, nil, ipamapi.ErrIPOutOfRange
+		return nil, nil, nil, nil, ipamapi.ErrIPOutOfRange
 	}
 
 	c := p
@@ -453,15 +453,15 @@ 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, nil, nil, types.InternalErrorf("could not find bitmask in datastore for %s on address %v request from pool %s: %v",
 			k.String(), prefAddress, poolID, err)
 	}
 	ip, err := a.getAddress(p.Pool, bm, prefAddress, p.Range)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, nil, err
 	}
 
-	return &net.IPNet{IP: ip, Mask: p.Pool.Mask}, nil, nil
+	return &net.IPNet{IP: ip, Mask: p.Pool.Mask}, nil, nil, nil, nil
 }
 
 // ReleaseAddress releases the address from the specified pool ID
diff --git a/ipamapi/contract.go b/ipamapi/contract.go
@@ -71,7 +71,7 @@ type Ipam interface {
 	// ReleasePool releases the address pool identified by the passed id
 	ReleasePool(poolID string) error
 	// Request address from the specified pool ID. Input options or required IP can be passed.
-	RequestAddress(string, net.IP, map[string]string) (*net.IPNet, map[string]string, error)
+	RequestAddress(string, net.IP, map[string]string) (*net.IPNet, []string, []string, map[string]string, error)
 	// Release the address from the specified pool ID
 	ReleaseAddress(string, net.IP) error
 }
diff --git a/ipams/remote/api/api.go b/ipams/remote/api/api.go
@@ -74,8 +74,10 @@ type RequestAddressRequest struct {
 // RequestAddressResponse represents the expected data in the response message to a ``request address`` request
 type RequestAddressResponse struct {
 	Response
-	Address string // in CIDR format
-	Data    map[string]string
+	Address          string // in CIDR format
+	DNSServers       []string
+	DNSSearchDomains []string
+	Data             map[string]string
 }
 
 // ReleaseAddressRequest represents the expected data in a ``release address`` request message
diff --git a/ipams/remote/remote.go b/ipams/remote/remote.go
@@ -95,7 +95,7 @@ func (a *allocator) ReleasePool(poolID string) error {
 }
 
 // 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) {
+func (a *allocator) RequestAddress(poolID string, address net.IP, options map[string]string) (*net.IPNet, []string, []string, map[string]string, error) {
 	var (
 		prefAddress string
 		retAddress  *net.IPNet
@@ -107,12 +107,12 @@ func (a *allocator) RequestAddress(poolID string, address net.IP, options map[st
 	req := &api.RequestAddressRequest{PoolID: poolID, Address: prefAddress, Options: options}
 	res := &api.RequestAddressResponse{}
 	if err := a.call("RequestAddress", req, res); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, nil, err
 	}
 	if res.Address != "" {
 		retAddress, err = types.ParseCIDR(res.Address)
 	}
-	return retAddress, res.Data, err
+	return retAddress, res.DNSServers, res.DNSSearchDomains, res.Data, err
 }
 
 // ReleaseAddress releases the address from the specified address pool
diff --git a/ipams/windowsipam/windowsipam.go b/ipams/windowsipam/windowsipam.go
@@ -63,7 +63,7 @@ func (a *allocator) ReleasePool(poolID string) error {
 
 // RequestAddress returns an address from the specified pool ID.
 // Always allocate the 0.0.0.0/32 ip if no preferred address was specified
-func (a *allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[string]string) (*net.IPNet, map[string]string, error) {
+func (a *allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[string]string) (*net.IPNet, []string, []string, map[string]string, error) {
 	log.Debugf("RequestAddress(%s, %v, %v) %s", poolID, prefAddress, opts, opts["RequestAddressType"])
 	_, ipNet, err := net.ParseCIDR(poolID)
 
diff --git a/network.go b/network.go
@@ -1044,7 +1044,7 @@ func (n *network) ipamAllocateVersion(ipVer int, ipam ipamapi.Ipam) error {
 			var gatewayOpts = map[string]string{
 				ipamapi.RequestAddressType: netlabel.Gateway,
 			}
-			if d.Gateway, _, err = ipam.RequestAddress(d.PoolID, net.ParseIP(cfg.Gateway), gatewayOpts); err != nil {
+			if d.Gateway, _, _, _, err = ipam.RequestAddress(d.PoolID, net.ParseIP(cfg.Gateway), gatewayOpts); err != nil {
 				return types.InternalErrorf("failed to allocate gateway (%v): %v", cfg.Gateway, err)
 			}
 		}
@@ -1062,7 +1062,7 @@ func (n *network) ipamAllocateVersion(ipVer int, ipam ipamapi.Ipam) error {
 					return types.ForbiddenErrorf("auxilairy address: (%s:%s) must belong to the master pool: %s", k, v, d.Pool)
 				}
 				// Attempt reservation in the container addressable pool, silent the error if address does not belong to that pool
-				if d.IPAMData.AuxAddresses[k], _, err = ipam.RequestAddress(d.PoolID, ip, nil); err != nil && err != ipamapi.ErrIPOutOfRange {
+				if d.IPAMData.AuxAddresses[k], _, _, _, err = ipam.RequestAddress(d.PoolID, ip, nil); err != nil && err != ipamapi.ErrIPOutOfRange {
 					return types.InternalErrorf("failed to allocate secondary ip address (%s:%s): %v", k, v, err)
 				}
 			}

Original file line number	Diff line number	Diff line change
`@@ -416,32 +416,32 @@ func (a Allocator) getPredefinedPool(as string, ipV6 bool) (net.IPNet, error)`
`416`	`416`	`}`
`417`	`417`
`418`	`418`	`// RequestAddress returns an address from the specified pool ID`
`419`		`-func (a Allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[string]string) (net.IPNet, map[string]string, error) {`
	`419`	`+func (a Allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[string]string) (net.IPNet, []string, []string, map[string]string, error) {`
`420`	`420`	`log.Debugf("RequestAddress(%s, %v, %v)", poolID, prefAddress, opts)`
`421`	`421`	`k := SubnetKey{}`
`422`	`422`	`if err := k.FromString(poolID); err != nil {`
`423`		`- return nil, nil, types.BadRequestErrorf("invalid pool id: %s", poolID)`
	`423`	`+ return nil, nil, nil, nil, types.BadRequestErrorf("invalid pool id: %s", poolID)`
`424`	`424`	`}`
`425`	`425`
`426`	`426`	`if err := a.refresh(k.AddressSpace); err != nil {`
`427`		`- return nil, nil, err`
	`427`	`+ return nil, nil, nil, nil, err`
`428`	`428`	`}`
`429`	`429`
`430`	`430`	`aSpace, err := a.getAddrSpace(k.AddressSpace)`
`431`	`431`	`if err != nil {`
`432`		`- return nil, nil, err`
	`432`	`+ return nil, nil, nil, nil, err`
`433`	`433`	`}`
`434`	`434`
`435`	`435`	`aSpace.Lock()`
`436`	`436`	`p, ok := aSpace.subnets[k]`
`437`	`437`	`if !ok {`
`438`	`438`	`aSpace.Unlock()`
`439`		`- return nil, nil, types.NotFoundErrorf("cannot find address pool for poolID:%s", poolID)`
	`439`	`+ return nil, nil, nil, nil, types.NotFoundErrorf("cannot find address pool for poolID:%s", poolID)`
`440`	`440`	`}`
`441`	`441`
`442`	`442`	`if prefAddress != nil && !p.Pool.Contains(prefAddress) {`
`443`	`443`	`aSpace.Unlock()`
`444`		`- return nil, nil, ipamapi.ErrIPOutOfRange`
	`444`	`+ return nil, nil, nil, nil, ipamapi.ErrIPOutOfRange`
`445`	`445`	`}`
`446`	`446`
`447`	`447`	`c := p`
`@@ -453,15 +453,15 @@ func (a *Allocator) RequestAddress(poolID string, prefAddress net.IP, opts map[s`
`453`	`453`
`454`	`454`	`bm, err := a.retrieveBitmask(k, c.Pool)`
`455`	`455`	`if err != nil {`
`456`		`- return nil, nil, types.InternalErrorf("could not find bitmask in datastore for %s on address %v request from pool %s: %v",`
	`456`	`+ return nil, nil, nil, nil, types.InternalErrorf("could not find bitmask in datastore for %s on address %v request from pool %s: %v",`
`457`	`457`	`k.String(), prefAddress, poolID, err)`
`458`	`458`	`}`
`459`	`459`	`ip, err := a.getAddress(p.Pool, bm, prefAddress, p.Range)`
`460`	`460`	`if err != nil {`
`461`		`- return nil, nil, err`
	`461`	`+ return nil, nil, nil, nil, err`
`462`	`462`	`}`
`463`	`463`
`464`		`- return &net.IPNet{IP: ip, Mask: p.Pool.Mask}, nil, nil`
	`464`	`+ return &net.IPNet{IP: ip, Mask: p.Pool.Mask}, nil, nil, nil, nil`
`465`	`465`	`}`
`466`	`466`
`467`	`467`	`// ReleaseAddress releases the address from the specified pool ID`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ type Ipam interface {`
`71`	`71`	`// ReleasePool releases the address pool identified by the passed id`
`72`	`72`	`ReleasePool(poolID string) error`
`73`	`73`	`// Request address from the specified pool ID. Input options or required IP can be passed.`
`74`		`- RequestAddress(string, net.IP, map[string]string) (*net.IPNet, map[string]string, error)`
	`74`	`+ RequestAddress(string, net.IP, map[string]string) (*net.IPNet, []string, []string, map[string]string, error)`
`75`	`75`	`// Release the address from the specified pool ID`
`76`	`76`	`ReleaseAddress(string, net.IP) error`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ func (a *allocator) ReleasePool(poolID string) error {`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`// RequestAddress requests an address from the address pool`
`98`		`-func (a allocator) RequestAddress(poolID string, address net.IP, options map[string]string) (net.IPNet, map[string]string, error) {`
	`98`	`+func (a allocator) RequestAddress(poolID string, address net.IP, options map[string]string) (net.IPNet, []string, []string, map[string]string, error) {`
`99`	`99`	`var (`
`100`	`100`	`prefAddress string`
`101`	`101`	`retAddress *net.IPNet`
`@@ -107,12 +107,12 @@ func (a *allocator) RequestAddress(poolID string, address net.IP, options map[st`
`107`	`107`	`req := &api.RequestAddressRequest{PoolID: poolID, Address: prefAddress, Options: options}`
`108`	`108`	`res := &api.RequestAddressResponse{}`
`109`	`109`	`if err := a.call("RequestAddress", req, res); err != nil {`
`110`		`- return nil, nil, err`
	`110`	`+ return nil, nil, nil, nil, err`
`111`	`111`	`}`
`112`	`112`	`if res.Address != "" {`
`113`	`113`	`retAddress, err = types.ParseCIDR(res.Address)`
`114`	`114`	`}`
`115`		`- return retAddress, res.Data, err`
	`115`	`+ return retAddress, res.DNSServers, res.DNSSearchDomains, res.Data, err`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`// ReleaseAddress releases the address from the specified address pool`
Original file line number	Diff line number	Diff line change
`@@ -1044,7 +1044,7 @@ func (n *network) ipamAllocateVersion(ipVer int, ipam ipamapi.Ipam) error {`
`1044`	`1044`	`var gatewayOpts = map[string]string{`
`1045`	`1045`	`ipamapi.RequestAddressType: netlabel.Gateway,`
`1046`	`1046`	`}`
`1047`		`- if d.Gateway, _, err = ipam.RequestAddress(d.PoolID, net.ParseIP(cfg.Gateway), gatewayOpts); err != nil {`
	`1047`	`+ if d.Gateway, _, _, _, err = ipam.RequestAddress(d.PoolID, net.ParseIP(cfg.Gateway), gatewayOpts); err != nil {`
`1048`	`1048`	`return types.InternalErrorf("failed to allocate gateway (%v): %v", cfg.Gateway, err)`
`1049`	`1049`	`}`
`1050`	`1050`	`}`
`@@ -1062,7 +1062,7 @@ func (n *network) ipamAllocateVersion(ipVer int, ipam ipamapi.Ipam) error {`
`1062`	`1062`	`return types.ForbiddenErrorf("auxilairy address: (%s:%s) must belong to the master pool: %s", k, v, d.Pool)`
`1063`	`1063`	`}`
`1064`	`1064`	`// Attempt reservation in the container addressable pool, silent the error if address does not belong to that pool`
`1065`		`- if d.IPAMData.AuxAddresses[k], _, err = ipam.RequestAddress(d.PoolID, ip, nil); err != nil && err != ipamapi.ErrIPOutOfRange {`
	`1065`	`+ if d.IPAMData.AuxAddresses[k], _, _, _, err = ipam.RequestAddress(d.PoolID, ip, nil); err != nil && err != ipamapi.ErrIPOutOfRange {`
`1066`	`1066`	`return types.InternalErrorf("failed to allocate secondary ip address (%s:%s): %v", k, v, err)`
`1067`	`1067`	`}`
`1068`	`1068`	`}`