new file mode 100644

@@ -0,0 +1,52 @@

+package main

+

+import (

+	"github.com/docker/docker/daemon/config"

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

+	"github.com/spf13/pflag"

+)

+

+const (

+	// defaultShutdownTimeout is the default shutdown timeout for the daemon

+	defaultShutdownTimeout = 15

+)

+

+// installCommonConfigFlags adds flags to the pflag.FlagSet to configure the daemon

+func installCommonConfigFlags(conf *config.Config, flags *pflag.FlagSet) {

+	var maxConcurrentDownloads, maxConcurrentUploads int

+

+	conf.ServiceOptions.InstallCliFlags(flags)

+

+	flags.Var(opts.NewNamedListOptsRef("storage-opts", &conf.GraphOptions, nil), "storage-opt", "Storage driver options")

+	flags.Var(opts.NewNamedListOptsRef("authorization-plugins", &conf.AuthorizationPlugins, nil), "authorization-plugin", "Authorization plugins to load")

+	flags.Var(opts.NewNamedListOptsRef("exec-opts", &conf.ExecOptions, nil), "exec-opt", "Runtime execution options")

+	flags.StringVarP(&conf.Pidfile, "pidfile", "p", defaultPidFile, "Path to use for daemon PID file")

+	flags.StringVarP(&conf.Root, "graph", "g", defaultGraph, "Root of the Docker runtime")

+	flags.BoolVarP(&conf.AutoRestart, "restart", "r", true, "--restart on the daemon has been deprecated in favor of --restart policies on docker run")

+	flags.MarkDeprecated("restart", "Please use a restart policy on docker run")

+	flags.StringVarP(&conf.GraphDriver, "storage-driver", "s", "", "Storage driver to use")

+	flags.IntVar(&conf.Mtu, "mtu", 0, "Set the containers network MTU")

+	flags.BoolVar(&conf.RawLogs, "raw-logs", false, "Full timestamps without ANSI coloring")

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

+	flags.Var(opts.NewListOptsRef(&conf.DNS, opts.ValidateIPAddress), "dns", "DNS server to use")

+	flags.Var(opts.NewNamedListOptsRef("dns-opts", &conf.DNSOptions, nil), "dns-opt", "DNS options to use")

+	flags.Var(opts.NewListOptsRef(&conf.DNSSearch, opts.ValidateDNSSearch), "dns-search", "DNS search domains to use")

+	flags.Var(opts.NewNamedListOptsRef("labels", &conf.Labels, opts.ValidateLabel), "label", "Set key=value labels to the daemon")

+	flags.StringVar(&conf.LogConfig.Type, "log-driver", "json-file", "Default driver for container logs")

+	flags.Var(opts.NewNamedMapOpts("log-opts", conf.LogConfig.Config, nil), "log-opt", "Default log driver options for containers")

+	flags.StringVar(&conf.ClusterAdvertise, "cluster-advertise", "", "Address or interface name to advertise")

+	flags.StringVar(&conf.ClusterStore, "cluster-store", "", "URL of the distributed storage backend")

+	flags.Var(opts.NewNamedMapOpts("cluster-store-opts", conf.ClusterOpts, nil), "cluster-store-opt", "Set cluster store options")

+	flags.StringVar(&conf.CorsHeaders, "api-cors-header", "", "Set CORS headers in the Engine API")

+	flags.IntVar(&maxConcurrentDownloads, "max-concurrent-downloads", config.DefaultMaxConcurrentDownloads, "Set the max concurrent downloads for each pull")

+	flags.IntVar(&maxConcurrentUploads, "max-concurrent-uploads", config.DefaultMaxConcurrentUploads, "Set the max concurrent uploads for each push")

+	flags.IntVar(&conf.ShutdownTimeout, "shutdown-timeout", defaultShutdownTimeout, "Set the default shutdown timeout")

+

+	flags.StringVar(&conf.SwarmDefaultAdvertiseAddr, "swarm-default-advertise-addr", "", "Set default address or interface for swarm advertised address")

+	flags.BoolVar(&conf.Experimental, "experimental", false, "Enable experimental features")

+

+	flags.StringVar(&conf.MetricsAddress, "metrics-addr", "", "Set default address and port to serve the metrics api on")

+

+	conf.MaxConcurrentDownloads = &maxConcurrentDownloads

+	conf.MaxConcurrentUploads = &maxConcurrentUploads

+}

new file mode 100644

@@ -0,0 +1,34 @@

+// +build solaris linux freebsd

+

+package main

+

+import (

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

+	"github.com/docker/docker/daemon/config"

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

+	"github.com/spf13/pflag"

+)

+

+var (

+	defaultPidFile  = "/var/run/docker.pid"

+	defaultGraph    = "/var/lib/docker"

+	defaultExecRoot = "/var/run/docker"

+)

+

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

+// the current process that are common across Unix platforms.

+func installUnixConfigFlags(conf *config.Config, flags *pflag.FlagSet) {

+	conf.Runtimes = make(map[string]types.Runtime)

+

+	flags.StringVarP(&conf.SocketGroup, "group", "G", "docker", "Group for the unix socket")

+	flags.StringVar(&conf.BridgeConfig.IP, "bip", "", "Specify network bridge IP")

+	flags.StringVarP(&conf.BridgeConfig.Iface, "bridge", "b", "", "Attach containers to a network bridge")

+	flags.StringVar(&conf.BridgeConfig.FixedCIDR, "fixed-cidr", "", "IPv4 subnet for fixed IPs")

+	flags.Var(opts.NewIPOpt(&conf.BridgeConfig.DefaultGatewayIPv4, ""), "default-gateway", "Container default gateway IPv4 address")

+	flags.Var(opts.NewIPOpt(&conf.BridgeConfig.DefaultGatewayIPv6, ""), "default-gateway-v6", "Container default gateway IPv6 address")

+	flags.BoolVar(&conf.BridgeConfig.InterContainerCommunication, "icc", true, "Enable inter-container communication")

+	flags.Var(opts.NewIPOpt(&conf.BridgeConfig.DefaultIP, "0.0.0.0"), "ip", "Default IP when binding container ports")

+	flags.Var(opts.NewNamedRuntimeOpt("runtimes", &conf.Runtimes, config.StockRuntimeName), "add-runtime", "Register an additional OCI compatible runtime")

+	flags.StringVar(&conf.DefaultRuntime, "default-runtime", config.StockRuntimeName, "Default OCI runtime for containers")

+

+}

new file mode 100644

@@ -0,0 +1,9 @@

+package main

+

+import (

+	"github.com/docker/docker/daemon/config"

+	"github.com/spf13/pflag"

+)

+

+func attachExperimentalFlags(conf *config.Config, cmd *pflag.FlagSet) {

+}

new file mode 100644

@@ -0,0 +1,19 @@

+package main

+

+import (

+	"github.com/docker/docker/daemon/config"

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

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

+	"github.com/spf13/pflag"

+)

+

+// installConfigFlags adds flags to the pflag.FlagSet to configure the daemon

+func installConfigFlags(conf *config.Config, flags *pflag.FlagSet) {

+	// First handle install flags which are consistent cross-platform

+	installCommonConfigFlags(conf, flags)

+

+	// Then install flags common to unix platforms

+	installUnixConfigFlags(conf, flags)

+

+	attachExperimentalFlags(conf, flags)

+}

new file mode 100644

@@ -0,0 +1,51 @@

+// +build linux,!solaris freebsd,!solaris

+

+package main

+

+import (

+	"github.com/docker/docker/daemon/config"

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

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

+	"github.com/spf13/pflag"

+)

+

+// installConfigFlags adds flags to the pflag.FlagSet to configure the daemon

+func installConfigFlags(conf *config.Config, flags *pflag.FlagSet) {

+	// First handle install flags which are consistent cross-platform

+	installCommonConfigFlags(conf, flags)

+

+	// Then install flags common to unix platforms

+	installUnixConfigFlags(conf, flags)

+

+	conf.Ulimits = make(map[string]*units.Ulimit)

+

+	// Set default value for `--default-shm-size`

+	conf.ShmSize = opts.MemBytes(config.DefaultShmSize)

+

+	// Then platform-specific install flags

+	flags.BoolVar(&conf.EnableSelinuxSupport, "selinux-enabled", false, "Enable selinux support")

+	flags.Var(opts.NewUlimitOpt(&conf.Ulimits), "default-ulimit", "Default ulimits for containers")

+	flags.BoolVar(&conf.BridgeConfig.EnableIPTables, "iptables", true, "Enable addition of iptables rules")

+	flags.BoolVar(&conf.BridgeConfig.EnableIPForward, "ip-forward", true, "Enable net.ipv4.ip_forward")

+	flags.BoolVar(&conf.BridgeConfig.EnableIPMasq, "ip-masq", true, "Enable IP masquerading")

+	flags.BoolVar(&conf.BridgeConfig.EnableIPv6, "ipv6", false, "Enable IPv6 networking")

+	flags.StringVar(&conf.ExecRoot, "exec-root", defaultExecRoot, "Root directory for execution state files")

+	flags.StringVar(&conf.BridgeConfig.FixedCIDRv6, "fixed-cidr-v6", "", "IPv6 subnet for fixed IPs")

+	flags.BoolVar(&conf.BridgeConfig.EnableUserlandProxy, "userland-proxy", true, "Use userland proxy for loopback traffic")

+	flags.StringVar(&conf.BridgeConfig.UserlandProxyPath, "userland-proxy-path", "", "Path to the userland proxy binary")

+	flags.BoolVar(&conf.EnableCors, "api-enable-cors", false, "Enable CORS headers in the Engine API, this is deprecated by --api-cors-header")

+	flags.MarkDeprecated("api-enable-cors", "Please use --api-cors-header")

+	flags.StringVar(&conf.CgroupParent, "cgroup-parent", "", "Set parent cgroup for all containers")

+	flags.StringVar(&conf.RemappedRoot, "userns-remap", "", "User/Group setting for user namespaces")

+	flags.StringVar(&conf.ContainerdAddr, "containerd", "", "Path to containerd socket")

+	flags.BoolVar(&conf.LiveRestoreEnabled, "live-restore", false, "Enable live restore of docker when containers are still running")

+	flags.IntVar(&conf.OOMScoreAdjust, "oom-score-adjust", -500, "Set the oom_score_adj for the daemon")

+	flags.BoolVar(&conf.Init, "init", false, "Run an init in the container to forward signals and reap processes")

+	flags.StringVar(&conf.InitPath, "init-path", "", "Path to the docker-init binary")

+	flags.Int64Var(&conf.CPURealtimePeriod, "cpu-rt-period", 0, "Limit the CPU real-time period in microseconds")

+	flags.Int64Var(&conf.CPURealtimeRuntime, "cpu-rt-runtime", 0, "Limit the CPU real-time runtime in microseconds")

+	flags.StringVar(&conf.SeccompProfile, "seccomp-profile", "", "Path to seccomp profile")

+	flags.Var(&conf.ShmSize, "default-shm-size", "Default shm size for containers")

+

+	attachExperimentalFlags(conf, flags)

+}

new file mode 100644

@@ -0,0 +1,32 @@

+// +build linux,!solaris freebsd,!solaris

+

+package main

+

+import (

+	"runtime"

+	"testing"

+

+	"github.com/docker/docker/daemon/config"

+	"github.com/docker/docker/pkg/testutil/assert"

+	"github.com/spf13/pflag"

+)

+

+func TestDaemonParseShmSize(t *testing.T) {

+	if runtime.GOOS == "solaris" {

+		t.Skip("ShmSize not supported on Solaris\n")

+	}

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

+

+	conf := &config.Config{}

+	installConfigFlags(conf, flags)

+	// By default `--default-shm-size=64M`

+	expectedValue := 64 * 1024 * 1024

+	if conf.ShmSize.Value() != int64(expectedValue) {

+		t.Fatalf("expected default shm size %d, got %d", expectedValue, conf.ShmSize.Value())

+	}

+	assert.NilError(t, flags.Set("default-shm-size", "128M"))

+	expectedValue = 128 * 1024 * 1024

+	if conf.ShmSize.Value() != int64(expectedValue) {

+		t.Fatalf("expected default shm size %d, got %d", expectedValue, conf.ShmSize.Value())

+	}

+}

new file mode 100644

@@ -0,0 +1,25 @@

+package main

+

+import (

+	"os"

+	"path/filepath"

+

+	"github.com/docker/docker/daemon/config"

+	"github.com/spf13/pflag"

+)

+

+var (

+	defaultPidFile string

+	defaultGraph   = filepath.Join(os.Getenv("programdata"), "docker")

+)

+

+// installConfigFlags adds flags to the pflag.FlagSet to configure the daemon

+func installConfigFlags(conf *config.Config, flags *pflag.FlagSet) {

+	// First handle install flags which are consistent cross-platform

+	installCommonConfigFlags(conf, flags)

+

+	// Then platform-specific install flags.

+	flags.StringVar(&conf.BridgeConfig.FixedCIDR, "fixed-cidr", "", "IPv4 subnet for fixed IPs")

+	flags.StringVarP(&conf.BridgeConfig.Iface, "bridge", "b", "", "Attach containers to a virtual switch")

+	flags.StringVarP(&conf.SocketGroup, "group", "G", "", "Users or groups that can access the named pipe")

+}

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

 	cliflags "github.com/docker/docker/cli/flags"

 	"github.com/docker/docker/daemon"

 	"github.com/docker/docker/daemon/cluster"

+	"github.com/docker/docker/daemon/config"

 	"github.com/docker/docker/daemon/logger"

 	"github.com/docker/docker/dockerversion"

 	"github.com/docker/docker/libcontainerd"

@@ -54,7 +55,7 @@ const (

 // DaemonCli represents the daemon CLI.

 type DaemonCli struct {

-	*daemon.Config

+	*config.Config

 	configFile *string

 	flags      *pflag.FlagSet

@@ -68,7 +69,7 @@ func NewDaemonCli() *DaemonCli {

 	return &DaemonCli{}

 }

-func migrateKey(config *daemon.Config) (err error) {

+func migrateKey(config *config.Config) (err error) {

 	// No migration necessary on Windows

 	if runtime.GOOS == "windows" {

 		return nil

@@ -335,7 +336,7 @@ func (cli *DaemonCli) start(opts daemonOptions) (err error) {

 }

 func (cli *DaemonCli) reloadConfig() {

-	reload := func(config *daemon.Config) {

+	reload := func(config *config.Config) {

 		// Revalidate and reload the authorization plugins

 		if err := validateAuthzPlugins(config.AuthorizationPlugins, cli.d.PluginStore); err != nil {

@@ -363,7 +364,7 @@ func (cli *DaemonCli) reloadConfig() {

 		}

 	}

-	if err := daemon.ReloadConfiguration(*cli.configFile, cli.flags, reload); err != nil {

+	if err := config.Reload(*cli.configFile, cli.flags, reload); err != nil {

 		logrus.Error(err)

 	}

 }

@@ -395,24 +396,24 @@ func shutdownDaemon(d *daemon.Daemon) {

 	}

 }

-func loadDaemonCliConfig(opts daemonOptions) (*daemon.Config, error) {

-	config := opts.daemonConfig

+func loadDaemonCliConfig(opts daemonOptions) (*config.Config, error) {

+	conf := opts.daemonConfig

 	flags := opts.flags

-	config.Debug = opts.common.Debug

-	config.Hosts = opts.common.Hosts

-	config.LogLevel = opts.common.LogLevel

-	config.TLS = opts.common.TLS

-	config.TLSVerify = opts.common.TLSVerify

-	config.CommonTLSOptions = daemon.CommonTLSOptions{}

+	conf.Debug = opts.common.Debug

+	conf.Hosts = opts.common.Hosts

+	conf.LogLevel = opts.common.LogLevel

+	conf.TLS = opts.common.TLS

+	conf.TLSVerify = opts.common.TLSVerify

+	conf.CommonTLSOptions = config.CommonTLSOptions{}

 	if opts.common.TLSOptions != nil {

-		config.CommonTLSOptions.CAFile = opts.common.TLSOptions.CAFile

-		config.CommonTLSOptions.CertFile = opts.common.TLSOptions.CertFile

-		config.CommonTLSOptions.KeyFile = opts.common.TLSOptions.KeyFile

+		conf.CommonTLSOptions.CAFile = opts.common.TLSOptions.CAFile

+		conf.CommonTLSOptions.CertFile = opts.common.TLSOptions.CertFile

+		conf.CommonTLSOptions.KeyFile = opts.common.TLSOptions.KeyFile

 	}

 	if opts.configFile != "" {

-		c, err := daemon.MergeDaemonConfigurations(config, flags, opts.configFile)

+		c, err := config.MergeDaemonConfigurations(conf, flags, opts.configFile)

 		if err != nil {

 			if flags.Changed(flagDaemonConfigFile) || !os.IsNotExist(err) {

 				return nil, fmt.Errorf("unable to configure the Docker daemon with file %s: %v\n", opts.configFile, err)

@@ -421,11 +422,11 @@ func loadDaemonCliConfig(opts daemonOptions) (*daemon.Config, error) {

 		// the merged configuration can be nil if the config file didn't exist.

 		// leave the current configuration as it is if when that happens.

 		if c != nil {

-			config = c

+			conf = c

 		}

 	}

-	if err := daemon.ValidateConfiguration(config); err != nil {

+	if err := config.Validate(conf); err != nil {

 		return nil, err

 	}

@@ -442,20 +443,20 @@ func loadDaemonCliConfig(opts daemonOptions) (*daemon.Config, error) {

 	// }

 	// config.Labels = newLabels

 	//

-	if _, err := daemon.GetConflictFreeLabels(config.Labels); err != nil {

+	if _, err := config.GetConflictFreeLabels(conf.Labels); err != nil {

 		logrus.Warnf("Engine labels with duplicate keys and conflicting values have been deprecated: %s", err)

 	}

 	// Regardless of whether the user sets it to true or false, if they

 	// specify TLSVerify at all then we need to turn on TLS

-	if config.IsValueSet(cliflags.FlagTLSVerify) {

-		config.TLS = true

+	if conf.IsValueSet(cliflags.FlagTLSVerify) {

+		conf.TLS = true

 	}

 	// ensure that the log level is the one set after merging configurations

-	cliflags.SetLogLevel(config.LogLevel)

+	cliflags.SetLogLevel(conf.LogLevel)

-	return config, nil

+	return conf, nil

 }

 func initRouter(s *apiserver.Server, d *daemon.Daemon, c *cluster.Cluster) {

@@ -5,7 +5,7 @@ import (

 	"github.com/Sirupsen/logrus"

 	cliflags "github.com/docker/docker/cli/flags"

-	"github.com/docker/docker/daemon"

+	"github.com/docker/docker/daemon/config"

 	"github.com/docker/docker/pkg/testutil/assert"

 	"github.com/docker/docker/pkg/testutil/tempfile"

 	"github.com/spf13/pflag"

@@ -13,12 +13,12 @@ import (

 func defaultOptions(configFile string) daemonOptions {

 	opts := daemonOptions{

-		daemonConfig: &daemon.Config{},

+		daemonConfig: &config.Config{},

 		flags:        &pflag.FlagSet{},

 		common:       cliflags.NewCommonOptions(),

 	}

 	opts.common.InstallFlags(opts.flags)

-	opts.daemonConfig.InstallFlags(opts.flags)

+	installConfigFlags(opts.daemonConfig, opts.flags)

 	opts.flags.StringVar(&opts.configFile, flagDaemonConfigFile, defaultDaemonConfigFile, "")

 	opts.configFile = configFile

 	return opts

@@ -6,10 +6,11 @@

 package main

 import (

-	"github.com/docker/docker/daemon"

+	"testing"

+

+	"github.com/docker/docker/daemon/config"

 	"github.com/docker/docker/pkg/testutil/assert"

 	"github.com/docker/docker/pkg/testutil/tempfile"

-	"testing"

 )

 func TestLoadDaemonCliConfigWithDaemonFlags(t *testing.T) {

@@ -82,10 +83,10 @@ func TestLoadDaemonConfigWithTrueDefaultValues(t *testing.T) {

 	// make sure reloading doesn't generate configuration

 	// conflicts after normalizing boolean values.

-	reload := func(reloadedConfig *daemon.Config) {

+	reload := func(reloadedConfig *config.Config) {

 		assert.Equal(t, reloadedConfig.EnableUserlandProxy, false)

 	}

-	assert.NilError(t, daemon.ReloadConfiguration(opts.configFile, opts.flags, reload))

+	assert.NilError(t, config.Reload(opts.configFile, opts.flags, reload))

 }

 func TestLoadDaemonConfigWithTrueDefaultValuesLeaveDefaults(t *testing.T) {

@@ -9,7 +9,7 @@ import (

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/cli"

 	cliflags "github.com/docker/docker/cli/flags"

-	"github.com/docker/docker/daemon"

+	"github.com/docker/docker/daemon/config"

 	"github.com/docker/docker/dockerversion"

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

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

@@ -20,14 +20,14 @@ import (

 type daemonOptions struct {

 	version      bool

 	configFile   string

-	daemonConfig *daemon.Config

+	daemonConfig *config.Config

 	common       *cliflags.CommonOptions

 	flags        *pflag.FlagSet

 }

 func newDaemonCommand() *cobra.Command {

 	opts := daemonOptions{

-		daemonConfig: daemon.NewConfig(),

+		daemonConfig: config.New(),

 		common:       cliflags.NewCommonOptions(),

 	}

@@ -48,7 +48,7 @@ func newDaemonCommand() *cobra.Command {

 	flags.BoolVarP(&opts.version, "version", "v", false, "Print version information and quit")

 	flags.StringVar(&opts.configFile, flagDaemonConfigFile, defaultDaemonConfigFile, "Daemon configuration file")

 	opts.common.InstallFlags(flags)

-	opts.daemonConfig.InstallFlags(flags)

+	installConfigFlags(opts.daemonConfig, flags)

 	installServiceFlags(flags)

 	return cmd

deleted file mode 100644

@@ -1,539 +0,0 @@

-package daemon

-

-import (

-	"bytes"

-	"encoding/json"

-	"errors"

-	"fmt"

-	"io"

-	"io/ioutil"

-	"runtime"

-	"sort"

-	"strings"

-	"sync"

-

-	"github.com/Sirupsen/logrus"

-	"github.com/docker/docker/opts"

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

-	"github.com/docker/docker/registry"

-	"github.com/imdario/mergo"

-	"github.com/spf13/pflag"

-)

-

-const (

-	// defaultMaxConcurrentDownloads is the default value for

-	// maximum number of downloads that

-	// may take place at a time for each pull.

-	defaultMaxConcurrentDownloads = 3

-	// defaultMaxConcurrentUploads is the default value for

-	// maximum number of uploads that

-	// may take place at a time for each push.

-	defaultMaxConcurrentUploads = 5

-	// stockRuntimeName is the reserved name/alias used to represent the

-	// OCI runtime being shipped with the docker daemon package.

-	stockRuntimeName = "runc"

-)

-

-const (

-	defaultNetworkMtu    = 1500

-	disableNetworkBridge = "none"

-)

-

-const (

-	defaultShutdownTimeout = 15

-)

-

-// flatOptions contains configuration keys

-// that MUST NOT be parsed as deep structures.

-// Use this to differentiate these options

-// with others like the ones in CommonTLSOptions.

-var flatOptions = map[string]bool{

-	"cluster-store-opts": true,

-	"log-opts":           true,

-	"runtimes":           true,

-	"default-ulimits":    true,

-}

-

-// 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 use.

-type LogConfig struct {

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

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

-}

-

-// commonBridgeConfig stores all the platform-common bridge driver specific

-// configuration.

-type commonBridgeConfig struct {

-	Iface     string `json:"bridge,omitempty"`

-	FixedCIDR string `json:"fixed-cidr,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 use.

-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 is

-// common across platforms.

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

-// using the same names that the flags in the command line use.

-type CommonConfig struct {

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

-	AutoRestart          bool                `json:"-"`

-	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"`

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

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

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

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

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

-	RawLogs              bool                `json:"raw-logs,omitempty"`

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

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

-	TrustKeyPath         string              `json:"-"`

-	CorsHeaders          string              `json:"api-cors-header,omitempty"`

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

-

-	// LiveRestoreEnabled determines whether we should keep containers

-	// alive upon daemon shutdown/start

-	LiveRestoreEnabled bool `json:"live-restore,omitempty"`

-

-	// 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 `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 `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 `json:"cluster-advertise,omitempty"`

-

-	// MaxConcurrentDownloads is the maximum number of downloads that

-	// may take place at a time for each pull.

-	MaxConcurrentDownloads *int `json:"max-concurrent-downloads,omitempty"`

-

-	// MaxConcurrentUploads is the maximum number of uploads that

-	// may take place at a time for each push.

-	MaxConcurrentUploads *int `json:"max-concurrent-uploads,omitempty"`

-

-	// ShutdownTimeout is the timeout value (in seconds) the daemon will wait for the container

-	// to stop when daemon is being shutdown

-	ShutdownTimeout int `json:"shutdown-timeout,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:"tlsverify,omitempty"`

-

-	// Embedded structs that allow config

-	// deserialization without the full struct.

-	CommonTLSOptions

-

-	// SwarmDefaultAdvertiseAddr is the default host/IP or network interface

-	// to use if a wildcard address is specified in the ListenAddr value

-	// given to the /swarm/init endpoint and no advertise address is

-	// specified.

-	SwarmDefaultAdvertiseAddr string `json:"swarm-default-advertise-addr"`

-	MetricsAddress            string `json:"metrics-addr"`

-

-	LogConfig

-	bridgeConfig // bridgeConfig holds bridge network specific configuration.

-	registry.ServiceOptions

-

-	reloadLock sync.Mutex

-	valuesSet  map[string]interface{}

-

-	Experimental bool `json:"experimental"` // Experimental indicates whether experimental features should be exposed or not

-}

-

-// InstallCommonFlags adds flags to the pflag.FlagSet to configure the daemon

-func (config *Config) InstallCommonFlags(flags *pflag.FlagSet) {

-	var maxConcurrentDownloads, maxConcurrentUploads int

-

-	config.ServiceOptions.InstallCliFlags(flags)

-

-	flags.Var(opts.NewNamedListOptsRef("storage-opts", &config.GraphOptions, nil), "storage-opt", "Storage driver options")

-	flags.Var(opts.NewNamedListOptsRef("authorization-plugins", &config.AuthorizationPlugins, nil), "authorization-plugin", "Authorization plugins to load")

-	flags.Var(opts.NewNamedListOptsRef("exec-opts", &config.ExecOptions, nil), "exec-opt", "Runtime execution options")

-	flags.StringVarP(&config.Pidfile, "pidfile", "p", defaultPidFile, "Path to use for daemon PID file")

-	flags.StringVarP(&config.Root, "graph", "g", defaultGraph, "Root of the Docker runtime")

-	flags.BoolVarP(&config.AutoRestart, "restart", "r", true, "--restart on the daemon has been deprecated in favor of --restart policies on docker run")

-	flags.MarkDeprecated("restart", "Please use a restart policy on docker run")

-	flags.StringVarP(&config.GraphDriver, "storage-driver", "s", "", "Storage driver to use")

-	flags.IntVar(&config.Mtu, "mtu", 0, "Set the containers network MTU")

-	flags.BoolVar(&config.RawLogs, "raw-logs", false, "Full timestamps without ANSI coloring")

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

-	flags.Var(opts.NewListOptsRef(&config.DNS, opts.ValidateIPAddress), "dns", "DNS server to use")

-	flags.Var(opts.NewNamedListOptsRef("dns-opts", &config.DNSOptions, nil), "dns-opt", "DNS options to use")

-	flags.Var(opts.NewListOptsRef(&config.DNSSearch, opts.ValidateDNSSearch), "dns-search", "DNS search domains to use")

-	flags.Var(opts.NewNamedListOptsRef("labels", &config.Labels, opts.ValidateLabel), "label", "Set key=value labels to the daemon")

-	flags.StringVar(&config.LogConfig.Type, "log-driver", "json-file", "Default driver for container logs")

-	flags.Var(opts.NewNamedMapOpts("log-opts", config.LogConfig.Config, nil), "log-opt", "Default log driver options for containers")

-	flags.StringVar(&config.ClusterAdvertise, "cluster-advertise", "", "Address or interface name to advertise")

-	flags.StringVar(&config.ClusterStore, "cluster-store", "", "URL of the distributed storage backend")

-	flags.Var(opts.NewNamedMapOpts("cluster-store-opts", config.ClusterOpts, nil), "cluster-store-opt", "Set cluster store options")

-	flags.StringVar(&config.CorsHeaders, "api-cors-header", "", "Set CORS headers in the Engine API")

-	flags.IntVar(&maxConcurrentDownloads, "max-concurrent-downloads", defaultMaxConcurrentDownloads, "Set the max concurrent downloads for each pull")

-	flags.IntVar(&maxConcurrentUploads, "max-concurrent-uploads", defaultMaxConcurrentUploads, "Set the max concurrent uploads for each push")

-	flags.IntVar(&config.ShutdownTimeout, "shutdown-timeout", defaultShutdownTimeout, "Set the default shutdown timeout")

-

-	flags.StringVar(&config.SwarmDefaultAdvertiseAddr, "swarm-default-advertise-addr", "", "Set default address or interface for swarm advertised address")

-	flags.BoolVar(&config.Experimental, "experimental", false, "Enable experimental features")

-

-	flags.StringVar(&config.MetricsAddress, "metrics-addr", "", "Set default address and port to serve the metrics api on")

-

-	config.MaxConcurrentDownloads = &maxConcurrentDownloads

-	config.MaxConcurrentUploads = &maxConcurrentUploads

-}

-

-// IsValueSet returns true if a configuration value

-// was explicitly set in the configuration file.

-func (config *Config) IsValueSet(name string) bool {

-	if config.valuesSet == nil {

-		return false

-	}

-	_, ok := config.valuesSet[name]

-	return ok

-}

-

-// NewConfig returns a new fully initialized Config struct

-func NewConfig() *Config {

-	config := Config{}

-	config.LogConfig.Config = make(map[string]string)

-	config.ClusterOpts = make(map[string]string)

-

-	if runtime.GOOS != "linux" {

-		config.V2Only = true

-	}

-	return &config

-}

-

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

-	if runtime.GOOS == "solaris" && (clusterAdvertise != "" || clusterStore != "") {

-		return "", errors.New("Cluster Advertise Settings not supported on Solaris")

-	}

-	if clusterAdvertise == "" {

-		return "", errDiscoveryDisabled

-	}

-	if clusterStore == "" {

-		return "", errors.New("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

-}

-

-// GetConflictFreeLabels validates Labels for conflict

-// In swarm the duplicates for labels are removed

-// so we only take same values here, no conflict values

-// If the key-value is the same we will only take the last label

-func GetConflictFreeLabels(labels []string) ([]string, error) {

-	labelMap := map[string]string{}

-	for _, label := range labels {

-		stringSlice := strings.SplitN(label, "=", 2)

-		if len(stringSlice) > 1 {

-			// If there is a conflict we will return an error

-			if v, ok := labelMap[stringSlice[0]]; ok && v != stringSlice[1] {

-				return nil, fmt.Errorf("conflict labels for %s=%s and %s=%s", stringSlice[0], stringSlice[1], stringSlice[0], v)

-			}

-			labelMap[stringSlice[0]] = stringSlice[1]

-		}

-	}

-

-	newLabels := []string{}

-	for k, v := range labelMap {

-		newLabels = append(newLabels, fmt.Sprintf("%s=%s", k, v))

-	}

-	return newLabels, nil

-}

-

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

-func ReloadConfiguration(configFile string, flags *pflag.FlagSet, reload func(*Config)) error {

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

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

-	if err != nil {

-		return err

-	}

-

-	if err := ValidateConfiguration(newConfig); err != nil {

-		return fmt.Errorf("file configuration validation failed (%v)", err)

-	}

-

-	// Labels of the docker engine used to allow multiple values associated with the same key.

-	// This is deprecated in 1.13, and, be removed after 3 release cycles.

-	// The following will check the conflict of labels, and report a warning for deprecation.

-	//

-	// TODO: After 3 release cycles (1.16) an error will be returned, and labels will be

-	// sanitized to consolidate duplicate key-value pairs (config.Labels = newLabels):

-	//

-	// newLabels, err := GetConflictFreeLabels(newConfig.Labels)

-	// if err != nil {

-	//      return err

-	// }

-	// newConfig.Labels = newLabels

-	//

-	if _, err := GetConflictFreeLabels(newConfig.Labels); err != nil {

-		logrus.Warnf("Engine labels with duplicate keys and conflicting values have been deprecated: %s", err)

-	}

-

-	reload(newConfig)

-	return nil

-}

-

-// boolValue is an interface that boolean value flags implement

-// to tell the command line how to make -name equivalent to -name=true.

-type boolValue interface {

-	IsBoolFlag() bool

-}

-

-// 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 *pflag.FlagSet, configFile string) (*Config, error) {

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

-	if err != nil {

-		return nil, err

-	}

-

-	if err := ValidateConfiguration(fileConfig); err != nil {

-		return nil, fmt.Errorf("file configuration validation failed (%v)", err)

-	}

-

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

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

-		return nil, err

-	}

-

-	// We need to validate again once both fileConfig and flagsConfig

-	// have been merged

-	if err := ValidateConfiguration(fileConfig); err != nil {

-		return nil, fmt.Errorf("file configuration validation failed (%v)", 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 *pflag.FlagSet) (*Config, error) {

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

-	if err != nil {

-		return nil, err

-	}

-

-	var config Config

-	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

-		}

-

-		configSet := configValuesSet(jsonConfig)

-

-		if err := findConfigurationConflicts(configSet, flags); err != nil {

-			return nil, err

-		}

-

-		// Override flag values to make sure the values set in the config file with nullable values, like `false`,

-		// are not overridden by default truthy values from the flags that were not explicitly set.

-		// See https://github.com/docker/docker/issues/20289 for an example.

-		//

-		// TODO: Rewrite configuration logic to avoid same issue with other nullable values, like numbers.

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

-		for key, value := range configSet {

-			f := flags.Lookup(key)

-			if f == nil { // ignore named flags that don't match

-				namedOptions[key] = value

-				continue

-			}

-

-			if _, ok := f.Value.(boolValue); ok {

-				f.Value.Set(fmt.Sprintf("%v", value))

-			}

-		}

-		if len(namedOptions) > 0 {

-			// set also default for mergeVal flags that are boolValue at the same time.

-			flags.VisitAll(func(f *pflag.Flag) {

-				if opt, named := f.Value.(opts.NamedOption); named {

-					v, set := namedOptions[opt.Name()]

-					_, boolean := f.Value.(boolValue)

-					if set && boolean {

-						f.Value.Set(fmt.Sprintf("%v", v))

-					}

-				}

-			})

-		}

-

-		config.valuesSet = configSet

-	}

-

-	reader = bytes.NewReader(b)

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

-	return &config, err

-}

-

-// configValuesSet returns the configuration values explicitly set in the file.

-func configValuesSet(config map[string]interface{}) map[string]interface{} {

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

-	for k, v := range config {

-		if m, isMap := v.(map[string]interface{}); isMap && !flatOptions[k] {

-			for km, vm := range m {

-				flatten[km] = vm

-			}

-			continue

-		}

-

-		flatten[k] = v

-	}

-	return flatten

-}

-

-// findConfigurationConflicts iterates over the provided flags searching for

-// duplicated configurations and unknown keys. It returns an error with all the conflicts if

-// it finds any.