@@ -260,15 +260,11 @@ func (cli *DockerCli) CmdBuild(args ...string) error {

 // validateTag checks if the given image name can be resolved.

 func validateTag(rawRepo string) (string, error) {

-	ref, err := reference.ParseNamed(rawRepo)

+	_, err := reference.ParseNamed(rawRepo)

 	if err != nil {

 		return "", err

 	}

-	if err := registry.ValidateRepositoryName(ref); err != nil {

-		return "", err

-	}

-

 	return rawRepo, nil

 }

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

 	"github.com/docker/docker/opts"

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

 	"github.com/docker/docker/reference"

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

 	"github.com/docker/docker/runconfig"

 )

@@ -44,9 +43,6 @@ func (cli *DockerCli) CmdCommit(args ...string) error {

 		if err != nil {

 			return err

 		}

-		if err := registry.ValidateRepositoryName(ref); err != nil {

-			return err

-		}

 		repositoryName = ref.Name()

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

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

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

 	"github.com/docker/docker/reference"

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

 )

 // CmdImport creates an empty filesystem image, imports the contents of the tarball into the image, and optionally tags the image.

@@ -45,11 +44,7 @@ func (cli *DockerCli) CmdImport(args ...string) error {

 	if repository != "" {

 		//Check if the given image name can be resolved

-		ref, err := reference.ParseNamed(repository)

-		if err != nil {

-			return err

-		}

-		if err := registry.ValidateRepositoryName(ref); err != nil {

+		if _, err := reference.ParseNamed(repository); err != nil {

 			return err

 		}

 	}

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

 	Cli "github.com/docker/docker/cli"

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

 	"github.com/docker/docker/reference"

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

 )

 // CmdTag tags an image into a repository.

@@ -35,11 +34,6 @@ func (cli *DockerCli) CmdTag(args ...string) error {

 		tag = tagged.Tag()

 	}

-	//Check if the given image name can be resolved

-	if err := registry.ValidateRepositoryName(ref); err != nil {

-		return err

-	}

-

 	options := types.ImageTagOptions{

 		ImageID:        cmd.Arg(0),

 		RepositoryName: ref.Name(),

@@ -167,12 +167,12 @@ func (cli *DockerCli) getNotaryRepository(repoInfo *registry.RepositoryInfo, aut

 	}

 	creds := simpleCredentialStore{auth: authConfig}

-	tokenHandler := auth.NewTokenHandler(authTransport, creds, repoInfo.CanonicalName.Name(), "push", "pull")

+	tokenHandler := auth.NewTokenHandler(authTransport, creds, repoInfo.FullName(), "push", "pull")

 	basicHandler := auth.NewBasicHandler(creds)

 	modifiers = append(modifiers, transport.RequestModifier(auth.NewAuthorizer(challengeManager, tokenHandler, basicHandler)))

 	tr := transport.NewTransport(base, modifiers...)

-	return client.NewNotaryRepository(cli.trustDirectory(), repoInfo.CanonicalName.Name(), server, tr, cli.getPassphraseRetriever())

+	return client.NewNotaryRepository(cli.trustDirectory(), repoInfo.FullName(), server, tr, cli.getPassphraseRetriever())

 }

 func convertTarget(t client.Target) (target, error) {

@@ -298,7 +298,7 @@ func (cli *DockerCli) trustedPull(repoInfo *registry.RepositoryInfo, ref registr

 		for _, tgt := range targets {

 			t, err := convertTarget(*tgt)

 			if err != nil {

-				fmt.Fprintf(cli.out, "Skipping target for %q\n", repoInfo.LocalName)

+				fmt.Fprintf(cli.out, "Skipping target for %q\n", repoInfo.Name())

 				continue

 			}

 			refs = append(refs, t)

@@ -321,19 +321,19 @@ func (cli *DockerCli) trustedPull(repoInfo *registry.RepositoryInfo, ref registr

 		if displayTag != "" {

 			displayTag = ":" + displayTag

 		}

-		fmt.Fprintf(cli.out, "Pull (%d of %d): %s%s@%s\n", i+1, len(refs), repoInfo.LocalName, displayTag, r.digest)

+		fmt.Fprintf(cli.out, "Pull (%d of %d): %s%s@%s\n", i+1, len(refs), repoInfo.Name(), displayTag, r.digest)

-		if err := cli.imagePullPrivileged(authConfig, repoInfo.LocalName.Name(), r.digest.String(), requestPrivilege); err != nil {

+		if err := cli.imagePullPrivileged(authConfig, repoInfo.Name(), r.digest.String(), requestPrivilege); err != nil {

 			return err

 		}

 		// If reference is not trusted, tag by trusted reference

 		if !r.reference.HasDigest() {

-			tagged, err := reference.WithTag(repoInfo.LocalName, r.reference.String())

+			tagged, err := reference.WithTag(repoInfo, r.reference.String())

 			if err != nil {

 				return err

 			}

-			trustedRef, err := reference.WithDigest(repoInfo.LocalName, r.digest)

+			trustedRef, err := reference.WithDigest(repoInfo, r.digest)

 			if err := cli.tagTrusted(trustedRef, tagged); err != nil {

 				return err

@@ -384,7 +384,7 @@ func targetStream(in io.Writer) (io.WriteCloser, <-chan []target) {

 func (cli *DockerCli) trustedPush(repoInfo *registry.RepositoryInfo, tag string, authConfig types.AuthConfig, requestPrivilege lib.RequestPrivilegeFunc) error {

 	streamOut, targetChan := targetStream(cli.out)

-	reqError := cli.imagePushPrivileged(authConfig, repoInfo.LocalName.Name(), tag, streamOut, requestPrivilege)

+	reqError := cli.imagePushPrivileged(authConfig, repoInfo.Name(), tag, streamOut, requestPrivilege)

 	// Close stream channel to finish target parsing

 	if err := streamOut.Close(); err != nil {

@@ -455,7 +455,7 @@ func (cli *DockerCli) trustedPush(repoInfo *registry.RepositoryInfo, tag string,

 	if err := repo.Initialize(rootKeyID); err != nil {

 		return notaryError(err)

 	}

-	fmt.Fprintf(cli.out, "Finished initializing %q\n", repoInfo.CanonicalName)

+	fmt.Fprintf(cli.out, "Finished initializing %q\n", repoInfo.FullName())

 	return notaryError(repo.Publish())

 }

@@ -1043,7 +1043,6 @@ func (daemon *Daemon) TagImage(newTag reference.Named, imageName string) error {

 	if err != nil {

 		return err

 	}

-	newTag = registry.NormalizeLocalReference(newTag)

 	if err := daemon.referenceStore.AddTag(newTag, imageID, true); err != nil {

 		return err

 	}

@@ -1301,7 +1300,6 @@ func (daemon *Daemon) GetImageID(refOrID string) (image.ID, error) {

 	// Treat it as a possible tag or digest reference

 	if ref, err := reference.ParseNamed(refOrID); err == nil {

-		ref = registry.NormalizeLocalReference(ref)

 		if id, err := daemon.referenceStore.Get(ref); err == nil {

 			return id, nil

 		}

@@ -87,17 +87,15 @@ func Pull(ctx context.Context, ref reference.Named, imagePullConfig *ImagePullCo

 	}

 	// makes sure name is not empty or `scratch`

-	if err := validateRepoName(repoInfo.LocalName.Name()); err != nil {

+	if err := validateRepoName(repoInfo.Name()); err != nil {

 		return err

 	}

-	endpoints, err := imagePullConfig.RegistryService.LookupPullEndpoints(repoInfo.CanonicalName)

+	endpoints, err := imagePullConfig.RegistryService.LookupPullEndpoints(repoInfo)

 	if err != nil {

 		return err

 	}

-	localName := registry.NormalizeLocalReference(ref)

-

 	var (

 		// use a slice to append the error strings and return a joined string to caller

 		errors []string

@@ -112,7 +110,7 @@ func Pull(ctx context.Context, ref reference.Named, imagePullConfig *ImagePullCo

 		discardNoSupportErrors bool

 	)

 	for _, endpoint := range endpoints {

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

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

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

 		if err != nil {

@@ -148,7 +146,7 @@ func Pull(ctx context.Context, ref reference.Named, imagePullConfig *ImagePullCo

 			}

 		}

-		imagePullConfig.EventsService.Log("pull", localName.String(), "")

+		imagePullConfig.EventsService.Log("pull", ref.String(), "")

 		return nil

 	}

@@ -65,18 +65,18 @@ func (p *v1Puller) Pull(ctx context.Context, ref reference.Named) (fallback bool

 		// TODO(dmcgowan): Check if should fallback

 		return false, err

 	}

-	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.")

+	progress.Message(p.config.ProgressOutput, "", p.repoInfo.FullName()+": 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(ctx context.Context, ref reference.Named) error {

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

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

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

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

 	if err != nil {

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

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

+			return fmt.Errorf("Error: image %s not found", p.repoInfo.RemoteName())

 		}

 		// Unexpected HTTP error

 		return err

@@ -86,13 +86,13 @@ func (p *v1Puller) pullRepository(ctx context.Context, ref reference.Named) erro

 	var tagsList map[string]string

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

 	if !isTagged {

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

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

 	} else {

 		var tagID string

 		tagsList = make(map[string]string)

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

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

 		if err == registry.ErrRepoNotFound {

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

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

 		}

 		tagsList[tagged.Tag()] = tagID

 	}

@@ -121,14 +121,7 @@ func (p *v1Puller) pullRepository(ctx context.Context, ref reference.Named) erro

 		}

 	}

-	localNameRef := p.repoInfo.LocalName

-	if isTagged {

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

-		if err != nil {

-			localNameRef = p.repoInfo.LocalName

-		}

-	}

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

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

 	return nil

 }

@@ -138,7 +131,7 @@ func (p *v1Puller) downloadImage(ctx context.Context, repoData *registry.Reposit

 		return nil

 	}

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

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

 	if err != nil {

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

 		logrus.Debug(retErr.Error())

@@ -149,15 +142,15 @@ func (p *v1Puller) downloadImage(ctx context.Context, repoData *registry.Reposit

 		return err

 	}

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

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

 	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.CanonicalName.Name(), ep))

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

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

 			continue

 		}

 		success = true

@@ -165,12 +158,12 @@ func (p *v1Puller) downloadImage(ctx context.Context, repoData *registry.Reposit

 	}

 	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.CanonicalName.Name(), ep)

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

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

 				continue

 			}

 			success = true

@@ -178,7 +171,7 @@ func (p *v1Puller) downloadImage(ctx context.Context, repoData *registry.Reposit

 		}

 	}

 	if !success {

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

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

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

 		return err

 	}

@@ -54,19 +54,11 @@ func (p *v2Puller) Pull(ctx context.Context, ref reference.Named) (fallback bool

 func (p *v2Puller) pullV2Repository(ctx context.Context, ref reference.Named) (err error) {

 	var refs []reference.Named

-	taggedName := p.repoInfo.LocalName

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

-		taggedName, err = reference.WithTag(p.repoInfo.LocalName, tagged.Tag())

-		if err != nil {

-			return err

-		}

-		refs = []reference.Named{taggedName}

-	} else if digested, isCanonical := ref.(reference.Canonical); isCanonical {

-		taggedName, err = reference.WithDigest(p.repoInfo.LocalName, digested.Digest())

-		if err != nil {

-			return err

-		}

-		refs = []reference.Named{taggedName}

+	taggedName := ref

+	if _, isTagged := ref.(reference.NamedTagged); isTagged {

+		refs = []reference.Named{ref}

+	} else if _, isCanonical := ref.(reference.Canonical); isCanonical {

+		refs = []reference.Named{ref}

 	} else {

 		manSvc, err := p.repo.Manifests(ctx)

 		if err != nil {

@@ -81,7 +73,7 @@ func (p *v2Puller) pullV2Repository(ctx context.Context, ref reference.Named) (e

 		// This probably becomes a lot nicer after the manifest

 		// refactor...

 		for _, tag := range tags {

-			tagRef, err := reference.WithTag(p.repoInfo.LocalName, tag)

+			tagRef, err := reference.WithTag(ref, tag)

 			if err != nil {

 				return err

 			}

@@ -291,7 +283,7 @@ func (p *v2Puller) pullV2Tag(ctx context.Context, ref reference.Named) (tagUpdat

 		return false, err

 	}

-	manifestDigest, _, err := digestFromManifest(unverifiedManifest, p.repoInfo.LocalName.Name())

+	manifestDigest, _, err := digestFromManifest(unverifiedManifest, p.repoInfo)

 	if err != nil {

 		return false, err

 	}

@@ -104,21 +104,21 @@ func Push(ctx context.Context, ref reference.Named, imagePushConfig *ImagePushCo

 		return err

 	}

-	endpoints, err := imagePushConfig.RegistryService.LookupPushEndpoints(repoInfo.CanonicalName)

+	endpoints, err := imagePushConfig.RegistryService.LookupPushEndpoints(repoInfo)

 	if err != nil {

 		return err

 	}

-	progress.Messagef(imagePushConfig.ProgressOutput, "", "The push refers to a repository [%s]", repoInfo.CanonicalName.String())

+	progress.Messagef(imagePushConfig.ProgressOutput, "", "The push refers to a repository [%s]", repoInfo.FullName())

-	associations := imagePushConfig.ReferenceStore.ReferencesByName(repoInfo.LocalName)

+	associations := imagePushConfig.ReferenceStore.ReferencesByName(repoInfo)

 	if len(associations) == 0 {

-		return fmt.Errorf("Repository does not exist: %s", repoInfo.LocalName)

+		return fmt.Errorf("Repository does not exist: %s", repoInfo.Name())

 	}

 	var lastErr error

 	for _, endpoint := range endpoints {

-		logrus.Debugf("Trying to push %s to %s %s", repoInfo.CanonicalName, endpoint.URL, endpoint.Version)

+		logrus.Debugf("Trying to push %s to %s %s", repoInfo.FullName(), endpoint.URL, endpoint.Version)

 		pusher, err := NewPusher(ref, endpoint, repoInfo, imagePushConfig)

 		if err != nil {

@@ -143,12 +143,12 @@ func Push(ctx context.Context, ref reference.Named, imagePushConfig *ImagePushCo

 		}

-		imagePushConfig.EventsService.Log("push", repoInfo.LocalName.Name(), "")

+		imagePushConfig.EventsService.Log("push", repoInfo.Name(), "")

 		return nil

 	}

 	if lastErr == nil {

-		lastErr = fmt.Errorf("no endpoints found for %s", repoInfo.CanonicalName)

+		lastErr = fmt.Errorf("no endpoints found for %s", repoInfo.FullName())

 	}

 	return lastErr

 }

@@ -351,8 +351,8 @@ func (p *v1Pusher) pushImageToEndpoint(ctx context.Context, endpoint string, ima

 		}

 		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/"+p.repoInfo.RemoteName.Name()+"/tags/"+tag)

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

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

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

 					return err

 				}

 			}

@@ -381,18 +381,18 @@ func (p *v1Pusher) pushRepository(ctx context.Context) error {

 	// 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.RemoteName, imageIndex, false, nil)

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

 	if err != nil {

 		return err

 	}

-	progress.Message(p.config.ProgressOutput, "", "Pushing repository "+p.repoInfo.CanonicalName.String())

+	progress.Message(p.config.ProgressOutput, "", "Pushing repository "+p.repoInfo.FullName())

 	// 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.RemoteName, imageIndex, true, repoData.Endpoints)

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

 	return err

 }

@@ -52,8 +52,6 @@ func (p *v2Pusher) Push(ctx context.Context) (fallback bool, err error) {

 		return true, err

 	}

-	localName := p.repoInfo.LocalName.Name()

-

 	var associations []reference.Association

 	if _, isTagged := p.ref.(reference.NamedTagged); isTagged {

 		imageID, err := p.config.ReferenceStore.Get(p.ref)

@@ -72,10 +70,10 @@ func (p *v2Pusher) Push(ctx context.Context) (fallback bool, err error) {

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

 	}

 	if err != nil {

-		return false, fmt.Errorf("error getting tags for %s: %s", localName, err)

+		return false, fmt.Errorf("error getting tags for %s: %s", p.repoInfo.Name(), err)

 	}

 	if len(associations) == 0 {

-		return false, fmt.Errorf("no tags to push for %s", localName)

+		return false, fmt.Errorf("no tags to push for %s", p.repoInfo.Name())

 	}

 	for _, association := range associations {

@@ -159,7 +157,7 @@ func (p *v2Pusher) pushV2Tag(ctx context.Context, association reference.Associat

 		return err

 	}

-	manifestDigest, manifestSize, err := digestFromManifest(signed, p.repo.Name())

+	manifestDigest, manifestSize, err := digestFromManifest(signed, ref)

 	if err != nil {

 		return err

 	}

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

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

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

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

+	"github.com/docker/docker/reference"

 	"github.com/docker/docker/registry"

 	"golang.org/x/net/context"

 )

@@ -37,10 +38,10 @@ func (dcs dumbCredentialStore) Basic(*url.URL) (string, string) {

 func NewV2Repository(repoInfo *registry.RepositoryInfo, endpoint registry.APIEndpoint, metaHeaders http.Header, authConfig *types.AuthConfig, actions ...string) (distribution.Repository, error) {

 	ctx := context.Background()

-	repoName := repoInfo.CanonicalName

+	repoName := repoInfo.FullName()

 	// If endpoint does not support CanonicalName, use the RemoteName instead

 	if endpoint.TrimHostname {

-		repoName = repoInfo.RemoteName

+		repoName = repoInfo.RemoteName()

 	}

 	// TODO(dmcgowan): Call close idle connections when complete, use keep alive

@@ -99,16 +100,16 @@ func NewV2Repository(repoInfo *registry.RepositoryInfo, endpoint registry.APIEnd

 		modifiers = append(modifiers, auth.NewAuthorizer(challengeManager, passThruTokenHandler))

 	} else {

 		creds := dumbCredentialStore{auth: authConfig}

-		tokenHandler := auth.NewTokenHandler(authTransport, creds, repoName.Name(), actions...)

+		tokenHandler := auth.NewTokenHandler(authTransport, creds, repoName, actions...)

 		basicHandler := auth.NewBasicHandler(creds)

 		modifiers = append(modifiers, auth.NewAuthorizer(challengeManager, tokenHandler, basicHandler))

 	}

 	tr := transport.NewTransport(base, modifiers...)

-	return client.NewRepository(ctx, repoName.Name(), endpoint.URL, tr)

+	return client.NewRepository(ctx, repoName, endpoint.URL, tr)

 }

-func digestFromManifest(m *schema1.SignedManifest, localName string) (digest.Digest, int, error) {

+func digestFromManifest(m *schema1.SignedManifest, name reference.Named) (digest.Digest, int, error) {

 	payload, err := m.Payload()

 	if err != nil {

 		// If this failed, the signatures section was corrupted

@@ -117,7 +118,7 @@ func digestFromManifest(m *schema1.SignedManifest, localName string) (digest.Dig

 	}

 	manifestDigest, err := digest.FromBytes(payload)

 	if err != nil {

-		logrus.Infof("Could not compute manifest digest for %s:%s : %v", localName, m.Tag, err)

+		logrus.Infof("Could not compute manifest digest for %s:%s : %v", name.Name(), m.Tag, err)

 	}

 	return manifestDigest, len(payload), nil

 }

@@ -58,16 +58,14 @@ func TestTokenPassThru(t *testing.T) {

 	}

 	n, _ := reference.ParseNamed("testremotename")

 	repoInfo := &registry.RepositoryInfo{

+		Named: n,

 		Index: &registrytypes.IndexInfo{

 			Name:     "testrepo",

 			Mirrors:  nil,

 			Secure:   false,

 			Official: false,

 		},

-		RemoteName:    n,

-		LocalName:     n,

-		CanonicalName: n,

-		Official:      false,

+		Official: false,

 	}

 	imagePullConfig := &ImagePullConfig{

 		MetaHeaders: http.Header{},

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

 	"github.com/docker/docker/layer"

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

 	"github.com/docker/docker/reference"

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

 )

 type imageDescriptor struct {

@@ -74,7 +73,6 @@ func (l *tarexporter) parseNames(names []string) (map[image.ID]*imageDescriptor,

 		if err != nil {

 			return nil, err

 		}

-		ref = registry.NormalizeLocalReference(ref)

 		if ref.Name() == string(digest.Canonical) {

 			imgID, err := l.is.Search(name)

 			if err != nil {

@@ -1,21 +1,37 @@

 package reference

 import (

+	"fmt"

+	"strings"

+

 	"github.com/docker/distribution/digest"

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

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

 )

-// Reference is an opaque object reference identifier that may include

-// modifiers such as a hostname, name, tag, and digest.

-type Reference interface {

-	// String returns the full reference

-	String() string

-}

+const (

+	// DefaultTag defines the default tag used when performing images related actions and no tag or digest is specified

+	DefaultTag = "latest"

+	// DefaultHostname is the default built-in hostname

+	DefaultHostname = "docker.io"

+	// LegacyDefaultHostname is automatically converted to DefaultHostname

+	LegacyDefaultHostname = "index.docker.io"

+	// DefaultRepoPrefix is the prefix used for default repositories in default host

+	DefaultRepoPrefix = "library/"

+)

 // Named is an object with a full name

 type Named interface {

-	Reference

+	// Name returns normalized repository name, like "ubuntu".

 	Name() string

+	// String returns full reference, like "ubuntu@sha256:abcdef..."

+	String() string

+	// FullName returns full repository name with hostname, like "docker.io/library/ubuntu"

+	FullName() string

+	// Hostname returns hostname for the reference, like "docker.io"

+	Hostname() string

+	// RemoteName returns the repository component of the full name, like "library/ubuntu"

+	RemoteName() string

 }

 // NamedTagged is an object including a name and tag.

@@ -35,26 +51,122 @@ type Canonical interface {

 // the Named interface. The reference must have a name, otherwise an error is

 // returned.

 // If an error was encountered it is returned, along with a nil Reference.

-// NOTE: ParseNamed will not handle short digests.

 func ParseNamed(s string) (Named, error) {

-	// todo: docker specific validation

-	return distreference.ParseNamed(s)

+	named, err := distreference.ParseNamed(s)

+	if err != nil {

+		return nil, err

+	}

+	r, err := WithName(named.Name())

+	if err != nil {

+		return nil, err

+	}

+	if canonical, isCanonical := named.(distreference.Canonical); isCanonical {

+		return WithDigest(r, canonical.Digest())

+	}

+	if tagged, isTagged := named.(distreference.NamedTagged); isTagged {

+		return WithTag(r, tagged.Tag())

+	}

+	return r, nil

 }

 // WithName returns a named object representing the given string. If the input

 // is invalid ErrReferenceInvalidFormat will be returned.

 func WithName(name string) (Named, error) {

-	return distreference.WithName(name)

+	name = normalize(name)

+	if err := validateName(name); err != nil {

+		return nil, err

+	}

+	r, err := distreference.WithName(name)

+	if err != nil {

+		return nil, err

+	}

+	return &namedRef{r}, nil

 }

 // WithTag combines the name from "name" and the tag from "tag" to form a

 // reference incorporating both the name and the tag.

 func WithTag(name Named, tag string) (NamedTagged, error) {

-	return distreference.WithTag(name, tag)

+	r, err := distreference.WithTag(name, tag)

+	if err != nil {

+		return nil, err

+	}

+	return &taggedRef{namedRef{r}}, nil

 }

 // WithDigest combines the name from "name" and the digest from "digest" to form

 // a reference incorporating both the name and the digest.

 func WithDigest(name Named, digest digest.Digest) (Canonical, error) {

-	return distreference.WithDigest(name, digest)

+	r, err := distreference.WithDigest(name, digest)

+	if err != nil {

+		return nil, err

+	}

+	return &canonicalRef{namedRef{r}}, nil

+}

+

+type namedRef struct {

+	distreference.Named

+}

+type taggedRef struct {

+	namedRef

+}

+type canonicalRef struct {

+	namedRef

+}

+

+func (r *namedRef) FullName() string {

+	hostname, remoteName := splitHostname(r.Name())

+	return hostname + "/" + remoteName

+}

+func (r *namedRef) Hostname() string {

+	hostname, _ := splitHostname(r.Name())

+	return hostname

+}

+func (r *namedRef) RemoteName() string {

+	_, remoteName := splitHostname(r.Name())

+	return remoteName

+}

+func (r *taggedRef) Tag() string {

+	return r.namedRef.Named.(distreference.NamedTagged).Tag()

+}

+func (r *canonicalRef) Digest() digest.Digest {

+	return r.namedRef.Named.(distreference.Canonical).Digest()

+}

+

+// splitHostname splits a repository name to hostname and remotename string.

+// If no valid hostname is found, the default hostname is used. Repository name

+// needs to be already validated before.

+func splitHostname(name string) (hostname, remoteName string) {

+	i := strings.IndexRune(name, '/')

+	if i == -1 || (!strings.ContainsAny(name[:i], ".:") && name[:i] != "localhost") {

+		hostname, remoteName = DefaultHostname, name

+	} else {

+		hostname, remoteName = name[:i], name[i+1:]

+	}

+	if hostname == LegacyDefaultHostname {

+		hostname = DefaultHostname

+	}

+	if hostname == DefaultHostname && !strings.ContainsRune(remoteName, '/') {

+		remoteName = DefaultRepoPrefix + remoteName

+	}

+	return

+}

+

+// normalize returns a repository name in its normalized form, meaning it

+// will not contain default hostname nor library/ prefix for official images.

+func normalize(name string) string {

+	host, remoteName := splitHostname(name)

+	if host == DefaultHostname {

+		if strings.HasPrefix(remoteName, DefaultRepoPrefix) {

+			return strings.TrimPrefix(remoteName, DefaultRepoPrefix)

+		}

+		return remoteName

+	}

+	return name

+}

+

+func validateName(name string) error {

+	if err := v1.ValidateID(name); err == nil {

+		return fmt.Errorf("Invalid repository name (%s), cannot specify 64-byte hexadecimal strings", name)

+	}

+	return nil

 }

new file mode 100644

@@ -0,0 +1,275 @@

+package reference

+

+import (

+	"testing"

+

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

+)

+

+func TestValidateReferenceName(t *testing.T) {

+	validRepoNames := []string{

+		"docker/docker",

+		"library/debian",

+		"debian",

+		"docker.io/docker/docker",

+		"docker.io/library/debian",

+		"docker.io/debian",

+		"index.docker.io/docker/docker",

+		"index.docker.io/library/debian",

+		"index.docker.io/debian",

+		"127.0.0.1:5000/docker/docker",

+		"127.0.0.1:5000/library/debian",

+		"127.0.0.1:5000/debian",

+		"thisisthesongthatneverendsitgoesonandonandonthisisthesongthatnev",

+	}

+	invalidRepoNames := []string{

+		"https://github.com/docker/docker",

+		"docker/Docker",

+		"-docker",

+		"-docker/docker",

+		"-docker.io/docker/docker",

+		"docker///docker",

+		"docker.io/docker/Docker",

+		"docker.io/docker///docker",

+		"1a3f5e7d9c1b3a5f7e9d1c3b5a7f9e1d3c5b7a9f1e3d5d7c9b1a3f5e7d9c1b3a",

+		"docker.io/1a3f5e7d9c1b3a5f7e9d1c3b5a7f9e1d3c5b7a9f1e3d5d7c9b1a3f5e7d9c1b3a",

+	}

+

+	for _, name := range invalidRepoNames {

+		_, err := ParseNamed(name)

+		if err == nil {

+			t.Fatalf("Expected invalid repo name for %q", name)

+		}

+	}

+

+	for _, name := range validRepoNames {

+		_, err := ParseNamed(name)

+		if err != nil {

+			t.Fatalf("Error parsing repo name %s, got: %q", name, err)

+		}

+	}

+}

+

+func TestValidateRemoteName(t *testing.T) {

+	validRepositoryNames := []string{

+		// Sanity check.

+		"docker/docker",

+

+		// Allow 64-character non-hexadecimal names (hexadecimal names are forbidden).

+		"thisisthesongthatneverendsitgoesonandonandonthisisthesongthatnev",

+

+		// Allow embedded hyphens.

+		"docker-rules/docker",

+

+		// Allow multiple hyphens as well.

+		"docker---rules/docker",

+

+		//Username doc and image name docker being tested.

+		"doc/docker",

+

+		// single character names are now allowed.

+		"d/docker",

+		"jess/t",

+

+		// Consecutive underscores.

+		"dock__er/docker",

+	}

+	for _, repositoryName := range validRepositoryNames {

+		_, err := ParseNamed(repositoryName)

+		if err != nil {

+			t.Errorf("Repository name should be valid: %v. Error: %v", repositoryName, err)

+		}

+	}

+

+	invalidRepositoryNames := []string{

+		// Disallow capital letters.

+		"docker/Docker",

+

+		// Only allow one slash.

+		"docker///docker",

+

+		// Disallow 64-character hexadecimal.

+		"1a3f5e7d9c1b3a5f7e9d1c3b5a7f9e1d3c5b7a9f1e3d5d7c9b1a3f5e7d9c1b3a",

+

+		// Disallow leading and trailing hyphens in namespace.

+		"-docker/docker",

+		"docker-/docker",

+		"-docker-/docker",

+

+		// Don't allow underscores everywhere (as opposed to hyphens).

+		"____/____",

+

+		"_docker/_docker",

+

+		// Disallow consecutive periods.

+		"dock..er/docker",

+		"dock_.er/docker",

+		"dock-.er/docker",

+

+		// No repository.

+		"docker/",

+

+		//namespace too long

+		"this_is_not_a_valid_namespace_because_its_lenth_is_greater_than_255_this_is_not_a_valid_namespace_because_its_lenth_is_greater_than_255_this_is_not_a_valid_namespace_because_its_lenth_is_greater_than_255_this_is_not_a_valid_namespace_because_its_lenth_is_greater_than_255/docker",

+	}

+	for _, repositoryName := range invalidRepositoryNames {

+		if _, err := ParseNamed(repositoryName); err == nil {

+			t.Errorf("Repository name should be invalid: %v", repositoryName)

+		}

+	}

+}

+

+func TestParseRepositoryInfo(t *testing.T) {

+	type tcase struct {

+		RemoteName, NormalizedName, FullName, AmbiguousName, Hostname string

+	}

+

+	tcases := []tcase{

+		{

+			RemoteName:     "fooo/bar",

+			NormalizedName: "fooo/bar",

+			FullName:       "docker.io/fooo/bar",

+			AmbiguousName:  "index.docker.io/fooo/bar",

+			Hostname:       "docker.io",

+		},

+		{

+			RemoteName:     "library/ubuntu",

+			NormalizedName: "ubuntu",

+			FullName:       "docker.io/library/ubuntu",

+			AmbiguousName:  "library/ubuntu",

+			Hostname:       "docker.io",

+		},

+		{

+			RemoteName:     "nonlibrary/ubuntu",

+			NormalizedName: "nonlibrary/ubuntu",

+			FullName:       "docker.io/nonlibrary/ubuntu",

+			AmbiguousName:  "",

+			Hostname:       "docker.io",

+		},

+		{

+			RemoteName:     "other/library",

+			NormalizedName: "other/library",

+			FullName:       "docker.io/other/library",

+			AmbiguousName:  "",