@@ -29,7 +29,7 @@ clone git github.com/RackSec/srslog 259aed10dfa74ea2961eddd1d9847619f6e98837

 clone git github.com/imdario/mergo 0.2.1

 #get libnetwork packages

-clone git github.com/docker/libnetwork v0.8.0-dev.1

+clone git github.com/docker/libnetwork b66c0385f30c6aa27b2957ed1072682c19a0b0b4

 clone git github.com/docker/go-events 2e7d352816128aa84f4d29b2a21d400133701a0d

 clone git github.com/armon/go-radix e39d623f12e8e41c7b5529e9a9dd67a1e2261f80

 clone git github.com/armon/go-metrics eb0af217e5e9747e41dd5303755356b62d28e3ec

@@ -1,5 +1,17 @@

 # Changelog

+## 0.8.0-dev.2 (2016-05-07)

+- Fix an issue which may arise during sandbox cleanup (https://github.com/docker/libnetwork/pull/1157)

+- Fix cleanup logic in case of ipv6 allocation failure

+- Don't add /etc/hosts record if container's ip is empty (--net=none)

+- Fix default gw logic for internal networks

+- Error when updating IPv6 gateway (https://github.com/docker/libnetwork/issues/1142)

+- Fixes https://github.com/docker/libnetwork/issues/1113

+- Fixes https://github.com/docker/libnetwork/issues/1069

+- Fxies https://github.com/docker/libnetwork/issues/1117

+- Increase the concurrent query rate-limit count

+- Changes to build libnetwork in Solaris

+

 ## 0.8.0-dev.1 (2016-04-16)

 - Fixes docker/docker#16964

 - Added maximum egress bandwidth qos for Windows

@@ -5,8 +5,8 @@ dockerargs = --privileged -v $(shell pwd):/go/src/github.com/docker/libnetwork -

 container_env = -e "INSIDECONTAINER=-incontainer=true"

 docker = docker run --rm -it ${dockerargs} $$EXTRA_ARGS ${container_env} ${build_image}

 ciargs = -e CIRCLECI -e "COVERALLS_TOKEN=$$COVERALLS_TOKEN" -e "INSIDECONTAINER=-incontainer=true"

-cidocker = docker run ${dockerargs} ${ciargs} ${container_env} ${build_image}

-CROSS_PLATFORMS = linux/amd64 linux/386 linux/arm windows/amd64 windows/386

+cidocker = docker run ${dockerargs} ${ciargs} $$EXTRA_ARGS ${container_env} ${build_image}

+CROSS_PLATFORMS = linux/amd64 linux/386 linux/arm windows/amd64

 all: ${build_image}.created build check integration-tests clean

@@ -102,4 +102,4 @@ circle-ci-check: ${build_image}.created

 circle-ci-build: ${build_image}.created

 	@${cidocker} make build-local

-circle-ci: circle-ci-check circle-ci-build integration-tests

+circle-ci: circle-ci-check circle-ci-cross circle-ci-build integration-tests

@@ -34,7 +34,7 @@ func main() {

 	// Create a network for containers to join.

 	// NewNetwork accepts Variadic optional arguments that libnetwork and Drivers can use.

-	network, err := controller.NewNetwork(networkType, "network1")

+	network, err := controller.NewNetwork(networkType, "network1", "")

 	if err != nil {

 		log.Fatalf("controller.NewNetwork: %s", err)

 	}

new file mode 100644

@@ -0,0 +1,369 @@

+package libnetwork

+

+import (

+	"fmt"

+	"net"

+	"os"

+	"strings"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/go-events"

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

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

+	"github.com/docker/libnetwork/driverapi"

+	"github.com/docker/libnetwork/networkdb"

+)

+

+type agent struct {

+	networkDB         *networkdb.NetworkDB

+	bindAddr          string

+	epTblCancel       func()

+	driverCancelFuncs map[string][]func()

+}

+

+func getBindAddr(ifaceName string) (string, error) {

+	iface, err := net.InterfaceByName(ifaceName)

+	if err != nil {

+		return "", fmt.Errorf("failed to find interface %s: %v", ifaceName, err)

+	}

+

+	addrs, err := iface.Addrs()

+	if err != nil {

+		return "", fmt.Errorf("failed to get interface addresses: %v", err)

+	}

+

+	for _, a := range addrs {

+		addr, ok := a.(*net.IPNet)

+		if !ok {

+			continue

+		}

+		addrIP := addr.IP

+

+		if addrIP.IsLinkLocalUnicast() {

+			continue

+		}

+

+		return addrIP.String(), nil

+	}

+

+	return "", fmt.Errorf("failed to get bind address")

+}

+

+func resolveAddr(addrOrInterface string) (string, error) {

+	// Try and see if this is a valid IP address

+	if net.ParseIP(addrOrInterface) != nil {

+		return addrOrInterface, nil

+	}

+

+	// If not a valid IP address, it should be a valid interface

+	return getBindAddr(addrOrInterface)

+}

+

+func (c *controller) agentInit(bindAddrOrInterface string) error {

+	if !c.cfg.Daemon.IsAgent {

+		return nil

+	}

+

+	bindAddr, err := resolveAddr(bindAddrOrInterface)

+	if err != nil {

+		return err

+	}

+

+	hostname, _ := os.Hostname()

+	nDB, err := networkdb.New(&networkdb.Config{

+		BindAddr: bindAddr,

+		NodeName: hostname,

+	})

+

+	if err != nil {

+		return err

+	}

+

+	ch, cancel := nDB.Watch("endpoint_table", "", "")

+

+	c.agent = &agent{

+		networkDB:         nDB,

+		bindAddr:          bindAddr,

+		epTblCancel:       cancel,

+		driverCancelFuncs: make(map[string][]func()),

+	}

+

+	go c.handleTableEvents(ch, c.handleEpTableEvent)

+	return nil

+}

+

+func (c *controller) agentJoin(remotes []string) error {

+	if c.agent == nil {

+		return nil

+	}

+

+	return c.agent.networkDB.Join(remotes)

+}

+

+func (c *controller) agentDriverNotify(d driverapi.Driver) {

+	if c.agent == nil {

+		return

+	}

+

+	d.DiscoverNew(discoverapi.NodeDiscovery, discoverapi.NodeDiscoveryData{

+		Address: c.agent.bindAddr,

+		Self:    true,

+	})

+}

+

+func (c *controller) agentClose() {

+	if c.agent == nil {

+		return

+	}

+

+	for _, cancelFuncs := range c.agent.driverCancelFuncs {

+		for _, cancel := range cancelFuncs {

+			cancel()

+		}

+	}

+	c.agent.epTblCancel()

+

+	c.agent.networkDB.Close()

+}

+

+func (n *network) isClusterEligible() bool {

+	if n.driverScope() != datastore.GlobalScope {

+		return false

+	}

+

+	c := n.getController()

+	if c.agent == nil {

+		return false

+	}

+

+	return true

+}

+

+func (n *network) joinCluster() error {

+	if !n.isClusterEligible() {

+		return nil

+	}

+

+	c := n.getController()

+	return c.agent.networkDB.JoinNetwork(n.ID())

+}

+

+func (n *network) leaveCluster() error {

+	if !n.isClusterEligible() {

+		return nil

+	}

+

+	c := n.getController()

+	return c.agent.networkDB.LeaveNetwork(n.ID())

+}

+

+func (ep *endpoint) addToCluster() error {

+	n := ep.getNetwork()

+	if !n.isClusterEligible() {

+		return nil

+	}

+

+	c := n.getController()

+	if !ep.isAnonymous() && ep.Iface().Address() != nil {

+		if err := c.addServiceBinding(ep.svcName, ep.svcID, n.ID(), ep.ID(), ep.Iface().Address().IP); err != nil {

+			return err

+		}

+

+		if err := c.agent.networkDB.CreateEntry("endpoint_table", n.ID(), ep.ID(), []byte(fmt.Sprintf("%s,%s,%s,%s", ep.Name(), ep.svcName,

+			ep.svcID, ep.Iface().Address().IP))); err != nil {

+			return err

+		}

+	}

+

+	for _, te := range ep.joinInfo.driverTableEntries {

+		if err := c.agent.networkDB.CreateEntry(te.tableName, n.ID(), te.key, te.value); err != nil {

+			return err

+		}

+	}

+

+	return nil

+}

+

+func (ep *endpoint) deleteFromCluster() error {

+	n := ep.getNetwork()

+	if !n.isClusterEligible() {

+		return nil

+	}

+

+	c := n.getController()

+	if !ep.isAnonymous() {

+		if ep.Iface().Address() != nil {

+			if err := c.rmServiceBinding(ep.svcName, ep.svcID, n.ID(), ep.ID(), ep.Iface().Address().IP); err != nil {

+				return err

+			}

+		}

+

+		if err := c.agent.networkDB.DeleteEntry("endpoint_table", n.ID(), ep.ID()); err != nil {

+			return err

+		}

+	}

+

+	if ep.joinInfo == nil {

+		return nil

+	}

+

+	for _, te := range ep.joinInfo.driverTableEntries {

+		if err := c.agent.networkDB.DeleteEntry(te.tableName, n.ID(), te.key); err != nil {

+			return err

+		}

+	}

+

+	return nil

+}

+

+func (n *network) addDriverWatches() {

+	if !n.isClusterEligible() {

+		return

+	}

+

+	c := n.getController()

+	for _, tableName := range n.driverTables {

+		ch, cancel := c.agent.networkDB.Watch(tableName, n.ID(), "")

+		c.Lock()

+		c.agent.driverCancelFuncs[n.ID()] = append(c.agent.driverCancelFuncs[n.ID()], cancel)

+		c.Unlock()

+

+		go c.handleTableEvents(ch, n.handleDriverTableEvent)

+		d, err := n.driver(false)

+		if err != nil {

+			logrus.Errorf("Could not resolve driver %s while walking driver tabl: %v", n.networkType, err)

+			return

+		}

+

+		c.agent.networkDB.WalkTable(tableName, func(nid, key string, value []byte) bool {

+			d.EventNotify(driverapi.Create, n.ID(), tableName, key, value)

+			return false

+		})

+	}

+}

+

+func (n *network) cancelDriverWatches() {

+	if !n.isClusterEligible() {

+		return

+	}

+

+	c := n.getController()

+	c.Lock()

+	cancelFuncs := c.agent.driverCancelFuncs[n.ID()]

+	delete(c.agent.driverCancelFuncs, n.ID())

+	c.Unlock()

+

+	for _, cancel := range cancelFuncs {

+		cancel()

+	}

+}

+

+func (c *controller) handleTableEvents(ch chan events.Event, fn func(events.Event)) {

+	for {

+		select {

+		case ev, ok := <-ch:

+			if !ok {

+				return

+			}

+

+			fn(ev)

+		}

+	}

+}

+

+func (n *network) handleDriverTableEvent(ev events.Event) {

+	d, err := n.driver(false)

+	if err != nil {

+		logrus.Errorf("Could not resolve driver %s while handling driver table event: %v", n.networkType, err)

+		return

+	}

+

+	var (

+		etype driverapi.EventType

+		tname string

+		key   string

+		value []byte

+	)

+

+	switch event := ev.(type) {

+	case networkdb.CreateEvent:

+		tname = event.Table

+		key = event.Key

+		value = event.Value

+		etype = driverapi.Create

+	case networkdb.DeleteEvent:

+		tname = event.Table

+		key = event.Key

+		value = event.Value

+		etype = driverapi.Delete

+	case networkdb.UpdateEvent:

+		tname = event.Table

+		key = event.Key

+		value = event.Value

+		etype = driverapi.Delete

+	}

+

+	d.EventNotify(etype, n.ID(), tname, key, value)

+}

+

+func (c *controller) handleEpTableEvent(ev events.Event) {

+	var (

+		nid   string

+		eid   string

+		value string

+		isAdd bool

+	)

+

+	switch event := ev.(type) {

+	case networkdb.CreateEvent:

+		nid = event.NetworkID

+		eid = event.Key

+		value = string(event.Value)

+		isAdd = true

+	case networkdb.DeleteEvent:

+		nid = event.NetworkID

+		eid = event.Key

+		value = string(event.Value)

+	case networkdb.UpdateEvent:

+		logrus.Errorf("Unexpected update service table event = %#v", event)

+	}

+

+	nw, err := c.NetworkByID(nid)

+	if err != nil {

+		logrus.Errorf("Could not find network %s while handling service table event: %v", nid, err)

+		return

+	}

+	n := nw.(*network)

+

+	vals := strings.Split(value, ",")

+	if len(vals) < 4 {

+		logrus.Errorf("Incorrect service table value = %s", value)

+		return

+	}

+

+	name := vals[0]

+	svcName := vals[1]

+	svcID := vals[2]

+	ip := net.ParseIP(vals[3])

+

+	if name == "" || ip == nil {

+		logrus.Errorf("Invalid endpoint name/ip received while handling service table event %s", value)

+		return

+	}

+

+	if isAdd {

+		if err := c.addServiceBinding(svcName, svcID, nid, eid, ip); err != nil {

+			logrus.Errorf("Failed adding service binding for value %s: %v", value, err)

+			return

+		}

+

+		n.addSvcRecords(name, ip, nil, true)

+	} else {

+		if err := c.rmServiceBinding(svcName, svcID, nid, eid, ip); err != nil {

+			logrus.Errorf("Failed adding service binding for value %s: %v", value, err)

+			return

+		}

+

+		n.deleteSvcRecords(name, ip, nil, true)

+	}

+}

@@ -370,6 +370,8 @@ func (h *Handle) set(ordinal, start, end uint64, any bool, release bool) (uint64

 // checks is needed because to cover the case where the number of bits is not a multiple of blockLen

 func (h *Handle) validateOrdinal(ordinal uint64) error {

+	h.Lock()

+	defer h.Unlock()

 	if ordinal >= h.bits {

 		return fmt.Errorf("bit does not belong to the sequence")

 	}

@@ -75,6 +75,10 @@ func (h *Handle) CopyTo(o datastore.KVObject) error {

 	defer h.Unlock()

 	dstH := o.(*Handle)

+	if h == dstH {

+		return nil

+	}

+	dstH.Lock()

 	dstH.bits = h.bits

 	dstH.unselected = h.unselected

 	dstH.head = h.head.getCopy()

@@ -83,6 +87,7 @@ func (h *Handle) CopyTo(o datastore.KVObject) error {

 	dstH.dbIndex = h.dbIndex

 	dstH.dbExists = h.dbExists

 	dstH.store = h.store

+	dstH.Unlock()

 	return nil

 }

@@ -22,9 +22,12 @@ type Config struct {

 // DaemonCfg represents libnetwork core configuration

 type DaemonCfg struct {

 	Debug          bool

+	IsAgent        bool

 	DataDir        string

 	DefaultNetwork string

 	DefaultDriver  string

+	Bind           string

+	Neighbors      []string

 	Labels         []string

 	DriverCfg      map[string]interface{}

 }

@@ -81,6 +84,27 @@ func ParseConfigOptions(cfgOptions ...Option) *Config {

 // to the controller

 type Option func(c *Config)

+// OptionBind function returns an option setter for setting a bind interface or address

+func OptionBind(bind string) Option {

+	return func(c *Config) {

+		c.Daemon.Bind = bind

+	}

+}

+

+// OptionAgent function returns an option setter for setting agent mode

+func OptionAgent() Option {

+	return func(c *Config) {

+		c.Daemon.IsAgent = true

+	}

+}

+

+// OptionNeighbors function returns an option setter for setting a list of neighbors to join.

+func OptionNeighbors(neighbors []string) Option {

+	return func(c *Config) {

+		c.Daemon.Neighbors = neighbors

+	}

+}

+

 // OptionDefaultNetwork function returns an option setter for a default network

 func OptionDefaultNetwork(dn string) Option {

 	return func(c *Config) {

@@ -15,7 +15,7 @@ create network namespaces and allocate interfaces for containers to use.

 	// Create a network for containers to join.

 	// NewNetwork accepts Variadic optional arguments that libnetwork and Drivers can make use of

-	network, err := controller.NewNetwork(networkType, "network1")

+	network, err := controller.NewNetwork(networkType, "network1", "")

 	if err != nil {

 		return

 	}

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

 	"github.com/docker/libnetwork/datastore"

 	"github.com/docker/libnetwork/discoverapi"

 	"github.com/docker/libnetwork/driverapi"

+	"github.com/docker/libnetwork/drvregistry"

 	"github.com/docker/libnetwork/hostdiscovery"

 	"github.com/docker/libnetwork/ipamapi"

 	"github.com/docker/libnetwork/netlabel"

@@ -75,7 +76,7 @@ type NetworkController interface {

 	Config() config.Config

 	// Create a new network. The options parameter carries network specific options.

-	NewNetwork(networkType, name string, options ...NetworkOption) (Network, error)

+	NewNetwork(networkType, name string, id string, options ...NetworkOption) (Network, error)

 	// Networks returns the list of Network(s) managed by this controller.

 	Networks() []Network

@@ -119,55 +120,74 @@ type NetworkWalker func(nw Network) bool

 // When the function returns true, the walk will stop.

 type SandboxWalker func(sb Sandbox) bool

-type driverData struct {

-	driver     driverapi.Driver

-	capability driverapi.Capability

-}

-

-type ipamData struct {

-	driver     ipamapi.Ipam

-	capability *ipamapi.Capability

-	// 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 sandboxTable map[string]*sandbox

 type controller struct {

-	id             string

-	drivers        driverTable

-	ipamDrivers    ipamTable

-	sandboxes      sandboxTable

-	cfg            *config.Config

-	stores         []datastore.DataStore

-	discovery      hostdiscovery.HostDiscovery

-	extKeyListener net.Listener

-	watchCh        chan *endpoint

-	unWatchCh      chan *endpoint

-	svcDb          map[string]svcInfo

-	nmap           map[string]*netWatch

-	defOsSbox      osl.Sandbox

-	sboxOnce       sync.Once

+	id              string

+	drvRegistry     *drvregistry.DrvRegistry

+	sandboxes       sandboxTable

+	cfg             *config.Config

+	stores          []datastore.DataStore

+	discovery       hostdiscovery.HostDiscovery

+	extKeyListener  net.Listener

+	watchCh         chan *endpoint

+	unWatchCh       chan *endpoint

+	svcRecords      map[string]svcInfo

+	nmap            map[string]*netWatch

+	serviceBindings map[string]*service

+	defOsSbox       osl.Sandbox

+	sboxOnce        sync.Once

+	agent           *agent

 	sync.Mutex

 }

+type initializer struct {

+	fn    drvregistry.InitFunc

+	ntype string

+}

+

 // New creates a new instance of network controller.

 func New(cfgOptions ...config.Option) (NetworkController, error) {

 	c := &controller{

-		id:          stringid.GenerateRandomID(),

-		cfg:         config.ParseConfigOptions(cfgOptions...),

-		sandboxes:   sandboxTable{},

-		drivers:     driverTable{},

-		ipamDrivers: ipamTable{},

-		svcDb:       make(map[string]svcInfo),

+		id:              stringid.GenerateRandomID(),

+		cfg:             config.ParseConfigOptions(cfgOptions...),

+		sandboxes:       sandboxTable{},

+		svcRecords:      make(map[string]svcInfo),

+		serviceBindings: make(map[string]*service),

+	}

+

+	if err := c.agentInit(c.cfg.Daemon.Bind); err != nil {

+		return nil, err

+	}

+

+	if err := c.agentJoin(c.cfg.Daemon.Neighbors); err != nil {

+		return nil, err

 	}

 	if err := c.initStores(); err != nil {

 		return nil, err

 	}

+	drvRegistry, err := drvregistry.New(c.getStore(datastore.LocalScope), c.getStore(datastore.GlobalScope), c.RegisterDriver, nil)

+	if err != nil {

+		return nil, err

+	}

+

+	for _, i := range getInitializers() {

+		var dcfg map[string]interface{}

+

+		// External plugins don't need config passed through daemon. They can

+		// bootstrap themselves

+		if i.ntype != "remote" {

+			dcfg = c.makeDriverConfig(i.ntype)

+		}

+

+		if err := drvRegistry.AddDriver(i.ntype, i.fn, dcfg); err != nil {

+			return nil, err

+		}

+	}

+	c.drvRegistry = drvRegistry

+

 	if c.cfg != nil && c.cfg.Cluster.Watcher != nil {

 		if err := c.initDiscovery(c.cfg.Cluster.Watcher); err != nil {

 			// Failing to initialize discovery is a bad situation to be in.

@@ -176,15 +196,6 @@ func New(cfgOptions ...config.Option) (NetworkController, error) {

 		}

 	}

-	if err := initDrivers(c); err != nil {

-		return nil, err

-	}

-

-	if err := initIpams(c, c.getStore(datastore.LocalScope),

-		c.getStore(datastore.GlobalScope)); err != nil {

-		return nil, err

-	}

-

 	c.sandboxCleanup()

 	c.cleanupLocalEndpoints()

 	c.networkCleanup()

@@ -196,8 +207,67 @@ func New(cfgOptions ...config.Option) (NetworkController, error) {

 	return c, nil

 }

+func (c *controller) makeDriverConfig(ntype string) map[string]interface{} {

+	if c.cfg == nil {

+		return nil

+	}

+

+	config := make(map[string]interface{})

+

+	for _, label := range c.cfg.Daemon.Labels {

+		if !strings.HasPrefix(netlabel.Key(label), netlabel.DriverPrefix+"."+ntype) {

+			continue

+		}

+

+		config[netlabel.Key(label)] = netlabel.Value(label)

+	}

+

+	drvCfg, ok := c.cfg.Daemon.DriverCfg[ntype]

+	if ok {

+		for k, v := range drvCfg.(map[string]interface{}) {

+			config[k] = v

+		}

+	}

+

+	for k, v := range c.cfg.Scopes {

+		if !v.IsValid() {

+			continue

+		}

+		config[netlabel.MakeKVClient(k)] = discoverapi.DatastoreConfigData{

+			Scope:    k,

+			Provider: v.Client.Provider,

+			Address:  v.Client.Address,

+			Config:   v.Client.Config,

+		}

+	}

+

+	return config

+}

+

 var procReloadConfig = make(chan (bool), 1)

+func (c *controller) processAgentConfig(cfg *config.Config) (bool, error) {

+	if c.cfg.Daemon.IsAgent == cfg.Daemon.IsAgent {

+		// Agent configuration not changed

+		return false, nil

+	}

+

+	c.Lock()

+	c.cfg = cfg

+	c.Unlock()

+

+	if err := c.agentInit(c.cfg.Daemon.Bind); err != nil {

+		return false, err

+	}

+

+	if err := c.agentJoin(c.cfg.Daemon.Neighbors); err != nil {

+		c.agentClose()

+		return false, err

+	}

+

+	return true, nil

+}

+

 func (c *controller) ReloadConfiguration(cfgOptions ...config.Option) error {

 	procReloadConfig <- true

 	defer func() { <-procReloadConfig }()

@@ -206,6 +276,16 @@ func (c *controller) ReloadConfiguration(cfgOptions ...config.Option) error {

 	// Refuse the configuration if it alters an existing datastore client configuration.

 	update := false

 	cfg := config.ParseConfigOptions(cfgOptions...)

+

+	isAgentConfig, err := c.processAgentConfig(cfg)

+	if err != nil {

+		return err

+	}

+

+	if isAgentConfig {

+		return nil

+	}

+

 	for s := range c.cfg.Scopes {

 		if _, ok := cfg.Scopes[s]; !ok {

 			return types.ForbiddenErrorf("cannot accept new configuration because it removes an existing datastore client")

@@ -228,16 +308,6 @@ func (c *controller) ReloadConfiguration(cfgOptions ...config.Option) error {

 		return nil

 	}

-	c.Lock()

-	c.cfg = cfg

-	c.Unlock()

-

-	if c.discovery == nil && c.cfg.Cluster.Watcher != nil {

-		if err := c.initDiscovery(c.cfg.Cluster.Watcher); err != nil {

-			log.Errorf("Failed to Initialize Discovery after configuration update: %v", err)

-		}

-	}

-

 	var dsConfig *discoverapi.DatastoreConfigData

 	for scope, sCfg := range cfg.Scopes {

 		if scope == datastore.LocalScope || !sCfg.IsValid() {

@@ -255,17 +325,25 @@ func (c *controller) ReloadConfiguration(cfgOptions ...config.Option) error {

 		return nil

 	}

-	for nm, id := range c.getIpamDrivers() {

-		err := id.driver.DiscoverNew(discoverapi.DatastoreConfig, *dsConfig)

+	c.drvRegistry.WalkIPAMs(func(name string, driver ipamapi.Ipam, cap *ipamapi.Capability) bool {

+		err := driver.DiscoverNew(discoverapi.DatastoreConfig, *dsConfig)

 		if err != nil {

-			log.Errorf("Failed to set datastore in driver %s: %v", nm, err)

+			log.Errorf("Failed to set datastore in driver %s: %v", name, err)

 		}

-	}

+		return false

+	})

-	for nm, id := range c.getNetDrivers() {

-		err := id.driver.DiscoverNew(discoverapi.DatastoreConfig, *dsConfig)

+	c.drvRegistry.WalkDrivers(func(name string, driver driverapi.Driver, capability driverapi.Capability) bool {

+		err := driver.DiscoverNew(discoverapi.DatastoreConfig, *dsConfig)

 		if err != nil {

-			log.Errorf("Failed to set datastore in driver %s: %v", nm, err)

+			log.Errorf("Failed to set datastore in driver %s: %v", name, err)

+		}

+		return false

+	})

+

+	if c.discovery == nil && c.cfg.Cluster.Watcher != nil {

+		if err := c.initDiscovery(c.cfg.Cluster.Watcher); err != nil {

+			log.Errorf("Failed to Initialize Discovery after configuration update: %v", err)

 		}

 	}

@@ -333,34 +411,30 @@ func (c *controller) hostLeaveCallback(nodes []net.IP) {

 }

 func (c *controller) processNodeDiscovery(nodes []net.IP, add bool) {

-	c.Lock()

-	drivers := []*driverData{}

-	for _, d := range c.drivers {

-		drivers = append(drivers, d)

-	}

-	c.Unlock()

-

-	for _, d := range drivers {

-		c.pushNodeDiscovery(d, nodes, add)

-	}

+	c.drvRegistry.WalkDrivers(func(name string, driver driverapi.Driver, capability driverapi.Capability) bool {

+		c.pushNodeDiscovery(driver, capability, nodes, add)

+		return false

+	})

 }

-func (c *controller) pushNodeDiscovery(d *driverData, nodes []net.IP, add bool) {

+func (c *controller) pushNodeDiscovery(d driverapi.Driver, cap driverapi.Capability, nodes []net.IP, add bool) {

 	var self net.IP

 	if c.cfg != nil {

 		addr := strings.Split(c.cfg.Cluster.Address, ":")

 		self = net.ParseIP(addr[0])

 	}

-	if d == nil || d.capability.DataScope != datastore.GlobalScope || nodes == nil {

+

+	if d == nil || cap.DataScope != datastore.GlobalScope || nodes == nil {

 		return

 	}

+

 	for _, node := range nodes {

 		nodeData := discoverapi.NodeDiscoveryData{Address: node.String(), Self: node.Equal(self)}

 		var err error

 		if add {

-			err = d.driver.DiscoverNew(discoverapi.NodeDiscovery, nodeData)

+			err = d.DiscoverNew(discoverapi.NodeDiscovery, nodeData)

 		} else {

-			err = d.driver.DiscoverDelete(discoverapi.NodeDiscovery, nodeData)

+			err = d.DiscoverDelete(discoverapi.NodeDiscovery, nodeData)

 		}

 		if err != nil {

 			log.Debugf("discovery notification error : %v", err)

@@ -378,73 +452,36 @@ func (c *controller) Config() config.Config {

 }

 func (c *controller) RegisterDriver(networkType string, driver driverapi.Driver, capability driverapi.Capability) error {

-	if !config.IsValidName(networkType) {

-		return ErrInvalidName(networkType)

-	}

-

 	c.Lock()

-	if _, ok := c.drivers[networkType]; ok {

-		c.Unlock()

-		return driverapi.ErrActiveRegistration(networkType)

-	}

-	dData := &driverData{driver, capability}

-	c.drivers[networkType] = dData

 	hd := c.discovery

 	c.Unlock()

 	if hd != nil {

-		c.pushNodeDiscovery(dData, hd.Fetch(), true)

+		c.pushNodeDiscovery(driver, capability, hd.Fetch(), true)

 	}

+	c.agentDriverNotify(driver)

 	return nil

 }