Add DNS options to RequestAddress API

Signed-off-by: Divya Vavili <vavili.divya@gmail.com>

Author: dvavili

endpoint.go

@@ -391,6 +391,12 @@ func (ep *endpoint) sbJoin(sb *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)
+	}
+
 	nid := n.ID()
 
 	ep.processOptions(options...)
@@ -887,13 +893,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
@@ -926,10 +936,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

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

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

ipamapi/contract.go

@@ -73,7 +73,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
 }

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

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

network.go

@@ -1055,7 +1055,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)
 			}
 		}
@@ -1073,7 +1073,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)
 				}
 			}