@@ -23,7 +23,7 @@ import (

 	"github.com/docker/docker/pkg/httputils"

 	"github.com/docker/docker/pkg/jsonmessage"

 	flag "github.com/docker/docker/pkg/mflag"

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

+	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/pkg/streamformatter"

 	"github.com/docker/docker/pkg/ulimit"

 	"github.com/docker/docker/pkg/units"

@@ -169,16 +169,9 @@ func (cli *DockerCli) CmdBuild(args ...string) error {

 	context = replaceDockerfileTarWrapper(context, newDockerfile, relDockerfile)

 	// Setup an upload progress bar

-	// FIXME: ProgressReader shouldn't be this annoying to use

-	sf := streamformatter.NewStreamFormatter()

-	var body io.Reader = progressreader.New(progressreader.Config{

-		In:        context,

-		Out:       cli.out,

-		Formatter: sf,

-		NewLines:  true,

-		ID:        "",

-		Action:    "Sending build context to Docker daemon",

-	})

+	progressOutput := streamformatter.NewStreamFormatter().NewProgressOutput(cli.out, true)

+

+	var body io.Reader = progress.NewProgressReader(context, progressOutput, 0, "", "Sending build context to Docker daemon")

 	var memory int64

 	if *flMemoryString != "" {

@@ -447,17 +440,10 @@ func getContextFromURL(out io.Writer, remoteURL, dockerfileName string) (absCont

 		return "", "", fmt.Errorf("unable to download remote context %s: %v", remoteURL, err)

 	}

 	defer response.Body.Close()

+	progressOutput := streamformatter.NewStreamFormatter().NewProgressOutput(out, true)

 	// Pass the response body through a progress reader.

-	progReader := &progressreader.Config{

-		In:        response.Body,

-		Out:       out,

-		Formatter: streamformatter.NewStreamFormatter(),

-		Size:      response.ContentLength,

-		NewLines:  true,

-		ID:        "",

-		Action:    fmt.Sprintf("Downloading build context from remote url: %s", remoteURL),

-	}

+	progReader := progress.NewProgressReader(response.Body, progressOutput, response.ContentLength, "", fmt.Sprintf("Downloading build context from remote url: %s", remoteURL))

 	return getContextFromReader(progReader, dockerfileName)

 }

@@ -23,7 +23,7 @@ import (

 	"github.com/docker/docker/pkg/archive"

 	"github.com/docker/docker/pkg/chrootarchive"

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

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

+	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/pkg/streamformatter"

 	"github.com/docker/docker/pkg/ulimit"

 	"github.com/docker/docker/runconfig"

@@ -325,7 +325,7 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 	sf := streamformatter.NewJSONStreamFormatter()

 	errf := func(err error) error {

 		// Do not write the error in the http output if it's still empty.

-		// This prevents from writing a 200(OK) when there is an interal error.

+		// This prevents from writing a 200(OK) when there is an internal error.

 		if !output.Flushed() {

 			return err

 		}

@@ -401,23 +401,17 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 	remoteURL := r.FormValue("remote")

 	// Currently, only used if context is from a remote url.

-	// The field `In` is set by DetectContextFromRemoteURL.

 	// Look at code in DetectContextFromRemoteURL for more information.

-	pReader := &progressreader.Config{

-		// TODO: make progressreader streamformatter-agnostic

-		Out:       output,

-		Formatter: sf,

-		Size:      r.ContentLength,

-		NewLines:  true,

-		ID:        "Downloading context",

-		Action:    remoteURL,

+	createProgressReader := func(in io.ReadCloser) io.ReadCloser {

+		progressOutput := sf.NewProgressOutput(output, true)

+		return progress.NewProgressReader(in, progressOutput, r.ContentLength, "Downloading context", remoteURL)

 	}

 	var (

 		context        builder.ModifiableContext

 		dockerfileName string

 	)

-	context, dockerfileName, err = daemonbuilder.DetectContextFromRemoteURL(r.Body, remoteURL, pReader)

+	context, dockerfileName, err = daemonbuilder.DetectContextFromRemoteURL(r.Body, remoteURL, createProgressReader)

 	if err != nil {

 		return errf(err)

 	}

@@ -29,7 +29,7 @@ import (

 	"github.com/docker/docker/pkg/httputils"

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

 	"github.com/docker/docker/pkg/jsonmessage"

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

+	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/pkg/streamformatter"

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

 	"github.com/docker/docker/pkg/stringutils"

@@ -264,17 +264,11 @@ func (b *Builder) download(srcURL string) (fi builder.FileInfo, err error) {

 		return

 	}

+	stdoutFormatter := b.Stdout.(*streamformatter.StdoutFormatter)

+	progressOutput := stdoutFormatter.StreamFormatter.NewProgressOutput(stdoutFormatter.Writer, true)

+	progressReader := progress.NewProgressReader(resp.Body, progressOutput, resp.ContentLength, "", "Downloading")

 	// Download and dump result to tmp file

-	if _, err = io.Copy(tmpFile, progressreader.New(progressreader.Config{

-		In: resp.Body,

-		// TODO: make progressreader streamformatter agnostic

-		Out:       b.Stdout.(*streamformatter.StdoutFormatter).Writer,

-		Formatter: b.Stdout.(*streamformatter.StdoutFormatter).StreamFormatter,

-		Size:      resp.ContentLength,

-		NewLines:  true,

-		ID:        "",

-		Action:    "Downloading",

-	})); err != nil {

+	if _, err = io.Copy(tmpFile, progressReader); err != nil {

 		tmpFile.Close()

 		return

 	}

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

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

 	"github.com/docker/docker/distribution"

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

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

 	derr "github.com/docker/docker/errors"

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/image/tarexport"

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

 	"github.com/docker/docker/pkg/namesgenerator"

 	"github.com/docker/docker/pkg/nat"

 	"github.com/docker/docker/pkg/parsers/filters"

+	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/pkg/signal"

+	"github.com/docker/docker/pkg/streamformatter"

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

 	"github.com/docker/docker/pkg/stringutils"

 	"github.com/docker/docker/pkg/sysinfo"

@@ -66,6 +69,16 @@ import (

 	lntypes "github.com/docker/libnetwork/types"

 	"github.com/docker/libtrust"

 	"github.com/opencontainers/runc/libcontainer"

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

+)

+

+const (

+	// maxDownloadConcurrency is the maximum number of downloads that

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

+	maxDownloadConcurrency = 3

+	// maxUploadConcurrency is the maximum number of uploads that

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

+	maxUploadConcurrency = 5

 )

 var (

@@ -126,7 +139,8 @@ type Daemon struct {

 	containers                *contStore

 	execCommands              *exec.Store

 	tagStore                  tag.Store

-	distributionPool          *distribution.Pool

+	downloadManager           *xfer.LayerDownloadManager

+	uploadManager             *xfer.LayerUploadManager

 	distributionMetadataStore dmetadata.Store

 	trustKey                  libtrust.PrivateKey

 	idIndex                   *truncindex.TruncIndex

@@ -738,7 +752,8 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 		return nil, err

 	}

-	distributionPool := distribution.NewPool()

+	d.downloadManager = xfer.NewLayerDownloadManager(d.layerStore, maxDownloadConcurrency)

+	d.uploadManager = xfer.NewLayerUploadManager(maxUploadConcurrency)

 	ifs, err := image.NewFSStoreBackend(filepath.Join(imageRoot, "imagedb"))

 	if err != nil {

@@ -834,7 +849,6 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 	d.containers = &contStore{s: make(map[string]*container.Container)}

 	d.execCommands = exec.NewStore()

 	d.tagStore = tagStore

-	d.distributionPool = distributionPool

 	d.distributionMetadataStore = distributionMetadataStore

 	d.trustKey = trustKey

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

@@ -1038,23 +1052,53 @@ func (daemon *Daemon) TagImage(newTag reference.Named, imageName string) error {

 	return nil

 }

+func writeDistributionProgress(cancelFunc func(), outStream io.Writer, progressChan <-chan progress.Progress) {

+	progressOutput := streamformatter.NewJSONStreamFormatter().NewProgressOutput(outStream, false)

+	operationCancelled := false

+

+	for prog := range progressChan {

+		if err := progressOutput.WriteProgress(prog); err != nil && !operationCancelled {

+			logrus.Errorf("error writing progress to client: %v", err)

+			cancelFunc()

+			operationCancelled = true

+			// Don't return, because we need to continue draining

+			// progressChan until it's closed to avoid a deadlock.

+		}

+	}

+}

+

 // PullImage initiates a pull operation. image is the repository name to pull, and

 // tag may be either empty, or indicate a specific tag to pull.

 func (daemon *Daemon) PullImage(ref reference.Named, metaHeaders map[string][]string, authConfig *cliconfig.AuthConfig, outStream io.Writer) error {

+	// Include a buffer so that slow client connections don't affect

+	// transfer performance.

+	progressChan := make(chan progress.Progress, 100)

+

+	writesDone := make(chan struct{})

+

+	ctx, cancelFunc := context.WithCancel(context.Background())

+

+	go func() {

+		writeDistributionProgress(cancelFunc, outStream, progressChan)

+		close(writesDone)

+	}()

+

 	imagePullConfig := &distribution.ImagePullConfig{

 		MetaHeaders:     metaHeaders,

 		AuthConfig:      authConfig,

-		OutStream:       outStream,

+		ProgressOutput:  progress.ChanOutput(progressChan),

 		RegistryService: daemon.RegistryService,

 		EventsService:   daemon.EventsService,

 		MetadataStore:   daemon.distributionMetadataStore,

-		LayerStore:      daemon.layerStore,

 		ImageStore:      daemon.imageStore,

 		TagStore:        daemon.tagStore,

-		Pool:            daemon.distributionPool,

+		DownloadManager: daemon.downloadManager,

 	}

-	return distribution.Pull(ref, imagePullConfig)

+	err := distribution.Pull(ctx, ref, imagePullConfig)

+	close(progressChan)

+	<-writesDone

+	return err

 }

 // ExportImage exports a list of images to the given output stream. The

@@ -1069,10 +1113,23 @@ func (daemon *Daemon) ExportImage(names []string, outStream io.Writer) error {

 // PushImage initiates a push operation on the repository named localName.

 func (daemon *Daemon) PushImage(ref reference.Named, metaHeaders map[string][]string, authConfig *cliconfig.AuthConfig, outStream io.Writer) error {

+	// Include a buffer so that slow client connections don't affect

+	// transfer performance.

+	progressChan := make(chan progress.Progress, 100)

+

+	writesDone := make(chan struct{})

+

+	ctx, cancelFunc := context.WithCancel(context.Background())

+

+	go func() {

+		writeDistributionProgress(cancelFunc, outStream, progressChan)

+		close(writesDone)

+	}()

+

 	imagePushConfig := &distribution.ImagePushConfig{

 		MetaHeaders:     metaHeaders,

 		AuthConfig:      authConfig,

-		OutStream:       outStream,

+		ProgressOutput:  progress.ChanOutput(progressChan),

 		RegistryService: daemon.RegistryService,

 		EventsService:   daemon.EventsService,

 		MetadataStore:   daemon.distributionMetadataStore,

@@ -1080,9 +1137,13 @@ func (daemon *Daemon) PushImage(ref reference.Named, metaHeaders map[string][]st

 		ImageStore:      daemon.imageStore,

 		TagStore:        daemon.tagStore,

 		TrustKey:        daemon.trustKey,

+		UploadManager:   daemon.uploadManager,

 	}

-	return distribution.Push(ref, imagePushConfig)

+	err := distribution.Push(ctx, ref, imagePushConfig)

+	close(progressChan)

+	<-writesDone

+	return err

 }

 // LookupImage looks up an image by name and returns it as an ImageInspect

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

 	"github.com/docker/docker/pkg/httputils"

 	"github.com/docker/docker/pkg/idtools"

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

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

 	"github.com/docker/docker/pkg/urlutil"

 	"github.com/docker/docker/registry"

 	"github.com/docker/docker/runconfig"

@@ -239,7 +238,7 @@ func (d Docker) Start(c *container.Container) error {

 // DetectContextFromRemoteURL returns a context and in certain cases the name of the dockerfile to be used

 // irrespective of user input.

 // progressReader is only used if remoteURL is actually a URL (not empty, and not a Git endpoint).

-func DetectContextFromRemoteURL(r io.ReadCloser, remoteURL string, progressReader *progressreader.Config) (context builder.ModifiableContext, dockerfileName string, err error) {

+func DetectContextFromRemoteURL(r io.ReadCloser, remoteURL string, createProgressReader func(in io.ReadCloser) io.ReadCloser) (context builder.ModifiableContext, dockerfileName string, err error) {

 	switch {

 	case remoteURL == "":

 		context, err = builder.MakeTarSumContext(r)

@@ -262,8 +261,7 @@ func DetectContextFromRemoteURL(r io.ReadCloser, remoteURL string, progressReade

 			},

 			// fallback handler (tar context)

 			"": func(rc io.ReadCloser) (io.ReadCloser, error) {

-				progressReader.In = rc

-				return progressReader, nil

+				return createProgressReader(rc), nil

 			},

 		})

 	default:

@@ -13,7 +13,7 @@ import (

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/layer"

 	"github.com/docker/docker/pkg/httputils"

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

+	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/pkg/streamformatter"

 	"github.com/docker/docker/runconfig"

 )

@@ -47,16 +47,8 @@ func (daemon *Daemon) ImportImage(src string, newRef reference.Named, msg string

 		if err != nil {

 			return err

 		}

-		progressReader := progressreader.New(progressreader.Config{

-			In:        resp.Body,

-			Out:       outStream,

-			Formatter: sf,

-			Size:      resp.ContentLength,

-			NewLines:  true,

-			ID:        "",

-			Action:    "Importing",

-		})

-		archive = progressReader

+		progressOutput := sf.NewProgressOutput(outStream, true)

+		archive = progress.NewProgressReader(resp.Body, progressOutput, resp.ContentLength, "", "Importing")

 	}

 	defer archive.Close()

@@ -23,20 +23,20 @@ func (idserv *V1IDService) namespace() string {

 }

 // Get finds a layer by its V1 ID.

-func (idserv *V1IDService) Get(v1ID, registry string) (layer.ChainID, error) {

+func (idserv *V1IDService) Get(v1ID, registry string) (layer.DiffID, error) {

 	if err := v1.ValidateID(v1ID); err != nil {

-		return layer.ChainID(""), err

+		return layer.DiffID(""), err

 	}

 	idBytes, err := idserv.store.Get(idserv.namespace(), registry+","+v1ID)

 	if err != nil {

-		return layer.ChainID(""), err

+		return layer.DiffID(""), err

 	}

-	return layer.ChainID(idBytes), nil

+	return layer.DiffID(idBytes), nil

 }

 // Set associates an image with a V1 ID.

-func (idserv *V1IDService) Set(v1ID, registry string, id layer.ChainID) error {

+func (idserv *V1IDService) Set(v1ID, registry string, id layer.DiffID) error {

 	if err := v1.ValidateID(v1ID); err != nil {

 		return err

 	}

@@ -24,22 +24,22 @@ func TestV1IDService(t *testing.T) {

 	testVectors := []struct {

 		registry string

 		v1ID     string

-		layerID  layer.ChainID

+		layerID  layer.DiffID

 	}{

 		{

 			registry: "registry1",

 			v1ID:     "f0cd5ca10b07f35512fc2f1cbf9a6cefbdb5cba70ac6b0c9e5988f4497f71937",

-			layerID:  layer.ChainID("sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4"),

+			layerID:  layer.DiffID("sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4"),

 		},

 		{

 			registry: "registry2",

 			v1ID:     "9e3447ca24cb96d86ebd5960cb34d1299b07e0a0e03801d90b9969a2c187dd6e",

-			layerID:  layer.ChainID("sha256:86e0e091d0da6bde2456dbb48306f3956bbeb2eae1b5b9a43045843f69fe4aaa"),

+			layerID:  layer.DiffID("sha256:86e0e091d0da6bde2456dbb48306f3956bbeb2eae1b5b9a43045843f69fe4aaa"),

 		},

 		{

 			registry: "registry1",

 			v1ID:     "9e3447ca24cb96d86ebd5960cb34d1299b07e0a0e03801d90b9969a2c187dd6e",

-			layerID:  layer.ChainID("sha256:03f4658f8b782e12230c1783426bd3bacce651ce582a4ffb6fbbfa2079428ecb"),

+			layerID:  layer.DiffID("sha256:03f4658f8b782e12230c1783426bd3bacce651ce582a4ffb6fbbfa2079428ecb"),

 		},

 	}

deleted file mode 100644

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

-package distribution

-

-import (

-	"sync"

-

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

-)

-

-// A Pool manages concurrent pulls. It deduplicates in-progress downloads.

-type Pool struct {

-	sync.Mutex

-	pullingPool map[string]*broadcaster.Buffered

-}

-

-// NewPool creates a new Pool.

-func NewPool() *Pool {

-	return &Pool{

-		pullingPool: make(map[string]*broadcaster.Buffered),

-	}

-}

-

-// add checks if a pull is already running, and returns (broadcaster, true)

-// if a running operation is found. Otherwise, it creates a new one and returns

-// (broadcaster, false).

-func (pool *Pool) add(key string) (*broadcaster.Buffered, bool) {

-	pool.Lock()

-	defer pool.Unlock()

-

-	if p, exists := pool.pullingPool[key]; exists {

-		return p, true

-	}

-

-	broadcaster := broadcaster.NewBuffered()

-	pool.pullingPool[key] = broadcaster

-

-	return broadcaster, false

-}

-

-func (pool *Pool) removeWithError(key string, broadcasterResult error) error {

-	pool.Lock()

-	defer pool.Unlock()

-	if broadcaster, exists := pool.pullingPool[key]; exists {

-		broadcaster.CloseWithError(broadcasterResult)

-		delete(pool.pullingPool, key)

-	}

-	return nil

-}

-

-func (pool *Pool) remove(key string) error {

-	return pool.removeWithError(key, nil)

-}

deleted file mode 100644

@@ -1,28 +0,0 @@

-package distribution

-

-import (

-	"testing"

-)

-

-func TestPools(t *testing.T) {

-	p := NewPool()

-

-	if _, found := p.add("test1"); found {

-		t.Fatal("Expected pull test1 not to be in progress")

-	}

-	if _, found := p.add("test2"); found {

-		t.Fatal("Expected pull test2 not to be in progress")

-	}

-	if _, found := p.add("test1"); !found {

-		t.Fatalf("Expected pull test1 to be in progress`")

-	}

-	if err := p.remove("test2"); err != nil {

-		t.Fatal(err)

-	}

-	if err := p.remove("test2"); err != nil {

-		t.Fatal(err)

-	}

-	if err := p.remove("test1"); err != nil {

-		t.Fatal(err)

-	}

-}

@@ -2,7 +2,7 @@ package distribution

 import (

 	"fmt"

-	"io"

+	"os"

 	"strings"

 	"github.com/Sirupsen/logrus"

@@ -10,11 +10,12 @@ import (

 	"github.com/docker/docker/cliconfig"

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

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

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

 	"github.com/docker/docker/image"

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

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

+	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/registry"

 	"github.com/docker/docker/tag"

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

 )

 // ImagePullConfig stores pull configuration.

@@ -25,9 +26,9 @@ type ImagePullConfig struct {

 	// AuthConfig holds authentication credentials for authenticating with

 	// the registry.

 	AuthConfig *cliconfig.AuthConfig

-	// OutStream is the output writer for showing the status of the pull

+	// ProgressOutput is the interface for showing the status of the pull

 	// operation.

-	OutStream io.Writer

+	ProgressOutput progress.Output

 	// RegistryService is the registry service to use for TLS configuration

 	// and endpoint lookup.

 	RegistryService *registry.Service

@@ -36,14 +37,12 @@ type ImagePullConfig struct {

 	// MetadataStore is the storage backend for distribution-specific

 	// metadata.

 	MetadataStore metadata.Store

-	// LayerStore manages layers.

-	LayerStore layer.Store

 	// ImageStore manages images.

 	ImageStore image.Store

 	// TagStore manages tags.

 	TagStore tag.Store

-	// Pool manages concurrent pulls.

-	Pool *Pool

+	// DownloadManager manages concurrent pulls.

+	DownloadManager *xfer.LayerDownloadManager

 }

 // Puller is an interface that abstracts pulling for different API versions.

@@ -51,7 +50,7 @@ type Puller interface {

 	// Pull tries to pull the image referenced by `tag`

 	// Pull returns an error if any, as well as a boolean that determines whether to retry Pull on the next configured endpoint.

 	//

-	Pull(ref reference.Named) (fallback bool, err error)

+	Pull(ctx context.Context, ref reference.Named) (fallback bool, err error)

 }

 // newPuller returns a Puller interface that will pull from either a v1 or v2

@@ -59,14 +58,13 @@ type Puller interface {

 // whether a v1 or v2 puller will be created. The other parameters are passed

 // through to the underlying puller implementation for use during the actual

 // pull operation.

-func newPuller(endpoint registry.APIEndpoint, repoInfo *registry.RepositoryInfo, imagePullConfig *ImagePullConfig, sf *streamformatter.StreamFormatter) (Puller, error) {

+func newPuller(endpoint registry.APIEndpoint, repoInfo *registry.RepositoryInfo, imagePullConfig *ImagePullConfig) (Puller, error) {

 	switch endpoint.Version {

 	case registry.APIVersion2:

 		return &v2Puller{

 			blobSumService: metadata.NewBlobSumService(imagePullConfig.MetadataStore),

 			endpoint:       endpoint,

 			config:         imagePullConfig,

-			sf:             sf,

 			repoInfo:       repoInfo,

 		}, nil

 	case registry.APIVersion1:

@@ -74,7 +72,6 @@ func newPuller(endpoint registry.APIEndpoint, repoInfo *registry.RepositoryInfo,

 			v1IDService: metadata.NewV1IDService(imagePullConfig.MetadataStore),

 			endpoint:    endpoint,

 			config:      imagePullConfig,

-			sf:          sf,

 			repoInfo:    repoInfo,

 		}, nil

 	}

@@ -83,9 +80,7 @@ func newPuller(endpoint registry.APIEndpoint, repoInfo *registry.RepositoryInfo,

 // Pull initiates a pull operation. image is the repository name to pull, and

 // tag may be either empty, or indicate a specific tag to pull.

-func Pull(ref reference.Named, imagePullConfig *ImagePullConfig) error {

-	var sf = streamformatter.NewJSONStreamFormatter()

-

+func Pull(ctx context.Context, ref reference.Named, imagePullConfig *ImagePullConfig) error {

 	// Resolve the Repository name from fqn to RepositoryInfo

 	repoInfo, err := imagePullConfig.RegistryService.ResolveRepository(ref)

 	if err != nil {

@@ -120,12 +115,19 @@ func Pull(ref reference.Named, imagePullConfig *ImagePullConfig) error {

 	for _, endpoint := range endpoints {

 		logrus.Debugf("Trying to pull %s from %s %s", repoInfo.LocalName, endpoint.URL, endpoint.Version)

-		puller, err := newPuller(endpoint, repoInfo, imagePullConfig, sf)

+		puller, err := newPuller(endpoint, repoInfo, imagePullConfig)

 		if err != nil {

 			errors = append(errors, err.Error())

 			continue

 		}

-		if fallback, err := puller.Pull(ref); err != nil {

+		if fallback, err := puller.Pull(ctx, ref); err != nil {

+			// Was this pull cancelled? If so, don't try to fall

+			// back.

+			select {

+			case <-ctx.Done():

+				fallback = false

+			default:

+			}

 			if fallback {

 				if _, ok := err.(registry.ErrNoSupport); !ok {

 					// Because we found an error that's not ErrNoSupport, discard all subsequent ErrNoSupport errors.

@@ -165,11 +167,11 @@ func Pull(ref reference.Named, imagePullConfig *ImagePullConfig) error {

 // status message indicates that a newer image was downloaded. Otherwise, it

 // indicates that the image is up to date. requestedTag is the tag the message

 // will refer to.

-func writeStatus(requestedTag string, out io.Writer, sf *streamformatter.StreamFormatter, layersDownloaded bool) {

+func writeStatus(requestedTag string, out progress.Output, layersDownloaded bool) {

 	if layersDownloaded {

-		out.Write(sf.FormatStatus("", "Status: Downloaded newer image for %s", requestedTag))

+		progress.Message(out, "", "Status: Downloaded newer image for "+requestedTag)

 	} else {

-		out.Write(sf.FormatStatus("", "Status: Image is up to date for %s", requestedTag))

+		progress.Message(out, "", "Status: Image is up to date for "+requestedTag)

 	}

 }

@@ -183,3 +185,16 @@ func validateRepoName(name string) error {

 	}

 	return nil

 }

+

+// tmpFileClose creates a closer function for a temporary file that closes the file

+// and also deletes it.

+func tmpFileCloser(tmpFile *os.File) func() error {

+	return func() error {

+		tmpFile.Close()

+		if err := os.RemoveAll(tmpFile.Name()); err != nil {

+			logrus.Errorf("Failed to remove temp file: %s", tmpFile.Name())

+		}

+

+		return nil

+	}

+}

@@ -1,43 +1,42 @@

 package distribution

 import (

-	"encoding/json"

 	"errors"

 	"fmt"

 	"io"

+	"io/ioutil"

 	"net"

 	"net/url"

 	"strings"

-	"sync"

 	"time"

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/distribution/reference"

 	"github.com/docker/distribution/registry/client/transport"

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

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

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/image/v1"

 	"github.com/docker/docker/layer"

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

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

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

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

+	"github.com/docker/docker/pkg/progress"

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

 	"github.com/docker/docker/registry"

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

 )

 type v1Puller struct {

 	v1IDService *metadata.V1IDService

 	endpoint    registry.APIEndpoint

 	config      *ImagePullConfig

-	sf          *streamformatter.StreamFormatter

 	repoInfo    *registry.RepositoryInfo

 	session     *registry.Session

 }

-func (p *v1Puller) Pull(ref reference.Named) (fallback bool, err error) {

+func (p *v1Puller) Pull(ctx context.Context, ref reference.Named) (fallback bool, err error) {

 	if _, isDigested := ref.(reference.Digested); isDigested {

 		// Allowing fallback, because HTTPS v1 is before HTTP v2

-		return true, registry.ErrNoSupport{errors.New("Cannot pull by digest with v1 registry")}

+		return true, registry.ErrNoSupport{Err: errors.New("Cannot pull by digest with v1 registry")}

 	}

 	tlsConfig, err := p.config.RegistryService.TLSConfig(p.repoInfo.Index.Name)

@@ -62,19 +61,17 @@ func (p *v1Puller) Pull(ref reference.Named) (fallback bool, err error) {

 		logrus.Debugf("Fallback from error: %s", err)

 		return true, err

 	}

-	if err := p.pullRepository(ref); err != nil {

+	if err := p.pullRepository(ctx, ref); err != nil {

 		// TODO(dmcgowan): Check if should fallback

 		return false, err

 	}

-	out := p.config.OutStream

-	out.Write(p.sf.FormatStatus("", "%s: this image was pulled from a legacy registry.  Important: This registry version will not be supported in future versions of docker.", p.repoInfo.CanonicalName.Name()))

+	progress.Message(p.config.ProgressOutput, "", p.repoInfo.CanonicalName.Name()+": this image was pulled from a legacy registry.  Important: This registry version will not be supported in future versions of docker.")

 	return false, nil

 }

-func (p *v1Puller) pullRepository(ref reference.Named) error {

-	out := p.config.OutStream

-	out.Write(p.sf.FormatStatus("", "Pulling repository %s", p.repoInfo.CanonicalName.Name()))

+func (p *v1Puller) pullRepository(ctx context.Context, ref reference.Named) error {

+	progress.Message(p.config.ProgressOutput, "", "Pulling repository "+p.repoInfo.CanonicalName.Name())

 	repoData, err := p.session.GetRepositoryData(p.repoInfo.RemoteName)

 	if err != nil {

@@ -112,46 +109,18 @@ func (p *v1Puller) pullRepository(ref reference.Named) error {

 		}

 	}

-	errors := make(chan error)

-	layerDownloaded := make(chan struct{})

-

 	layersDownloaded := false

-	var wg sync.WaitGroup

 	for _, imgData := range repoData.ImgList {

 		if isTagged && imgData.Tag != tagged.Tag() {

 			continue

 		}

-		wg.Add(1)

-		go func(img *registry.ImgData) {

-			p.downloadImage(out, repoData, img, layerDownloaded, errors)

-			wg.Done()

-		}(imgData)

-	}

-

-	go func() {

-		wg.Wait()

-		close(errors)

-	}()

-

-	var lastError error

-selectLoop:

-	for {

-		select {

-		case err, ok := <-errors:

-			if !ok {

-				break selectLoop

-			}

-			lastError = err

-		case <-layerDownloaded:

-			layersDownloaded = true

+		err := p.downloadImage(ctx, repoData, imgData, &layersDownloaded)

+		if err != nil {

+			return err

 		}

 	}

-	if lastError != nil {

-		return lastError

-	}

-

 	localNameRef := p.repoInfo.LocalName

 	if isTagged {

 		localNameRef, err = reference.WithTag(localNameRef, tagged.Tag())

@@ -159,194 +128,143 @@ selectLoop:

 			localNameRef = p.repoInfo.LocalName

 		}

 	}

-	writeStatus(localNameRef.String(), out, p.sf, layersDownloaded)

+	writeStatus(localNameRef.String(), p.config.ProgressOutput, layersDownloaded)

 	return nil

 }

-func (p *v1Puller) downloadImage(out io.Writer, repoData *registry.RepositoryData, img *registry.ImgData, layerDownloaded chan struct{}, errors chan error) {

+func (p *v1Puller) downloadImage(ctx context.Context, repoData *registry.RepositoryData, img *registry.ImgData, layersDownloaded *bool) error {

 	if img.Tag == "" {

 		logrus.Debugf("Image (id: %s) present in this repository but untagged, skipping", img.ID)

-		return

+		return nil

 	}

 	localNameRef, err := reference.WithTag(p.repoInfo.LocalName, img.Tag)

 	if err != nil {

 		retErr := fmt.Errorf("Image (id: %s) has invalid tag: %s", img.ID, img.Tag)

 		logrus.Debug(retErr.Error())

-		errors <- retErr

+		return retErr

 	}

 	if err := v1.ValidateID(img.ID); err != nil {

-		errors <- err

-		return

+		return err

 	}

-	out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s", img.Tag, p.repoInfo.CanonicalName.Name()), nil))

+	progress.Updatef(p.config.ProgressOutput, stringid.TruncateID(img.ID), "Pulling image (%s) from %s", img.Tag, p.repoInfo.CanonicalName.Name())

 	success := false

 	var lastErr error

-	var isDownloaded bool

 	for _, ep := range p.repoInfo.Index.Mirrors {

 		ep += "v1/"

-		out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, mirror: %s", img.Tag, p.repoInfo.CanonicalName.Name(), ep), nil))

-		if isDownloaded, err = p.pullImage(out, img.ID, ep, localNameRef); err != nil {

+		progress.Updatef(p.config.ProgressOutput, stringid.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, mirror: %s", img.Tag, p.repoInfo.CanonicalName.Name(), ep))

+		if err = p.pullImage(ctx, img.ID, ep, localNameRef, layersDownloaded); err != nil {

 			// Don't report errors when pulling from mirrors.

 			logrus.Debugf("Error pulling image (%s) from %s, mirror: %s, %s", img.Tag, p.repoInfo.CanonicalName.Name(), ep, err)

 			continue

 		}

-		if isDownloaded {

-			layerDownloaded <- struct{}{}

-		}

 		success = true

 		break

 	}

 	if !success {

 		for _, ep := range repoData.Endpoints {

-			out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, endpoint: %s", img.Tag, p.repoInfo.CanonicalName.Name(), ep), nil))

-			if isDownloaded, err = p.pullImage(out, img.ID, ep, localNameRef); err != nil {

+			progress.Updatef(p.config.ProgressOutput, stringid.TruncateID(img.ID), "Pulling image (%s) from %s, endpoint: %s", img.Tag, p.repoInfo.CanonicalName.Name(), ep)

+			if err = p.pullImage(ctx, img.ID, ep, localNameRef, layersDownloaded); err != nil {

 				// It's not ideal that only the last error is returned, it would be better to concatenate the errors.

 				// As the error is also given to the output stream the user will see the error.

 				lastErr = err

-				out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), fmt.Sprintf("Error pulling image (%s) from %s, endpoint: %s, %s", img.Tag, p.repoInfo.CanonicalName.Name(), ep, err), nil))

+				progress.Updatef(p.config.ProgressOutput, stringid.TruncateID(img.ID), "Error pulling image (%s) from %s, endpoint: %s, %s", img.Tag, p.repoInfo.CanonicalName.Name(), ep, err)

 				continue

 			}

-			if isDownloaded {

-				layerDownloaded <- struct{}{}

-			}

 			success = true

 			break

 		}

 	}

 	if !success {

 		err := fmt.Errorf("Error pulling image (%s) from %s, %v", img.Tag, p.repoInfo.CanonicalName.Name(), lastErr)

-		out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), err.Error(), nil))

-		errors <- err

-		return

+		progress.Update(p.config.ProgressOutput, stringid.TruncateID(img.ID), err.Error())

+		return err

 	}

-	out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), "Download complete", nil))

+	progress.Update(p.config.ProgressOutput, stringid.TruncateID(img.ID), "Download complete")

+	return nil

 }

-func (p *v1Puller) pullImage(out io.Writer, v1ID, endpoint string, localNameRef reference.Named) (layersDownloaded bool, err error) {

+func (p *v1Puller) pullImage(ctx context.Context, v1ID, endpoint string, localNameRef reference.Named, layersDownloaded *bool) (err error) {

 	var history []string

 	history, err = p.session.GetRemoteHistory(v1ID, endpoint)

 	if err != nil {

-		return false, err

+		return err

 	}

 	if len(history) < 1 {

-		return false, fmt.Errorf("empty history for image %s", v1ID)

+		return fmt.Errorf("empty history for image %s", v1ID)

 	}

-	out.Write(p.sf.FormatProgress(stringid.TruncateID(v1ID), "Pulling dependent layers", nil))

-	// FIXME: Try to stream the images?

-	// FIXME: Launch the getRemoteImage() in goroutines

+	progress.Update(p.config.ProgressOutput, stringid.TruncateID(v1ID), "Pulling dependent layers")

 	var (

-		referencedLayers []layer.Layer

-		parentID         layer.ChainID

-		newHistory       []image.History

-		img              *image.V1Image

-		imgJSON          []byte

-		imgSize          int64

+		descriptors []xfer.DownloadDescriptor

+		newHistory  []image.History

+		imgJSON     []byte