@@ -1598,12 +1598,12 @@ func (daemon *Daemon) initDiscovery(config *Config) error {

 // daemon according to those changes.

 // This are the settings that Reload changes:

 // - Daemon labels.

+// - Cluster discovery (reconfigure and restart).

 func (daemon *Daemon) Reload(config *Config) error {

 	daemon.configStore.reloadLock.Lock()

+	defer daemon.configStore.reloadLock.Unlock()

 	daemon.configStore.Labels = config.Labels

-	daemon.configStore.reloadLock.Unlock()

-

-	return nil

+	return daemon.reloadClusterDiscovery(config)

 }

 func (daemon *Daemon) reloadClusterDiscovery(config *Config) error {

@@ -1640,6 +1640,19 @@ func (daemon *Daemon) reloadClusterDiscovery(config *Config) error {

 	daemon.configStore.ClusterOpts = config.ClusterOpts

 	daemon.configStore.ClusterAdvertise = newAdvertise

+	if daemon.netController == nil {

+		return nil

+	}

+	netOptions, err := daemon.networkOptions(daemon.configStore)

+	if err != nil {

+		logrus.Warnf("Failed to reload configuration with network controller: %v", err)

+		return nil

+	}

+	err = daemon.netController.ReloadConfiguration(netOptions...)

+	if err != nil {

+		logrus.Warnf("Failed to reload configuration with network controller: %v", err)

+	}

+

 	return nil

 }

@@ -371,7 +371,7 @@ func TestDaemonDiscoveryReload(t *testing.T) {

 		&discovery.Entry{Host: "127.0.0.1", Port: "5555"},

 	}

-	if err := daemon.reloadClusterDiscovery(newConfig); err != nil {

+	if err := daemon.Reload(newConfig); err != nil {

 		t.Fatal(err)

 	}

 	ch, errCh = daemon.discoveryWatcher.Watch(stopCh)

@@ -403,7 +403,7 @@ func TestDaemonDiscoveryReloadFromEmptyDiscovery(t *testing.T) {

 		&discovery.Entry{Host: "127.0.0.1", Port: "5555"},

 	}

-	if err := daemon.reloadClusterDiscovery(newConfig); err != nil {

+	if err := daemon.Reload(newConfig); err != nil {

 		t.Fatal(err)

 	}

 	stopCh := make(chan struct{})

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

 	"github.com/docker/docker/pkg/idtools"

 	"github.com/docker/docker/pkg/system"

 	"github.com/docker/libnetwork"

+	nwconfig "github.com/docker/libnetwork/config"

 	blkiodev "github.com/opencontainers/runc/libcontainer/configs"

 )

@@ -251,3 +252,7 @@ func restoreCustomImage(is image.Store, ls layer.Store, rs reference.Store) erro

 	}

 	return nil

 }

+

+func (daemon *Daemon) networkOptions(dconfig *Config) ([]nwconfig.Option, error) {

+	return nil, fmt.Errorf("Network controller config reload not aavailable on Windows yet")

+}

@@ -890,4 +890,13 @@ if there are conflicts, but it won't stop execution.

 The list of currently supported options that can be reconfigured is this:

 - `debug`: it changes the daemon to debug mode when set to true.

+- `cluster-store`: it reloads the discovery store with the new address.

+- `cluster-store-opts`: it uses the new options to reload the discovery store.

+- `cluster-advertise`: it modifies the address advertised after reloading.

 - `labels`: it replaces the daemon labels with a new set of labels.

+

+Updating and reloading the cluster configurations such as `--cluster-store`,

+`--cluster-advertise` and `--cluster-store-opts` will take effect only if

+these configurations were not previously configured. Configuration reload will

+log a warning message if it detects a change in previously configured cluster

+configurations.

\ No newline at end of file

@@ -29,7 +29,7 @@ clone git github.com/RackSec/srslog 6eb773f331e46fbba8eecb8e794e635e75fc04de

 clone git github.com/imdario/mergo 0.2.1

 #get libnetwork packages

-clone git github.com/docker/libnetwork v0.7.0-dev.2

+clone git github.com/docker/libnetwork v0.7.0-dev.3

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

 clone git github.com/hashicorp/go-msgpack 71c2886f5a673a35f909803f38ece5810165097b

 clone git github.com/hashicorp/memberlist 9a1e242e454d2443df330bdd51a436d5a9058fc4

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

 	"strconv"

 	"strings"

 	"sync"

+	"syscall"

 	"time"

 	"github.com/docker/docker/pkg/integration/checker"

@@ -2156,3 +2157,43 @@ func (s *DockerDaemonSuite) TestDaemonDebugLog(c *check.C) {

 	newD.Stop()

 	c.Assert(b.String(), checker.Contains, debugLog)

 }

+

+func (s *DockerSuite) TestDaemonDiscoveryBackendConfigReload(c *check.C) {

+	testRequires(c, SameHostDaemon, DaemonIsLinux)

+

+	// daemon config file

+	daemonConfig := `{ "debug" : false }`

+	configFilePath := "test.json"

+

+	configFile, err := os.Create(configFilePath)

+	c.Assert(err, checker.IsNil)

+	fmt.Fprintf(configFile, "%s", daemonConfig)

+

+	d := NewDaemon(c)

+	err = d.Start(fmt.Sprintf("--config-file=%s", configFilePath))

+	c.Assert(err, checker.IsNil)

+	defer d.Stop()

+

+	// daemon config file

+	daemonConfig = `{

+	      "cluster-store": "consul://consuladdr:consulport/some/path",

+	      "cluster-advertise": "192.168.56.100:0",

+	      "debug" : false

+	}`

+

+	configFile.Close()

+	os.Remove(configFilePath)

+

+	configFile, err = os.Create(configFilePath)

+	c.Assert(err, checker.IsNil)

+	fmt.Fprintf(configFile, "%s", daemonConfig)

+

+	syscall.Kill(d.cmd.Process.Pid, syscall.SIGHUP)

+

+	time.Sleep(3 * time.Second)

+

+	out, err := d.Cmd("info")

+	c.Assert(err, checker.IsNil)

+	c.Assert(out, checker.Contains, fmt.Sprintf("Cluster store: consul://consuladdr:consulport/some/path"))

+	c.Assert(out, checker.Contains, fmt.Sprintf("Cluster advertise: 192.168.56.100:0"))

+}

@@ -1389,6 +1389,14 @@ func (s *DockerSuite) TestUserDefinedNetworkConnectivity(c *check.C) {

 	c.Assert(err, check.NotNil)

 }

+func (s *DockerSuite) TestEmbeddedDNSInvalidInput(c *check.C) {

+	testRequires(c, DaemonIsLinux, NotUserNamespace)

+	dockerCmd(c, "network", "create", "-d", "bridge", "nw1")

+

+	// Sending garbge to embedded DNS shouldn't crash the daemon

+	dockerCmd(c, "run", "-i", "--net=nw1", "--name=c1", "debian:jessie", "bash", "-c", "echo InvalidQuery > /dev/udp/127.0.0.11/53")

+}

+

 func (s *DockerSuite) TestDockerNetworkConnectFailsNoInspectChange(c *check.C) {

 	dockerCmd(c, "run", "-d", "--name=bb", "busybox", "top")

 	c.Assert(waitRun("bb"), check.IsNil)

@@ -1,5 +1,13 @@

 # Changelog

+## 0.7.0-dev.3 (2016-02-17)

+- Fixes https://github.com/docker/docker/issues/20350

+- Fixes https://github.com/docker/docker/issues/20145

+- Initial Windows HNS integration

+- Allow passing global datastore config to libnetwork after boot

+- Set Recursion Available bit in DNS query responses

+- Make sure iptables chains are recreated on firewalld reload

+

 ## 0.7.0-dev.2 (2016-02-11)

 - Fixes https://github.com/docker/docker/issues/20140

@@ -8,6 +8,5 @@ RUN cd /go/src && mkdir -p golang.org/x && \

 RUN go get github.com/tools/godep \

 		github.com/golang/lint/golint \

 		golang.org/x/tools/cmd/vet \

-		golang.org/x/tools/cmd/goimports \

 		golang.org/x/tools/cmd/cover\

 		github.com/mattn/goveralls

@@ -53,7 +53,7 @@ check-code:

 check-format:

 	@echo "Checking format... "

-	test -z "$$(goimports -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"

+	test -z "$$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"

 	@echo "Done checking format"

 run-tests:

@@ -61,6 +61,22 @@ func ParseConfig(tomlCfgFile string) (*Config, error) {

 	return cfg, nil

 }

+// ParseConfigOptions parses the configuration options and returns

+// a reference to the corresponding Config structure

+func ParseConfigOptions(cfgOptions ...Option) *Config {

+	cfg := &Config{

+		Daemon: DaemonCfg{

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

+		},

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

+	}

+

+	cfg.ProcessOptions(cfgOptions...)

+	cfg.LoadDefaultScopes(cfg.Daemon.DataDir)

+

+	return cfg

+}

+

 // Option is an option setter function type used to pass various configurations

 // to the controller

 type Option func(c *Config)

@@ -106,6 +106,9 @@ type NetworkController interface {

 	// Stop network controller

 	Stop()

+

+	// ReloadCondfiguration updates the controller configuration

+	ReloadConfiguration(cfgOptions ...config.Option) error

 }

 // NetworkWalker is a client provided function which will be used to walk the Networks.

@@ -129,7 +132,6 @@ type ipamData struct {

 }

 type driverTable map[string]*driverData

-

 type ipamTable map[string]*ipamData

 type sandboxTable map[string]*sandbox

@@ -153,22 +155,9 @@ type controller struct {

 // 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.ProcessOptions(cfgOptions...)

-	}

-	cfg.LoadDefaultScopes(cfg.Daemon.DataDir)

-

 	c := &controller{

 		id:          stringid.GenerateRandomID(),

-		cfg:         cfg,

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

 		sandboxes:   sandboxTable{},

 		drivers:     driverTable{},

 		ipamDrivers: ipamTable{},

@@ -179,8 +168,8 @@ func New(cfgOptions ...config.Option) (NetworkController, error) {

 		return nil, err

 	}

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

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

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

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

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

 			// But it cannot fail creating the Controller

 			log.Errorf("Failed to Initialize Discovery : %v", err)

@@ -206,6 +195,83 @@ func New(cfgOptions ...config.Option) (NetworkController, error) {

 	return c, nil

 }

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

+

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

+	procReloadConfig <- true

+	defer func() { <-procReloadConfig }()

+

+	// For now we accept the configuration reload only as a mean to provide a global store config after boot.

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

+	update := false

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

+	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")

+		}

+	}

+	for s, nSCfg := range cfg.Scopes {

+		if eSCfg, ok := c.cfg.Scopes[s]; ok {

+			if eSCfg.Client.Provider != nSCfg.Client.Provider ||

+				eSCfg.Client.Address != nSCfg.Client.Address {

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

+			}

+		} else {

+			update = true

+		}

+	}

+	if !update {

+		return nil

+	}

+

+	c.Lock()

+	c.cfg = cfg

+	c.Unlock()

+

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

+		return err

+	}

+

+	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() {

+			continue

+		}

+		dsConfig = &discoverapi.DatastoreConfigData{

+			Scope:    scope,

+			Provider: sCfg.Client.Provider,

+			Address:  sCfg.Client.Address,

+			Config:   sCfg.Client.Config,

+		}

+		break

+	}

+	if dsConfig == nil {

+		return nil

+	}

+

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

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

+		if err != nil {

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

+		}

+	}

+

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

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

+		if err != nil {

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

+		}

+	}

+

+	return nil

+}

+

 func (c *controller) ID() string {

 	return c.id

 }

@@ -726,6 +792,26 @@ func (c *controller) getIpamDriver(name string) (ipamapi.Ipam, error) {

 	return id.driver, nil

 }

+func (c *controller) getIpamDrivers() ipamTable {

+	c.Lock()

+	defer c.Unlock()

+	table := ipamTable{}

+	for i, d := range c.ipamDrivers {

+		table[i] = d

+	}

+	return table

+}

+

+func (c *controller) getNetDrivers() driverTable {

+	c.Lock()

+	defer c.Unlock()

+	table := driverTable{}

+	for i, d := range c.drivers {

+		table[i] = d

+	}

+	return table

+}

+

 func (c *controller) Stop() {

 	c.closeStores()

 	c.stopExternalKeyListener()

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

 	"github.com/docker/libkv/store/consul"

 	"github.com/docker/libkv/store/etcd"

 	"github.com/docker/libkv/store/zookeeper"

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

 	"github.com/docker/libnetwork/types"

 )

@@ -253,6 +254,34 @@ func NewDataStore(scope string, cfg *ScopeCfg) (DataStore, error) {

 	return newClient(scope, cfg.Client.Provider, cfg.Client.Address, cfg.Client.Config, cached)

 }

+// NewDataStoreFromConfig creates a new instance of LibKV data store starting from the datastore config data

+func NewDataStoreFromConfig(dsc discoverapi.DatastoreConfigData) (DataStore, error) {

+	var (

+		ok    bool

+		sCfgP *store.Config

+	)

+

+	sCfgP, ok = dsc.Config.(*store.Config)

+	if !ok && dsc.Config != nil {

+		return nil, fmt.Errorf("cannot parse store configuration: %v", dsc.Config)

+	}

+

+	scopeCfg := &ScopeCfg{

+		Client: ScopeClientCfg{

+			Address:  dsc.Address,

+			Provider: dsc.Provider,

+			Config:   sCfgP,

+		},

+	}

+

+	ds, err := NewDataStore(dsc.Scope, scopeCfg)

+	if err != nil {

+		return nil, fmt.Errorf("failed to construct datastore client from datastore configuration %v: %v", dsc, err)

+	}

+

+	return ds, err

+}

+

 func (ds *datastore) Close() {

 	ds.store.Close()

 }

@@ -16,8 +16,8 @@ type DiscoveryType int

 const (

 	// NodeDiscovery represents Node join/leave events provided by discovery

 	NodeDiscovery = iota + 1

-	// DatastoreUpdate represents a add/remove datastore event

-	DatastoreUpdate

+	// DatastoreConfig represents a add/remove datastore event

+	DatastoreConfig

 )

 // NodeDiscoveryData represents the structure backing the node discovery data json string

@@ -26,8 +26,9 @@ type NodeDiscoveryData struct {

 	Self    bool

 }

-// DatastoreUpdateData is the data for the datastore update event message

-type DatastoreUpdateData struct {

+// DatastoreConfigData is the data for the datastore update event message

+type DatastoreConfigData struct {

+	Scope    string

 	Provider string

 	Address  string

 	Config   interface{}

@@ -3,11 +3,13 @@ package libnetwork

 import (

 	"strings"

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

 	"github.com/docker/libnetwork/driverapi"

 	"github.com/docker/libnetwork/ipamapi"

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

+

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

 	remoteIpam "github.com/docker/libnetwork/ipams/remote"

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

 )

 type initializer struct {

@@ -56,10 +58,12 @@ func makeDriverConfig(c *controller, ntype string) map[string]interface{} {

 		if !v.IsValid() {

 			continue

 		}

-

-		config[netlabel.MakeKVProvider(k)] = v.Client.Provider

-		config[netlabel.MakeKVProviderURL(k)] = v.Client.Address

-		config[netlabel.MakeKVProviderConfig(k)] = v.Client.Config

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

+			Scope:    k,

+			Provider: v.Client.Provider,

+			Address:  v.Client.Address,

+			Config:   v.Client.Config,

+		}

 	}

 	return config

@@ -133,6 +133,9 @@ func Init(dc driverapi.DriverCallback, config map[string]interface{}) error {

 	if out, err := exec.Command("modprobe", "-va", "nf_nat").CombinedOutput(); err != nil {

 		logrus.Warnf("Running modprobe nf_nat failed with message: `%s`, error: %v", strings.TrimSpace(string(out)), err)

 	}

+	if out, err := exec.Command("modprobe", "-va", "xt_conntrack").CombinedOutput(); err != nil {

+		logrus.Warnf("Running modprobe xt_conntrack failed with message: `%s`, error: %v", strings.TrimSpace(string(out)), err)

+	}

 	if err := iptables.FirewalldInit(); err != nil {

 		logrus.Debugf("Fail to initialize firewalld: %v, using raw iptables instead", err)

 	}

@@ -384,6 +387,8 @@ func (d *driver) configure(option map[string]interface{}) error {

 		if err != nil {

 			return err

 		}

+		// Make sure on firewall reload, first thing being re-played is chains creation

+		iptables.OnReloaded(func() { logrus.Debugf("Recreating iptables chains on firewall reload"); setupIPChains(config) })

 	}

 	d.Lock()

@@ -6,9 +6,9 @@ import (

 	"net"

 	"github.com/Sirupsen/logrus"

-	"github.com/docker/libkv/store"

 	"github.com/docker/libkv/store/boltdb"

 	"github.com/docker/libnetwork/datastore"

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

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/types"

 )

@@ -16,27 +16,15 @@ import (

 const bridgePrefix = "bridge"

 func (d *driver) initStore(option map[string]interface{}) error {

-	var err error

-

-	provider, provOk := option[netlabel.LocalKVProvider]

-	provURL, urlOk := option[netlabel.LocalKVProviderURL]

-

-	if provOk && urlOk {

-		cfg := &datastore.ScopeCfg{

-			Client: datastore.ScopeClientCfg{

-				Provider: provider.(string),

-				Address:  provURL.(string),

-			},

+	if data, ok := option[netlabel.LocalKVClient]; ok {

+		var err error

+		dsc, ok := data.(discoverapi.DatastoreConfigData)

+		if !ok {

+			return types.InternalErrorf("incorrect data in datastore configuration: %v", data)

 		}

-

-		provConfig, confOk := option[netlabel.LocalKVProviderConfig]

-		if confOk {

-			cfg.Client.Config = provConfig.(*store.Config)

-		}

-

-		d.store, err = datastore.NewDataStore(datastore.LocalScope, cfg)

+		d.store, err = datastore.NewDataStoreFromConfig(dsc)

 		if err != nil {

-			return fmt.Errorf("bridge driver failed to initialize data store: %v", err)

+			return types.InternalErrorf("bridge driver failed to initialize data store: %v", err)

 		}

 		return d.populateNetworks()

@@ -6,12 +6,12 @@ import (

 	"sync"

 	"github.com/Sirupsen/logrus"

-	"github.com/docker/libkv/store"

 	"github.com/docker/libnetwork/datastore"

 	"github.com/docker/libnetwork/discoverapi"

 	"github.com/docker/libnetwork/driverapi"

 	"github.com/docker/libnetwork/idm"

 	"github.com/docker/libnetwork/netlabel"

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

 	"github.com/hashicorp/serf/serf"

 )

@@ -25,6 +25,8 @@ const (

 	vxlanVethMTU = 1450

 )

+var initVxlanIdm = make(chan (bool), 1)

+

 type driver struct {

 	eventCh      chan serf.Event

 	notifyCh     chan ovNotify

@@ -56,6 +58,18 @@ func Init(dc driverapi.DriverCallback, config map[string]interface{}) error {

 		config: config,

 	}

+	if data, ok := config[netlabel.GlobalKVClient]; ok {

+		var err error

+		dsc, ok := data.(discoverapi.DatastoreConfigData)

+		if !ok {

+			return types.InternalErrorf("incorrect data in datastore configuration: %v", data)

+		}

+		d.store, err = datastore.NewDataStoreFromConfig(dsc)

+		if err != nil {

+			return types.InternalErrorf("failed to initialize data store: %v", err)

+		}

+	}

+

 	return dc.RegisterDriver(networkType, d, c)

 }

@@ -73,42 +87,33 @@ func Fini(drv driverapi.Driver) {

 }

 func (d *driver) configure() error {

-	var err error

+	if d.store == nil {

+		return types.NoServiceErrorf("datastore is not available")

+	}

-	if len(d.config) == 0 {

-		return nil

+	if d.vxlanIdm == nil {

+		return d.initializeVxlanIdm()

 	}

-	d.once.Do(func() {

-		provider, provOk := d.config[netlabel.GlobalKVProvider]

-		provURL, urlOk := d.config[netlabel.GlobalKVProviderURL]

+	return nil

+}

-		if provOk && urlOk {

-			cfg := &datastore.ScopeCfg{

-				Client: datastore.ScopeClientCfg{

-					Provider: provider.(string),

-					Address:  provURL.(string),

-				},

-			}

-			provConfig, confOk := d.config[netlabel.GlobalKVProviderConfig]

-			if confOk {

-				cfg.Client.Config = provConfig.(*store.Config)

-			}

-			d.store, err = datastore.NewDataStore(datastore.GlobalScope, cfg)

-			if err != nil {

-				err = fmt.Errorf("failed to initialize data store: %v", err)

-				return

-			}

-		}

+func (d *driver) initializeVxlanIdm() error {

+	var err error

-		d.vxlanIdm, err = idm.New(d.store, "vxlan-id", vxlanIDStart, vxlanIDEnd)

-		if err != nil {

-			err = fmt.Errorf("failed to initialize vxlan id manager: %v", err)

-			return

-		}

-	})

+	initVxlanIdm <- true

+	defer func() { <-initVxlanIdm }()

+

+	if d.vxlanIdm != nil {

+		return nil

+	}

+

+	d.vxlanIdm, err = idm.New(d.store, "vxlan-id", vxlanIDStart, vxlanIDEnd)

+	if err != nil {

+		return fmt.Errorf("failed to initialize vxlan id manager: %v", err)

+	}

-	return err

+	return nil

 }

 func (d *driver) Type() string {

@@ -187,12 +192,27 @@ func (d *driver) pushLocalEndpointEvent(action, nid, eid string) {

 // DiscoverNew is a notification for a new discovery event, such as a new node joining a cluster

 func (d *driver) DiscoverNew(dType discoverapi.DiscoveryType, data interface{}) error {

-	if dType == discoverapi.NodeDiscovery {

+	switch dType {

+	case discoverapi.NodeDiscovery:

 		nodeData, ok := data.(discoverapi.NodeDiscoveryData)

 		if !ok || nodeData.Address == "" {

 			return fmt.Errorf("invalid discovery data")

 		}

 		d.nodeJoin(nodeData.Address, nodeData.Self)

+	case discoverapi.DatastoreConfig:

+		var err error

+		if d.store != nil {

+			return types.ForbiddenErrorf("cannot accept datastore configuration: Overlay driver has a datastore configured already")

+		}

+		dsc, ok := data.(discoverapi.DatastoreConfigData)

+		if !ok {

+			return types.InternalErrorf("incorrect data in datastore configuration: %v", data)

+		}

+		d.store, err = datastore.NewDataStoreFromConfig(dsc)

+		if err != nil {

+			return types.InternalErrorf("failed to initialize data store: %v", err)

+		}

+	default:

 	}

 	return nil

 }

new file mode 100644

@@ -0,0 +1,12 @@

+package windows

+

+const (

+	// NetworkName label for bridge driver

+	NetworkName = "com.docker.network.windowsshim.networkname"

+

+	// HNSID of the discovered network

+	HNSID = "com.docker.network.windowsshim.hnsid"

+

+	// RoutingDomain of the network

+	RoutingDomain = "com.docker.network.windowsshim.routingdomain"

+)

@@ -1,57 +1,419 @@

+// +build windows

+

+// Shim for the Host Network Service (HNS) to manage networking for

+// Windows Server containers and Hyper-V containers. This module

+// is a basic libnetwork driver that passes all the calls to HNS

+// It implements the 4 networking modes supported by HNS L2Bridge,

+// L2Tunnel, NAT and Transparent(DHCP)

+//

+// The network are stored in memory and docker daemon ensures discovering

+// and loading these networks on startup

+

 package windows

 import (

+	"encoding/json"

+	"fmt"

+	"net"

+	"strings"

+	"sync"

+

+	"github.com/Microsoft/hcsshim"

+	log "github.com/Sirupsen/logrus"

 	"github.com/docker/libnetwork/datastore"

 	"github.com/docker/libnetwork/discoverapi"

 	"github.com/docker/libnetwork/driverapi"

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

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

 )

-const networkType = "windows"

+// networkConfiguration for network specific configuration

+type networkConfiguration struct {

+	ID    string

+	Type  string

+	Name  string

+	HnsID string

+	RDID  string

+}

+

+type hnsEndpoint struct {

+	id         string

+	profileID  string

+	macAddress net.HardwareAddr

+	addr       *net.IPNet

+}

+

+type hnsNetwork struct {

+	id        string

+	config    *networkConfiguration

+	endpoints map[string]*hnsEndpoint // key: endpoint id

+	driver    *driver                 // The network's driver

+	sync.Mutex

+}

+

+type driver struct {

+	name     string

+	networks map[string]*hnsNetwork

+	sync.Mutex

+}

+

+func isValidNetworkType(networkType string) bool {

+	if "L2Bridge" == networkType || "L2Tunnel" == networkType || "NAT" == networkType || "Transparent" == networkType {

+		return true

+	}

+

+	return false

+}

+

+// New constructs a new bridge driver

+func newDriver(networkType string) *driver {

+	return &driver{name: networkType, networks: map[string]*hnsNetwork{}}

+}

+

+// GetInit returns an initializer for the given network type

+func GetInit(networkType string) func(dc driverapi.DriverCallback, config map[string]interface{}) error {

+	return func(dc driverapi.DriverCallback, config map[string]interface{}) error {

+		if !isValidNetworkType(networkType) {

+			return types.BadRequestErrorf("Network type not supported: %s", networkType)

+		}

+

+		return dc.RegisterDriver(networkType, newDriver(networkType), driverapi.Capability{

+			DataScope: datastore.LocalScope,

+		})

+	}

+}

+

+func (d *driver) getNetwork(id string) (*hnsNetwork, error) {

+	d.Lock()

+	defer d.Unlock()

+

+	if nw, ok := d.networks[id]; ok {

+		return nw, nil

+	}

+

+	return nil, types.NotFoundErrorf("network not found: %s", id)

+}

+

+func (n *hnsNetwork) getEndpoint(eid string) (*hnsEndpoint, error) {

+	n.Lock()

+	defer n.Unlock()

+

+	if ep, ok := n.endpoints[eid]; ok {

+		return ep, nil

+	}

+

+	return nil, types.NotFoundErrorf("Endpoint not found: %s", eid)

+}

+

+func (d *driver) parseNetworkOptions(id string, genericOptions map[string]string) (*networkConfiguration, error) {

+	config := &networkConfiguration{}

-// TODO Windows. This is a placeholder for now

+	for label, value := range genericOptions {

+		switch label {

+		case NetworkName:

+			config.Name = value

+		case HNSID:

+			config.HnsID = value

+		case RoutingDomain:

+			config.RDID = value

+		}

+	}

-type driver struct{}

+	config.ID = id

+	config.Type = d.name

+	return config, nil

+}

+

+func (c *networkConfiguration) processIPAM(id string, ipamV4Data, ipamV6Data []driverapi.IPAMData) error {

+	if len(ipamV6Data) > 0 {

+		return types.ForbiddenErrorf("windowsshim driver doesnt support v6 subnets")

+	}

-// Init registers a new instance of null driver

-func Init(dc driverapi.DriverCallback, config map[string]interface{}) error {

-	c := driverapi.Capability{

-		DataScope: datastore.LocalScope,

+	if len(ipamV4Data) == 0 {

+		return types.BadRequestErrorf("network %s requires ipv4 configuration", id)

 	}

-	return dc.RegisterDriver(networkType, &driver{}, c)

+

+	return nil

 }

+// Create a new network

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

+	if _, err := d.getNetwork(id); err == nil {

+		return types.ForbiddenErrorf("network %s exists", id)

+	}

+

+	genData, ok := option[netlabel.GenericData].(map[string]string)

+	if !ok {

+		return fmt.Errorf("Unknown generic data option")

+	}

+

+	// Parse and validate the config. It should not conflict with existing networks' config

+	config, err := d.parseNetworkOptions(id, genData)

+	if err != nil {

+		return err

+	}

+