@@ -83,13 +83,6 @@ func installCommonConfigFlags(conf *config.Config, flags *pflag.FlagSet) error {

 	flags.IntVar(&conf.NetworkControlPlaneMTU, "network-control-plane-mtu", config.DefaultNetworkMtu, "Network Control plane MTU")

-	// "--deprecated-key-path" is to allow configuration of the key used

-	// for the daemon ID and the deprecated image signing. It was never

-	// exposed as a command line option but is added here to allow

-	// overriding the default path in configuration.

-	flags.Var(opts.NewQuotedString(&conf.TrustKeyPath), "deprecated-key-path", "Path to key file for ID and image signing")

-	flags.MarkHidden("deprecated-key-path")

-

 	conf.MaxConcurrentDownloads = &maxConcurrentDownloads

 	conf.MaxConcurrentUploads = &maxConcurrentUploads

 	return nil

@@ -103,10 +96,4 @@ func installRegistryServiceFlags(options *registry.ServiceOptions, flags *pflag.

 	flags.Var(ana, "allow-nondistributable-artifacts", "Allow push of nondistributable artifacts to registry")

 	flags.Var(mirrors, "registry-mirror", "Preferred Docker registry mirror")

 	flags.Var(insecureRegistries, "insecure-registry", "Enable insecure registry communication")

-

-	if runtime.GOOS != "windows" {

-		// TODO: Remove this flag after 3 release cycles (18.03)

-		flags.BoolVar(&options.V2Only, "disable-legacy-registry", true, "Disable contacting legacy registries")

-		flags.MarkHidden("disable-legacy-registry")

-	}

 }

@@ -454,17 +454,6 @@ func loadDaemonCliConfig(opts *daemonOptions) (*config.Config, error) {

 		return nil, err

 	}

-	if runtime.GOOS != "windows" {

-		if flags.Changed("disable-legacy-registry") {

-			// TODO: Remove this error after 3 release cycles (18.03)

-			return nil, errors.New("ERROR: The '--disable-legacy-registry' flag has been removed. Interacting with legacy (v1) registries is no longer supported")

-		}

-		if !conf.V2Only {

-			// TODO: Remove this error after 3 release cycles (18.03)

-			return nil, errors.New("ERROR: The 'disable-legacy-registry' configuration option has been removed. Interacting with legacy (v1) registries is no longer supported")

-		}

-	}

-

 	if flags.Changed("graph") {

 		logrus.Warnf(`The "-g / --graph" flag is deprecated. Please use "--data-root" instead`)

 	}

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

 	"io/ioutil"

 	"os"

 	"reflect"

-	"runtime"

 	"strings"

 	"sync"

@@ -246,10 +245,6 @@ func New() *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

 }

@@ -39,12 +39,7 @@ func newPuller(endpoint registry.APIEndpoint, repoInfo *registry.RepositoryInfo,

 			repoInfo:          repoInfo,

 		}, nil

 	case registry.APIVersion1:

-		return &v1Puller{

-			v1IDService: metadata.NewV1IDService(imagePullConfig.MetadataStore),

-			endpoint:    endpoint,

-			config:      imagePullConfig,

-			repoInfo:    repoInfo,

-		}, nil

+		return nil, fmt.Errorf("protocol version %d no longer supported. Please contact admins of registry %s", endpoint.Version, endpoint.URL)

 	}

 	return nil, fmt.Errorf("unknown version %d for registry %s", endpoint.Version, endpoint.URL)

 }

deleted file mode 100644

@@ -1,365 +0,0 @@

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

-

-import (

-	"context"

-	"errors"

-	"fmt"

-	"io"

-	"io/ioutil"

-	"net"

-	"net/url"

-	"os"

-	"strings"

-	"time"

-

-	"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/dockerversion"

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

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

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

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

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

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

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

-	specs "github.com/opencontainers/image-spec/specs-go/v1"

-	"github.com/sirupsen/logrus"

-)

-

-type v1Puller struct {

-	v1IDService *metadata.V1IDService

-	endpoint    registry.APIEndpoint

-	config      *ImagePullConfig

-	repoInfo    *registry.RepositoryInfo

-	session     *registry.Session

-}

-

-func (p *v1Puller) Pull(ctx context.Context, ref reference.Named, _ *specs.Platform) error {

-	if _, isCanonical := ref.(reference.Canonical); isCanonical {

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

-		return fallbackError{err: ErrNoSupport{Err: errors.New("Cannot pull by digest with v1 registry")}}

-	}

-

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

-	if err != nil {

-		return err

-	}

-	// Adds Docker-specific headers as well as user-specified headers (metaHeaders)

-	tr := transport.NewTransport(

-		// TODO(tiborvass): was ReceiveTimeout

-		registry.NewTransport(tlsConfig),

-		registry.Headers(dockerversion.DockerUserAgent(ctx), p.config.MetaHeaders)...,

-	)

-	client := registry.HTTPClient(tr)

-	v1Endpoint := p.endpoint.ToV1Endpoint(dockerversion.DockerUserAgent(ctx), p.config.MetaHeaders)

-	p.session, err = registry.NewSession(client, p.config.AuthConfig, v1Endpoint)

-	if err != nil {

-		// TODO(dmcgowan): Check if should fallback

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

-		return fallbackError{err: err}

-	}

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

-		// TODO(dmcgowan): Check if should fallback

-		return err

-	}

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

-

-	return nil

-}

-

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

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

-

-	tagged, isTagged := ref.(reference.NamedTagged)

-

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

-	if err != nil {

-		if strings.Contains(err.Error(), "HTTP code: 404") {

-			if isTagged {

-				return fmt.Errorf("Error: image %s:%s not found", reference.Path(p.repoInfo.Name), tagged.Tag())

-			}

-			return fmt.Errorf("Error: image %s not found", reference.Path(p.repoInfo.Name))

-		}

-		// Unexpected HTTP error

-		return err

-	}

-

-	logrus.Debug("Retrieving the tag list")

-	var tagsList map[string]string

-	if !isTagged {

-		tagsList, err = p.session.GetRemoteTags(repoData.Endpoints, p.repoInfo.Name)

-	} else {

-		var tagID string

-		tagsList = make(map[string]string)

-		tagID, err = p.session.GetRemoteTag(repoData.Endpoints, p.repoInfo.Name, tagged.Tag())

-		if err == registry.ErrRepoNotFound {

-			return fmt.Errorf("Tag %s not found in repository %s", tagged.Tag(), p.repoInfo.Name.Name())

-		}

-		tagsList[tagged.Tag()] = tagID

-	}

-	if err != nil {

-		logrus.Errorf("unable to get remote tags: %s", err)

-		return err

-	}

-

-	for tag, id := range tagsList {

-		repoData.ImgList[id] = &registry.ImgData{

-			ID:       id,

-			Tag:      tag,

-			Checksum: "",

-		}

-	}

-

-	layersDownloaded := false

-	for _, imgData := range repoData.ImgList {

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

-			continue

-		}

-

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

-		if err != nil {

-			return err

-		}

-	}

-

-	writeStatus(reference.FamiliarString(ref), p.config.ProgressOutput, layersDownloaded)

-	return nil

-}

-

-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 nil

-	}

-

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

-	if err != nil {

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

-		logrus.Debug(retErr.Error())

-		return retErr

-	}

-

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

-		return err

-	}

-

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

-	success := false

-	var lastErr error

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

-		ep += "v1/"

-		progress.Updatef(p.config.ProgressOutput, stringid.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, mirror: %s", img.Tag, p.repoInfo.Name.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.Name.Name(), ep, err)

-			continue

-		}

-		success = true

-		break

-	}

-	if !success {

-		for _, ep := range repoData.Endpoints {

-			progress.Updatef(p.config.ProgressOutput, stringid.TruncateID(img.ID), "Pulling image (%s) from %s, endpoint: %s", img.Tag, p.repoInfo.Name.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

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

-				continue

-			}

-			success = true

-			break

-		}

-	}

-	if !success {

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

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

-		return err

-	}

-	return nil

-}

-

-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 err

-	}

-	if len(history) < 1 {

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

-	}

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

-

-	var (

-		descriptors []xfer.DownloadDescriptor

-		newHistory  []image.History

-		imgJSON     []byte

-		imgSize     int64

-	)

-

-	// Iterate over layers, in order from bottom-most to top-most. Download

-	// config for all layers and create descriptors.

-	for i := len(history) - 1; i >= 0; i-- {

-		v1LayerID := history[i]

-		imgJSON, imgSize, err = p.downloadLayerConfig(v1LayerID, endpoint)

-		if err != nil {

-			return err

-		}

-

-		// Create a new-style config from the legacy configs

-		h, err := v1.HistoryFromConfig(imgJSON, false)

-		if err != nil {

-			return err

-		}

-		newHistory = append(newHistory, h)

-

-		layerDescriptor := &v1LayerDescriptor{

-			v1LayerID:        v1LayerID,

-			indexName:        p.repoInfo.Index.Name,

-			endpoint:         endpoint,

-			v1IDService:      p.v1IDService,

-			layersDownloaded: layersDownloaded,

-			layerSize:        imgSize,

-			session:          p.session,

-		}

-

-		descriptors = append(descriptors, layerDescriptor)

-	}

-

-	rootFS := image.NewRootFS()

-	resultRootFS, release, err := p.config.DownloadManager.Download(ctx, *rootFS, "", descriptors, p.config.ProgressOutput)

-	if err != nil {

-		return err

-	}

-	defer release()

-

-	config, err := v1.MakeConfigFromV1Config(imgJSON, &resultRootFS, newHistory)

-	if err != nil {

-		return err

-	}

-

-	imageID, err := p.config.ImageStore.Put(config)

-	if err != nil {

-		return err

-	}

-

-	if p.config.ReferenceStore != nil {

-		if err := p.config.ReferenceStore.AddTag(localNameRef, imageID, true); err != nil {

-			return err

-		}

-	}

-

-	return nil

-}

-

-func (p *v1Puller) downloadLayerConfig(v1LayerID, endpoint string) (imgJSON []byte, imgSize int64, err error) {

-	progress.Update(p.config.ProgressOutput, stringid.TruncateID(v1LayerID), "Pulling metadata")

-

-	retries := 5

-	for j := 1; j <= retries; j++ {

-		imgJSON, imgSize, err := p.session.GetRemoteImageJSON(v1LayerID, endpoint)

-		if err != nil && j == retries {

-			progress.Update(p.config.ProgressOutput, stringid.TruncateID(v1LayerID), "Error pulling layer metadata")

-			return nil, 0, err

-		} else if err != nil {

-			time.Sleep(time.Duration(j) * 500 * time.Millisecond)

-			continue

-		}

-

-		return imgJSON, imgSize, nil

-	}

-

-	// not reached

-	return nil, 0, nil

-}

-

-type v1LayerDescriptor struct {

-	v1LayerID        string

-	indexName        string

-	endpoint         string

-	v1IDService      *metadata.V1IDService

-	layersDownloaded *bool

-	layerSize        int64

-	session          *registry.Session

-	tmpFile          *os.File

-}

-

-func (ld *v1LayerDescriptor) Key() string {

-	return "v1:" + ld.v1LayerID

-}

-

-func (ld *v1LayerDescriptor) ID() string {

-	return stringid.TruncateID(ld.v1LayerID)

-}

-

-func (ld *v1LayerDescriptor) DiffID() (layer.DiffID, error) {

-	return ld.v1IDService.Get(ld.v1LayerID, ld.indexName)

-}

-

-func (ld *v1LayerDescriptor) Download(ctx context.Context, progressOutput progress.Output) (io.ReadCloser, int64, error) {

-	progress.Update(progressOutput, ld.ID(), "Pulling fs layer")

-	layerReader, err := ld.session.GetRemoteImageLayer(ld.v1LayerID, ld.endpoint, ld.layerSize)

-	if err != nil {

-		progress.Update(progressOutput, ld.ID(), "Error pulling dependent layers")

-		if uerr, ok := err.(*url.Error); ok {

-			err = uerr.Err

-		}

-		if terr, ok := err.(net.Error); ok && terr.Timeout() {

-			return nil, 0, err

-		}

-		return nil, 0, xfer.DoNotRetry{Err: err}

-	}

-	*ld.layersDownloaded = true

-

-	ld.tmpFile, err = ioutil.TempFile("", "GetImageBlob")

-	if err != nil {

-		layerReader.Close()

-		return nil, 0, err

-	}

-

-	reader := progress.NewProgressReader(ioutils.NewCancelReadCloser(ctx, layerReader), progressOutput, ld.layerSize, ld.ID(), "Downloading")

-	defer reader.Close()

-

-	_, err = io.Copy(ld.tmpFile, reader)

-	if err != nil {

-		ld.Close()

-		return nil, 0, err

-	}

-

-	progress.Update(progressOutput, ld.ID(), "Download complete")

-

-	logrus.Debugf("Downloaded %s to tempfile %s", ld.ID(), ld.tmpFile.Name())

-

-	ld.tmpFile.Seek(0, 0)

-

-	// hand off the temporary file to the download manager, so it will only

-	// be closed once

-	tmpFile := ld.tmpFile

-	ld.tmpFile = nil

-

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

-		tmpFile.Close()

-		err := os.RemoveAll(tmpFile.Name())

-		if err != nil {

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

-		}

-		return err

-	}), ld.layerSize, nil

-}

-

-func (ld *v1LayerDescriptor) Close() {

-	if ld.tmpFile != nil {

-		ld.tmpFile.Close()

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

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

-		}

-		ld.tmpFile = nil

-	}

-}

-

-func (ld *v1LayerDescriptor) Registered(diffID layer.DiffID) {

-	// Cache mapping from this layer's DiffID to the blobsum

-	ld.v1IDService.Set(ld.v1LayerID, ld.indexName, diffID)

-}

@@ -41,13 +41,7 @@ func NewPusher(ref reference.Named, endpoint registry.APIEndpoint, repoInfo *reg

 			config:            imagePushConfig,

 		}, nil

 	case registry.APIVersion1:

-		return &v1Pusher{

-			v1IDService: metadata.NewV1IDService(imagePushConfig.MetadataStore),

-			ref:         ref,

-			endpoint:    endpoint,

-			repoInfo:    repoInfo,

-			config:      imagePushConfig,

-		}, nil

+		return nil, fmt.Errorf("protocol version %d no longer supported. Please contact admins of registry %s", endpoint.Version, endpoint.URL)

 	}

 	return nil, fmt.Errorf("unknown version %d for registry %s", endpoint.Version, endpoint.URL)

 }

deleted file mode 100644

@@ -1,457 +0,0 @@

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

-

-import (

-	"context"

-	"fmt"

-	"sync"

-

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

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

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

-	"github.com/docker/docker/dockerversion"

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

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

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

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

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

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

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

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

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

-	"github.com/sirupsen/logrus"

-)

-

-type v1Pusher struct {

-	v1IDService *metadata.V1IDService

-	endpoint    registry.APIEndpoint

-	ref         reference.Named

-	repoInfo    *registry.RepositoryInfo

-	config      *ImagePushConfig

-	session     *registry.Session

-}

-

-func (p *v1Pusher) Push(ctx context.Context) error {

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

-	if err != nil {

-		return err

-	}

-	// Adds Docker-specific headers as well as user-specified headers (metaHeaders)

-	tr := transport.NewTransport(

-		// TODO(tiborvass): was NoTimeout

-		registry.NewTransport(tlsConfig),

-		registry.Headers(dockerversion.DockerUserAgent(ctx), p.config.MetaHeaders)...,

-	)

-	client := registry.HTTPClient(tr)

-	v1Endpoint := p.endpoint.ToV1Endpoint(dockerversion.DockerUserAgent(ctx), p.config.MetaHeaders)

-	p.session, err = registry.NewSession(client, p.config.AuthConfig, v1Endpoint)

-	if err != nil {

-		// TODO(dmcgowan): Check if should fallback

-		return fallbackError{err: err}

-	}

-	if err := p.pushRepository(ctx); err != nil {

-		// TODO(dmcgowan): Check if should fallback

-		return err

-	}

-	return nil

-}

-

-// v1Image exposes the configuration, filesystem layer ID, and a v1 ID for an

-// image being pushed to a v1 registry.

-type v1Image interface {

-	Config() []byte

-	Layer() layer.Layer

-	V1ID() string

-}

-

-type v1ImageCommon struct {

-	layer  layer.Layer

-	config []byte

-	v1ID   string

-}

-

-func (common *v1ImageCommon) Config() []byte {

-	return common.config

-}

-

-func (common *v1ImageCommon) V1ID() string {

-	return common.v1ID

-}

-

-func (common *v1ImageCommon) Layer() layer.Layer {

-	return common.layer

-}

-

-// v1TopImage defines a runnable (top layer) image being pushed to a v1

-// registry.

-type v1TopImage struct {

-	v1ImageCommon

-	imageID image.ID

-}

-

-func newV1TopImage(imageID image.ID, img *image.Image, l layer.Layer, parent *v1DependencyImage) (*v1TopImage, error) {

-	v1ID := imageID.Digest().Hex()

-	parentV1ID := ""

-	if parent != nil {

-		parentV1ID = parent.V1ID()

-	}

-

-	config, err := v1.MakeV1ConfigFromConfig(img, v1ID, parentV1ID, false)

-	if err != nil {

-		return nil, err

-	}

-

-	return &v1TopImage{

-		v1ImageCommon: v1ImageCommon{

-			v1ID:   v1ID,

-			config: config,

-			layer:  l,

-		},

-		imageID: imageID,

-	}, nil

-}

-

-// v1DependencyImage defines a dependency layer being pushed to a v1 registry.

-type v1DependencyImage struct {

-	v1ImageCommon

-}

-

-func newV1DependencyImage(l layer.Layer, parent *v1DependencyImage) *v1DependencyImage {

-	v1ID := digest.Digest(l.ChainID()).Hex()

-

-	var config string

-	if parent != nil {

-		config = fmt.Sprintf(`{"id":"%s","parent":"%s"}`, v1ID, parent.V1ID())

-	} else {

-		config = fmt.Sprintf(`{"id":"%s"}`, v1ID)

-	}

-	return &v1DependencyImage{

-		v1ImageCommon: v1ImageCommon{

-			v1ID:   v1ID,

-			config: []byte(config),

-			layer:  l,

-		},

-	}

-}

-

-// Retrieve the all the images to be uploaded in the correct order

-func (p *v1Pusher) getImageList() (imageList []v1Image, tagsByImage map[image.ID][]string, referencedLayers []PushLayer, err error) {

-	tagsByImage = make(map[image.ID][]string)

-

-	// Ignore digest references

-	if _, isCanonical := p.ref.(reference.Canonical); isCanonical {

-		return

-	}

-

-	tagged, isTagged := p.ref.(reference.NamedTagged)

-	if isTagged {

-		// Push a specific tag

-		var imgID image.ID

-		var dgst digest.Digest

-		dgst, err = p.config.ReferenceStore.Get(p.ref)

-		if err != nil {

-			return

-		}

-		imgID = image.IDFromDigest(dgst)

-

-		imageList, err = p.imageListForTag(imgID, nil, &referencedLayers)

-		if err != nil {

-			return

-		}

-

-		tagsByImage[imgID] = []string{tagged.Tag()}

-

-		return

-	}

-

-	imagesSeen := make(map[digest.Digest]struct{})

-	dependenciesSeen := make(map[layer.ChainID]*v1DependencyImage)

-

-	associations := p.config.ReferenceStore.ReferencesByName(p.ref)

-	for _, association := range associations {

-		if tagged, isTagged = association.Ref.(reference.NamedTagged); !isTagged {

-			// Ignore digest references.

-			continue

-		}

-

-		imgID := image.IDFromDigest(association.ID)

-		tagsByImage[imgID] = append(tagsByImage[imgID], tagged.Tag())

-

-		if _, present := imagesSeen[association.ID]; present {

-			// Skip generating image list for already-seen image

-			continue

-		}

-		imagesSeen[association.ID] = struct{}{}

-

-		imageListForThisTag, err := p.imageListForTag(imgID, dependenciesSeen, &referencedLayers)

-		if err != nil {

-			return nil, nil, nil, err

-		}

-

-		// append to main image list

-		imageList = append(imageList, imageListForThisTag...)

-	}

-	if len(imageList) == 0 {

-		return nil, nil, nil, fmt.Errorf("No images found for the requested repository / tag")

-	}

-	logrus.Debugf("Image list: %v", imageList)

-	logrus.Debugf("Tags by image: %v", tagsByImage)

-

-	return

-}

-

-func (p *v1Pusher) imageListForTag(imgID image.ID, dependenciesSeen map[layer.ChainID]*v1DependencyImage, referencedLayers *[]PushLayer) (imageListForThisTag []v1Image, err error) {

-	ics, ok := p.config.ImageStore.(*imageConfigStore)

-	if !ok {

-		return nil, fmt.Errorf("only image store images supported for v1 push")

-	}

-	img, err := ics.Store.Get(imgID)

-	if err != nil {

-		return nil, err

-	}

-

-	topLayerID := img.RootFS.ChainID()

-

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

-		return nil, system.ErrNotSupportedOperatingSystem

-	}

-	pl, err := p.config.LayerStores[img.OperatingSystem()].Get(topLayerID)

-	*referencedLayers = append(*referencedLayers, pl)

-	if err != nil {

-		return nil, fmt.Errorf("failed to get top layer from image: %v", err)

-	}

-

-	// V1 push is deprecated, only support existing layerstore layers

-	lsl, ok := pl.(*storeLayer)

-	if !ok {

-		return nil, fmt.Errorf("only layer store layers supported for v1 push")

-	}

-	l := lsl.Layer

-

-	dependencyImages, parent := generateDependencyImages(l.Parent(), dependenciesSeen)

-

-	topImage, err := newV1TopImage(imgID, img, l, parent)

-	if err != nil {

-		return nil, err

-	}

-

-	imageListForThisTag = append(dependencyImages, topImage)

-

-	return

-}

-

-func generateDependencyImages(l layer.Layer, dependenciesSeen map[layer.ChainID]*v1DependencyImage) (imageListForThisTag []v1Image, parent *v1DependencyImage) {

-	if l == nil {

-		return nil, nil

-	}

-

-	imageListForThisTag, parent = generateDependencyImages(l.Parent(), dependenciesSeen)

-

-	if dependenciesSeen != nil {

-		if dependencyImage, present := dependenciesSeen[l.ChainID()]; present {

-			// This layer is already on the list, we can ignore it

-			// and all its parents.

-			return imageListForThisTag, dependencyImage

-		}

-	}

-

-	dependencyImage := newV1DependencyImage(l, parent)

-	imageListForThisTag = append(imageListForThisTag, dependencyImage)

-

-	if dependenciesSeen != nil {

-		dependenciesSeen[l.ChainID()] = dependencyImage

-	}

-

-	return imageListForThisTag, dependencyImage

-}

-

-// createImageIndex returns an index of an image's layer IDs and tags.

-func createImageIndex(images []v1Image, tags map[image.ID][]string) []*registry.ImgData {

-	var imageIndex []*registry.ImgData

-	for _, img := range images {

-		v1ID := img.V1ID()

-

-		if topImage, isTopImage := img.(*v1TopImage); isTopImage {

-			if tags, hasTags := tags[topImage.imageID]; hasTags {

-				// If an image has tags you must add an entry in the image index

-				// for each tag

-				for _, tag := range tags {

-					imageIndex = append(imageIndex, &registry.ImgData{

-						ID:  v1ID,

-						Tag: tag,

-					})

-				}

-				continue

-			}

-		}

-

-		// If the image does not have a tag it still needs to be sent to the

-		// registry with an empty tag so that it is associated with the repository

-		imageIndex = append(imageIndex, &registry.ImgData{

-			ID:  v1ID,

-			Tag: "",

-		})

-	}

-	return imageIndex

-}

-

-// lookupImageOnEndpoint checks the specified endpoint to see if an image exists

-// and if it is absent then it sends the image id to the channel to be pushed.

-func (p *v1Pusher) lookupImageOnEndpoint(wg *sync.WaitGroup, endpoint string, images chan v1Image, imagesToPush chan string) {

-	defer wg.Done()

-	for image := range images {

-		v1ID := image.V1ID()

-		truncID := stringid.TruncateID(image.Layer().DiffID().String())

-		if err := p.session.LookupRemoteImage(v1ID, endpoint); err != nil {

-			logrus.Errorf("Error in LookupRemoteImage: %s", err)

-			imagesToPush <- v1ID

-			progress.Update(p.config.ProgressOutput, truncID, "Waiting")

-		} else {

-			progress.Update(p.config.ProgressOutput, truncID, "Already exists")

-		}

-	}

-}

-

-func (p *v1Pusher) pushImageToEndpoint(ctx context.Context, endpoint string, imageList []v1Image, tags map[image.ID][]string, repo *registry.RepositoryData) error {

-	workerCount := len(imageList)

-	// start a maximum of 5 workers to check if images exist on the specified endpoint.

-	if workerCount > 5 {

-		workerCount = 5

-	}

-	var (

-		wg           = &sync.WaitGroup{}

-		imageData    = make(chan v1Image, workerCount*2)

-		imagesToPush = make(chan string, workerCount*2)

-		pushes       = make(chan map[string]struct{}, 1)

-	)

-	for i := 0; i < workerCount; i++ {

-		wg.Add(1)

-		go p.lookupImageOnEndpoint(wg, endpoint, imageData, imagesToPush)

-	}

-	// start a go routine that consumes the images to push

-	go func() {

-		shouldPush := make(map[string]struct{})

-		for id := range imagesToPush {

-			shouldPush[id] = struct{}{}

-		}

-		pushes <- shouldPush

-	}()

-	for _, v1Image := range imageList {

-		imageData <- v1Image

-	}

-	// close the channel to notify the workers that there will be no more images to check.

-	close(imageData)

-	wg.Wait()

-	close(imagesToPush)

-	// wait for all the images that require pushes to be collected into a consumable map.

-	shouldPush := <-pushes

-	// finish by pushing any images and tags to the endpoint.  The order that the images are pushed

-	// is very important that is why we are still iterating over the ordered list of imageIDs.

-	for _, img := range imageList {

-		v1ID := img.V1ID()

-		if _, push := shouldPush[v1ID]; push {

-			if _, err := p.pushImage(ctx, img, endpoint); err != nil {

-				// FIXME: Continue on error?

-				return err

-			}

-		}

-		if topImage, isTopImage := img.(*v1TopImage); isTopImage {

-			for _, tag := range tags[topImage.imageID] {

-				progress.Messagef(p.config.ProgressOutput, "", "Pushing tag for rev [%s] on {%s}", stringid.TruncateID(v1ID), endpoint+"repositories/"+reference.Path(p.repoInfo.Name)+"/tags/"+tag)

-				if err := p.session.PushRegistryTag(p.repoInfo.Name, v1ID, tag, endpoint); err != nil {

-					return err

-				}

-			}

-		}

-	}

-	return nil

-}

-

-// pushRepository pushes layers that do not already exist on the registry.

-func (p *v1Pusher) pushRepository(ctx context.Context) error {

-	imgList, tags, referencedLayers, err := p.getImageList()

-	defer func() {

-		for _, l := range referencedLayers {

-			l.Release()

-		}

-	}()

-	if err != nil {

-		return err

-	}

-

-	imageIndex := createImageIndex(imgList, tags)

-	for _, data := range imageIndex {

-		logrus.Debugf("Pushing ID: %s with Tag: %s", data.ID, data.Tag)

-	}

-

-	// Register all the images in a repository with the registry

-	// If an image is not in this list it will not be associated with the repository

-	repoData, err := p.session.PushImageJSONIndex(p.repoInfo.Name, imageIndex, false, nil)

-	if err != nil {

-		return err

-	}

-	// push the repository to each of the endpoints only if it does not exist.

-	for _, endpoint := range repoData.Endpoints {

-		if err := p.pushImageToEndpoint(ctx, endpoint, imgList, tags, repoData); err != nil {

-			return err

-		}

-	}

-	_, err = p.session.PushImageJSONIndex(p.repoInfo.Name, imageIndex, true, repoData.Endpoints)

-	return err

-}

-

-func (p *v1Pusher) pushImage(ctx context.Context, v1Image v1Image, ep string) (checksum string, err error) {

-	l := v1Image.Layer()

-	v1ID := v1Image.V1ID()

-	truncID := stringid.TruncateID(l.DiffID().String())

-

-	jsonRaw := v1Image.Config()

-	progress.Update(p.config.ProgressOutput, truncID, "Pushing")

-

-	// General rule is to use ID for graph accesses and compatibilityID for

-	// calls to session.registry()

-	imgData := &registry.ImgData{