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

 	"github.com/docker/docker/pkg/reexec"

 	"github.com/docker/libnetwork"

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

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/options"

 	"github.com/docker/libnetwork/testutils"

@@ -88,11 +89,13 @@ func i2sbL(i interface{}) []*sandboxResource {

 }

 func createTestNetwork(t *testing.T, network string) (libnetwork.NetworkController, libnetwork.Network) {

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

 	}

-	defer c.Stop()

 	netOption := options.Generic{

 		netlabel.GenericData: options.Generic{

@@ -175,6 +178,9 @@ func TestJson(t *testing.T) {

 func TestCreateDeleteNetwork(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -249,6 +255,9 @@ func TestCreateDeleteNetwork(t *testing.T) {

 func TestGetNetworksAndEndpoints(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -518,6 +527,9 @@ func TestGetNetworksAndEndpoints(t *testing.T) {

 func TestProcGetServices(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -686,6 +698,7 @@ func TestProcGetService(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	c, nw := createTestNetwork(t, "network")

+	defer c.Stop()

 	ep1, err := nw.CreateEndpoint("db")

 	if err != nil {

 		t.Fatal(err)

@@ -738,6 +751,8 @@ func TestProcPublishUnpublishService(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	c, _ := createTestNetwork(t, "network")

+	defer c.Stop()

+

 	vars := make(map[string]string)

 	vbad, err := json.Marshal("bad service create data")

@@ -870,6 +885,7 @@ func TestAttachDetachBackend(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	c, nw := createTestNetwork(t, "network")

+	defer c.Stop()

 	ep1, err := nw.CreateEndpoint("db")

 	if err != nil {

 		t.Fatal(err)

@@ -994,6 +1010,9 @@ func TestAttachDetachBackend(t *testing.T) {

 }

 func TestDetectGetNetworksInvalidQueryComposition(t *testing.T) {

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -1011,6 +1030,7 @@ func TestDetectGetEndpointsInvalidQueryComposition(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	c, _ := createTestNetwork(t, "network")

+	defer c.Stop()

 	vars := map[string]string{urlNwName: "network", urlEpName: "x", urlEpPID: "y"}

 	_, errRsp := procGetEndpoints(c, vars, nil)

@@ -1023,6 +1043,7 @@ func TestDetectGetServicesInvalidQueryComposition(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	c, _ := createTestNetwork(t, "network")

+	defer c.Stop()

 	vars := map[string]string{urlNwName: "network", urlEpName: "x", urlEpPID: "y"}

 	_, errRsp := procGetServices(c, vars, nil)

@@ -1040,6 +1061,8 @@ func TestFindNetworkUtil(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	c, nw := createTestNetwork(t, "network")

+	defer c.Stop()

+

 	nid := nw.ID()

 	_, errRsp := findNetwork(c, "", byName)

@@ -1102,6 +1125,9 @@ func TestFindNetworkUtil(t *testing.T) {

 func TestCreateDeleteEndpoints(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -1225,6 +1251,9 @@ func TestCreateDeleteEndpoints(t *testing.T) {

 func TestJoinLeave(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -1382,6 +1411,8 @@ func TestFindEndpointUtilPanic(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	defer checkPanic(t)

 	c, nw := createTestNetwork(t, "network")

+	defer c.Stop()

+

 	nid := nw.ID()

 	findEndpoint(c, nid, "", byID, -1)

 }

@@ -1390,6 +1421,8 @@ func TestFindServiceUtilPanic(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	defer checkPanic(t)

 	c, _ := createTestNetwork(t, "network")

+	defer c.Stop()

+

 	findService(c, "random_service", -1)

 }

@@ -1397,6 +1430,8 @@ func TestFindEndpointUtil(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	c, nw := createTestNetwork(t, "network")

+	defer c.Stop()

+

 	nid := nw.ID()

 	ep, err := nw.CreateEndpoint("secondEp", nil)

@@ -1443,7 +1478,8 @@ func TestFindEndpointUtil(t *testing.T) {

 		t.Fatalf("Unexepected failure: %v", errRsp)

 	}

-	if ep0 != ep1 || ep0 != ep2 || ep0 != ep3 || ep0 != ep4 || ep0 != ep5 {

+	if ep0.ID() != ep1.ID() || ep0.ID() != ep2.ID() ||

+		ep0.ID() != ep3.ID() || ep0.ID() != ep4.ID() || ep0.ID() != ep5.ID() {

 		t.Fatalf("Diffenrent queries returned different endpoints")

 	}

@@ -1665,6 +1701,9 @@ func TestwriteJSON(t *testing.T) {

 func TestHttpHandlerUninit(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -1732,6 +1771,9 @@ func TestHttpHandlerBadBody(t *testing.T) {

 	rsp := newWriter()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -1765,6 +1807,9 @@ func TestEndToEnd(t *testing.T) {

 	rsp := newWriter()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -2213,6 +2258,9 @@ func TestEndToEndErrorMessage(t *testing.T) {

 	rsp := newWriter()

+	// Cleanup local datastore file

+	os.Remove(datastore.DefaultScopes("")[datastore.LocalScope].Client.Address)

+

 	c, err := libnetwork.New()

 	if err != nil {

 		t.Fatal(err)

@@ -22,10 +22,12 @@ import (

 	"github.com/docker/docker/pkg/reexec"

 	"github.com/Sirupsen/logrus"

+	psignal "github.com/docker/docker/pkg/signal"

 	"github.com/docker/docker/pkg/term"

 	"github.com/docker/libnetwork"

 	"github.com/docker/libnetwork/api"

 	"github.com/docker/libnetwork/config"

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

 	"github.com/docker/libnetwork/driverapi"

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/options"

@@ -76,6 +78,7 @@ func processConfig(cfg *config.Config) []config.Option {

 	if cfg == nil {

 		return options

 	}

+

 	dn := "bridge"

 	if strings.TrimSpace(cfg.Daemon.DefaultNetwork) != "" {

 		dn = cfg.Daemon.DefaultNetwork

@@ -91,12 +94,12 @@ func processConfig(cfg *config.Config) []config.Option {

 	if cfg.Daemon.Labels != nil {

 		options = append(options, config.OptionLabels(cfg.Daemon.Labels))

 	}

-	if strings.TrimSpace(cfg.GlobalStore.Client.Provider) != "" {

-		options = append(options, config.OptionKVProvider(cfg.GlobalStore.Client.Provider))

-	}

-	if strings.TrimSpace(cfg.GlobalStore.Client.Address) != "" {

-		options = append(options, config.OptionKVProviderURL(cfg.GlobalStore.Client.Address))

+

+	if dcfg, ok := cfg.Scopes[datastore.GlobalScope]; ok && dcfg.IsValid() {

+		options = append(options, config.OptionKVProvider(dcfg.Client.Provider))

+		options = append(options, config.OptionKVProviderURL(dcfg.Client.Address))

 	}

+

 	dOptions, err := startDiscovery(&cfg.Cluster)

 	if err != nil {

 		logrus.Infof("Skipping discovery : %s", err.Error())

@@ -182,8 +185,9 @@ func createDefaultNetwork(c libnetwork.NetworkController) {

 			genericOption[netlabel.GenericData] = map[string]interface{}{

 				"BridgeName": nw,

 			}

-			networkOption := libnetwork.NetworkOptionGeneric(genericOption)

-			createOptions = append(createOptions, networkOption)

+			createOptions = append(createOptions,

+				libnetwork.NetworkOptionGeneric(genericOption),

+				libnetwork.NetworkOptionPersist(false))

 		}

 		_, err := c.NewNetwork(d, nw, createOptions...)

 		if err != nil {

@@ -214,6 +218,7 @@ func (d *dnetConnection) dnetDaemon(cfgFile string) error {

 		fmt.Println("Error starting dnetDaemon :", err)

 		return err

 	}

+

 	createDefaultNetwork(controller)

 	httpHandler := api.NewHTTPHandler(controller)

 	r := mux.NewRouter().StrictSlash(false)

@@ -231,10 +236,21 @@ func (d *dnetConnection) dnetDaemon(cfgFile string) error {

 	post.Methods("GET", "PUT", "POST", "DELETE").HandlerFunc(httpHandler)

 	handleSignals(controller)

+	setupDumpStackTrap()

 	return http.ListenAndServe(d.addr, r)

 }

+func setupDumpStackTrap() {

+	c := make(chan os.Signal, 1)

+	signal.Notify(c, syscall.SIGUSR1)

+	go func() {

+		for range c {

+			psignal.DumpStacks()

+		}

+	}()

+}

+

 func handleSignals(controller libnetwork.NetworkController) {

 	c := make(chan os.Signal, 1)

 	signals := []os.Signal{os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT}

@@ -7,19 +7,21 @@ import (

 	log "github.com/Sirupsen/logrus"

 	"github.com/docker/docker/pkg/discovery"

 	"github.com/docker/libkv/store"

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

 	"github.com/docker/libnetwork/netlabel"

 )

 // Config encapsulates configurations of various Libnetwork components

 type Config struct {

-	Daemon                  DaemonCfg

-	Cluster                 ClusterCfg

-	GlobalStore, LocalStore DatastoreCfg

+	Daemon  DaemonCfg

+	Cluster ClusterCfg

+	Scopes  map[string]*datastore.ScopeCfg

 }

 // DaemonCfg represents libnetwork core configuration

 type DaemonCfg struct {

 	Debug          bool

+	DataDir        string

 	DefaultNetwork string

 	DefaultDriver  string

 	Labels         []string

@@ -34,26 +36,28 @@ type ClusterCfg struct {

 	Heartbeat uint64

 }

-// DatastoreCfg represents Datastore configuration.

-type DatastoreCfg struct {

-	Embedded bool

-	Client   DatastoreClientCfg

-}

-

-// DatastoreClientCfg represents Datastore Client-only mode configuration

-type DatastoreClientCfg struct {

-	Provider string

-	Address  string

-	Config   *store.Config

+// LoadDefaultScopes loads default scope configs for scopes which

+// doesn't have explicit user specified configs.

+func (c *Config) LoadDefaultScopes(dataDir string) {

+	for k, v := range datastore.DefaultScopes(dataDir) {

+		if _, ok := c.Scopes[k]; !ok {

+			c.Scopes[k] = v

+		}

+	}

 }

 // ParseConfig parses the libnetwork configuration file

 func ParseConfig(tomlCfgFile string) (*Config, error) {

-	var cfg Config

-	if _, err := toml.DecodeFile(tomlCfgFile, &cfg); err != nil {

+	cfg := &Config{

+		Scopes: map[string]*datastore.ScopeCfg{},

+	}

+

+	if _, err := toml.DecodeFile(tomlCfgFile, cfg); err != nil {

 		return nil, err

 	}

-	return &cfg, nil

+

+	cfg.LoadDefaultScopes(cfg.Daemon.DataDir)

+	return cfg, nil

 }

 // Option is a option setter function type used to pass varios configurations

@@ -98,7 +102,10 @@ func OptionLabels(labels []string) Option {

 func OptionKVProvider(provider string) Option {

 	return func(c *Config) {

 		log.Infof("Option OptionKVProvider: %s", provider)

-		c.GlobalStore.Client.Provider = strings.TrimSpace(provider)

+		if _, ok := c.Scopes[datastore.GlobalScope]; !ok {

+			c.Scopes[datastore.GlobalScope] = &datastore.ScopeCfg{}

+		}

+		c.Scopes[datastore.GlobalScope].Client.Provider = strings.TrimSpace(provider)

 	}

 }

@@ -106,7 +113,10 @@ func OptionKVProvider(provider string) Option {

 func OptionKVProviderURL(url string) Option {

 	return func(c *Config) {

 		log.Infof("Option OptionKVProviderURL: %s", url)

-		c.GlobalStore.Client.Address = strings.TrimSpace(url)

+		if _, ok := c.Scopes[datastore.GlobalScope]; !ok {

+			c.Scopes[datastore.GlobalScope] = &datastore.ScopeCfg{}

+		}

+		c.Scopes[datastore.GlobalScope].Client.Address = strings.TrimSpace(url)

 	}

 }

@@ -124,6 +134,13 @@ func OptionDiscoveryAddress(address string) Option {

 	}

 }

+// OptionDataDir function returns an option setter for data folder

+func OptionDataDir(dataDir string) Option {

+	return func(c *Config) {

+		c.Daemon.DataDir = dataDir

+	}

+}

+

 // ProcessOptions processes options and stores it in config

 func (c *Config) ProcessOptions(options ...Option) {

 	for _, opt := range options {

@@ -145,7 +162,10 @@ func IsValidName(name string) bool {

 func OptionLocalKVProvider(provider string) Option {

 	return func(c *Config) {

 		log.Infof("Option OptionLocalKVProvider: %s", provider)

-		c.LocalStore.Client.Provider = strings.TrimSpace(provider)

+		if _, ok := c.Scopes[datastore.LocalScope]; !ok {

+			c.Scopes[datastore.LocalScope] = &datastore.ScopeCfg{}

+		}

+		c.Scopes[datastore.LocalScope].Client.Provider = strings.TrimSpace(provider)

 	}

 }

@@ -153,7 +173,10 @@ func OptionLocalKVProvider(provider string) Option {

 func OptionLocalKVProviderURL(url string) Option {

 	return func(c *Config) {

 		log.Infof("Option OptionLocalKVProviderURL: %s", url)

-		c.LocalStore.Client.Address = strings.TrimSpace(url)

+		if _, ok := c.Scopes[datastore.LocalScope]; !ok {

+			c.Scopes[datastore.LocalScope] = &datastore.ScopeCfg{}

+		}

+		c.Scopes[datastore.LocalScope].Client.Address = strings.TrimSpace(url)

 	}

 }

@@ -161,6 +184,9 @@ func OptionLocalKVProviderURL(url string) Option {

 func OptionLocalKVProviderConfig(config *store.Config) Option {

 	return func(c *Config) {

 		log.Infof("Option OptionLocalKVProviderConfig: %v", config)

-		c.LocalStore.Client.Config = config

+		if _, ok := c.Scopes[datastore.LocalScope]; !ok {

+			c.Scopes[datastore.LocalScope] = &datastore.ScopeCfg{}

+		}

+		c.Scopes[datastore.LocalScope].Client.Config = config

 	}

 }

@@ -124,73 +124,71 @@ type ipamData struct {

 }

 type driverTable map[string]*driverData

+

+//type networkTable map[string]*network

+//type endpointTable map[string]*endpoint

 type ipamTable map[string]*ipamData

-type networkTable map[string]*network

-type endpointTable map[string]*endpoint

 type sandboxTable map[string]*sandbox

 type controller struct {

-	id                      string

-	networks                networkTable

-	drivers                 driverTable

-	ipamDrivers             ipamTable

-	sandboxes               sandboxTable

-	cfg                     *config.Config

-	globalStore, localStore datastore.DataStore

-	discovery               hostdiscovery.HostDiscovery

-	extKeyListener          net.Listener

+	id string

+	//networks       networkTable

+	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]svcMap

 	sync.Mutex

 }

 // New creates a new instance of network controller.

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

 	var cfg *config.Config

+	cfg = &config.Config{

+		Daemon: config.DaemonCfg{

+			DriverCfg: make(map[string]interface{}),

+		},

+		Scopes: make(map[string]*datastore.ScopeCfg),

+	}

+

 	if len(cfgOptions) > 0 {

-		cfg = &config.Config{

-			Daemon: config.DaemonCfg{

-				DriverCfg: make(map[string]interface{}),

-			},

-		}

 		cfg.ProcessOptions(cfgOptions...)

 	}

+	cfg.LoadDefaultScopes(cfg.Daemon.DataDir)

+

 	c := &controller{

 		id:          stringid.GenerateRandomID(),

 		cfg:         cfg,

-		networks:    networkTable{},

 		sandboxes:   sandboxTable{},

 		drivers:     driverTable{},

-		ipamDrivers: ipamTable{}}

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

-		return nil, err

+		ipamDrivers: ipamTable{},

+		svcDb:       make(map[string]svcMap),

 	}

-	if cfg != nil {

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

-			// Failing to initalize datastore is a bad situation to be in.

-			// 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 {

+	if err := c.initStores(); 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 cfg != nil && cfg.Cluster.Watcher != nil {

 		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.restoreFromLocalStore(); err != nil {

-			log.Debugf("Failed to restore from local Datastore due to %v", err)

-		}

+	}

+

+	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

 	}

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

@@ -325,15 +323,6 @@ func (c *controller) NewNetwork(networkType, name string, options ...NetworkOpti

 	if !config.IsValidName(name) {

 		return nil, ErrInvalidName(name)

 	}

-	// Check if a network already exists with the specified network name

-	c.Lock()

-	for _, n := range c.networks {

-		if n.name == name {

-			c.Unlock()

-			return nil, NetworkNameError(name)

-		}

-	}

-	c.Unlock()

 	// Construct the network object

 	network := &network{

@@ -342,13 +331,15 @@ func (c *controller) NewNetwork(networkType, name string, options ...NetworkOpti

 		ipamType:    ipamapi.DefaultIPAM,

 		id:          stringid.GenerateRandomID(),

 		ctrlr:       c,

-		endpoints:   endpointTable{},

 		persist:     true,

+		drvOnce:     &sync.Once{},

 	}

 	network.processOptions(options...)

-	if _, err := c.loadNetworkDriver(network); err != nil {

+	// Make sure we have a driver available for this network type

+	// before we allocate anything.

+	if _, err := network.driver(); err != nil {

 		return nil, err

 	}

@@ -364,7 +355,16 @@ func (c *controller) NewNetwork(networkType, name string, options ...NetworkOpti

 		}

 	}()

-	if err = c.addNetwork(network); err != nil {

+	// addNetwork can be called for local scope network lazily when

+	// an endpoint is created after a restart and the network was

+	// created in previous life. Make sure you wrap around the driver

+	// notification of network creation in once call so that the driver

+	// invoked only once in case both the network and endpoint creation

+	// happens in the same lifetime.

+	network.drvOnce.Do(func() {

+		err = c.addNetwork(network)

+	})

+	if err != nil {

 		return nil, err

 	}

@@ -380,35 +380,28 @@ func (c *controller) NewNetwork(networkType, name string, options ...NetworkOpti

 }

 func (c *controller) addNetwork(n *network) error {

-	if _, err := c.loadNetworkDriver(n); err != nil {

+	d, err := n.driver()

+	if err != nil {

 		return err

 	}

-	n.Lock()

-	d := n.driver

-	n.Unlock()

 	// Create the network

 	if err := d.CreateNetwork(n.id, n.generic, n.getIPv4Data(), n.getIPv6Data()); err != nil {

 		return err

 	}

-	if n.isGlobalScoped() {

-		if err := n.watchEndpoints(); err != nil {

-			return err

-		}

-	}

-	c.Lock()

-	c.networks[n.id] = n

-	c.Unlock()

 	return nil

 }

 func (c *controller) Networks() []Network {

-	c.Lock()

-	defer c.Unlock()

+	var list []Network

-	list := make([]Network, 0, len(c.networks))

-	for _, n := range c.networks {

+	networks, err := c.getNetworksFromStore()

+	if err != nil {

+		log.Error(err)

+	}

+

+	for _, n := range networks {

 		list = append(list, n)

 	}

@@ -450,12 +443,13 @@ func (c *controller) NetworkByID(id string) (Network, error) {

 	if id == "" {

 		return nil, ErrInvalidID(id)

 	}

-	c.Lock()

-	defer c.Unlock()

-	if n, ok := c.networks[id]; ok {

-		return n, nil

+

+	n, err := c.getNetworkFromStore(id)

+	if err != nil {

+		return nil, ErrNoSuchNetwork(id)

 	}

-	return nil, ErrNoSuchNetwork(id)

+

+	return n, nil

 }

 // NewSandbox creates a new sandbox for the passed container id

@@ -620,30 +614,7 @@ func (c *controller) getIpamDriver(name string) (ipamapi.Ipam, error) {

 }

 func (c *controller) Stop() {

-	if c.localStore != nil {

-		c.localStore.KVStore().Close()

-	}

+	c.closeStores()

 	c.stopExternalKeyListener()

 	osl.GC()

 }

-

-func (c *controller) loadNetworkDriver(n *network) (driverapi.Driver, error) {

-	// Check if a driver for the specified network type is available

-	c.Lock()

-	dd, ok := c.drivers[n.networkType]

-	c.Unlock()

-	if !ok {

-		var err error

-		dd, err = c.loadDriver(n.networkType)

-		if err != nil {

-			return nil, err

-		}

-	}

-

-	n.Lock()

-	n.svcRecords = svcMap{}

-	n.driver = dd.driver

-	n.dataScope = dd.capability.DataScope

-	n.Unlock()

-	return dd.driver, nil

-}

@@ -1,10 +1,6 @@

 package driverapi

-import (

-	"net"

-

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

-)

+import "net"

 // NetworkPluginEndpointType represents the Endpoint Type used by Plugin system

 const NetworkPluginEndpointType = "NetworkDriver"

@@ -105,7 +101,7 @@ type DriverCallback interface {

 // Capability represents the high level capabilities of the drivers which libnetwork can make use of

 type Capability struct {

-	DataScope datastore.DataScope

+	DataScope string

 }

 // DiscoveryType represents the type of discovery element the DiscoverNew function is invoked on

@@ -3,6 +3,7 @@ package libnetwork

 import (

 	"strings"

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

 	"github.com/docker/libnetwork/driverapi"

 	"github.com/docker/libnetwork/ipamapi"

 	builtinIpam "github.com/docker/libnetwork/ipams/builtin"

@@ -32,9 +33,9 @@ func makeDriverConfig(c *controller, ntype string) map[string]interface{} {

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

-	if c.validateGlobalStoreConfig() {

-		config[netlabel.KVProvider] = c.cfg.GlobalStore.Client.Provider

-		config[netlabel.KVProviderURL] = c.cfg.GlobalStore.Client.Address

+	if dcfg, ok := c.cfg.Scopes[datastore.GlobalScope]; ok && dcfg.IsValid() {

+		config[netlabel.KVProvider] = dcfg.Client.Provider

+		config[netlabel.KVProviderURL] = dcfg.Client.Address

 	}

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

@@ -43,12 +43,16 @@ func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo,

 		return err

 	}

+	// Since we perform lazy configuration make sure we try

+	// configuring the driver when we enter CreateEndpoint since

+	// CreateNetwork may not be called in every node.

+	if err := d.configure(); err != nil {

+		return err

+	}

+

 	n := d.network(nid)

 	if n == nil {

-		n, err = d.createNetworkfromStore(nid)

-		if err != nil {

-			return fmt.Errorf("network id %q not found", nid)

-		}

+		return fmt.Errorf("network id %q not found", nid)

 	}

 	ep := &endpoint{

@@ -45,12 +45,13 @@ type network struct {

 }

 func (d *driver) CreateNetwork(id string, option map[string]interface{}, ipV4Data, ipV6Data []driverapi.IPAMData) error {

-	var err error

 	if id == "" {

 		return fmt.Errorf("invalid network id")

 	}

-	if err = d.configure(); err != nil {

+	// Since we perform lazy configuration make sure we try

+	// configuring the driver when we enter CreateNetwork

+	if err := d.configure(); err != nil {

 		return err

 	}

@@ -71,29 +72,16 @@ func (d *driver) CreateNetwork(id string, option map[string]interface{}, ipV4Dat

 		n.subnets = append(n.subnets, s)

 	}

-	for {

-		// If the datastore has the network object already

-		// there is no need to do a write.

-		err = d.store.GetObject(datastore.Key(n.Key()...), n)

-		if err == nil || err != datastore.ErrKeyNotFound {

-			break

-		}

-

-		err = n.writeToStore()

-		if err == nil || err != datastore.ErrKeyModified {

-			break

-		}

-	}

-

-	if err != nil {

+	if err := n.writeToStore(); err != nil {

 		return fmt.Errorf("failed to update data store for network %v: %v", n.id, err)

 	}

+

 	d.addNetwork(n)

 	return nil

 }

-func (d *driver) createNetworkfromStore(nid string) (*network, error) {

+/* func (d *driver) createNetworkfromStore(nid string) (*network, error) {

 	n := &network{

 		id:        nid,

 		driver:    d,

@@ -107,7 +95,7 @@ func (d *driver) createNetworkfromStore(nid string) (*network, error) {

 		return nil, fmt.Errorf("unable to get network %q from data store, %v", nid, err)

 	}

 	return n, nil

-}

+}*/

 func (d *driver) DeleteNetwork(nid string) error {

 	if nid == "" {

@@ -313,9 +301,34 @@ func (d *driver) deleteNetwork(nid string) {

 func (d *driver) network(nid string) *network {

 	d.Lock()

-	defer d.Unlock()

+	networks := d.networks

+	d.Unlock()

-	return d.networks[nid]

+	n, ok := networks[nid]

+	if !ok {

+		n = d.getNetworkFromStore(nid)

+		if n != nil {

+			n.driver = d

+			n.endpoints = endpointTable{}

+			n.once = &sync.Once{}

+			networks[nid] = n

+		}

+	}

+

+	return n

+}

+

+func (d *driver) getNetworkFromStore(nid string) *network {

+	if d.store == nil {

+		return nil

+	}

+

+	n := &network{id: nid}

+	if err := d.store.GetObject(datastore.Key(n.Key()...), n); err != nil {

+		return nil

+	}

+

+	return n

 }

 func (n *network) sandbox() osl.Sandbox {

@@ -408,30 +421,23 @@ func (n *network) SetValue(value []byte) error {

 	subnetIP, _ := types.ParseCIDR(subnetIPstr)

 	gwIP, _ := types.ParseCIDR(gwIPstr)

-	// If the network is being created by reading from the

-	// datastore subnets have to created. If the network

-	// already exists update only the subnets' vni field

-	if len(n.subnets) == 0 {

-		s := &subnet{

-			subnetIP: subnetIP,

-			gwIP:     gwIP,

-			vni:      vni,

-			once:     &sync.Once{},

-		}

-		n.subnets = append(n.subnets, s)

-		return nil

+	s := &subnet{

+		subnetIP: subnetIP,

+		gwIP:     gwIP,

+		vni:      vni,

+		once:     &sync.Once{},

 	}

+	n.subnets = append(n.subnets, s)

 	sNet := n.getMatchingSubnet(subnetIP)

 	if sNet != nil {

-		if vni != 0 {

-			sNet.vni = vni

-		}

+		sNet.vni = vni

 	}

+

 	return nil

 }

-func (n *network) DataScope() datastore.DataScope {

+func (n *network) DataScope() string {

 	return datastore.GlobalScope