diff --git a/daemon/daemon.go b/daemon/daemon.go index 64ca00debb..ba3e03a01f 100644 --- a/daemon/daemon.go +++ b/daemon/daemon.go @@ -84,30 +84,28 @@ var ( // Daemon holds information about the Docker daemon. type Daemon struct { - ID string - repository string - containers container.Store - containersReplica container.ViewDB - execCommands *exec.Store - imageService *images.ImageService - idIndex *truncindex.TruncIndex - configStore *config.Config - statsCollector *stats.Collector - defaultLogConfig containertypes.LogConfig - RegistryService registry.Service - EventsService *events.Events - netController libnetwork.NetworkController - volumes *volumesservice.VolumesService - discoveryWatcher discovery.Reloader - root string - seccompEnabled bool - apparmorEnabled bool - shutdown bool - idMapping *idtools.IdentityMapping - // TODO: move graphDrivers field to an InfoService - graphDrivers map[string]string // By operating system - - PluginStore *plugin.Store // todo: remove + ID string + repository string + containers container.Store + containersReplica container.ViewDB + execCommands *exec.Store + imageService *images.ImageService + idIndex *truncindex.TruncIndex + configStore *config.Config + statsCollector *stats.Collector + defaultLogConfig containertypes.LogConfig + RegistryService registry.Service + EventsService *events.Events + netController libnetwork.NetworkController + volumes *volumesservice.VolumesService + discoveryWatcher discovery.Reloader + root string + seccompEnabled bool + apparmorEnabled bool + shutdown bool + idMapping *idtools.IdentityMapping + graphDriver string // TODO: move graphDriver field to an InfoService + PluginStore *plugin.Store // TODO: remove pluginManager *plugin.Manager linkIndex *linkIndex containerdCli *containerd.Client @@ -251,8 +249,7 @@ func (daemon *Daemon) restore() error { return } // Ignore the container if it does not support the current driver being used by the graph - currentDriverForContainerOS := daemon.graphDrivers[c.OS] - if (c.Driver == "" && currentDriverForContainerOS == "aufs") || c.Driver == currentDriverForContainerOS { + if (c.Driver == "" && daemon.graphDriver == "aufs") || c.Driver == daemon.graphDriver { rwlayer, err := daemon.imageService.GetLayerByID(c.ID, c.OS) if err != nil { log.WithError(err).Error("failed to load container mount") @@ -872,27 +869,19 @@ func NewDaemon(ctx context.Context, config *config.Config, pluginStore *plugin.S } } - // On Windows we don't support the environment variable, or a user supplied graphdriver - // as Windows has no choice in terms of which graphdrivers to use. It's a case of - // running Windows containers on Windows - windowsfilter, running Linux containers on Windows, - // lcow. Unix platforms however run a single graphdriver for all containers, and it can - // be set through an environment variable, a daemon start parameter, or chosen through - // initialization of the layerstore through driver priority order for example. - d.graphDrivers = make(map[string]string) - layerStores := make(map[string]layer.Store) if isWindows { - d.graphDrivers[runtime.GOOS] = "windowsfilter" - if system.LCOWSupported() { - d.graphDrivers["linux"] = "lcow" - } + // On Windows we don't support the environment variable, or a user supplied graphdriver + d.graphDriver = "windowsfilter" } else { - driverName := os.Getenv("DOCKER_DRIVER") - if driverName == "" { - driverName = config.GraphDriver + // Unix platforms however run a single graphdriver for all containers, and it can + // be set through an environment variable, a daemon start parameter, or chosen through + // initialization of the layerstore through driver priority order for example. + if drv := os.Getenv("DOCKER_DRIVER"); drv != "" { + d.graphDriver = drv + logrus.Infof("Setting the storage driver from the $DOCKER_DRIVER environment variable (%s)", drv) } else { - logrus.Infof("Setting the storage driver from the $DOCKER_DRIVER environment variable (%s)", driverName) + d.graphDriver = config.GraphDriver // May still be empty. Layerstore init determines instead. } - d.graphDrivers[runtime.GOOS] = driverName // May still be empty. Layerstore init determines instead. } d.RegistryService = registryService @@ -985,42 +974,39 @@ func NewDaemon(ctx context.Context, config *config.Config, pluginStore *plugin.S return nil, err } - for operatingSystem, gd := range d.graphDrivers { - layerStores[operatingSystem], err = layer.NewStoreFromOptions(layer.StoreOptions{ - Root: config.Root, - MetadataStorePathTemplate: filepath.Join(config.Root, "image", "%s", "layerdb"), - GraphDriver: gd, - GraphDriverOptions: config.GraphOptions, - IDMapping: idMapping, - PluginGetter: d.PluginStore, - ExperimentalEnabled: config.Experimental, - OS: operatingSystem, - }) - if err != nil { - return nil, err - } - - // As layerstore initialization may set the driver - d.graphDrivers[operatingSystem] = layerStores[operatingSystem].DriverName() - } - - // Configure and validate the kernels security support. Note this is a Linux/FreeBSD - // operation only, so it is safe to pass *just* the runtime OS graphdriver. - if err := configureKernelSecuritySupport(config, d.graphDrivers[runtime.GOOS]); err != nil { + layerStore, err := layer.NewStoreFromOptions(layer.StoreOptions{ + Root: config.Root, + MetadataStorePathTemplate: filepath.Join(config.Root, "image", "%s", "layerdb"), + GraphDriver: d.graphDriver, + GraphDriverOptions: config.GraphOptions, + IDMapping: idMapping, + PluginGetter: d.PluginStore, + ExperimentalEnabled: config.Experimental, + OS: runtime.GOOS, + }) + if err != nil { return nil, err } - imageRoot := filepath.Join(config.Root, "image", d.graphDrivers[runtime.GOOS]) + // As layerstore initialization may set the driver + d.graphDriver = layerStore.DriverName() + + // Configure and validate the kernels security support. Note this is a Linux/FreeBSD + // operation only, so it is safe to pass *just* the runtime OS graphdriver. + if err := configureKernelSecuritySupport(config, d.graphDriver); err != nil { + return nil, err + } + + imageRoot := filepath.Join(config.Root, "image", d.graphDriver) ifs, err := image.NewFSStoreBackend(filepath.Join(imageRoot, "imagedb")) if err != nil { return nil, err } - lgrMap := make(map[string]image.LayerGetReleaser) - for los, ls := range layerStores { - lgrMap[los] = ls - } - imageStore, err := image.NewImageStore(ifs, lgrMap) + // TODO remove multiple imagestores map now that LCOW is no more + imageStore, err := image.NewImageStore(ifs, map[string]image.LayerGetReleaser{ + runtime.GOOS: layerStore, + }) if err != nil { return nil, err } @@ -1098,7 +1084,7 @@ func NewDaemon(ctx context.Context, config *config.Config, pluginStore *plugin.S DistributionMetadataStore: distributionMetadataStore, EventsService: d.EventsService, ImageStore: imageStore, - LayerStores: layerStores, + LayerStores: map[string]layer.Store{runtime.GOOS: layerStore}, // TODO remove multiple LayerStores map now that LCOW is no more MaxConcurrentDownloads: *config.MaxConcurrentDownloads, MaxConcurrentUploads: *config.MaxConcurrentUploads, MaxDownloadAttempts: *config.MaxDownloadAttempts, @@ -1156,20 +1142,10 @@ func NewDaemon(ctx context.Context, config *config.Config, pluginStore *plugin.S engineCpus.Set(float64(info.NCPU)) engineMemory.Set(float64(info.MemTotal)) - gd := "" - for os, driver := range d.graphDrivers { - if len(gd) > 0 { - gd += ", " - } - gd += driver - if len(d.graphDrivers) > 1 { - gd = fmt.Sprintf("%s (%s)", gd, os) - } - } logrus.WithFields(logrus.Fields{ - "version": dockerversion.Version, - "commit": dockerversion.GitCommit, - "graphdriver(s)": gd, + "version": dockerversion.Version, + "commit": dockerversion.GitCommit, + "graphdriver": d.graphDriver, }).Info("Docker daemon") return d, nil diff --git a/daemon/info.go b/daemon/info.go index 59c3af92fe..c92c6146a9 100644 --- a/daemon/info.go +++ b/daemon/info.go @@ -143,24 +143,14 @@ func (daemon *Daemon) fillClusterInfo(v *types.Info) { } func (daemon *Daemon) fillDriverInfo(v *types.Info) { - var ds [][2]string - drivers := "" - statuses := daemon.imageService.LayerStoreStatus() - for os, gd := range daemon.graphDrivers { - ds = append(ds, statuses[os]...) - drivers += gd - if len(daemon.graphDrivers) > 1 { - drivers += fmt.Sprintf(" (%s) ", os) - } - switch gd { - case "aufs", "devicemapper", "overlay": - v.Warnings = append(v.Warnings, fmt.Sprintf("WARNING: the %s storage-driver is deprecated, and will be removed in a future release.", gd)) - } + switch daemon.graphDriver { + case "aufs", "devicemapper", "overlay": + v.Warnings = append(v.Warnings, fmt.Sprintf("WARNING: the %s storage-driver is deprecated, and will be removed in a future release.", daemon.graphDriver)) } - drivers = strings.TrimSpace(drivers) - v.Driver = drivers - v.DriverStatus = ds + statuses := daemon.imageService.LayerStoreStatus() + v.Driver = daemon.graphDriver + v.DriverStatus = statuses[runtime.GOOS] fillDriverWarnings(v) }