new file mode 100644

@@ -0,0 +1,30 @@

+package server

+

+import (

+	"net/http"

+	"sync"

+

+	"github.com/gorilla/mux"

+)

+

+// routerSwapper is an http.Handler that allow you to swap

+// mux routers.

+type routerSwapper struct {

+	mu     sync.Mutex

+	router *mux.Router

+}

+

+// Swap changes the old router with the new one.

+func (rs *routerSwapper) Swap(newRouter *mux.Router) {

+	rs.mu.Lock()

+	rs.router = newRouter

+	rs.mu.Unlock()

+}

+

+// ServeHTTP makes the routerSwapper to implement the http.Handler interface.

+func (rs *routerSwapper) ServeHTTP(w http.ResponseWriter, r *http.Request) {

+	rs.mu.Lock()

+	router := rs.router

+	rs.mu.Unlock()

+	router.ServeHTTP(w, r)

+}

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

 	"crypto/tls"

 	"net"

 	"net/http"

-	"os"

 	"strings"

 	"github.com/Sirupsen/logrus"

@@ -42,10 +41,11 @@ type Config struct {

 // Server contains instance details for the server

 type Server struct {

-	cfg          *Config

-	servers      []*HTTPServer

-	routers      []router.Router

-	authZPlugins []authorization.Plugin

+	cfg           *Config

+	servers       []*HTTPServer

+	routers       []router.Router

+	authZPlugins  []authorization.Plugin

+	routerSwapper *routerSwapper

 }

 // Addr contains string representation of address and its protocol (tcp, unix...).

@@ -80,12 +80,14 @@ func (s *Server) Close() {

 	}

 }

-// ServeAPI loops through all initialized servers and spawns goroutine

-// with Server method for each. It sets CreateMux() as Handler also.

-func (s *Server) ServeAPI() error {

+// serveAPI loops through all initialized servers and spawns goroutine

+// with Server method for each. It sets createMux() as Handler also.

+func (s *Server) serveAPI() error {

+	s.initRouterSwapper()

+

 	var chErrors = make(chan error, len(s.servers))

 	for _, srv := range s.servers {

-		srv.srv.Handler = s.CreateMux()

+		srv.srv.Handler = s.routerSwapper

 		go func(srv *HTTPServer) {

 			var err error

 			logrus.Infof("API listen on %s", srv.l.Addr())

@@ -186,11 +188,11 @@ func (s *Server) addRouter(r router.Router) {

 	s.routers = append(s.routers, r)

 }

-// CreateMux initializes the main router the server uses.

+// createMux initializes the main router the server uses.

 // we keep enableCors just for legacy usage, need to be removed in the future

-func (s *Server) CreateMux() *mux.Router {

+func (s *Server) createMux() *mux.Router {

 	m := mux.NewRouter()

-	if os.Getenv("DEBUG") != "" {

+	if utils.IsDebugEnabled() {

 		profilerSetup(m, "/debug/")

 	}

@@ -207,3 +209,36 @@ func (s *Server) CreateMux() *mux.Router {

 	return m

 }

+

+// Wait blocks the server goroutine until it exits.

+// It sends an error message if there is any error during

+// the API execution.

+func (s *Server) Wait(waitChan chan error) {

+	if err := s.serveAPI(); err != nil {

+		logrus.Errorf("ServeAPI error: %v", err)

+		waitChan <- err

+		return

+	}

+	waitChan <- nil

+}

+

+func (s *Server) initRouterSwapper() {

+	s.routerSwapper = &routerSwapper{

+		router: s.createMux(),

+	}

+}

+

+// Reload reads configuration changes and modifies the

+// server according to those changes.

+// Currently, only the --debug configuration is taken into account.

+func (s *Server) Reload(config *daemon.Config) {

+	debugEnabled := utils.IsDebugEnabled()

+	switch {

+	case debugEnabled && !config.Debug: // disable debug

+		utils.DisableDebug()

+		s.routerSwapper.Swap(s.createMux())

+	case config.Debug && !debugEnabled: // enable debug

+		utils.EnableDebug()

+		s.routerSwapper.Swap(s.createMux())

+	}

+}

@@ -1,9 +1,19 @@

 package daemon

 import (

+	"bytes"

+	"encoding/json"

+	"fmt"

+	"io"

+	"io/ioutil"

+	"strings"

+	"sync"

+

+	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/opts"

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

 	flag "github.com/docker/docker/pkg/mflag"

-	"github.com/docker/engine-api/types/container"

+	"github.com/imdario/mergo"

 )

 const (

@@ -11,42 +21,69 @@ const (

 	disableNetworkBridge = "none"

 )

+// LogConfig represents the default log configuration.

+// It includes json tags to deserialize configuration from a file

+// using the same names that the flags in the command line uses.

+type LogConfig struct {

+	Type   string            `json:"log-driver,omitempty"`

+	Config map[string]string `json:"log-opts,omitempty"`

+}

+

+// CommonTLSOptions defines TLS configuration for the daemon server.

+// It includes json tags to deserialize configuration from a file

+// using the same names that the flags in the command line uses.

+type CommonTLSOptions struct {

+	CAFile   string `json:"tlscacert,omitempty"`

+	CertFile string `json:"tlscert,omitempty"`

+	KeyFile  string `json:"tlskey,omitempty"`

+}

+

 // CommonConfig defines the configuration of a docker daemon which are

 // common across platforms.

+// It includes json tags to deserialize configuration from a file

+// using the same names that the flags in the command line uses.

 type CommonConfig struct {

-	AuthorizationPlugins []string // AuthorizationPlugins holds list of authorization plugins

-	AutoRestart          bool

-	Bridge               bridgeConfig // Bridge holds bridge network specific configuration.

-	Context              map[string][]string

-	DisableBridge        bool

-	DNS                  []string

-	DNSOptions           []string

-	DNSSearch            []string

-	ExecOptions          []string

-	ExecRoot             string

-	GraphDriver          string

-	GraphOptions         []string

-	Labels               []string

-	LogConfig            container.LogConfig

-	Mtu                  int

-	Pidfile              string

-	RemappedRoot         string

-	Root                 string

-	TrustKeyPath         string

+	AuthorizationPlugins []string            `json:"authorization-plugins,omitempty"` // AuthorizationPlugins holds list of authorization plugins

+	AutoRestart          bool                `json:"-"`

+	Bridge               bridgeConfig        `json:"-"` // Bridge holds bridge network specific configuration.

+	Context              map[string][]string `json:"-"`

+	DisableBridge        bool                `json:"-"`

+	DNS                  []string            `json:"dns,omitempty"`

+	DNSOptions           []string            `json:"dns-opts,omitempty"`

+	DNSSearch            []string            `json:"dns-search,omitempty"`

+	ExecOptions          []string            `json:"exec-opts,omitempty"`

+	ExecRoot             string              `json:"exec-root,omitempty"`

+	GraphDriver          string              `json:"storage-driver,omitempty"`

+	GraphOptions         []string            `json:"storage-opts,omitempty"`

+	Labels               []string            `json:"labels,omitempty"`

+	LogConfig            LogConfig           `json:"log-config,omitempty"`

+	Mtu                  int                 `json:"mtu,omitempty"`

+	Pidfile              string              `json:"pidfile,omitempty"`

+	Root                 string              `json:"graph,omitempty"`

+	TrustKeyPath         string              `json:"-"`

 	// ClusterStore is the storage backend used for the cluster information. It is used by both

 	// multihost networking (to store networks and endpoints information) and by the node discovery

 	// mechanism.

-	ClusterStore string

+	ClusterStore string `json:"cluster-store,omitempty"`

 	// ClusterOpts is used to pass options to the discovery package for tuning libkv settings, such

 	// as TLS configuration settings.

-	ClusterOpts map[string]string

+	ClusterOpts map[string]string `json:"cluster-store-opts,omitempty"`

 	// ClusterAdvertise is the network endpoint that the Engine advertises for the purpose of node

 	// discovery. This should be a 'host:port' combination on which that daemon instance is

 	// reachable by other hosts.

-	ClusterAdvertise string

+	ClusterAdvertise string `json:"cluster-advertise,omitempty"`

+

+	Debug      bool             `json:"debug,omitempty"`

+	Hosts      []string         `json:"hosts,omitempty"`

+	LogLevel   string           `json:"log-level,omitempty"`

+	TLS        bool             `json:"tls,omitempty"`

+	TLSVerify  bool             `json:"tls-verify,omitempty"`

+	TLSOptions CommonTLSOptions `json:"tls-opts,omitempty"`

+

+	reloadLock sync.Mutex

 }

 // InstallCommonFlags adds command-line options to the top-level flag parser for

@@ -54,9 +91,9 @@ type CommonConfig struct {

 // Subsequent calls to `flag.Parse` will populate config with values parsed

 // from the command-line.

 func (config *Config) InstallCommonFlags(cmd *flag.FlagSet, usageFn func(string) string) {

-	cmd.Var(opts.NewListOptsRef(&config.GraphOptions, nil), []string{"-storage-opt"}, usageFn("Set storage driver options"))

-	cmd.Var(opts.NewListOptsRef(&config.AuthorizationPlugins, nil), []string{"-authorization-plugin"}, usageFn("List authorization plugins in order from first evaluator to last"))

-	cmd.Var(opts.NewListOptsRef(&config.ExecOptions, nil), []string{"-exec-opt"}, usageFn("Set exec driver options"))

+	cmd.Var(opts.NewNamedListOptsRef("storage-opts", &config.GraphOptions, nil), []string{"-storage-opt"}, usageFn("Set storage driver options"))

+	cmd.Var(opts.NewNamedListOptsRef("authorization-plugins", &config.AuthorizationPlugins, nil), []string{"-authorization-plugin"}, usageFn("List authorization plugins in order from first evaluator to last"))

+	cmd.Var(opts.NewNamedListOptsRef("exec-opts", &config.ExecOptions, nil), []string{"-exec-opt"}, usageFn("Set exec driver options"))

 	cmd.StringVar(&config.Pidfile, []string{"p", "-pidfile"}, defaultPidFile, usageFn("Path to use for daemon PID file"))

 	cmd.StringVar(&config.Root, []string{"g", "-graph"}, defaultGraph, usageFn("Root of the Docker runtime"))

 	cmd.StringVar(&config.ExecRoot, []string{"-exec-root"}, "/var/run/docker", usageFn("Root of the Docker execdriver"))

@@ -65,12 +102,131 @@ func (config *Config) InstallCommonFlags(cmd *flag.FlagSet, usageFn func(string)

 	cmd.IntVar(&config.Mtu, []string{"#mtu", "-mtu"}, 0, usageFn("Set the containers network MTU"))

 	// FIXME: why the inconsistency between "hosts" and "sockets"?

 	cmd.Var(opts.NewListOptsRef(&config.DNS, opts.ValidateIPAddress), []string{"#dns", "-dns"}, usageFn("DNS server to use"))

-	cmd.Var(opts.NewListOptsRef(&config.DNSOptions, nil), []string{"-dns-opt"}, usageFn("DNS options to use"))

+	cmd.Var(opts.NewNamedListOptsRef("dns-opts", &config.DNSOptions, nil), []string{"-dns-opt"}, usageFn("DNS options to use"))

 	cmd.Var(opts.NewListOptsRef(&config.DNSSearch, opts.ValidateDNSSearch), []string{"-dns-search"}, usageFn("DNS search domains to use"))

-	cmd.Var(opts.NewListOptsRef(&config.Labels, opts.ValidateLabel), []string{"-label"}, usageFn("Set key=value labels to the daemon"))

+	cmd.Var(opts.NewNamedListOptsRef("labels", &config.Labels, opts.ValidateLabel), []string{"-label"}, usageFn("Set key=value labels to the daemon"))

 	cmd.StringVar(&config.LogConfig.Type, []string{"-log-driver"}, "json-file", usageFn("Default driver for container logs"))

-	cmd.Var(opts.NewMapOpts(config.LogConfig.Config, nil), []string{"-log-opt"}, usageFn("Set log driver options"))

+	cmd.Var(opts.NewNamedMapOpts("log-opts", config.LogConfig.Config, nil), []string{"-log-opt"}, usageFn("Set log driver options"))

 	cmd.StringVar(&config.ClusterAdvertise, []string{"-cluster-advertise"}, "", usageFn("Address or interface name to advertise"))

 	cmd.StringVar(&config.ClusterStore, []string{"-cluster-store"}, "", usageFn("Set the cluster store"))

-	cmd.Var(opts.NewMapOpts(config.ClusterOpts, nil), []string{"-cluster-store-opt"}, usageFn("Set cluster store options"))

+	cmd.Var(opts.NewNamedMapOpts("cluster-store-opts", config.ClusterOpts, nil), []string{"-cluster-store-opt"}, usageFn("Set cluster store options"))

+}

+

+func parseClusterAdvertiseSettings(clusterStore, clusterAdvertise string) (string, error) {

+	if clusterAdvertise == "" {

+		return "", errDiscoveryDisabled

+	}

+	if clusterStore == "" {

+		return "", fmt.Errorf("invalid cluster configuration. --cluster-advertise must be accompanied by --cluster-store configuration")

+	}

+

+	advertise, err := discovery.ParseAdvertise(clusterAdvertise)

+	if err != nil {

+		return "", fmt.Errorf("discovery advertise parsing failed (%v)", err)

+	}

+	return advertise, nil

+}

+

+// ReloadConfiguration reads the configuration in the host and reloads the daemon and server.

+func ReloadConfiguration(configFile string, flags *flag.FlagSet, reload func(*Config)) {

+	logrus.Infof("Got signal to reload configuration, reloading from: %s", configFile)

+	newConfig, err := getConflictFreeConfiguration(configFile, flags)

+	if err != nil {

+		logrus.Error(err)

+	} else {

+		reload(newConfig)

+	}

+}

+

+// MergeDaemonConfigurations reads a configuration file,

+// loads the file configuration in an isolated structure,

+// and merges the configuration provided from flags on top

+// if there are no conflicts.

+func MergeDaemonConfigurations(flagsConfig *Config, flags *flag.FlagSet, configFile string) (*Config, error) {

+	fileConfig, err := getConflictFreeConfiguration(configFile, flags)

+	if err != nil {

+		return nil, err

+	}

+

+	// merge flags configuration on top of the file configuration

+	if err := mergo.Merge(fileConfig, flagsConfig); err != nil {

+		return nil, err

+	}

+

+	return fileConfig, nil

+}

+

+// getConflictFreeConfiguration loads the configuration from a JSON file.

+// It compares that configuration with the one provided by the flags,

+// and returns an error if there are conflicts.

+func getConflictFreeConfiguration(configFile string, flags *flag.FlagSet) (*Config, error) {

+	b, err := ioutil.ReadFile(configFile)

+	if err != nil {

+		return nil, err

+	}

+

+	var reader io.Reader

+	if flags != nil {

+		var jsonConfig map[string]interface{}

+		reader = bytes.NewReader(b)

+		if err := json.NewDecoder(reader).Decode(&jsonConfig); err != nil {

+			return nil, err

+		}

+

+		if err := findConfigurationConflicts(jsonConfig, flags); err != nil {

+			return nil, err

+		}

+	}

+

+	var config Config

+	reader = bytes.NewReader(b)

+	err = json.NewDecoder(reader).Decode(&config)

+	return &config, err

+}

+

+// findConfigurationConflicts iterates over the provided flags searching for

+// duplicated configurations. It returns an error with all the conflicts if

+// it finds any.

+func findConfigurationConflicts(config map[string]interface{}, flags *flag.FlagSet) error {

+	var conflicts []string

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

+	for k, v := range config {

+		if m, ok := v.(map[string]interface{}); ok {

+			for km, vm := range m {

+				flatten[km] = vm

+			}

+		} else {

+			flatten[k] = v

+		}

+	}

+

+	printConflict := func(name string, flagValue, fileValue interface{}) string {

+		return fmt.Sprintf("%s: (from flag: %v, from file: %v)", name, flagValue, fileValue)

+	}

+

+	collectConflicts := func(f *flag.Flag) {

+		// search option name in the json configuration payload if the value is a named option

+		if namedOption, ok := f.Value.(opts.NamedOption); ok {

+			if optsValue, ok := flatten[namedOption.Name()]; ok {

+				conflicts = append(conflicts, printConflict(namedOption.Name(), f.Value.String(), optsValue))

+			}

+		} else {

+			// search flag name in the json configuration payload without trailing dashes

+			for _, name := range f.Names {

+				name = strings.TrimLeft(name, "-")

+

+				if value, ok := flatten[name]; ok {

+					conflicts = append(conflicts, printConflict(name, f.Value.String(), value))

+					break

+				}

+			}

+		}

+	}

+

+	flags.Visit(collectConflicts)

+

+	if len(conflicts) > 0 {

+		return fmt.Errorf("the following directives are specified both as a flag and in the configuration file: %s", strings.Join(conflicts, ", "))

+	}

+	return nil

 }

new file mode 100644

@@ -0,0 +1,177 @@

+package daemon

+

+import (

+	"io/ioutil"

+	"os"

+	"strings"

+	"testing"

+

+	"github.com/docker/docker/opts"

+	"github.com/docker/docker/pkg/mflag"

+)

+

+func TestDaemonConfigurationMerge(t *testing.T) {

+	f, err := ioutil.TempFile("", "docker-config-")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	configFile := f.Name()

+	f.Write([]byte(`{"debug": true}`))

+	f.Close()

+

+	c := &Config{

+		CommonConfig: CommonConfig{

+			AutoRestart: true,

+			LogConfig: LogConfig{

+				Type:   "syslog",

+				Config: map[string]string{"tag": "test"},

+			},

+		},

+	}

+

+	cc, err := MergeDaemonConfigurations(c, nil, configFile)

+	if err != nil {

+		t.Fatal(err)

+	}

+	if !cc.Debug {

+		t.Fatalf("expected %v, got %v\n", true, cc.Debug)

+	}

+	if !cc.AutoRestart {

+		t.Fatalf("expected %v, got %v\n", true, cc.AutoRestart)

+	}

+	if cc.LogConfig.Type != "syslog" {

+		t.Fatalf("expected syslog config, got %q\n", cc.LogConfig)

+	}

+}

+

+func TestDaemonConfigurationNotFound(t *testing.T) {

+	_, err := MergeDaemonConfigurations(&Config{}, nil, "/tmp/foo-bar-baz-docker")

+	if err == nil || !os.IsNotExist(err) {

+		t.Fatalf("expected does not exist error, got %v", err)

+	}

+}

+

+func TestDaemonBrokenConfiguration(t *testing.T) {

+	f, err := ioutil.TempFile("", "docker-config-")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	configFile := f.Name()

+	f.Write([]byte(`{"Debug": tru`))

+	f.Close()

+

+	_, err = MergeDaemonConfigurations(&Config{}, nil, configFile)

+	if err == nil {

+		t.Fatalf("expected error, got %v", err)

+	}

+}

+

+func TestParseClusterAdvertiseSettings(t *testing.T) {

+	_, err := parseClusterAdvertiseSettings("something", "")

+	if err != errDiscoveryDisabled {

+		t.Fatalf("expected discovery disabled error, got %v\n", err)

+	}

+

+	_, err = parseClusterAdvertiseSettings("", "something")

+	if err == nil {

+		t.Fatalf("expected discovery store error, got %v\n", err)

+	}

+

+	_, err = parseClusterAdvertiseSettings("etcd", "127.0.0.1:8080")

+	if err != nil {

+		t.Fatal(err)

+	}

+}

+

+func TestFindConfigurationConflicts(t *testing.T) {

+	config := map[string]interface{}{"authorization-plugins": "foobar"}

+	flags := mflag.NewFlagSet("test", mflag.ContinueOnError)

+

+	err := findConfigurationConflicts(config, flags)

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	flags.String([]string{"authorization-plugins"}, "", "")

+	if err := flags.Set("authorization-plugins", "asdf"); err != nil {

+		t.Fatal(err)

+	}

+

+	err = findConfigurationConflicts(config, flags)

+	if err == nil {

+		t.Fatal("expected error, got nil")

+	}

+	if !strings.Contains(err.Error(), "authorization-plugins") {

+		t.Fatalf("expected authorization-plugins conflict, got %v", err)

+	}

+}

+

+func TestFindConfigurationConflictsWithNamedOptions(t *testing.T) {

+	config := map[string]interface{}{"hosts": []string{"qwer"}}

+	flags := mflag.NewFlagSet("test", mflag.ContinueOnError)

+

+	var hosts []string

+	flags.Var(opts.NewNamedListOptsRef("hosts", &hosts, opts.ValidateHost), []string{"H", "-host"}, "Daemon socket(s) to connect to")

+	if err := flags.Set("-host", "tcp://127.0.0.1:4444"); err != nil {

+		t.Fatal(err)

+	}

+	if err := flags.Set("H", "unix:///var/run/docker.sock"); err != nil {

+		t.Fatal(err)

+	}

+

+	err := findConfigurationConflicts(config, flags)

+	if err == nil {

+		t.Fatal("expected error, got nil")

+	}

+	if !strings.Contains(err.Error(), "hosts") {

+		t.Fatalf("expected hosts conflict, got %v", err)

+	}

+}

+

+func TestDaemonConfigurationMergeConflicts(t *testing.T) {

+	f, err := ioutil.TempFile("", "docker-config-")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	configFile := f.Name()

+	f.Write([]byte(`{"debug": true}`))

+	f.Close()

+

+	flags := mflag.NewFlagSet("test", mflag.ContinueOnError)

+	flags.Bool([]string{"debug"}, false, "")

+	flags.Set("debug", "false")

+

+	_, err = MergeDaemonConfigurations(&Config{}, flags, configFile)

+	if err == nil {

+		t.Fatal("expected error, got nil")

+	}

+	if !strings.Contains(err.Error(), "debug") {

+		t.Fatalf("expected debug conflict, got %v", err)

+	}

+}

+

+func TestDaemonConfigurationMergeConflictsWithInnerStructs(t *testing.T) {

+	f, err := ioutil.TempFile("", "docker-config-")

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	configFile := f.Name()

+	f.Write([]byte(`{"tlscacert": "/etc/certificates/ca.pem"}`))

+	f.Close()

+

+	flags := mflag.NewFlagSet("test", mflag.ContinueOnError)

+	flags.String([]string{"tlscacert"}, "", "")

+	flags.Set("tlscacert", "~/.docker/ca.pem")

+

+	_, err = MergeDaemonConfigurations(&Config{}, flags, configFile)

+	if err == nil {

+		t.Fatal("expected error, got nil")

+	}

+	if !strings.Contains(err.Error(), "tlscacert") {

+		t.Fatalf("expected tlscacert conflict, got %v", err)

+	}

+}

@@ -18,18 +18,20 @@ var (

 )

 // Config defines the configuration of a docker daemon.

+// It includes json tags to deserialize configuration from a file

+// using the same names that the flags in the command line uses.

 type Config struct {

 	CommonConfig

 	// Fields below here are platform specific.

-	CorsHeaders          string

-	EnableCors           bool

-	EnableSelinuxSupport bool

-	RemappedRoot         string

-	SocketGroup          string

-	CgroupParent         string

-	Ulimits              map[string]*units.Ulimit

+	CorsHeaders          string                   `json:"api-cors-headers,omitempty"`

+	EnableCors           bool                     `json:"api-enable-cors,omitempty"`

+	EnableSelinuxSupport bool                     `json:"selinux-enabled,omitempty"`

+	RemappedRoot         string                   `json:"userns-remap,omitempty"`

+	SocketGroup          string                   `json:"group,omitempty"`

+	CgroupParent         string                   `json:"cgroup-parent,omitempty"`

+	Ulimits              map[string]*units.Ulimit `json:"default-ulimits,omitempty"`

 }

 // bridgeConfig stores all the bridge driver specific

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

 	"github.com/docker/docker/layer"

 	"github.com/docker/docker/migrate/v1"

 	"github.com/docker/docker/pkg/archive"

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

 	"github.com/docker/docker/pkg/fileutils"

 	"github.com/docker/docker/pkg/graphdb"

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

@@ -155,7 +154,7 @@ type Daemon struct {

 	EventsService             *events.Events

 	netController             libnetwork.NetworkController

 	volumes                   *store.VolumeStore

-	discoveryWatcher          discovery.Watcher

+	discoveryWatcher          discoveryReloader

 	root                      string

 	seccompEnabled            bool

 	shutdown                  bool

@@ -292,7 +291,7 @@ func (daemon *Daemon) Register(container *container.Container) error {

 func (daemon *Daemon) restore() error {

 	var (

-		debug         = os.Getenv("DEBUG") != ""

+		debug         = utils.IsDebugEnabled()

 		currentDriver = daemon.GraphDriverName()

 		containers    = make(map[string]*container.Container)

 	)

@@ -772,19 +771,8 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 	// Discovery is only enabled when the daemon is launched with an address to advertise.  When

 	// initialized, the daemon is registered and we can store the discovery backend as its read-only

-	// DiscoveryWatcher version.

-	if config.ClusterStore != "" && config.ClusterAdvertise != "" {

-		advertise, err := discovery.ParseAdvertise(config.ClusterStore, config.ClusterAdvertise)

-		if err != nil {

-			return nil, fmt.Errorf("discovery advertise parsing failed (%v)", err)

-		}

-		config.ClusterAdvertise = advertise

-		d.discoveryWatcher, err = initDiscovery(config.ClusterStore, config.ClusterAdvertise, config.ClusterOpts)

-		if err != nil {

-			return nil, fmt.Errorf("discovery initialization failed (%v)", err)

-		}

-	} else if config.ClusterAdvertise != "" {

-		return nil, fmt.Errorf("invalid cluster configuration. --cluster-advertise must be accompanied by --cluster-store configuration")

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

+		return nil, err

 	}

 	d.netController, err = d.initNetworkController(config)

@@ -815,7 +803,10 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 	d.configStore = config

 	d.execDriver = ed

 	d.statsCollector = d.newStatsCollector(1 * time.Second)

-	d.defaultLogConfig = config.LogConfig

+	d.defaultLogConfig = containertypes.LogConfig{

+		Type:   config.LogConfig.Type,

+		Config: config.LogConfig.Config,

+	}

 	d.RegistryService = registryService

 	d.EventsService = eventsService

 	d.volumes = volStore

@@ -1521,6 +1512,76 @@ func (daemon *Daemon) newBaseContainer(id string) *container.Container {

 	return container.NewBaseContainer(id, daemon.containerRoot(id))

 }

+// initDiscovery initializes the discovery watcher for this daemon.

+func (daemon *Daemon) initDiscovery(config *Config) error {

+	advertise, err := parseClusterAdvertiseSettings(config.ClusterStore, config.ClusterAdvertise)

+	if err != nil {

+		if err == errDiscoveryDisabled {

+			return nil

+		}

+		return err

+	}

+

+	config.ClusterAdvertise = advertise

+	discoveryWatcher, err := initDiscovery(config.ClusterStore, config.ClusterAdvertise, config.ClusterOpts)

+	if err != nil {

+		return fmt.Errorf("discovery initialization failed (%v)", err)

+	}

+

+	daemon.discoveryWatcher = discoveryWatcher

+	return nil

+}

+

+// Reload reads configuration changes and modifies the

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

+	return daemon.reloadClusterDiscovery(config)

+}

+

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

+	newAdvertise, err := parseClusterAdvertiseSettings(config.ClusterStore, config.ClusterAdvertise)

+	if err != nil && err != errDiscoveryDisabled {

+		return err

+	}

+

+	// check discovery modifications

+	if !modifiedDiscoverySettings(daemon.configStore, newAdvertise, config.ClusterStore, config.ClusterOpts) {

+		return nil

+	}

+

+	// enable discovery for the first time if it was not previously enabled

+	if daemon.discoveryWatcher == nil {

+		discoveryWatcher, err := initDiscovery(config.ClusterStore, newAdvertise, config.ClusterOpts)

+		if err != nil {

+			return fmt.Errorf("discovery initialization failed (%v)", err)

+		}

+		daemon.discoveryWatcher = discoveryWatcher

+	} else {

+		if err == errDiscoveryDisabled {

+			// disable discovery if it was previously enabled and it's disabled now

+			daemon.discoveryWatcher.Stop()

+		} else {

+			// reload discovery

+			if err = daemon.discoveryWatcher.Reload(config.ClusterStore, newAdvertise, config.ClusterOpts); err != nil {

+				return err

+			}

+		}

+	}

+

+	daemon.configStore.ClusterStore = config.ClusterStore

+	daemon.configStore.ClusterOpts = config.ClusterOpts

+	daemon.configStore.ClusterAdvertise = newAdvertise

+

+	return nil

+}

+

 func convertLnNetworkStats(name string, stats *lntypes.InterfaceStatistics) *libcontainer.NetworkInterface {

 	n := &libcontainer.NetworkInterface{Name: name}

 	n.RxBytes = stats.RxBytes

@@ -4,9 +4,13 @@ import (

 	"io/ioutil"

 	"os"

 	"path/filepath"

+	"reflect"

 	"testing"

+	"time"

 	"github.com/docker/docker/container"

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

+	_ "github.com/docker/docker/pkg/discovery/memory"

 	"github.com/docker/docker/pkg/registrar"

 	"github.com/docker/docker/pkg/truncindex"

 	"github.com/docker/docker/volume"

@@ -371,3 +375,118 @@ func TestMerge(t *testing.T) {

 		}

 	}

 }

+

+func TestDaemonReloadLabels(t *testing.T) {

+	daemon := &Daemon{}

+	daemon.configStore = &Config{

+		CommonConfig: CommonConfig{

+			Labels: []string{"foo:bar"},

+		},

+	}

+

+	newConfig := &Config{

+		CommonConfig: CommonConfig{

+			Labels: []string{"foo:baz"},

+		},

+	}

+

+	daemon.Reload(newConfig)

+	label := daemon.configStore.Labels[0]

+	if label != "foo:baz" {

+		t.Fatalf("Expected daemon label `foo:baz`, got %s", label)

+	}

+}

+

+func TestDaemonDiscoveryReload(t *testing.T) {

+	daemon := &Daemon{}

+	daemon.configStore = &Config{

+		CommonConfig: CommonConfig{

+			ClusterStore:     "memory://127.0.0.1",

+			ClusterAdvertise: "127.0.0.1:3333",

+		},

+	}

+

+	if err := daemon.initDiscovery(daemon.configStore); err != nil {

+		t.Fatal(err)

+	}

+

+	expected := discovery.Entries{

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

+	}

+

+	stopCh := make(chan struct{})

+	defer close(stopCh)

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

+

+	select {

+	case <-time.After(1 * time.Second):

+		t.Fatal("failed to get discovery advertisements in time")

+	case e := <-ch:

+		if !reflect.DeepEqual(e, expected) {

+			t.Fatalf("expected %v, got %v\n", expected, e)

+		}

+	case e := <-errCh:

+		t.Fatal(e)

+	}

+

+	newConfig := &Config{

+		CommonConfig: CommonConfig{

+			ClusterStore:     "memory://127.0.0.1:2222",

+			ClusterAdvertise: "127.0.0.1:5555",

+		},

+	}

+

+	expected = discovery.Entries{

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

+	}

+

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

+		t.Fatal(err)

+	}

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

+

+	select {

+	case <-time.After(1 * time.Second):

+		t.Fatal("failed to get discovery advertisements in time")

+	case e := <-ch:

+		if !reflect.DeepEqual(e, expected) {

+			t.Fatalf("expected %v, got %v\n", expected, e)

+		}

+	case e := <-errCh:

+		t.Fatal(e)

+	}

+}

+

+func TestDaemonDiscoveryReloadFromEmptyDiscovery(t *testing.T) {

+	daemon := &Daemon{}

+	daemon.configStore = &Config{}

+

+	newConfig := &Config{

+		CommonConfig: CommonConfig{

+			ClusterStore:     "memory://127.0.0.1:2222",

+			ClusterAdvertise: "127.0.0.1:5555",

+		},

+	}

+

+	expected := discovery.Entries{

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

+	}

+

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

+		t.Fatal(err)

+	}

+	stopCh := make(chan struct{})

+	defer close(stopCh)

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

+

+	select {

+	case <-time.After(1 * time.Second):

+		t.Fatal("failed to get discovery advertisements in time")

+	case e := <-ch:

+		if !reflect.DeepEqual(e, expected) {

+			t.Fatalf("expected %v, got %v\n", expected, e)

+		}

+	case e := <-errCh:

+		t.Fatal(e)

+	}

+}

@@ -1,7 +1,9 @@

 package daemon

 import (