@@ -55,7 +55,7 @@ func (s *TagStore) CmdPull(job *engine.Job) engine.Status {

 		return job.Error(err)

 	}

-	r, err := registry.NewRegistry(authConfig, registry.HTTPRequestFactory(metaHeaders), endpoint, true)

+	r, err := registry.NewSession(authConfig, registry.HTTPRequestFactory(metaHeaders), endpoint, true)

 	if err != nil {

 		return job.Error(err)

 	}

@@ -72,7 +72,7 @@ func (s *TagStore) CmdPull(job *engine.Job) engine.Status {

 	return engine.StatusOK

 }

-func (s *TagStore) pullRepository(r *registry.Registry, out io.Writer, localName, remoteName, askedTag string, sf *utils.StreamFormatter, parallel bool) error {

+func (s *TagStore) pullRepository(r *registry.Session, out io.Writer, localName, remoteName, askedTag string, sf *utils.StreamFormatter, parallel bool) error {

 	out.Write(sf.FormatStatus("", "Pulling repository %s", localName))

 	repoData, err := r.GetRepositoryData(remoteName)

@@ -210,7 +210,7 @@ func (s *TagStore) pullRepository(r *registry.Registry, out io.Writer, localName

 	return nil

 }

-func (s *TagStore) pullImage(r *registry.Registry, out io.Writer, imgID, endpoint string, token []string, sf *utils.StreamFormatter) error {

+func (s *TagStore) pullImage(r *registry.Session, out io.Writer, imgID, endpoint string, token []string, sf *utils.StreamFormatter) error {

 	history, err := r.GetRemoteHistory(imgID, endpoint, token)

 	if err != nil {

 		return err

@@ -60,7 +60,7 @@ func (s *TagStore) getImageList(localRepo map[string]string, requestedTag string

 	return imageList, tagsByImage, nil

 }

-func (s *TagStore) pushRepository(r *registry.Registry, out io.Writer, localName, remoteName string, localRepo map[string]string, tag string, sf *utils.StreamFormatter) error {

+func (s *TagStore) pushRepository(r *registry.Session, out io.Writer, localName, remoteName string, localRepo map[string]string, tag string, sf *utils.StreamFormatter) error {

 	out = utils.NewWriteFlusher(out)

 	utils.Debugf("Local repo: %s", localRepo)

 	imgList, tagsByImage, err := s.getImageList(localRepo, tag)

@@ -142,7 +142,7 @@ func (s *TagStore) pushRepository(r *registry.Registry, out io.Writer, localName

 	return nil

 }

-func (s *TagStore) pushImage(r *registry.Registry, out io.Writer, remote, imgID, ep string, token []string, sf *utils.StreamFormatter) (checksum string, err error) {

+func (s *TagStore) pushImage(r *registry.Session, out io.Writer, remote, imgID, ep string, token []string, sf *utils.StreamFormatter) (checksum string, err error) {

 	out = utils.NewWriteFlusher(out)

 	jsonRaw, err := ioutil.ReadFile(path.Join(s.graph.Root, imgID, "json"))

 	if err != nil {

@@ -219,7 +219,7 @@ func (s *TagStore) CmdPush(job *engine.Job) engine.Status {

 	}

 	img, err := s.graph.Get(localName)

-	r, err2 := registry.NewRegistry(authConfig, registry.HTTPRequestFactory(metaHeaders), endpoint, false)

+	r, err2 := registry.NewSession(authConfig, registry.HTTPRequestFactory(metaHeaders), endpoint, false)

 	if err2 != nil {

 		return job.Error(err2)

 	}

new file mode 100644

@@ -0,0 +1,46 @@

+package registry

+

+import (

+	"runtime"

+

+	"github.com/docker/docker/dockerversion"

+	"github.com/docker/docker/pkg/parsers/kernel"

+	"github.com/docker/docker/utils"

+)

+

+func HTTPRequestFactory(metaHeaders map[string][]string) *utils.HTTPRequestFactory {

+	// FIXME: this replicates the 'info' job.

+	httpVersion := make([]utils.VersionInfo, 0, 4)

+	httpVersion = append(httpVersion, &simpleVersionInfo{"docker", dockerversion.VERSION})

+	httpVersion = append(httpVersion, &simpleVersionInfo{"go", runtime.Version()})

+	httpVersion = append(httpVersion, &simpleVersionInfo{"git-commit", dockerversion.GITCOMMIT})

+	if kernelVersion, err := kernel.GetKernelVersion(); err == nil {

+		httpVersion = append(httpVersion, &simpleVersionInfo{"kernel", kernelVersion.String()})

+	}

+	httpVersion = append(httpVersion, &simpleVersionInfo{"os", runtime.GOOS})

+	httpVersion = append(httpVersion, &simpleVersionInfo{"arch", runtime.GOARCH})

+	ud := utils.NewHTTPUserAgentDecorator(httpVersion...)

+	md := &utils.HTTPMetaHeadersDecorator{

+		Headers: metaHeaders,

+	}

+	factory := utils.NewHTTPRequestFactory(ud, md)

+	return factory

+}

+

+// simpleVersionInfo is a simple implementation of

+// the interface VersionInfo, which is used

+// to provide version information for some product,

+// component, etc. It stores the product name and the version

+// in string and returns them on calls to Name() and Version().

+type simpleVersionInfo struct {

+	name    string

+	version string

+}

+

+func (v *simpleVersionInfo) Name() string {

+	return v.name

+}

+

+func (v *simpleVersionInfo) Version() string {

+	return v.version

+}

@@ -1,33 +1,20 @@

 package registry

 import (

-	"bytes"

-	"crypto/sha256"

-	_ "crypto/sha512"

 	"crypto/tls"

 	"crypto/x509"

-	"encoding/hex"

 	"encoding/json"

 	"errors"

 	"fmt"

-	"io"

 	"io/ioutil"

 	"net"

 	"net/http"

-	"net/http/cookiejar"

-	"net/url"

 	"os"

 	"path"

 	"regexp"

-	"runtime"

-	"strconv"

 	"strings"

 	"time"

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

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

-	"github.com/docker/docker/pkg/parsers/kernel"

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

 	"github.com/docker/docker/utils"

 )

@@ -297,595 +284,6 @@ func ExpandAndVerifyRegistryUrl(hostname string) (string, error) {

 	return endpoint, nil

 }

-func setTokenAuth(req *http.Request, token []string) {

-	if req.Header.Get("Authorization") == "" { // Don't override

-		req.Header.Set("Authorization", "Token "+strings.Join(token, ","))

-	}

-}

-

-func (r *Registry) doRequest(req *http.Request) (*http.Response, *http.Client, error) {

-	return doRequest(req, r.jar, r.timeout)

-}

-

-// Retrieve the history of a given image from the Registry.

-// Return a list of the parent's json (requested image included)

-func (r *Registry) GetRemoteHistory(imgID, registry string, token []string) ([]string, error) {

-	req, err := r.reqFactory.NewRequest("GET", registry+"images/"+imgID+"/ancestry", nil)

-	if err != nil {

-		return nil, err

-	}

-	setTokenAuth(req, token)

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return nil, err

-	}

-	defer res.Body.Close()

-	if res.StatusCode != 200 {

-		if res.StatusCode == 401 {

-			return nil, errLoginRequired

-		}

-		return nil, utils.NewHTTPRequestError(fmt.Sprintf("Server error: %d trying to fetch remote history for %s", res.StatusCode, imgID), res)

-	}

-

-	jsonString, err := ioutil.ReadAll(res.Body)

-	if err != nil {

-		return nil, fmt.Errorf("Error while reading the http response: %s", err)

-	}

-

-	utils.Debugf("Ancestry: %s", jsonString)

-	history := new([]string)

-	if err := json.Unmarshal(jsonString, history); err != nil {

-		return nil, err

-	}

-	return *history, nil

-}

-

-// Check if an image exists in the Registry

-// TODO: This method should return the errors instead of masking them and returning false

-func (r *Registry) LookupRemoteImage(imgID, registry string, token []string) bool {

-

-	req, err := r.reqFactory.NewRequest("GET", registry+"images/"+imgID+"/json", nil)

-	if err != nil {

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

-		return false

-	}

-	setTokenAuth(req, token)

-	res, _, err := r.doRequest(req)

-	if err != nil {

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

-		return false

-	}

-	res.Body.Close()

-	return res.StatusCode == 200

-}

-

-// Retrieve an image from the Registry.

-func (r *Registry) GetRemoteImageJSON(imgID, registry string, token []string) ([]byte, int, error) {

-	// Get the JSON

-	req, err := r.reqFactory.NewRequest("GET", registry+"images/"+imgID+"/json", nil)

-	if err != nil {

-		return nil, -1, fmt.Errorf("Failed to download json: %s", err)

-	}

-	setTokenAuth(req, token)

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return nil, -1, fmt.Errorf("Failed to download json: %s", err)

-	}

-	defer res.Body.Close()

-	if res.StatusCode != 200 {

-		return nil, -1, utils.NewHTTPRequestError(fmt.Sprintf("HTTP code %d", res.StatusCode), res)

-	}

-

-	// if the size header is not present, then set it to '-1'

-	imageSize := -1

-	if hdr := res.Header.Get("X-Docker-Size"); hdr != "" {

-		imageSize, err = strconv.Atoi(hdr)

-		if err != nil {

-			return nil, -1, err

-		}

-	}

-

-	jsonString, err := ioutil.ReadAll(res.Body)

-	if err != nil {

-		return nil, -1, fmt.Errorf("Failed to parse downloaded json: %s (%s)", err, jsonString)

-	}

-	return jsonString, imageSize, nil

-}

-

-func (r *Registry) GetRemoteImageLayer(imgID, registry string, token []string, imgSize int64) (io.ReadCloser, error) {

-	var (

-		retries  = 5

-		client   *http.Client

-		res      *http.Response

-		imageURL = fmt.Sprintf("%simages/%s/layer", registry, imgID)

-	)

-

-	req, err := r.reqFactory.NewRequest("GET", imageURL, nil)

-	if err != nil {

-		return nil, fmt.Errorf("Error while getting from the server: %s\n", err)

-	}

-	setTokenAuth(req, token)

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

-		res, client, err = r.doRequest(req)

-		if err != nil {

-			res.Body.Close()

-			if i == retries {

-				return nil, fmt.Errorf("Server error: Status %d while fetching image layer (%s)",

-					res.StatusCode, imgID)

-			}

-			time.Sleep(time.Duration(i) * 5 * time.Second)

-			continue

-		}

-		break

-	}

-

-	if res.StatusCode != 200 {

-		res.Body.Close()

-		return nil, fmt.Errorf("Server error: Status %d while fetching image layer (%s)",

-			res.StatusCode, imgID)

-	}

-

-	if res.Header.Get("Accept-Ranges") == "bytes" && imgSize > 0 {

-		utils.Debugf("server supports resume")

-		return httputils.ResumableRequestReaderWithInitialResponse(client, req, 5, imgSize, res), nil

-	}

-	utils.Debugf("server doesn't support resume")

-	return res.Body, nil

-}

-

-func (r *Registry) GetRemoteTags(registries []string, repository string, token []string) (map[string]string, error) {

-	if strings.Count(repository, "/") == 0 {

-		// This will be removed once the Registry supports auto-resolution on

-		// the "library" namespace

-		repository = "library/" + repository

-	}

-	for _, host := range registries {

-		endpoint := fmt.Sprintf("%srepositories/%s/tags", host, repository)

-		req, err := r.reqFactory.NewRequest("GET", endpoint, nil)

-

-		if err != nil {

-			return nil, err

-		}

-		setTokenAuth(req, token)

-		res, _, err := r.doRequest(req)

-		if err != nil {

-			return nil, err

-		}

-

-		utils.Debugf("Got status code %d from %s", res.StatusCode, endpoint)

-		defer res.Body.Close()

-

-		if res.StatusCode != 200 && res.StatusCode != 404 {

-			continue

-		} else if res.StatusCode == 404 {

-			return nil, fmt.Errorf("Repository not found")

-		}

-

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

-		rawJSON, err := ioutil.ReadAll(res.Body)

-		if err != nil {

-			return nil, err

-		}

-		if err := json.Unmarshal(rawJSON, &result); err != nil {

-			return nil, err

-		}

-		return result, nil

-	}

-	return nil, fmt.Errorf("Could not reach any registry endpoint")

-}

-

-func buildEndpointsList(headers []string, indexEp string) ([]string, error) {

-	var endpoints []string

-	parsedUrl, err := url.Parse(indexEp)

-	if err != nil {

-		return nil, err

-	}

-	var urlScheme = parsedUrl.Scheme

-	// The Registry's URL scheme has to match the Index'

-	for _, ep := range headers {

-		epList := strings.Split(ep, ",")

-		for _, epListElement := range epList {

-			endpoints = append(

-				endpoints,

-				fmt.Sprintf("%s://%s/v1/", urlScheme, strings.TrimSpace(epListElement)))

-		}

-	}

-	return endpoints, nil

-}

-

-func (r *Registry) GetRepositoryData(remote string) (*RepositoryData, error) {

-	indexEp := r.indexEndpoint

-	repositoryTarget := fmt.Sprintf("%srepositories/%s/images", indexEp, remote)

-

-	utils.Debugf("[registry] Calling GET %s", repositoryTarget)

-

-	req, err := r.reqFactory.NewRequest("GET", repositoryTarget, nil)

-	if err != nil {

-		return nil, err

-	}

-	if r.authConfig != nil && len(r.authConfig.Username) > 0 {

-		req.SetBasicAuth(r.authConfig.Username, r.authConfig.Password)

-	}

-	req.Header.Set("X-Docker-Token", "true")

-

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return nil, err

-	}

-	defer res.Body.Close()

-	if res.StatusCode == 401 {

-		return nil, errLoginRequired

-	}

-	// TODO: Right now we're ignoring checksums in the response body.

-	// In the future, we need to use them to check image validity.

-	if res.StatusCode != 200 {

-		return nil, utils.NewHTTPRequestError(fmt.Sprintf("HTTP code: %d", res.StatusCode), res)

-	}

-

-	var tokens []string

-	if res.Header.Get("X-Docker-Token") != "" {

-		tokens = res.Header["X-Docker-Token"]

-	}

-

-	var endpoints []string

-	if res.Header.Get("X-Docker-Endpoints") != "" {

-		endpoints, err = buildEndpointsList(res.Header["X-Docker-Endpoints"], indexEp)

-		if err != nil {

-			return nil, err

-		}

-	} else {

-		// Assume the endpoint is on the same host

-		u, err := url.Parse(indexEp)

-		if err != nil {

-			return nil, err

-		}

-		endpoints = append(endpoints, fmt.Sprintf("%s://%s/v1/", u.Scheme, req.URL.Host))

-	}

-

-	checksumsJSON, err := ioutil.ReadAll(res.Body)

-	if err != nil {

-		return nil, err

-	}

-	remoteChecksums := []*ImgData{}

-	if err := json.Unmarshal(checksumsJSON, &remoteChecksums); err != nil {

-		return nil, err

-	}

-

-	// Forge a better object from the retrieved data

-	imgsData := make(map[string]*ImgData)

-	for _, elem := range remoteChecksums {

-		imgsData[elem.ID] = elem

-	}

-

-	return &RepositoryData{

-		ImgList:   imgsData,

-		Endpoints: endpoints,

-		Tokens:    tokens,

-	}, nil

-}

-

-func (r *Registry) PushImageChecksumRegistry(imgData *ImgData, registry string, token []string) error {

-

-	utils.Debugf("[registry] Calling PUT %s", registry+"images/"+imgData.ID+"/checksum")

-

-	req, err := r.reqFactory.NewRequest("PUT", registry+"images/"+imgData.ID+"/checksum", nil)

-	if err != nil {

-		return err

-	}

-	setTokenAuth(req, token)

-	req.Header.Set("X-Docker-Checksum", imgData.Checksum)

-	req.Header.Set("X-Docker-Checksum-Payload", imgData.ChecksumPayload)

-

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return fmt.Errorf("Failed to upload metadata: %s", err)

-	}

-	defer res.Body.Close()

-	if len(res.Cookies()) > 0 {

-		r.jar.SetCookies(req.URL, res.Cookies())

-	}

-	if res.StatusCode != 200 {

-		errBody, err := ioutil.ReadAll(res.Body)

-		if err != nil {

-			return fmt.Errorf("HTTP code %d while uploading metadata and error when trying to parse response body: %s", res.StatusCode, err)

-		}

-		var jsonBody map[string]string

-		if err := json.Unmarshal(errBody, &jsonBody); err != nil {

-			errBody = []byte(err.Error())

-		} else if jsonBody["error"] == "Image already exists" {

-			return ErrAlreadyExists

-		}

-		return fmt.Errorf("HTTP code %d while uploading metadata: %s", res.StatusCode, errBody)

-	}

-	return nil

-}

-

-// Push a local image to the registry

-func (r *Registry) PushImageJSONRegistry(imgData *ImgData, jsonRaw []byte, registry string, token []string) error {

-

-	utils.Debugf("[registry] Calling PUT %s", registry+"images/"+imgData.ID+"/json")

-

-	req, err := r.reqFactory.NewRequest("PUT", registry+"images/"+imgData.ID+"/json", bytes.NewReader(jsonRaw))

-	if err != nil {

-		return err

-	}

-	req.Header.Add("Content-type", "application/json")

-	setTokenAuth(req, token)

-

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return fmt.Errorf("Failed to upload metadata: %s", err)

-	}

-	defer res.Body.Close()

-	if res.StatusCode == 401 && strings.HasPrefix(registry, "http://") {

-		return utils.NewHTTPRequestError("HTTP code 401, Docker will not send auth headers over HTTP.", res)

-	}

-	if res.StatusCode != 200 {

-		errBody, err := ioutil.ReadAll(res.Body)

-		if err != nil {

-			return utils.NewHTTPRequestError(fmt.Sprintf("HTTP code %d while uploading metadata and error when trying to parse response body: %s", res.StatusCode, err), res)

-		}

-		var jsonBody map[string]string

-		if err := json.Unmarshal(errBody, &jsonBody); err != nil {

-			errBody = []byte(err.Error())

-		} else if jsonBody["error"] == "Image already exists" {

-			return ErrAlreadyExists

-		}

-		return utils.NewHTTPRequestError(fmt.Sprintf("HTTP code %d while uploading metadata: %s", res.StatusCode, errBody), res)

-	}

-	return nil

-}

-

-func (r *Registry) PushImageLayerRegistry(imgID string, layer io.Reader, registry string, token []string, jsonRaw []byte) (checksum string, checksumPayload string, err error) {

-

-	utils.Debugf("[registry] Calling PUT %s", registry+"images/"+imgID+"/layer")

-

-	tarsumLayer := &tarsum.TarSum{Reader: layer}

-	h := sha256.New()

-	h.Write(jsonRaw)

-	h.Write([]byte{'\n'})

-	checksumLayer := io.TeeReader(tarsumLayer, h)

-

-	req, err := r.reqFactory.NewRequest("PUT", registry+"images/"+imgID+"/layer", checksumLayer)

-	if err != nil {

-		return "", "", err

-	}

-	req.Header.Add("Content-Type", "application/octet-stream")

-	req.ContentLength = -1

-	req.TransferEncoding = []string{"chunked"}

-	setTokenAuth(req, token)

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return "", "", fmt.Errorf("Failed to upload layer: %s", err)

-	}

-	if rc, ok := layer.(io.Closer); ok {

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

-			return "", "", err

-		}

-	}

-	defer res.Body.Close()

-

-	if res.StatusCode != 200 {

-		errBody, err := ioutil.ReadAll(res.Body)

-		if err != nil {

-			return "", "", utils.NewHTTPRequestError(fmt.Sprintf("HTTP code %d while uploading metadata and error when trying to parse response body: %s", res.StatusCode, err), res)

-		}

-		return "", "", utils.NewHTTPRequestError(fmt.Sprintf("Received HTTP code %d while uploading layer: %s", res.StatusCode, errBody), res)

-	}

-

-	checksumPayload = "sha256:" + hex.EncodeToString(h.Sum(nil))

-	return tarsumLayer.Sum(jsonRaw), checksumPayload, nil

-}

-

-// push a tag on the registry.

-// Remote has the format '<user>/<repo>

-func (r *Registry) PushRegistryTag(remote, revision, tag, registry string, token []string) error {

-	// "jsonify" the string

-	revision = "\"" + revision + "\""

-	path := fmt.Sprintf("repositories/%s/tags/%s", remote, tag)

-

-	req, err := r.reqFactory.NewRequest("PUT", registry+path, strings.NewReader(revision))

-	if err != nil {

-		return err

-	}

-	req.Header.Add("Content-type", "application/json")

-	setTokenAuth(req, token)

-	req.ContentLength = int64(len(revision))

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return err

-	}

-	res.Body.Close()

-	if res.StatusCode != 200 && res.StatusCode != 201 {

-		return utils.NewHTTPRequestError(fmt.Sprintf("Internal server error: %d trying to push tag %s on %s", res.StatusCode, tag, remote), res)

-	}

-	return nil

-}

-

-func (r *Registry) PushImageJSONIndex(remote string, imgList []*ImgData, validate bool, regs []string) (*RepositoryData, error) {

-	cleanImgList := []*ImgData{}

-	indexEp := r.indexEndpoint

-

-	if validate {

-		for _, elem := range imgList {

-			if elem.Checksum != "" {

-				cleanImgList = append(cleanImgList, elem)

-			}

-		}

-	} else {

-		cleanImgList = imgList

-	}

-

-	imgListJSON, err := json.Marshal(cleanImgList)

-	if err != nil {

-		return nil, err

-	}

-	var suffix string

-	if validate {

-		suffix = "images"

-	}

-	u := fmt.Sprintf("%srepositories/%s/%s", indexEp, remote, suffix)

-	utils.Debugf("[registry] PUT %s", u)

-	utils.Debugf("Image list pushed to index:\n%s", imgListJSON)

-	req, err := r.reqFactory.NewRequest("PUT", u, bytes.NewReader(imgListJSON))

-	if err != nil {

-		return nil, err

-	}

-	req.Header.Add("Content-type", "application/json")

-	req.SetBasicAuth(r.authConfig.Username, r.authConfig.Password)

-	req.ContentLength = int64(len(imgListJSON))

-	req.Header.Set("X-Docker-Token", "true")

-	if validate {

-		req.Header["X-Docker-Endpoints"] = regs

-	}

-

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return nil, err

-	}

-	defer res.Body.Close()

-

-	// Redirect if necessary

-	for res.StatusCode >= 300 && res.StatusCode < 400 {

-		utils.Debugf("Redirected to %s", res.Header.Get("Location"))

-		req, err = r.reqFactory.NewRequest("PUT", res.Header.Get("Location"), bytes.NewReader(imgListJSON))

-		if err != nil {

-			return nil, err

-		}

-		req.SetBasicAuth(r.authConfig.Username, r.authConfig.Password)

-		req.ContentLength = int64(len(imgListJSON))

-		req.Header.Set("X-Docker-Token", "true")

-		if validate {

-			req.Header["X-Docker-Endpoints"] = regs

-		}

-		res, _, err := r.doRequest(req)

-		if err != nil {

-			return nil, err

-		}

-		defer res.Body.Close()

-	}

-

-	var tokens, endpoints []string

-	if !validate {

-		if res.StatusCode != 200 && res.StatusCode != 201 {

-			errBody, err := ioutil.ReadAll(res.Body)

-			if err != nil {

-				return nil, err

-			}

-			return nil, utils.NewHTTPRequestError(fmt.Sprintf("Error: Status %d trying to push repository %s: %s", res.StatusCode, remote, errBody), res)

-		}

-		if res.Header.Get("X-Docker-Token") != "" {

-			tokens = res.Header["X-Docker-Token"]

-			utils.Debugf("Auth token: %v", tokens)

-		} else {

-			return nil, fmt.Errorf("Index response didn't contain an access token")

-		}

-

-		if res.Header.Get("X-Docker-Endpoints") != "" {

-			endpoints, err = buildEndpointsList(res.Header["X-Docker-Endpoints"], indexEp)

-			if err != nil {

-				return nil, err

-			}

-		} else {

-			return nil, fmt.Errorf("Index response didn't contain any endpoints")

-		}

-	}

-	if validate {

-		if res.StatusCode != 204 {

-			errBody, err := ioutil.ReadAll(res.Body)

-			if err != nil {

-				return nil, err

-			}

-			return nil, utils.NewHTTPRequestError(fmt.Sprintf("Error: Status %d trying to push checksums %s: %s", res.StatusCode, remote, errBody), res)

-		}

-	}

-

-	return &RepositoryData{

-		Tokens:    tokens,

-		Endpoints: endpoints,

-	}, nil

-}

-

-func (r *Registry) SearchRepositories(term string) (*SearchResults, error) {

-	utils.Debugf("Index server: %s", r.indexEndpoint)

-	u := r.indexEndpoint + "search?q=" + url.QueryEscape(term)

-	req, err := r.reqFactory.NewRequest("GET", u, nil)

-	if err != nil {

-		return nil, err

-	}

-	if r.authConfig != nil && len(r.authConfig.Username) > 0 {

-		req.SetBasicAuth(r.authConfig.Username, r.authConfig.Password)

-	}

-	req.Header.Set("X-Docker-Token", "true")

-	res, _, err := r.doRequest(req)

-	if err != nil {

-		return nil, err

-	}

-	defer res.Body.Close()

-	if res.StatusCode != 200 {

-		return nil, utils.NewHTTPRequestError(fmt.Sprintf("Unexepected status code %d", res.StatusCode), res)

-	}

-	rawData, err := ioutil.ReadAll(res.Body)

-	if err != nil {

-		return nil, err

-	}

-	result := new(SearchResults)

-	err = json.Unmarshal(rawData, result)

-	return result, err

-}

-

-func (r *Registry) GetAuthConfig(withPasswd bool) *AuthConfig {

-	password := ""

-	if withPasswd {

-		password = r.authConfig.Password

-	}

-	return &AuthConfig{

-		Username: r.authConfig.Username,

-		Password: password,

-		Email:    r.authConfig.Email,

-	}

-}

-

-type SearchResult struct {

-	StarCount   int    `json:"star_count"`

-	IsOfficial  bool   `json:"is_official"`

-	Name        string `json:"name"`

-	IsTrusted   bool   `json:"is_trusted"`

-	Description string `json:"description"`

-}

-

-type SearchResults struct {

-	Query      string         `json:"query"`

-	NumResults int            `json:"num_results"`

-	Results    []SearchResult `json:"results"`

-}

-

-type RepositoryData struct {

-	ImgList   map[string]*ImgData

-	Endpoints []string

-	Tokens    []string

-}

-

-type ImgData struct {

-	ID              string `json:"id"`

-	Checksum        string `json:"checksum,omitempty"`

-	ChecksumPayload string `json:"-"`

-	Tag             string `json:",omitempty"`

-}

-

-type RegistryInfo struct {

-	Version    string `json:"version"`

-	Standalone bool   `json:"standalone"`

-}

-

-type Registry struct {

-	authConfig    *AuthConfig

-	reqFactory    *utils.HTTPRequestFactory

-	indexEndpoint string

-	jar           *cookiejar.Jar

-	timeout       TimeoutType

-}

-

 func trustedLocation(req *http.Request) bool {

 	var (

 		trusteds = []string{"docker.com", "docker.io"}

@@ -919,73 +317,3 @@ func AddRequiredHeadersToRedirectedRequests(req *http.Request, via []*http.Reque

 	}

 	return nil

 }

-

-func NewRegistry(authConfig *AuthConfig, factory *utils.HTTPRequestFactory, indexEndpoint string, timeout bool) (r *Registry, err error) {

-	r = &Registry{

-		authConfig:    authConfig,

-		indexEndpoint: indexEndpoint,

-	}

-

-	if timeout {

-		r.timeout = ReceiveTimeout

-	}

-

-	r.jar, err = cookiejar.New(nil)

-	if err != nil {

-		return nil, err

-	}

-

-	// If we're working with a standalone private registry over HTTPS, send Basic Auth headers

-	// alongside our requests.

-	if indexEndpoint != IndexServerAddress() && strings.HasPrefix(indexEndpoint, "https://") {

-		info, err := pingRegistryEndpoint(indexEndpoint)

-		if err != nil {

-			return nil, err

-		}

-		if info.Standalone {

-			utils.Debugf("Endpoint %s is eligible for private registry registry. Enabling decorator.", indexEndpoint)

-			dec := utils.NewHTTPAuthDecorator(authConfig.Username, authConfig.Password)

-			factory.AddDecorator(dec)

-		}

-	}

-

-	r.reqFactory = factory

-	return r, nil

-}

-

-func HTTPRequestFactory(metaHeaders map[string][]string) *utils.HTTPRequestFactory {

-	// FIXME: this replicates the 'info' job.

-	httpVersion := make([]utils.VersionInfo, 0, 4)

-	httpVersion = append(httpVersion, &simpleVersionInfo{"docker", dockerversion.VERSION})

-	httpVersion = append(httpVersion, &simpleVersionInfo{"go", runtime.Version()})

-	httpVersion = append(httpVersion, &simpleVersionInfo{"git-commit", dockerversion.GITCOMMIT})

-	if kernelVersion, err := kernel.GetKernelVersion(); err == nil {

-		httpVersion = append(httpVersion, &simpleVersionInfo{"kernel", kernelVersion.String()})

-	}

-	httpVersion = append(httpVersion, &simpleVersionInfo{"os", runtime.GOOS})

-	httpVersion = append(httpVersion, &simpleVersionInfo{"arch", runtime.GOARCH})

-	ud := utils.NewHTTPUserAgentDecorator(httpVersion...)

-	md := &utils.HTTPMetaHeadersDecorator{

-		Headers: metaHeaders,

-	}

-	factory := utils.NewHTTPRequestFactory(ud, md)

-	return factory

-}

-

-// simpleVersionInfo is a simple implementation of

-// the interface VersionInfo, which is used

-// to provide version information for some product,

-// component, etc. It stores the product name and the version

-// in string and returns them on calls to Name() and Version().

-type simpleVersionInfo struct {

-	name    string

-	version string

-}

-

-func (v *simpleVersionInfo) Name() string {

-	return v.name

-}

-

-func (v *simpleVersionInfo) Version() string {

-	return v.version

-}

@@ -16,9 +16,9 @@ var (

 	REPO     = "foo42/bar"

 )

-func spawnTestRegistry(t *testing.T) *Registry {

+func spawnTestRegistrySession(t *testing.T) *Session {

 	authConfig := &AuthConfig{}

-	r, err := NewRegistry(authConfig, utils.NewHTTPRequestFactory(), makeURL("/v1/"), true)

+	r, err := NewSession(authConfig, utils.NewHTTPRequestFactory(), makeURL("/v1/"), true)

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -34,7 +34,7 @@ func TestPingRegistryEndpoint(t *testing.T) {

 }

 func TestGetRemoteHistory(t *testing.T) {

-	r := spawnTestRegistry(t)

+	r := spawnTestRegistrySession(t)

 	hist, err := r.GetRemoteHistory(IMAGE_ID, makeURL("/v1/"), TOKEN)

 	if err != nil {

 		t.Fatal(err)

@@ -46,7 +46,7 @@ func TestGetRemoteHistory(t *testing.T) {

 }

 func TestLookupRemoteImage(t *testing.T) {

-	r := spawnTestRegistry(t)

+	r := spawnTestRegistrySession(t)

 	found := r.LookupRemoteImage(IMAGE_ID, makeURL("/v1/"), TOKEN)

 	assertEqual(t, found, true, "Expected remote lookup to succeed")

 	found = r.LookupRemoteImage("abcdef", makeURL("/v1/"), TOKEN)

@@ -54,7 +54,7 @@ func TestLookupRemoteImage(t *testing.T) {

 }

 func TestGetRemoteImageJSON(t *testing.T) {

-	r := spawnTestRegistry(t)

+	r := spawnTestRegistrySession(t)

 	json, size, err := r.GetRemoteImageJSON(IMAGE_ID, makeURL("/v1/"), TOKEN)

 	if err != nil {

 		t.Fatal(err)

@@ -71,7 +71,7 @@ func TestGetRemoteImageJSON(t *testing.T) {

 }

 func TestGetRemoteImageLayer(t *testing.T) {

-	r := spawnTestRegistry(t)

+	r := spawnTestRegistrySession(t)

 	data, err := r.GetRemoteImageLayer(IMAGE_ID, makeURL("/v1/"), TOKEN, 0)

 	if err != nil {

 		t.Fatal(err)

@@ -87,7 +87,7 @@ func TestGetRemoteImageLayer(t *testing.T) {

 }

 func TestGetRemoteTags(t *testing.T) {

-	r := spawnTestRegistry(t)

+	r := spawnTestRegistrySession(t)

 	tags, err := r.GetRemoteTags([]string{makeURL("/v1/")}, REPO, TOKEN)

 	if err != nil {

 		t.Fatal(err)

@@ -102,7 +102,7 @@ func TestGetRemoteTags(t *testing.T) {

 }

 func TestGetRepositoryData(t *testing.T) {

-	r := spawnTestRegistry(t)

+	r := spawnTestRegistrySession(t)

 	parsedUrl, err := url.Parse(makeURL("/v1/"))

 	if err != nil {

 		t.Fatal(err)

@@ -123,7 +123,7 @@ func TestGetRepositoryData(t *testing.T) {

 }

 func TestPushImageJSONRegistry(t *testing.T) {

-	r := spawnTestRegistry(t)

+	r := spawnTestRegistrySession(t)

 	imgData := &ImgData{

 		ID:       "77dbf71da1d00e3fbddc480176eac8994025630c6590d11cfc8fe1209c2a1d20",

 		Checksum: "sha256:1ac330d56e05eef6d438586545ceff7550d3bdcb6b19961f12c5ba714ee1bb37",