deleted file mode 100644

@@ -1,27 +0,0 @@

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

-

-import (

-	"github.com/docker/docker/builder"

-	"github.com/docker/docker/image/cache"

-	"github.com/sirupsen/logrus"

-)

-

-// MakeImageCache creates a stateful image cache.

-func (i *imageService) MakeImageCache(sourceRefs []string) builder.ImageCache {

-	if len(sourceRefs) == 0 {

-		return cache.NewLocal(i.imageStore)

-	}

-

-	cache := cache.New(i.imageStore)

-

-	for _, ref := range sourceRefs {

-		img, err := i.GetImage(ref)

-		if err != nil {

-			logrus.Warnf("Could not look up %s for cache resolution, skipping: %+v", ref, err)

-			continue

-		}

-		cache.Populate(img)

-	}

-

-	return cache

-}

@@ -62,6 +62,7 @@ type Backend interface {

 	GetAttachmentStore() *networkSettings.AttachmentStore

 }

+// ImageBackend is used by an executor to perform image operations

 type ImageBackend interface {

 	PullImage(ctx context.Context, image, tag, platform string, metaHeaders map[string][]string, authConfig *types.AuthConfig, outStream io.Writer) error

 	GetRepository(context.Context, reference.Named, *types.AuthConfig) (distribution.Repository, bool, error)

@@ -64,12 +64,6 @@ func (daemon *Daemon) setupConfigDir(c *container.Container) (setupErr error) {

 	return nil

 }

-// getSize returns real size & virtual size

-func (daemon *Daemon) getSize(containerID string) (int64, int64) {

-	// TODO Windows

-	return 0, 0

-}

-

 func (daemon *Daemon) setupIpcDirs(container *container.Container) error {

 	return nil

 }

@@ -157,7 +157,7 @@ func (daemon *Daemon) create(params types.ContainerCreateConfig, managed bool) (

 	}

 	// Set RWLayer for container after mount labels have been set

-	rwLayer, err := daemon.imageService.GetRWLayer(container, setupInitLayer(daemon.idMappings))

+	rwLayer, err := daemon.imageService.CreateLayer(container, setupInitLayer(daemon.idMappings))

 	if err != nil {

 		return nil, errdefs.System(err)

 	}

@@ -21,21 +21,21 @@ import (

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

 	containertypes "github.com/docker/docker/api/types/container"

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

+	"github.com/docker/docker/builder"

 	"github.com/docker/docker/container"

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

 	"github.com/docker/docker/daemon/discovery"

 	"github.com/docker/docker/daemon/events"

 	"github.com/docker/docker/daemon/exec"

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

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

 	"github.com/docker/docker/daemon/network"

 	"github.com/docker/docker/errdefs"

 	"github.com/sirupsen/logrus"

 	// register graph drivers

-	"github.com/docker/docker/builder"

 	_ "github.com/docker/docker/daemon/graphdriver/register"

 	"github.com/docker/docker/daemon/stats"

 	dmetadata "github.com/docker/docker/distribution/metadata"

-	"github.com/docker/docker/distribution/xfer"

 	"github.com/docker/docker/dockerversion"

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/layer"

@@ -75,23 +75,21 @@ type Daemon struct {

 	containers        container.Store

 	containersReplica container.ViewDB

 	execCommands      *exec.Store

-

-	imageService *imageService

-

-	idIndex          *truncindex.TruncIndex

-	configStore      *config.Config

-	statsCollector   *stats.Collector

-	defaultLogConfig containertypes.LogConfig

-	RegistryService  registry.Service

-	EventsService    *events.Events

-	netController    libnetwork.NetworkController

-	volumes          *store.VolumeStore

-	discoveryWatcher discovery.Reloader

-	root             string

-	seccompEnabled   bool

-	apparmorEnabled  bool

-	shutdown         bool

-	idMappings       *idtools.IDMappings

+	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           *store.VolumeStore

+	discoveryWatcher  discovery.Reloader

+	root              string

+	seccompEnabled    bool

+	apparmorEnabled   bool

+	shutdown          bool

+	idMappings        *idtools.IDMappings

 	// TODO: move graphDrivers field to an InfoService

 	graphDrivers map[string]string // By operating system

@@ -158,7 +156,7 @@ func (daemon *Daemon) restore() error {

 		// Ignore the container if it does not support the current driver being used by the graph

 		currentDriverForContainerOS := daemon.graphDrivers[container.OS]

 		if (container.Driver == "" && currentDriverForContainerOS == "aufs") || container.Driver == currentDriverForContainerOS {

-			rwlayer, err := daemon.imageService.GetRWLayerByID(container.ID, container.OS)

+			rwlayer, err := daemon.imageService.GetLayerByID(container.ID, container.OS)

 			if err != nil {

 				logrus.Errorf("Failed to load container mount %v: %v", id, err)

 				continue

@@ -808,8 +806,6 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 		return nil, err

 	}

-	eventsService := events.New()

-

 	// We have a single tag/reference store for the daemon globally. However, it's

 	// stored under the graphdriver. On host platforms which only support a single

 	// container OS, but multiple selectable graphdrivers, this means depending on which

@@ -863,7 +859,7 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 	d.idIndex = truncindex.NewTruncIndex([]string{})

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

-	d.EventsService = eventsService

+	d.EventsService = events.New()

 	d.volumes = volStore

 	d.root = config.Root

 	d.idMappings = idMappings

@@ -872,19 +868,21 @@ func NewDaemon(config *config.Config, registryService registry.Service, containe

 	d.linkIndex = newLinkIndex()

-	logrus.Debugf("Max Concurrent Downloads: %d", *config.MaxConcurrentDownloads)

-	logrus.Debugf("Max Concurrent Uploads: %d", *config.MaxConcurrentUploads)

-	d.imageService = &imageService{

-		trustKey:                  trustKey,

-		uploadManager:             xfer.NewLayerUploadManager(*config.MaxConcurrentUploads),

-		downloadManager:           xfer.NewLayerDownloadManager(layerStores, *config.MaxConcurrentDownloads),

-		registryService:           registryService,

-		referenceStore:            rs,

-		distributionMetadataStore: distributionMetadataStore,

-		imageStore:                imageStore,

-		eventsService:             eventsService,

-		containers:                d.containers,

-	}

+	// TODO: imageStore, distributionMetadataStore, and ReferenceStore are only

+	// used above to run migration. They could be initialized in ImageService

+	// if migration is called from daemon/images. layerStore might move as well.

+	d.imageService = images.NewImageService(images.ImageServiceConfig{

+		ContainerStore:            d.containers,

+		DistributionMetadataStore: distributionMetadataStore,

+		EventsService:             d.EventsService,

+		ImageStore:                imageStore,

+		LayerStores:               layerStores,

+		MaxConcurrentDownloads:    *config.MaxConcurrentDownloads,

+		MaxConcurrentUploads:      *config.MaxConcurrentUploads,

+		ReferenceStore:            rs,

+		RegistryService:           registryService,

+		TrustKey:                  trustKey,

+	})

 	go d.execCommandGC()

@@ -1007,7 +1005,7 @@ func (daemon *Daemon) Shutdown() error {

 				logrus.Errorf("Stop container error: %v", err)

 				return

 			}

-			if mountid, err := daemon.imageService.GetContainerMountID(c.ID, c.OS); err == nil {

+			if mountid, err := daemon.imageService.GetLayerMountID(c.ID, c.OS); err == nil {

 				daemon.cleanupMountsByID(mountid)

 			}

 			logrus.Debugf("container stopped %s", c.ID)

@@ -1020,7 +1018,9 @@ func (daemon *Daemon) Shutdown() error {

 		}

 	}

-	daemon.imageService.Cleanup()

+	if daemon.imageService != nil {

+		daemon.imageService.Cleanup()

+	}

 	// If we are part of a cluster, clean up cluster's stuff

 	if daemon.clusterProvider != nil {

@@ -1320,14 +1320,15 @@ func (daemon *Daemon) IDMappings() *idtools.IDMappings {

 	return daemon.idMappings

 }

-func (daemon *Daemon) ImageService() *imageService {

+// ImageService returns the Daemon's ImageService

+func (daemon *Daemon) ImageService() *images.ImageService {

 	return daemon.imageService

 }

-// TODO: tmp hack to merge interfaces

+// BuilderBackend returns the backend used by builder

 func (daemon *Daemon) BuilderBackend() builder.Backend {

 	return struct {

 		*Daemon

-		*imageService

+		*images.ImageService

 	}{daemon, daemon.imageService}

 }

@@ -120,7 +120,7 @@ func (daemon *Daemon) cleanupContainer(container *container.Container, forceRemo

 	// When container creation fails and `RWLayer` has not been created yet, we

 	// do not call `ReleaseRWLayer`

 	if container.RWLayer != nil {

-		err := daemon.imageService.ReleaseContainerLayer(container.RWLayer, container.OS)

+		err := daemon.imageService.ReleaseLayer(container.RWLayer, container.OS)

 		if err != nil {

 			err = errors.Wrapf(err, "container %s", container.ID)

 			container.SetRemovalError(err)

@@ -51,13 +51,13 @@ func (daemon *Daemon) containerExport(container *container.Container) (arch io.R

 	if !system.IsOSSupported(container.OS) {

 		return nil, fmt.Errorf("cannot export %s: %s ", container.ID, system.ErrNotSupportedOperatingSystem)

 	}

-	rwlayer, err := daemon.imageService.GetRWLayerByID(container.ID, container.OS)

+	rwlayer, err := daemon.imageService.GetLayerByID(container.ID, container.OS)

 	if err != nil {

 		return nil, err

 	}

 	defer func() {

 		if err != nil {

-			daemon.imageService.ReleaseContainerLayer(rwlayer, container.OS)

+			daemon.imageService.ReleaseLayer(rwlayer, container.OS)

 		}

 	}()

@@ -78,7 +78,7 @@ func (daemon *Daemon) containerExport(container *container.Container) (arch io.R

 	arch = ioutils.NewReadCloserWrapper(archive, func() error {

 		err := archive.Close()

 		rwlayer.Unmount()

-		daemon.imageService.ReleaseContainerLayer(rwlayer, container.OS)

+		daemon.imageService.ReleaseLayer(rwlayer, container.OS)

 		return err

 	})

 	daemon.LogContainerEvent(container, "export")

deleted file mode 100644

@@ -1,266 +0,0 @@

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

-

-import (

-	"context"

-	"fmt"

-	"os"

-

-	"github.com/docker/distribution/reference"

-	"github.com/docker/docker/api/types/events"

-	"github.com/docker/docker/container"

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

-	"github.com/docker/docker/distribution/metadata"

-	"github.com/docker/docker/distribution/xfer"

-	"github.com/docker/docker/errdefs"

-	"github.com/docker/docker/image"

-	"github.com/docker/docker/layer"

-	dockerreference "github.com/docker/docker/reference"

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

-	"github.com/docker/libtrust"

-	"github.com/opencontainers/go-digest"

-	"github.com/pkg/errors"

-	"github.com/sirupsen/logrus"

-)

-

-// errImageDoesNotExist is error returned when no image can be found for a reference.

-type errImageDoesNotExist struct {

-	ref reference.Reference

-}

-

-func (e errImageDoesNotExist) Error() string {

-	ref := e.ref

-	if named, ok := ref.(reference.Named); ok {

-		ref = reference.TagNameOnly(named)

-	}

-	return fmt.Sprintf("No such image: %s", reference.FamiliarString(ref))

-}

-

-func (e errImageDoesNotExist) NotFound() {}

-

-// GetImageIDAndOS returns an image ID and operating system corresponding to the image referred to by

-// refOrID.

-// called from list.go foldFilter()

-func (i imageService) GetImageIDAndOS(refOrID string) (image.ID, string, error) {

-	ref, err := reference.ParseAnyReference(refOrID)

-	if err != nil {

-		return "", "", errdefs.InvalidParameter(err)

-	}

-	namedRef, ok := ref.(reference.Named)

-	if !ok {

-		digested, ok := ref.(reference.Digested)

-		if !ok {

-			return "", "", errImageDoesNotExist{ref}

-		}

-		id := image.IDFromDigest(digested.Digest())

-		if img, err := i.imageStore.Get(id); err == nil {

-			return id, img.OperatingSystem(), nil

-		}

-		return "", "", errImageDoesNotExist{ref}

-	}

-

-	if digest, err := i.referenceStore.Get(namedRef); err == nil {

-		// Search the image stores to get the operating system, defaulting to host OS.

-		id := image.IDFromDigest(digest)

-		if img, err := i.imageStore.Get(id); err == nil {

-			return id, img.OperatingSystem(), nil

-		}

-	}

-

-	// Search based on ID

-	if id, err := i.imageStore.Search(refOrID); err == nil {

-		img, err := i.imageStore.Get(id)

-		if err != nil {

-			return "", "", errImageDoesNotExist{ref}

-		}

-		return id, img.OperatingSystem(), nil

-	}

-

-	return "", "", errImageDoesNotExist{ref}

-}

-

-// GetImage returns an image corresponding to the image referred to by refOrID.

-func (i *imageService) GetImage(refOrID string) (*image.Image, error) {

-	imgID, _, err := i.GetImageIDAndOS(refOrID)

-	if err != nil {

-		return nil, err

-	}

-	return i.imageStore.Get(imgID)

-}

-

-type containerStore interface {

-	// used by image delete

-	First(container.StoreFilter) *container.Container

-	// used by image prune, and image list

-	List() []*container.Container

-	// TODO: remove, only used for CommitBuildStep

-	Get(string) *container.Container

-}

-

-type imageService struct {

-	eventsService   *daemonevents.Events

-	containers      containerStore

-	downloadManager *xfer.LayerDownloadManager

-	uploadManager   *xfer.LayerUploadManager

-

-	// TODO: should accept a trust service instead of a key

-	trustKey libtrust.PrivateKey

-

-	registryService           registry.Service

-	referenceStore            dockerreference.Store

-	distributionMetadataStore metadata.Store

-	imageStore                image.Store

-	layerStores               map[string]layer.Store // By operating system

-

-	pruneRunning int32

-}

-

-// called from info.go

-func (i *imageService) CountImages() int {

-	return len(i.imageStore.Map())

-}

-

-// called from list.go to filter containers

-func (i *imageService) Children(id image.ID) []image.ID {

-	return i.imageStore.Children(id)

-}

-

-// TODO: accept an opt struct instead of container?

-// called from create.go

-func (i *imageService) GetRWLayer(container *container.Container, initFunc layer.MountInit) (layer.RWLayer, error) {

-	var layerID layer.ChainID

-	if container.ImageID != "" {

-		img, err := i.imageStore.Get(container.ImageID)

-		if err != nil {

-			return nil, err

-		}

-		layerID = img.RootFS.ChainID()

-	}

-

-	rwLayerOpts := &layer.CreateRWLayerOpts{

-		MountLabel: container.MountLabel,

-		InitFunc:   initFunc,

-		StorageOpt: container.HostConfig.StorageOpt,

-	}

-

-	// Indexing by OS is safe here as validation of OS has already been performed in create() (the only

-	// caller), and guaranteed non-nil

-	return i.layerStores[container.OS].CreateRWLayer(container.ID, layerID, rwLayerOpts)

-}

-

-// called from daemon.go Daemon.restore(), and Daemon.containerExport()

-func (i *imageService) GetRWLayerByID(cid string, os string) (layer.RWLayer, error) {

-	return i.layerStores[os].GetRWLayer(cid)

-}

-

-// called from info.go

-func (i *imageService) GraphDriverStatuses() map[string][][2]string {

-	result := make(map[string][][2]string)

-	for os, store := range i.layerStores {

-		result[os] = store.DriverStatus()

-	}

-	return result

-}

-

-// called from daemon.go Daemon.Shutdown(), and Daemon.Cleanup() (cleanup is actually continerCleanup)

-func (i *imageService) GetContainerMountID(cid string, os string) (string, error) {

-	return i.layerStores[os].GetMountID(cid)

-}

-

-// called from daemon.go Daemon.Shutdown()

-func (i *imageService) Cleanup() {

-	for os, ls := range i.layerStores {

-		if ls != nil {

-			if err := ls.Cleanup(); err != nil {

-				logrus.Errorf("Error during layer Store.Cleanup(): %v %s", err, os)

-			}

-		}

-	}

-}

-

-// moved from Daemon.GraphDriverName, multiple calls

-func (i *imageService) GraphDriverForOS(os string) string {

-	return i.layerStores[os].DriverName()

-}

-

-// called from delete.go Daemon.cleanupContainer(), and Daemon.containerExport()

-func (i *imageService) ReleaseContainerLayer(rwlayer layer.RWLayer, containerOS string) error {

-	metadata, err := i.layerStores[containerOS].ReleaseRWLayer(rwlayer)

-	layer.LogReleaseMetadata(metadata)

-	if err != nil && err != layer.ErrMountDoesNotExist && !os.IsNotExist(errors.Cause(err)) {

-		return errors.Wrapf(err, "driver %q failed to remove root filesystem",

-			i.layerStores[containerOS].DriverName())

-	}

-	return nil

-}

-

-// called from disk_usage.go

-func (i *imageService) LayerDiskUsage(ctx context.Context) (int64, error) {

-	var allLayersSize int64

-	layerRefs := i.getLayerRefs()

-	for _, ls := range i.layerStores {

-		allLayers := ls.Map()

-		for _, l := range allLayers {

-			select {

-			case <-ctx.Done():

-				return allLayersSize, ctx.Err()

-			default:

-				size, err := l.DiffSize()

-				if err == nil {

-					if _, ok := layerRefs[l.ChainID()]; ok {

-						allLayersSize += size

-					} else {

-						logrus.Warnf("found leaked image layer %v", l.ChainID())

-					}

-				} else {

-					logrus.Warnf("failed to get diff size for layer %v", l.ChainID())

-				}

-			}

-		}

-	}

-	return allLayersSize, nil

-}

-

-func (i *imageService) getLayerRefs() map[layer.ChainID]int {

-	tmpImages := i.imageStore.Map()

-	layerRefs := map[layer.ChainID]int{}

-	for id, img := range tmpImages {

-		dgst := digest.Digest(id)

-		if len(i.referenceStore.References(dgst)) == 0 && len(i.imageStore.Children(id)) != 0 {

-			continue

-		}

-

-		rootFS := *img.RootFS

-		rootFS.DiffIDs = nil

-		for _, id := range img.RootFS.DiffIDs {

-			rootFS.Append(id)

-			chid := rootFS.ChainID()

-			layerRefs[chid]++

-		}

-	}

-

-	return layerRefs

-}

-

-// LogImageEvent generates an event related to an image with only the default attributes.

-func (i *imageService) LogImageEvent(imageID, refName, action string) {

-	i.LogImageEventWithAttributes(imageID, refName, action, map[string]string{})

-}

-

-// LogImageEventWithAttributes generates an event related to an image with specific given attributes.

-func (i *imageService) LogImageEventWithAttributes(imageID, refName, action string, attributes map[string]string) {

-	img, err := i.GetImage(imageID)

-	if err == nil && img.Config != nil {

-		// image has not been removed yet.

-		// it could be missing if the event is `delete`.

-		copyAttributes(attributes, img.Config.Labels)

-	}

-	if refName != "" {

-		attributes["name"] = refName

-	}

-	actor := events.Actor{

-		ID:         imageID,

-		Attributes: attributes,

-	}

-

-	i.eventsService.Log(action, events.ImageEventType, actor)

-}

deleted file mode 100644

@@ -1,220 +0,0 @@

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

-

-import (

-	"io"

-

-	"github.com/docker/distribution/reference"

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

-	"github.com/docker/docker/api/types/backend"

-	"github.com/docker/docker/builder"

-	"github.com/docker/docker/image"

-	"github.com/docker/docker/image/cache"

-	"github.com/docker/docker/layer"

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

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

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

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

-	"github.com/pkg/errors"

-	"golang.org/x/net/context"

-)

-

-type roLayer struct {

-	released   bool

-	layerStore layer.Store

-	roLayer    layer.Layer

-}

-

-func (l *roLayer) DiffID() layer.DiffID {

-	if l.roLayer == nil {

-		return layer.DigestSHA256EmptyTar

-	}

-	return l.roLayer.DiffID()

-}

-

-func (l *roLayer) Release() error {

-	if l.released {

-		return nil

-	}

-	if l.roLayer != nil {

-		metadata, err := l.layerStore.Release(l.roLayer)

-		layer.LogReleaseMetadata(metadata)

-		if err != nil {

-			return errors.Wrap(err, "failed to release ROLayer")

-		}

-	}

-	l.roLayer = nil

-	l.released = true

-	return nil

-}

-

-func (l *roLayer) NewRWLayer() (builder.RWLayer, error) {

-	var chainID layer.ChainID

-	if l.roLayer != nil {

-		chainID = l.roLayer.ChainID()

-	}

-

-	mountID := stringid.GenerateRandomID()

-	newLayer, err := l.layerStore.CreateRWLayer(mountID, chainID, nil)

-	if err != nil {

-		return nil, errors.Wrap(err, "failed to create rwlayer")

-	}

-

-	rwLayer := &rwLayer{layerStore: l.layerStore, rwLayer: newLayer}

-

-	fs, err := newLayer.Mount("")

-	if err != nil {

-		rwLayer.Release()

-		return nil, err

-	}

-

-	rwLayer.fs = fs

-

-	return rwLayer, nil

-}

-

-type rwLayer struct {

-	released   bool

-	layerStore layer.Store

-	rwLayer    layer.RWLayer

-	fs         containerfs.ContainerFS

-}

-

-func (l *rwLayer) Root() containerfs.ContainerFS {

-	return l.fs

-}

-

-func (l *rwLayer) Commit() (builder.ROLayer, error) {

-	stream, err := l.rwLayer.TarStream()

-	if err != nil {

-		return nil, err

-	}

-	defer stream.Close()

-

-	var chainID layer.ChainID

-	if parent := l.rwLayer.Parent(); parent != nil {

-		chainID = parent.ChainID()

-	}

-

-	newLayer, err := l.layerStore.Register(stream, chainID)

-	if err != nil {

-		return nil, err

-	}

-	// TODO: An optimization would be to handle empty layers before returning

-	return &roLayer{layerStore: l.layerStore, roLayer: newLayer}, nil

-}

-

-func (l *rwLayer) Release() error {

-	if l.released {

-		return nil

-	}

-

-	if l.fs != nil {

-		if err := l.rwLayer.Unmount(); err != nil {

-			return errors.Wrap(err, "failed to unmount RWLayer")

-		}

-		l.fs = nil

-	}

-

-	metadata, err := l.layerStore.ReleaseRWLayer(l.rwLayer)

-	layer.LogReleaseMetadata(metadata)

-	if err != nil {

-		return errors.Wrap(err, "failed to release RWLayer")

-	}

-	l.released = true

-	return nil

-}

-

-func newROLayerForImage(img *image.Image, layerStore layer.Store) (builder.ROLayer, error) {

-	if img == nil || img.RootFS.ChainID() == "" {

-		return &roLayer{layerStore: layerStore}, nil

-	}

-	// Hold a reference to the image layer so that it can't be removed before

-	// it is released

-	layer, err := layerStore.Get(img.RootFS.ChainID())

-	if err != nil {

-		return nil, errors.Wrapf(err, "failed to get layer for image %s", img.ImageID())

-	}

-	return &roLayer{layerStore: layerStore, roLayer: layer}, nil

-}

-

-// TODO: could this use the regular daemon PullImage ?

-func (i *imageService) pullForBuilder(ctx context.Context, name string, authConfigs map[string]types.AuthConfig, output io.Writer, os string) (*image.Image, error) {

-	ref, err := reference.ParseNormalizedNamed(name)

-	if err != nil {

-		return nil, err

-	}

-	ref = reference.TagNameOnly(ref)

-

-	pullRegistryAuth := &types.AuthConfig{}

-	if len(authConfigs) > 0 {

-		// The request came with a full auth config, use it

-		repoInfo, err := i.registryService.ResolveRepository(ref)

-		if err != nil {

-			return nil, err

-		}

-

-		resolvedConfig := registry.ResolveAuthConfig(authConfigs, repoInfo.Index)

-		pullRegistryAuth = &resolvedConfig

-	}

-

-	if err := i.pullImageWithReference(ctx, ref, os, nil, pullRegistryAuth, output); err != nil {

-		return nil, err

-	}

-	return i.GetImage(name)

-}

-

-// GetImageAndReleasableLayer returns an image and releaseable layer for a reference or ID.

-// Every call to GetImageAndReleasableLayer MUST call releasableLayer.Release() to prevent

-// leaking of layers.

-func (i *imageService) GetImageAndReleasableLayer(ctx context.Context, refOrID string, opts backend.GetImageAndLayerOptions) (builder.Image, builder.ROLayer, error) {

-	if refOrID == "" {

-		if !system.IsOSSupported(opts.OS) {

-			return nil, nil, system.ErrNotSupportedOperatingSystem

-		}

-		layer, err := newROLayerForImage(nil, i.layerStores[opts.OS])

-		return nil, layer, err

-	}

-

-	if opts.PullOption != backend.PullOptionForcePull {

-		image, err := i.GetImage(refOrID)

-		if err != nil && opts.PullOption == backend.PullOptionNoPull {

-			return nil, nil, err

-		}

-		// TODO: shouldn't we error out if error is different from "not found" ?

-		if image != nil {

-			if !system.IsOSSupported(image.OperatingSystem()) {

-				return nil, nil, system.ErrNotSupportedOperatingSystem

-			}

-			layer, err := newROLayerForImage(image, i.layerStores[image.OperatingSystem()])

-			return image, layer, err

-		}

-	}

-

-	image, err := i.pullForBuilder(ctx, refOrID, opts.AuthConfig, opts.Output, opts.OS)

-	if err != nil {

-		return nil, nil, err

-	}

-	if !system.IsOSSupported(image.OperatingSystem()) {

-		return nil, nil, system.ErrNotSupportedOperatingSystem

-	}

-	layer, err := newROLayerForImage(image, i.layerStores[image.OperatingSystem()])

-	return image, layer, err

-}

-

-// CreateImage creates a new image by adding a config and ID to the image store.

-// This is similar to LoadImage() except that it receives JSON encoded bytes of

-// an image instead of a tar archive.

-func (i *imageService) CreateImage(config []byte, parent string) (builder.Image, error) {

-	id, err := i.imageStore.Create(config)

-	if err != nil {

-		return nil, errors.Wrapf(err, "failed to create image")

-	}

-

-	if parent != "" {

-		if err := i.imageStore.SetParent(id, image.ID(parent)); err != nil {

-			return nil, errors.Wrapf(err, "failed to set parent %s", parent)

-		}

-	}

-

-	return i.imageStore.Get(id)

-}

deleted file mode 100644

@@ -1,127 +0,0 @@

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

-

-import (

-	"encoding/json"

-	"io"

-

-	"github.com/docker/docker/api/types/backend"

-	"github.com/docker/docker/image"

-	"github.com/docker/docker/layer"

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

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

-	"github.com/pkg/errors"

-)

-

-// CommitImage creates a new image from a commit config

-func (i *imageService) CommitImage(c backend.CommitConfig) (image.ID, error) {

-	layerStore, ok := i.layerStores[c.ContainerOS]

-	if !ok {

-		return "", system.ErrNotSupportedOperatingSystem

-	}

-	rwTar, err := exportContainerRw(layerStore, c.ContainerID, c.ContainerMountLabel)

-	if err != nil {

-		return "", err

-	}

-	defer func() {

-		if rwTar != nil {

-			rwTar.Close()

-		}

-	}()

-

-	var parent *image.Image

-	if c.ParentImageID == "" {

-		parent = new(image.Image)

-		parent.RootFS = image.NewRootFS()

-	} else {

-		parent, err = i.imageStore.Get(image.ID(c.ParentImageID))

-		if err != nil {

-			return "", err

-		}

-	}

-

-	l, err := layerStore.Register(rwTar, parent.RootFS.ChainID())

-	if err != nil {

-		return "", err

-	}

-	defer layer.ReleaseAndLog(layerStore, l)

-

-	cc := image.ChildConfig{

-		ContainerID:     c.ContainerID,

-		Author:          c.Author,

-		Comment:         c.Comment,

-		ContainerConfig: c.ContainerConfig,

-		Config:          c.Config,

-		DiffID:          l.DiffID(),

-	}

-	config, err := json.Marshal(image.NewChildImage(parent, cc, c.ContainerOS))

-	if err != nil {

-		return "", err

-	}

-

-	id, err := i.imageStore.Create(config)

-	if err != nil {

-		return "", err

-	}

-

-	if c.ParentImageID != "" {

-		if err := i.imageStore.SetParent(id, image.ID(c.ParentImageID)); err != nil {

-			return "", err

-		}

-	}

-	return id, nil

-}

-

-func exportContainerRw(layerStore layer.Store, id, mountLabel string) (arch io.ReadCloser, err error) {

-	rwlayer, err := layerStore.GetRWLayer(id)

-	if err != nil {

-		return nil, err

-	}

-	defer func() {

-		if err != nil {

-			layerStore.ReleaseRWLayer(rwlayer)

-		}

-	}()

-

-	// TODO: this mount call is not necessary as we assume that TarStream() should

-	// mount the layer if needed. But the Diff() function for windows requests that

-	// the layer should be mounted when calling it. So we reserve this mount call

-	// until windows driver can implement Diff() interface correctly.

-	_, err = rwlayer.Mount(mountLabel)

-	if err != nil {

-		return nil, err

-	}

-

-	archive, err := rwlayer.TarStream()

-	if err != nil {

-		rwlayer.Unmount()

-		return nil, err

-	}

-	return ioutils.NewReadCloserWrapper(archive, func() error {

-			archive.Close()

-			err = rwlayer.Unmount()

-			layerStore.ReleaseRWLayer(rwlayer)

-			return err

-		}),

-		nil