a4befff5 |
package daemon |
1cbdaeba |
import ( |
677a6b35 |
"bytes"
"encoding/json" |
934328d8 |
"errors" |
677a6b35 |
"fmt"
"io"
"io/ioutil" |
fb833947 |
"runtime" |
677a6b35 |
"strings"
"sync"
"github.com/Sirupsen/logrus" |
353b7c8e |
"github.com/docker/docker/opts" |
677a6b35 |
"github.com/docker/docker/pkg/discovery" |
59586d02 |
"github.com/docker/docker/registry" |
677a6b35 |
"github.com/imdario/mergo" |
fb833947 |
"github.com/spf13/pflag" |
1cbdaeba |
)
|
c712e74b |
const ( |
7368e41c |
// 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 |
69af7d0d |
// stockRuntimeName is the reserved name/alias used to represent the
// OCI runtime being shipped with the docker daemon package.
stockRuntimeName = "runc" |
7368e41c |
)
const ( |
4d0a026c |
defaultNetworkMtu = 1500 |
67c254a6 |
disableNetworkBridge = "none" |
c712e74b |
)
|
d7be6b2d |
const (
defaultShutdownTimeout = 15
)
|
b6766e30 |
// 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, |
7b2e5216 |
"runtimes": true, |
e3164842 |
"default-ulimits": true, |
b6766e30 |
}
|
677a6b35 |
// LogConfig represents the default log configuration.
// It includes json tags to deserialize configuration from a file |
5c161ade |
// using the same names that the flags in the command line use. |
677a6b35 |
type LogConfig struct {
Type string `json:"log-driver,omitempty"`
Config map[string]string `json:"log-opts,omitempty"`
}
|
ff3525c8 |
// commonBridgeConfig stores all the platform-common bridge driver specific
// configuration.
type commonBridgeConfig struct {
Iface string `json:"bridge,omitempty"`
FixedCIDR string `json:"fixed-cidr,omitempty"`
}
|
677a6b35 |
// CommonTLSOptions defines TLS configuration for the daemon server.
// It includes json tags to deserialize configuration from a file |
5c161ade |
// using the same names that the flags in the command line use. |
677a6b35 |
type CommonTLSOptions struct {
CAFile string `json:"tlscacert,omitempty"`
CertFile string `json:"tlscert,omitempty"`
KeyFile string `json:"tlskey,omitempty"`
}
|
5c161ade |
// CommonConfig defines the configuration of a docker daemon which is |
b3bca3af |
// common across platforms. |
677a6b35 |
// It includes json tags to deserialize configuration from a file |
5c161ade |
// using the same names that the flags in the command line use. |
b3bca3af |
type CommonConfig struct { |
677a6b35 |
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"` |
87a450a3 |
RawLogs bool `json:"raw-logs,omitempty"` |
677a6b35 |
Root string `json:"graph,omitempty"` |
0906195f |
SocketGroup string `json:"group,omitempty"` |
677a6b35 |
TrustKeyPath string `json:"-"` |
f53902aa |
CorsHeaders string `json:"api-cors-header,omitempty"` |
2feb88cb |
EnableCors bool `json:"api-enable-cors,omitempty"` |
b9454223 |
// LiveRestoreEnabled determines whether we should keep containers
// alive upon daemon shutdown/start
LiveRestoreEnabled bool `json:"live-restore,omitempty"` |
7d193ef1 |
// 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. |
677a6b35 |
ClusterStore string `json:"cluster-store,omitempty"` |
7d193ef1 |
|
124792a8 |
// ClusterOpts is used to pass options to the discovery package for tuning libkv settings, such
// as TLS configuration settings. |
677a6b35 |
ClusterOpts map[string]string `json:"cluster-store-opts,omitempty"` |
124792a8 |
|
7d193ef1 |
// 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. |
677a6b35 |
ClusterAdvertise string `json:"cluster-advertise,omitempty"`
|
7368e41c |
// 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"`
|
d7be6b2d |
// 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"`
|
5e80ac0d |
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 |
a0ccd0d4 |
// 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"` |
3343d234 |
MetricsAddress string `json:"metrics-addr"` |
a0ccd0d4 |
|
5e80ac0d |
LogConfig |
c539be88 |
bridgeConfig // bridgeConfig holds bridge network specific configuration. |
59586d02 |
registry.ServiceOptions |
677a6b35 |
reloadLock sync.Mutex |
cd344697 |
valuesSet map[string]interface{} |
7781a1bf |
Experimental bool `json:"experimental"` // Experimental indicates whether experimental features should be exposed or not |
1cbdaeba |
} |
0d1a8251 |
|
fb833947 |
// InstallCommonFlags adds flags to the pflag.FlagSet to configure the daemon
func (config *Config) InstallCommonFlags(flags *pflag.FlagSet) { |
7368e41c |
var maxConcurrentDownloads, maxConcurrentUploads int
|
fb833947 |
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") |
31bf9ca0 |
flags.MarkDeprecated("restart", "Please use a restart policy on docker run") |
fb833947 |
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") |
353b7c8e |
// FIXME: why the inconsistency between "hosts" and "sockets"? |
fb833947 |
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") |
520e601d |
flags.StringVar(&config.CorsHeaders, "api-cors-header", "", "Set CORS headers in the Engine API") |
fb833947 |
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") |
d7be6b2d |
flags.IntVar(&config.ShutdownTimeout, "shutdown-timeout", defaultShutdownTimeout, "Set the default shutdown timeout") |
7368e41c |
|
14712f9f |
flags.StringVar(&config.SwarmDefaultAdvertiseAddr, "swarm-default-advertise-addr", "", "Set default address or interface for swarm advertised address") |
7781a1bf |
flags.BoolVar(&config.Experimental, "experimental", false, "Enable experimental features") |
a0ccd0d4 |
|
3343d234 |
flags.StringVar(&config.MetricsAddress, "metrics-addr", "", "Set default address and port to serve the metrics api on")
|
7368e41c |
config.MaxConcurrentDownloads = &maxConcurrentDownloads
config.MaxConcurrentUploads = &maxConcurrentUploads |
677a6b35 |
}
|
cd344697 |
// 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
}
|
fb833947 |
// 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
}
|
677a6b35 |
func parseClusterAdvertiseSettings(clusterStore, clusterAdvertise string) (string, error) { |
934328d8 |
if runtime.GOOS == "solaris" && (clusterAdvertise != "" || clusterStore != "") {
return "", errors.New("Cluster Advertise Settings not supported on Solaris")
} |
677a6b35 |
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
}
|
e4c9079d |
// GetConflictFreeLabels validate 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
}
|
677a6b35 |
// ReloadConfiguration reads the configuration in the host and reloads the daemon and server. |
fb833947 |
func ReloadConfiguration(configFile string, flags *pflag.FlagSet, reload func(*Config)) error { |
677a6b35 |
logrus.Infof("Got signal to reload configuration, reloading from: %s", configFile)
newConfig, err := getConflictFreeConfiguration(configFile, flags)
if err != nil { |
31cb96dc |
return err |
677a6b35 |
} |
825b5822 |
|
7b2e5216 |
if err := ValidateConfiguration(newConfig); err != nil { |
825b5822 |
return fmt.Errorf("file configuration validation failed (%v)", err)
}
|
e4c9079d |
// 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)
}
|
31cb96dc |
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 |
677a6b35 |
}
// 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. |
fb833947 |
func MergeDaemonConfigurations(flagsConfig *Config, flags *pflag.FlagSet, configFile string) (*Config, error) { |
677a6b35 |
fileConfig, err := getConflictFreeConfiguration(configFile, flags)
if err != nil {
return nil, err
}
|
7b2e5216 |
if err := ValidateConfiguration(fileConfig); err != nil { |
825b5822 |
return nil, fmt.Errorf("file configuration validation failed (%v)", err)
}
|
677a6b35 |
// merge flags configuration on top of the file configuration
if err := mergo.Merge(fileConfig, flagsConfig); err != nil {
return nil, err
}
|
7b2e5216 |
// 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)
}
|
677a6b35 |
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. |
fb833947 |
func getConflictFreeConfiguration(configFile string, flags *pflag.FlagSet) (*Config, error) { |
677a6b35 |
b, err := ioutil.ReadFile(configFile)
if err != nil {
return nil, err
}
|
cd344697 |
var config Config |
677a6b35 |
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
}
|
cd344697 |
configSet := configValuesSet(jsonConfig)
if err := findConfigurationConflicts(configSet, flags); err != nil { |
677a6b35 |
return nil, err
} |
cd344697 |
|
31cb96dc |
// Override flag values to make sure the values set in the config file with nullable values, like `false`, |
644a7426 |
// are not overridden by default truthy values from the flags that were not explicitly set. |
31cb96dc |
// 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 { |
31bf9ca0 |
f := flags.Lookup(key) |
31cb96dc |
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. |
fb833947 |
flags.VisitAll(func(f *pflag.Flag) { |
31cb96dc |
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))
}
}
})
}
|
cd344697 |
config.valuesSet = configSet |
677a6b35 |
}
reader = bytes.NewReader(b)
err = json.NewDecoder(reader).Decode(&config)
return &config, err
}
|
cd344697 |
// configValuesSet returns the configuration values explicitly set in the file.
func configValuesSet(config map[string]interface{}) map[string]interface{} { |
677a6b35 |
flatten := make(map[string]interface{})
for k, v := range config { |
b6766e30 |
if m, isMap := v.(map[string]interface{}); isMap && !flatOptions[k] { |
677a6b35 |
for km, vm := range m {
flatten[km] = vm
} |
b6766e30 |
continue |
677a6b35 |
} |
b6766e30 |
flatten[k] = v |
677a6b35 |
} |
cd344697 |
return flatten
}
// findConfigurationConflicts iterates over the provided flags searching for |
ed403867 |
// duplicated configurations and unknown keys. It returns an error with all the conflicts if |
cd344697 |
// it finds any. |
fb833947 |
func findConfigurationConflicts(config map[string]interface{}, flags *pflag.FlagSet) error { |
ed403867 |
// 1. Search keys from the file that we don't recognize as flags.
unknownKeys := make(map[string]interface{})
for key, value := range config { |
31bf9ca0 |
if flag := flags.Lookup(key); flag == nil { |
ed403867 |
unknownKeys[key] = value
}
}
|
5e80ac0d |
// 2. Discard values that implement NamedOption.
// Their configuration name differs from their flag name, like `labels` and `label`. |
31cb96dc |
if len(unknownKeys) > 0 { |
fb833947 |
unknownNamedConflicts := func(f *pflag.Flag) { |
31cb96dc |
if namedOption, ok := f.Value.(opts.NamedOption); ok {
if _, valid := unknownKeys[namedOption.Name()]; valid {
delete(unknownKeys, namedOption.Name())
} |
ed403867 |
}
} |
31cb96dc |
flags.VisitAll(unknownNamedConflicts) |
ed403867 |
}
if len(unknownKeys) > 0 {
var unknown []string
for key := range unknownKeys {
unknown = append(unknown, key)
}
return fmt.Errorf("the following directives don't match any configuration option: %s", strings.Join(unknown, ", "))
} |
677a6b35 |
|
ed403867 |
var conflicts []string |
677a6b35 |
printConflict := func(name string, flagValue, fileValue interface{}) string {
return fmt.Sprintf("%s: (from flag: %v, from file: %v)", name, flagValue, fileValue)
}
|
ed403867 |
// 3. Search keys that are present as a flag and as a file option. |
fb833947 |
duplicatedConflicts := func(f *pflag.Flag) { |
677a6b35 |
// search option name in the json configuration payload if the value is a named option
if namedOption, ok := f.Value.(opts.NamedOption); ok { |
cd344697 |
if optsValue, ok := config[namedOption.Name()]; ok { |
677a6b35 |
conflicts = append(conflicts, printConflict(namedOption.Name(), f.Value.String(), optsValue))
}
} else { |
fb833947 |
// search flag name in the json configuration payload
for _, name := range []string{f.Name, f.Shorthand} { |
cd344697 |
if value, ok := config[name]; ok { |
677a6b35 |
conflicts = append(conflicts, printConflict(name, f.Value.String(), value))
break
}
}
}
}
|
ed403867 |
flags.Visit(duplicatedConflicts) |
677a6b35 |
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 |
353b7c8e |
} |
825b5822 |
|
7b2e5216 |
// ValidateConfiguration validates some specific configs. |
7368e41c |
// such as config.DNS, config.Labels, config.DNSSearch,
// as well as config.MaxConcurrentDownloads, config.MaxConcurrentUploads. |
7b2e5216 |
func ValidateConfiguration(config *Config) error { |
825b5822 |
// validate DNS
for _, dns := range config.DNS {
if _, err := opts.ValidateIPAddress(dns); err != nil {
return err
}
}
// validate DNSSearch
for _, dnsSearch := range config.DNSSearch {
if _, err := opts.ValidateDNSSearch(dnsSearch); err != nil {
return err
}
}
// validate Labels
for _, label := range config.Labels {
if _, err := opts.ValidateLabel(label); err != nil {
return err
}
}
|
7368e41c |
// validate MaxConcurrentDownloads
if config.IsValueSet("max-concurrent-downloads") && config.MaxConcurrentDownloads != nil && *config.MaxConcurrentDownloads < 0 {
return fmt.Errorf("invalid max concurrent downloads: %d", *config.MaxConcurrentDownloads)
}
// validate MaxConcurrentUploads
if config.IsValueSet("max-concurrent-uploads") && config.MaxConcurrentUploads != nil && *config.MaxConcurrentUploads < 0 {
return fmt.Errorf("invalid max concurrent uploads: %d", *config.MaxConcurrentUploads)
} |
7b2e5216 |
// validate that "default" runtime is not reset
if runtimes := config.GetAllRuntimes(); len(runtimes) > 0 { |
69af7d0d |
if _, ok := runtimes[stockRuntimeName]; ok {
return fmt.Errorf("runtime name '%s' is reserved", stockRuntimeName) |
7b2e5216 |
}
}
|
69af7d0d |
if defaultRuntime := config.GetDefaultRuntimeName(); defaultRuntime != "" && defaultRuntime != stockRuntimeName { |
7b2e5216 |
runtimes := config.GetAllRuntimes()
if _, ok := runtimes[defaultRuntime]; !ok {
return fmt.Errorf("specified default runtime '%s' does not exist", defaultRuntime)
}
}
|
825b5822 |
return nil
} |