Merge pull request #42506 from thaJeztah/remove_lcow_step3

Remove LCOW (step 3): daemon: remove graphdriver indexing by OS

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()
+	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
 	}
 
+	// 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.graphDrivers[runtime.GOOS]); err != nil {
+	if err := configureKernelSecuritySupport(config, d.graphDriver); err != nil {
 		return nil, err
 	}
 
-	imageRoot := filepath.Join(config.Root, "image", d.graphDrivers[runtime.GOOS])
+	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

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)
 }