Merge pull request #15 from runcom/enhanc

drop docker/ code

README.md

@@ -117,10 +117,7 @@ TODO
 - update README with `layers` command
 - list all images on registry?
 - registry v2 search?
-- make skopeo docker registry v2 only
-- output raw manifest
-- download layers and support docker load tar(s)
-- get rid of docker/docker code (?)
+- download layers in parallel and support docker load tar(s)
 - show repo tags via flag or when reference isn't tagged or digested
 - add tests (integration with deployed registries in container - Docker-like)
 - support rkt/appc image spec

cmd/skopeo/inspect.go

@@ -3,19 +3,15 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"strings"
 
 	"github.com/Sirupsen/logrus"
 	"github.com/codegangsta/cli"
 	"github.com/projectatomic/skopeo"
-	pkgInspect "github.com/projectatomic/skopeo/docker/inspect"
-	"github.com/projectatomic/skopeo/types"
 )
 
 var inspectCmd = cli.Command{
 	Name:  "inspect",
 	Usage: "inspect images on a registry",
-	ArgsUsage: ``,
 	Flags: []cli.Flag{
 		cli.BoolFlag{
 			Name:  "raw",
@@ -23,12 +19,11 @@ var inspectCmd = cli.Command{
 		},
 	},
 	Action: func(c *cli.Context) {
-		if c.Bool("raw") {
 		img, err := skopeo.ParseImage(c.Args().First())
 		if err != nil {
 			logrus.Fatal(err)
 		}
-			// TODO(runcom): this is not falling back to v1
+		if c.Bool("raw") {
 			// TODO(runcom): hardcoded schema 2 version 1
 			b, err := img.RawManifest("2-1")
 			if err != nil {
@@ -37,34 +32,14 @@ var inspectCmd = cli.Command{
 			fmt.Println(string(b))
 			return
 		}
-		// get the Image interface before inspecting...utils.go parseImage
-		imgInspect, err := inspect(c)
+		imgInspect, err := img.Manifest()
 		if err != nil {
 			logrus.Fatal(err)
 		}
-		out, err := json.Marshal(imgInspect)
+		out, err := json.MarshalIndent(imgInspect, "", "    ")
 		if err != nil {
 			logrus.Fatal(err)
 		}
 		fmt.Println(string(out))
 	},
 }
-
-func inspect(c *cli.Context) (types.ImageManifest, error) {
-	var (
-		imgInspect types.ImageManifest
-		err        error
-		name       = c.Args().First()
-	)
-
-	switch {
-	case strings.HasPrefix(name, types.DockerPrefix):
-		imgInspect, err = pkgInspect.GetData(c, strings.Replace(name, "docker://", "", -1))
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, fmt.Errorf("%s image is invalid, please use 'docker://'", name)
-	}
-	return imgInspect, nil
-}

cmd/skopeo/layers.go

@@ -10,7 +10,6 @@ import (
 var layersCmd = cli.Command{
 	Name:  "layers",
 	Usage: "get images layers",
-	ArgsUsage: ``,
 	Action: func(context *cli.Context) {
 		img, err := skopeo.ParseImage(context.Args().First())
 		if err != nil {

docker.go

@@ -14,10 +14,11 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"time"
 
 	"github.com/Sirupsen/logrus"
 	"github.com/docker/docker/pkg/homedir"
-	"github.com/projectatomic/skopeo/docker/reference"
+	"github.com/projectatomic/skopeo/reference"
 	"github.com/projectatomic/skopeo/types"
 )
 
@@ -32,11 +33,23 @@ const (
 	dockerCfgObsolete = ".dockercfg"
 )
 
-var validHex = regexp.MustCompile(`^([a-f0-9]{64})$`)
+var (
+	validHex = regexp.MustCompile(`^([a-f0-9]{64})$`)
+)
+
+type errFetchManifest struct {
+	statusCode int
+	body       []byte
+}
+
+func (e errFetchManifest) Error() string {
+	return fmt.Sprintf("error fetching manifest: status code: %d, body: %s", e.statusCode, string(e.body))
+}
 
 type dockerImage struct {
 	ref             reference.Named
 	tag             string
+	digest          string
 	registry        string
 	username        string
 	password        string
@@ -53,13 +66,85 @@ func (i *dockerImage) RawManifest(version string) ([]byte, error) {
 	return i.rawManifest, nil
 }
 
-func (i *dockerImage) Manifest(version string) (types.ImageManifest, error) {
-	// TODO(runcom): port docker/docker implementation under  docker/ to just
-	// use this!!! and do not rely on docker upstream code - will need to support
-	// v1 fall back also...
-	return nil, nil
+func (i *dockerImage) Manifest() (types.ImageManifest, error) {
+	// TODO(runcom): unused version param for now, default to docker v2-1
+	m, err := i.getSchema1Manifest()
+	if err != nil {
+		return nil, err
+	}
+	ms1, ok := m.(*manifestSchema1)
+	if !ok {
+		return nil, fmt.Errorf("error retrivieng manifest schema1")
+	}
+	tags, err := i.getTags()
+	if err != nil {
+		return nil, err
+	}
+	imgManifest, err := makeImageManifest(i.ref.FullName(), ms1, i.digest, tags)
+	if err != nil {
+		return nil, err
+	}
+	return imgManifest, nil
 }
 
+func (i *dockerImage) getTags() ([]string, error) {
+	url := i.scheme + "://" + i.registry + "/v2/" + i.ref.RemoteName() + "/tags/list"
+	res, err := i.makeRequest("GET", url, i.WWWAuthenticate != "", nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		// print url also
+		return nil, fmt.Errorf("Invalid status code returned when fetching tags list %d", res.StatusCode)
+	}
+	type tagsRes struct {
+		Tags []string
+	}
+	tags := &tagsRes{}
+	if err := json.NewDecoder(res.Body).Decode(tags); err != nil {
+		return nil, err
+	}
+	return tags.Tags, nil
+}
+
+type config struct {
+	Labels map[string]string
+}
+
+type v1Image struct {
+	// Config is the configuration of the container received from the client
+	Config *config `json:"config,omitempty"`
+	// DockerVersion specifies version on which image is built
+	DockerVersion string `json:"docker_version,omitempty"`
+	// Created timestamp when image was created
+	Created time.Time `json:"created"`
+	// Architecture is the hardware that the image is build and runs on
+	Architecture string `json:"architecture,omitempty"`
+	// OS is the operating system used to build and run the image
+	OS string `json:"os,omitempty"`
+}
+
+func makeImageManifest(name string, m *manifestSchema1, dgst string, tagList []string) (types.ImageManifest, error) {
+	v1 := &v1Image{}
+	if err := json.Unmarshal([]byte(m.History[0].V1Compatibility), v1); err != nil {
+		return nil, err
+	}
+	return &types.DockerImageManifest{
+		Name:          name,
+		Tag:           m.Tag,
+		Digest:        dgst,
+		RepoTags:      tagList,
+		DockerVersion: v1.DockerVersion,
+		Created:       v1.Created,
+		Labels:        v1.Config.Labels,
+		Architecture:  v1.Architecture,
+		Os:            v1.OS,
+		Layers:        m.GetLayers(),
+	}, nil
+}
+
+// TODO(runcom)
 func (i *dockerImage) DockerTar() ([]byte, error) {
 	return nil, nil
 }
@@ -249,16 +334,15 @@ func (i *dockerImage) retrieveRawManifest() error {
 		return err
 	}
 	defer res.Body.Close()
-
-	if res.StatusCode != http.StatusOK {
-		// print body also
-		return fmt.Errorf("Invalid status code returned when fetching manifest %d", res.StatusCode)
-	}
 	manblob, err := ioutil.ReadAll(res.Body)
 	if err != nil {
 		return err
 	}
+	if res.StatusCode != http.StatusOK {
+		return errFetchManifest{res.StatusCode, manblob}
+	}
 	i.rawManifest = manblob
+	i.digest = res.Header.Get("Docker-Content-Digest")
 	return nil
 }
 
@@ -273,6 +357,13 @@ func (i *dockerImage) getSchema1Manifest() (manifest, error) {
 	if err := fixManifestLayers(mschema1); err != nil {
 		return nil, err
 	}
+	// TODO(runcom): verify manifest schema 1, 2 etc
+	//if len(m.FSLayers) != len(m.History) {
+	//return nil, fmt.Errorf("length of history not equal to number of layers for %q", ref.String())
+	//}
+	//if len(m.FSLayers) == 0 {
+	//return nil, fmt.Errorf("no FSLayers in manifest for %q", ref.String())
+	//}
 	return mschema1, nil
 }
 
@@ -372,16 +463,16 @@ func getDefaultConfigDir(confPath string) string {
 	return filepath.Join(homedir.Get(), confPath)
 }
 
-type DockerAuthConfigObsolete struct {
+type dockerAuthConfigObsolete struct {
 	Auth string `json:"auth"`
 }
 
-type DockerAuthConfig struct {
+type dockerAuthConfig struct {
 	Auth string `json:"auth,omitempty"`
 }
 
-type DockerConfigFile struct {
-	AuthConfigs map[string]DockerAuthConfig `json:"auths"`
+type dockerConfigFile struct {
+	AuthConfigs map[string]dockerAuthConfig `json:"auths"`
 }
 
 func decodeDockerAuth(s string) (string, string, error) {
@@ -408,7 +499,7 @@ func getAuth(hostname string) (string, string, error) {
 		if err != nil {
 			return "", "", err
 		}
-		var dockerAuth DockerConfigFile
+		var dockerAuth dockerConfigFile
 		if err := json.Unmarshal(j, &dockerAuth); err != nil {
 			return "", "", err
 		}
@@ -425,7 +516,7 @@ func getAuth(hostname string) (string, string, error) {
 		if err != nil {
 			return "", "", err
 		}
-		var dockerAuthOld map[string]DockerAuthConfigObsolete
+		var dockerAuthOld map[string]dockerAuthConfigObsolete
 		if err := json.Unmarshal(j, &dockerAuthOld); err != nil {
 			return "", "", err
 		}
@@ -440,7 +531,7 @@ func getAuth(hostname string) (string, string, error) {
 	return "", "", nil
 }
 
-type APIErr struct {
+type apiErr struct {
 	Code    string
 	Message string
 	Detail  interface{}
@@ -450,7 +541,7 @@ type pingResponse struct {
 	WWWAuthenticate string
 	APIVersion      string
 	scheme          string
-	errors          []APIErr
+	errors          []apiErr
 }
 
 func (pr *pingResponse) needsAuth() bool {
@@ -476,7 +567,7 @@ func ping(registry string) (*pingResponse, error) {
 		pr.scheme = scheme
 		if resp.StatusCode == http.StatusUnauthorized {
 			type APIErrors struct {
-				Errors []APIErr
+				Errors []apiErr
 			}
 			errs := &APIErrors{}
 			if err := json.NewDecoder(resp.Body).Decode(errs); err != nil {

docker/README

@@ -1,5 +0,0 @@
-TODO
-
-Eventually we want to get rid of inspect pkg which uses docker upstream code
-and use, instead, docker.go which calls the api directly
-Be aware that docker pkg do not fall back to v1! this must be implemented soon

docker/docker.go

@@ -1,550 +0,0 @@
-package docker
-
-import (
-	"crypto/tls"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/docker/pkg/homedir"
-	"github.com/projectatomic/skopeo/docker/reference"
-	"github.com/projectatomic/skopeo/types"
-)
-
-const (
-	dockerPrefix       = "docker://"
-	dockerHostname     = "docker.io"
-	dockerRegistry     = "registry-1.docker.io"
-	dockerAuthRegistry = "https://index.docker.io/v1/"
-
-	dockerCfg         = ".docker"
-	dockerCfgFileName = "config.json"
-	dockerCfgObsolete = ".dockercfg"
-)
-
-var validHex = regexp.MustCompile(`^([a-f0-9]{64})$`)
-
-type dockerImage struct {
-	ref             reference.Named
-	tag             string
-	registry        string
-	username        string
-	password        string
-	WWWAuthenticate string
-	scheme          string
-	rawManifest     []byte
-}
-
-func (i *dockerImage) RawManifest(version string) ([]byte, error) {
-	// TODO(runcom): unused version param for now, default to docker v2-1
-	if err := i.retrieveRawManifest(); err != nil {
-		return nil, err
-	}
-	return i.rawManifest, nil
-}
-
-func (i *dockerImage) Manifest(version string) (types.ImageManifest, error) {
-	// TODO(runcom): port docker/docker implementation under  docker/ to just
-	// use this!!! and do not rely on docker upstream code - will need to support
-	// v1 fall back also...
-	return nil, nil
-}
-
-func (i *dockerImage) DockerTar() ([]byte, error) {
-	return nil, nil
-}
-
-// will support v1 one day...
-type manifest interface {
-	String() string
-	GetLayers() []string
-}
-
-type manifestSchema1 struct {
-	Name     string
-	Tag      string
-	FSLayers []struct {
-		BlobSum string `json:"blobSum"`
-	} `json:"fsLayers"`
-	History []struct {
-		V1Compatibility string `json:"v1Compatibility"`
-	} `json:"history"`
-	// TODO(runcom) verify the downloaded manifest
-	//Signature []byte `json:"signature"`
-}
-
-func (m *manifestSchema1) GetLayers() []string {
-	layers := make([]string, len(m.FSLayers))
-	for i, layer := range m.FSLayers {
-		layers[i] = layer.BlobSum
-	}
-	return layers
-}
-
-func (m *manifestSchema1) String() string {
-	return fmt.Sprintf("%s-%s", sanitize(m.Name), sanitize(m.Tag))
-}
-
-func sanitize(s string) string {
-	return strings.Replace(s, "/", "-", -1)
-}
-
-func (i *dockerImage) makeRequest(method, url string, auth bool, headers map[string]string) (*http.Response, error) {
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Docker-Distribution-API-Version", "registry/2.0")
-	for n, h := range headers {
-		req.Header.Add(n, h)
-	}
-	if auth {
-		if err := i.setupRequestAuth(req); err != nil {
-			return nil, err
-		}
-	}
-	// insecure by default for now
-	tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
-	client := &http.Client{Transport: tr}
-	res, err := client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-func (i *dockerImage) setupRequestAuth(req *http.Request) error {
-	tokens := strings.SplitN(strings.TrimSpace(i.WWWAuthenticate), " ", 2)
-	if len(tokens) != 2 {
-		return fmt.Errorf("expected 2 tokens in WWW-Authenticate: %d, %s", len(tokens), i.WWWAuthenticate)
-	}
-	switch tokens[0] {
-	case "Basic":
-		req.SetBasicAuth(i.username, i.password)
-		return nil
-	case "Bearer":
-		// insecure by default for now
-		tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
-		client := &http.Client{Transport: tr}
-		res, err := client.Do(req)
-		if err != nil {
-			return err
-		}
-		hdr := res.Header.Get("WWW-Authenticate")
-		if hdr == "" || res.StatusCode != http.StatusUnauthorized {
-			// no need for bearer? wtf?
-			return nil
-		}
-		tokens = strings.Split(hdr, " ")
-		tokens = strings.Split(tokens[1], ",")
-		var realm, service, scope string
-		for _, token := range tokens {
-			if strings.HasPrefix(token, "realm") {
-				realm = strings.Trim(token[len("realm="):], "\"")
-			}
-			if strings.HasPrefix(token, "service") {
-				service = strings.Trim(token[len("service="):], "\"")
-			}
-			if strings.HasPrefix(token, "scope") {
-				scope = strings.Trim(token[len("scope="):], "\"")
-			}
-		}
-
-		if realm == "" {
-			return fmt.Errorf("missing realm in bearer auth challenge")
-		}
-		if service == "" {
-			return fmt.Errorf("missing service in bearer auth challenge")
-		}
-		// The scope can be empty if we're not getting a token for a specific repo
-		//if scope == "" && repo != "" {
-		if scope == "" {
-			return fmt.Errorf("missing scope in bearer auth challenge")
-		}
-		token, err := i.getBearerToken(realm, service, scope)
-		if err != nil {
-			return err
-		}
-		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
-		return nil
-	}
-	return fmt.Errorf("no handler for %s authentication", tokens[0])
-	// support docker bearer with authconfig's Auth string? see docker2aci
-}
-
-func (i *dockerImage) getBearerToken(realm, service, scope string) (string, error) {
-	authReq, err := http.NewRequest("GET", realm, nil)
-	if err != nil {
-		return "", err
-	}
-	getParams := authReq.URL.Query()
-	getParams.Add("service", service)
-	if scope != "" {
-		getParams.Add("scope", scope)
-	}
-	authReq.URL.RawQuery = getParams.Encode()
-	if i.username != "" && i.password != "" {
-		authReq.SetBasicAuth(i.username, i.password)
-	}
-	tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
-	client := &http.Client{Transport: tr}
-	res, err := client.Do(authReq)
-	if err != nil {
-		return "", err
-	}
-	defer res.Body.Close()
-	switch res.StatusCode {
-	case http.StatusUnauthorized:
-		return "", fmt.Errorf("unable to retrieve auth token: 401 unauthorized")
-	case http.StatusOK:
-		break
-	default:
-		return "", fmt.Errorf("unexpected http code: %d, URL: %s", res.StatusCode, authReq.URL)
-	}
-	tokenBlob, err := ioutil.ReadAll(res.Body)
-	if err != nil {
-		return "", err
-	}
-	tokenStruct := struct {
-		Token string `json:"token"`
-	}{}
-	if err := json.Unmarshal(tokenBlob, &tokenStruct); err != nil {
-		return "", err
-	}
-	// TODO(runcom): reuse tokens?
-	//hostAuthTokens, ok = rb.hostsV2AuthTokens[req.URL.Host]
-	//if !ok {
-	//hostAuthTokens = make(map[string]string)
-	//rb.hostsV2AuthTokens[req.URL.Host] = hostAuthTokens
-	//}
-	//hostAuthTokens[repo] = tokenStruct.Token
-	return tokenStruct.Token, nil
-}
-
-func (i *dockerImage) retrieveRawManifest() error {
-	if i.rawManifest != nil {
-		return nil
-	}
-	pr, err := ping(i.registry)
-	if err != nil {
-		return err
-	}
-	i.WWWAuthenticate = pr.WWWAuthenticate
-	i.scheme = pr.scheme
-	url := i.scheme + "://" + i.registry + "/v2/" + i.ref.RemoteName() + "/manifests/" + i.tag
-	// TODO(runcom) set manifest version header! schema1 for now - then schema2 etc etc and v1
-	// TODO(runcom) NO, switch on the resulter manifest like Docker is doing
-	res, err := i.makeRequest("GET", url, pr.needsAuth(), nil)
-	if err != nil {
-		return err
-	}
-	defer res.Body.Close()
-
-	if res.StatusCode != http.StatusOK {
-		// print body also
-		return fmt.Errorf("Invalid status code returned when fetching manifest %d", res.StatusCode)
-	}
-	manblob, err := ioutil.ReadAll(res.Body)
-	if err != nil {
-		return err
-	}
-	i.rawManifest = manblob
-	return nil
-}
-
-func (i *dockerImage) getSchema1Manifest() (manifest, error) {
-	if err := i.retrieveRawManifest(); err != nil {
-		return nil, err
-	}
-	mschema1 := &manifestSchema1{}
-	if err := json.Unmarshal(i.rawManifest, mschema1); err != nil {
-		return nil, err
-	}
-	if err := fixManifestLayers(mschema1); err != nil {
-		return nil, err
-	}
-	return mschema1, nil
-}
-
-func (i *dockerImage) Layers(layers ...string) error {
-	m, err := i.getSchema1Manifest()
-	if err != nil {
-		return err
-	}
-	tmpDir, err := ioutil.TempDir(".", "layers-"+m.String()+"-")
-	if err != nil {
-		return err
-	}
-	data, err := json.Marshal(m)
-	if err != nil {
-		return err
-	}
-	if err := ioutil.WriteFile(path.Join(tmpDir, "manifest.json"), data, 0644); err != nil {
-		return err
-	}
-	url := i.scheme + "://" + i.registry + "/v2/" + i.ref.RemoteName() + "/blobs/"
-	if len(layers) == 0 {
-		layers = m.GetLayers()
-	}
-	for _, l := range layers {
-		if !strings.HasPrefix(l, "sha256:") {
-			l = "sha256:" + l
-		}
-		if err := i.getLayer(l, url, tmpDir); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (i *dockerImage) getLayer(l, url, tmpDir string) error {
-	lurl := url + l
-	logrus.Infof("Downloading %s", lurl)
-	res, err := i.makeRequest("GET", lurl, i.WWWAuthenticate != "", nil)
-	if err != nil {
-		return err
-	}
-	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
-		// print url also
-		return fmt.Errorf("Invalid status code returned when fetching blob %d", res.StatusCode)
-	}
-	layerPath := path.Join(tmpDir, strings.Replace(l, "sha256:", "", -1)+".tar")
-	layerFile, err := os.Create(layerPath)
-	if err != nil {
-		return err
-	}
-	if _, err := io.Copy(layerFile, res.Body); err != nil {
-		return err
-	}
-	if err := layerFile.Sync(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func parseDockerImage(img string) (types.Image, error) {
-	ref, err := reference.ParseNamed(img)
-	if err != nil {
-		return nil, err
-	}
-	if reference.IsNameOnly(ref) {
-		ref = reference.WithDefaultTag(ref)
-	}
-	var tag string
-	switch x := ref.(type) {
-	case reference.Canonical:
-		tag = x.Digest().String()
-	case reference.NamedTagged:
-		tag = x.Tag()
-	}
-	var registry string
-	hostname := ref.Hostname()
-	if hostname == dockerHostname {
-		registry = dockerRegistry
-	} else {
-		registry = hostname
-	}
-	username, password, err := getAuth(ref.Hostname())
-	if err != nil {
-		return nil, err
-	}
-	return &dockerImage{
-		ref:      ref,
-		tag:      tag,
-		registry: registry,
-		username: username,
-		password: password,
-	}, nil
-}
-
-func getDefaultConfigDir(confPath string) string {
-	return filepath.Join(homedir.Get(), confPath)
-}
-
-type DockerAuthConfigObsolete struct {
-	Auth string `json:"auth"`
-}
-
-type DockerAuthConfig struct {
-	Auth string `json:"auth,omitempty"`
-}
-
-type DockerConfigFile struct {
-	AuthConfigs map[string]DockerAuthConfig `json:"auths"`
-}
-
-func decodeDockerAuth(s string) (string, string, error) {
-	decoded, err := base64.StdEncoding.DecodeString(s)
-	if err != nil {
-		return "", "", err
-	}
-	parts := strings.SplitN(string(decoded), ":", 2)
-	if len(parts) != 2 {
-		return "", "", fmt.Errorf("invalid auth configuration file")
-	}
-	user := parts[0]
-	password := strings.Trim(parts[1], "\x00")
-	return user, password, nil
-}
-
-func getAuth(hostname string) (string, string, error) {
-	if hostname == dockerHostname {
-		hostname = dockerAuthRegistry
-	}
-	dockerCfgPath := filepath.Join(getDefaultConfigDir(".docker"), dockerCfgFileName)
-	if _, err := os.Stat(dockerCfgPath); err == nil {
-		j, err := ioutil.ReadFile(dockerCfgPath)
-		if err != nil {
-			return "", "", err
-		}
-		var dockerAuth DockerConfigFile
-		if err := json.Unmarshal(j, &dockerAuth); err != nil {
-			return "", "", err
-		}
-		// try the normal case
-		if c, ok := dockerAuth.AuthConfigs[hostname]; ok {
-			return decodeDockerAuth(c.Auth)
-		}
-	} else if os.IsNotExist(err) {
-		oldDockerCfgPath := filepath.Join(getDefaultConfigDir(dockerCfgObsolete))
-		if _, err := os.Stat(oldDockerCfgPath); err != nil {
-			return "", "", nil //missing file is not an error
-		}
-		j, err := ioutil.ReadFile(oldDockerCfgPath)
-		if err != nil {
-			return "", "", err
-		}
-		var dockerAuthOld map[string]DockerAuthConfigObsolete
-		if err := json.Unmarshal(j, &dockerAuthOld); err != nil {
-			return "", "", err
-		}
-		if c, ok := dockerAuthOld[hostname]; ok {
-			return decodeDockerAuth(c.Auth)
-		}
-	} else {
-		// if file is there but we can't stat it for any reason other
-		// than it doesn't exist then stop
-		return "", "", fmt.Errorf("%s - %v", dockerCfgPath, err)
-	}
-	return "", "", nil
-}
-
-type APIErr struct {
-	Code    string
-	Message string
-	Detail  interface{}
-}
-
-type pingResponse struct {
-	WWWAuthenticate string
-	APIVersion      string
-	scheme          string
-	errors          []APIErr
-}
-
-func (pr *pingResponse) needsAuth() bool {
-	return pr.WWWAuthenticate != ""
-}
-
-func ping(registry string) (*pingResponse, error) {
-	// insecure by default for now
-	tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
-	client := &http.Client{Transport: tr}
-	ping := func(scheme string) (*pingResponse, error) {
-		resp, err := client.Get(scheme + "://" + registry + "/v2/")
-		if err != nil {
-			return nil, err
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusUnauthorized {
-			return nil, fmt.Errorf("error pinging repository, response code %d", resp.StatusCode)
-		}
-		pr := &pingResponse{}
-		pr.WWWAuthenticate = resp.Header.Get("WWW-Authenticate")
-		pr.APIVersion = resp.Header.Get("Docker-Distribution-Api-Version")
-		pr.scheme = scheme
-		if resp.StatusCode == http.StatusUnauthorized {
-			type APIErrors struct {
-				Errors []APIErr
-			}
-			errs := &APIErrors{}
-			if err := json.NewDecoder(resp.Body).Decode(errs); err != nil {
-				return nil, err
-			}
-			pr.errors = errs.Errors
-		}
-		return pr, nil
-	}
-	scheme := "https"
-	pr, err := ping(scheme)
-	if err != nil {
-		scheme = "http"
-		pr, err = ping(scheme)
-		if err == nil {
-			return pr, nil
-		}
-	}
-	return pr, err
-}
-
-func fixManifestLayers(manifest *manifestSchema1) error {
-	type imageV1 struct {
-		ID     string
-		Parent string
-	}
-	imgs := make([]*imageV1, len(manifest.FSLayers))
-	for i := range manifest.FSLayers {
-		img := &imageV1{}
-
-		if err := json.Unmarshal([]byte(manifest.History[i].V1Compatibility), img); err != nil {
-			return err
-		}
-
-		imgs[i] = img
-		if err := validateV1ID(img.ID); err != nil {
-			return err
-		}
-	}
-	if imgs[len(imgs)-1].Parent != "" {
-		return errors.New("Invalid parent ID in the base layer of the image.")
-	}
-	// check general duplicates to error instead of a deadlock
-	idmap := make(map[string]struct{})
-	var lastID string
-	for _, img := range imgs {
-		// skip IDs that appear after each other, we handle those later
-		if _, exists := idmap[img.ID]; img.ID != lastID && exists {
-			return fmt.Errorf("ID %+v appears multiple times in manifest", img.ID)
-		}
-		lastID = img.ID
-		idmap[lastID] = struct{}{}
-	}
-	// backwards loop so that we keep the remaining indexes after removing items
-	for i := len(imgs) - 2; i >= 0; i-- {
-		if imgs[i].ID == imgs[i+1].ID { // repeated ID. remove and continue
-			manifest.FSLayers = append(manifest.FSLayers[:i], manifest.FSLayers[i+1:]...)
-			manifest.History = append(manifest.History[:i], manifest.History[i+1:]...)
-		} else if imgs[i].Parent != imgs[i+1].ID {
-			return fmt.Errorf("Invalid parent ID. Expected %v, got %v.", imgs[i+1].ID, imgs[i].Parent)
-		}
-	}
-	return nil
-}
-
-func validateV1ID(id string) error {
-	if ok := validHex.MatchString(id); !ok {
-		return fmt.Errorf("image ID %q is invalid", id)
-	}
-	return nil
-}

docker/inspect/inspect.go

@@ -1,345 +0,0 @@
-package inspect
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/codegangsta/cli"
-	"github.com/docker/distribution/digest"
-	distreference "github.com/docker/distribution/reference"
-	"github.com/docker/distribution/registry/api/errcode"
-	"github.com/docker/distribution/registry/api/v2"
-	"github.com/docker/distribution/registry/client"
-	"github.com/docker/docker/api"
-	"github.com/docker/docker/cliconfig"
-	"github.com/docker/docker/distribution"
-	"github.com/docker/docker/dockerversion"
-	"github.com/docker/docker/image"
-	"github.com/docker/docker/opts"
-	versionPkg "github.com/docker/docker/pkg/version"
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/registry"
-	engineTypes "github.com/docker/engine-api/types"
-	registryTypes "github.com/docker/engine-api/types/registry"
-	"github.com/projectatomic/skopeo/types"
-	"golang.org/x/net/context"
-)
-
-// fallbackError wraps an error that can possibly allow fallback to a different
-// endpoint.
-type fallbackError struct {
-	// err is the error being wrapped.
-	err error
-	// confirmedV2 is set to true if it was confirmed that the registry
-	// supports the v2 protocol. This is used to limit fallbacks to the v1
-	// protocol.
-	confirmedV2 bool
-	transportOK bool
-}
-
-// Error renders the FallbackError as a string.
-func (f fallbackError) Error() string {
-	return f.err.Error()
-}
-
-type manifestFetcher interface {
-	Fetch(ctx context.Context, ref reference.Named) (types.ImageManifest, error)
-}
-
-func validateName(name string) error {
-	distref, err := distreference.ParseNamed(name)
-	if err != nil {
-		return err
-	}
-	hostname, _ := distreference.SplitHostname(distref)
-	if hostname == "" {
-		return fmt.Errorf("Please use a fully qualified repository name")
-	}
-	return nil
-}
-
-func GetData(c *cli.Context, name string) (types.ImageManifest, error) {
-	if err := validateName(name); err != nil {
-		return nil, err
-	}
-	ref, err := reference.ParseNamed(name)
-	if err != nil {
-		return nil, err
-	}
-	repoInfo, err := registry.ParseRepositoryInfo(ref)
-	if err != nil {
-		return nil, err
-	}
-	authConfig, err := getAuthConfig(c, repoInfo.Index)
-	if err != nil {
-		return nil, err
-	}
-	if err := validateRepoName(repoInfo.Name()); err != nil {
-		return nil, err
-	}
-	options := &registry.Options{}
-	options.Mirrors = opts.NewListOpts(nil)
-	options.InsecureRegistries = opts.NewListOpts(nil)
-	options.InsecureRegistries.Set("0.0.0.0/0")
-	registryService := registry.NewService(options)
-	// TODO(runcom): hacky, provide a way of passing tls cert (flag?) to be used to lookup
-	for _, ic := range registryService.Config.IndexConfigs {
-		ic.Secure = false
-	}
-
-	endpoints, err := registryService.LookupPullEndpoints(repoInfo.Hostname())
-	if err != nil {
-		return nil, err
-	}
-	logrus.Debugf("endpoints: %v", endpoints)
-
-	var (
-		ctx                    = context.Background()
-		lastErr                error
-		discardNoSupportErrors bool
-		imgInspect             types.ImageManifest
-		confirmedV2            bool
-		confirmedTLSRegistries = make(map[string]struct{})
-	)
-
-	for _, endpoint := range endpoints {
-		// make sure I can reach the registry, same as docker pull does
-		v1endpoint, err := endpoint.ToV1Endpoint(dockerversion.DockerUserAgent(), nil)
-		if err != nil {
-			return nil, err
-		}
-		if _, err := v1endpoint.Ping(); err != nil {
-			if strings.Contains(err.Error(), "timeout") {
-				return nil, err
-			}
-			continue
-		}
-
-		if confirmedV2 && endpoint.Version == registry.APIVersion1 {
-			logrus.Debugf("Skipping v1 endpoint %s because v2 registry was detected", endpoint.URL)
-			continue
-		}
-
-		if endpoint.URL.Scheme != "https" {
-			if _, confirmedTLS := confirmedTLSRegistries[endpoint.URL.Host]; confirmedTLS {
-				logrus.Debugf("Skipping non-TLS endpoint %s for host/port that appears to use TLS", endpoint.URL)
-				continue
-			}
-		}
-
-		logrus.Debugf("Trying to fetch image manifest of %s repository from %s %s", repoInfo.Name(), endpoint.URL, endpoint.Version)
-
-		//fetcher, err := newManifestFetcher(endpoint, repoInfo, config)
-		fetcher, err := newManifestFetcher(endpoint, repoInfo, authConfig, registryService)
-		if err != nil {
-			lastErr = err
-			continue
-		}
-
-		if imgInspect, err = fetcher.Fetch(ctx, ref); err != nil {
-			// Was this fetch cancelled? If so, don't try to fall back.
-			fallback := false
-			select {
-			case <-ctx.Done():
-			default:
-				if fallbackErr, ok := err.(fallbackError); ok {
-					fallback = true
-					confirmedV2 = confirmedV2 || fallbackErr.confirmedV2
-					if fallbackErr.transportOK && endpoint.URL.Scheme == "https" {
-						confirmedTLSRegistries[endpoint.URL.Host] = struct{}{}
-					}
-					err = fallbackErr.err
-				}
-			}
-			if fallback {
-				if _, ok := err.(distribution.ErrNoSupport); !ok {
-					// Because we found an error that's not ErrNoSupport, discard all subsequent ErrNoSupport errors.
-					discardNoSupportErrors = true
-					// save the current error
-					lastErr = err
-				} else if !discardNoSupportErrors {
-					// Save the ErrNoSupport error, because it's either the first error or all encountered errors
-					// were also ErrNoSupport errors.
-					lastErr = err
-				}
-				continue
-			}
-			logrus.Errorf("Not continuing with pull after error: %v", err)
-			return nil, err
-		}
-
-		return imgInspect, nil
-	}
-
-	if lastErr == nil {
-		lastErr = fmt.Errorf("no endpoints found for %s", ref.String())
-	}
-
-	return nil, lastErr
-}
-
-func newManifestFetcher(endpoint registry.APIEndpoint, repoInfo *registry.RepositoryInfo, authConfig engineTypes.AuthConfig, registryService *registry.Service) (manifestFetcher, error) {
-	switch endpoint.Version {
-	case registry.APIVersion2:
-		return &v2ManifestFetcher{
-			endpoint:   endpoint,
-			authConfig: authConfig,
-			service:    registryService,
-			repoInfo:   repoInfo,
-		}, nil
-	case registry.APIVersion1:
-		return &v1ManifestFetcher{
-			endpoint:   endpoint,
-			authConfig: authConfig,
-			service:    registryService,
-			repoInfo:   repoInfo,
-		}, nil
-	}
-	return nil, fmt.Errorf("unknown version %d for registry %s", endpoint.Version, endpoint.URL)
-}
-
-func getAuthConfig(c *cli.Context, index *registryTypes.IndexInfo) (engineTypes.AuthConfig, error) {
-	var (
-		username      = c.GlobalString("username")
-		password      = c.GlobalString("password")
-		cfg           = c.GlobalString("docker-cfg")
-		defAuthConfig = engineTypes.AuthConfig{
-			Username: c.GlobalString("username"),
-			Password: c.GlobalString("password"),
-			Email:    "stub@example.com",
-		}
-	)
-
-	//
-	// FINAL TODO(runcom): avoid returning empty config! just fallthrough and return
-	// the first useful authconfig
-	//
-
-	// TODO(runcom): ??? atomic needs this
-	// TODO(runcom): implement this to opt-in for docker-cfg, no need to make this
-	// work by default with docker's conf
-	//useDockerConf := c.GlobalString("use-docker-cfg")
-
-	if username != "" && password != "" {
-		return defAuthConfig, nil
-	}
-
-	confFile, err := cliconfig.Load(cfg)
-	if err != nil {
-		return engineTypes.AuthConfig{}, err
-	}
-	authConfig := registry.ResolveAuthConfig(confFile.AuthConfigs, index)
-	logrus.Debugf("authConfig for %s: %v", index.Name, authConfig)
-
-	return authConfig, nil
-}
-
-func validateRepoName(name string) error {
-	if name == "" {
-		return fmt.Errorf("Repository name can't be empty")
-	}
-	if name == api.NoBaseImageSpecifier {
-		return fmt.Errorf("'%s' is a reserved name", api.NoBaseImageSpecifier)
-	}
-	return nil
-}
-
-func makeImageManifest(img *image.Image, tag string, dgst digest.Digest, tagList []string) types.ImageManifest {
-	var digest string
-	if err := dgst.Validate(); err == nil {
-		digest = dgst.String()
-	}
-	return &types.DockerImageManifest{
-		Tag:             tag,
-		Digest:          digest,
-		RepoTags:        tagList,
-		Comment:         img.Comment,
-		Created:         img.Created.Format(time.RFC3339Nano),
-		ContainerConfig: &img.ContainerConfig,
-		DockerVersion:   img.DockerVersion,
-		Author:          img.Author,
-		Config:          img.Config,
-		Architecture:    img.Architecture,
-		Os:              img.OS,
-	}
-}
-
-func makeRawConfigFromV1Config(imageJSON []byte, rootfs *image.RootFS, history []image.History) (map[string]*json.RawMessage, error) {
-	var dver struct {
-		DockerVersion string `json:"docker_version"`
-	}
-
-	if err := json.Unmarshal(imageJSON, &dver); err != nil {
-		return nil, err
-	}
-
-	useFallback := versionPkg.Version(dver.DockerVersion).LessThan("1.8.3")
-
-	if useFallback {
-		var v1Image image.V1Image
-		err := json.Unmarshal(imageJSON, &v1Image)
-		if err != nil {
-			return nil, err
-		}
-		imageJSON, err = json.Marshal(v1Image)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	var c map[string]*json.RawMessage
-	if err := json.Unmarshal(imageJSON, &c); err != nil {
-		return nil, err
-	}
-
-	c["rootfs"] = rawJSON(rootfs)
-	c["history"] = rawJSON(history)
-
-	return c, nil
-}
-
-func rawJSON(value interface{}) *json.RawMessage {
-	jsonval, err := json.Marshal(value)
-	if err != nil {
-		return nil
-	}
-	return (*json.RawMessage)(&jsonval)
-}
-
-func continueOnError(err error) bool {
-	switch v := err.(type) {
-	case errcode.Errors:
-		if len(v) == 0 {
-			return true
-		}
-		return continueOnError(v[0])
-	case distribution.ErrNoSupport:
-		return continueOnError(v.Err)
-	case errcode.Error:
-		return shouldV2Fallback(v)
-	case *client.UnexpectedHTTPResponseError:
-		return true
-	case ImageConfigPullError:
-		return false
-	case error:
-		return !strings.Contains(err.Error(), strings.ToLower(syscall.ENOSPC.Error()))
-	}
-	// let's be nice and fallback if the error is a completely
-	// unexpected one.
-	// If new errors have to be handled in some way, please
-	// add them to the switch above.
-	return true
-}
-
-// shouldV2Fallback returns true if this error is a reason to fall back to v1.
-func shouldV2Fallback(err errcode.Error) bool {
-	switch err.Code {
-	case errcode.ErrorCodeUnauthorized, v2.ErrorCodeManifestUnknown, v2.ErrorCodeNameUnknown:
-		return true
-	}
-	return false
-}

docker/inspect/inspect_v1.go

@@ -1,170 +0,0 @@
-package inspect
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/registry/client/transport"
-	dockerdistribution "github.com/docker/docker/distribution"
-	"github.com/docker/docker/dockerversion"
-	"github.com/docker/docker/image"
-	"github.com/docker/docker/image/v1"
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/registry"
-	engineTypes "github.com/docker/engine-api/types"
-	"github.com/projectatomic/skopeo/types"
-	"golang.org/x/net/context"
-)
-
-type v1ManifestFetcher struct {
-	endpoint    registry.APIEndpoint
-	repoInfo    *registry.RepositoryInfo
-	repo        distribution.Repository
-	confirmedV2 bool
-	// wrap in a config?
-	authConfig engineTypes.AuthConfig
-	service    *registry.Service
-	session    *registry.Session
-}
-
-func (mf *v1ManifestFetcher) Fetch(ctx context.Context, ref reference.Named) (types.ImageManifest, error) {
-	var (
-		imgInspect types.ImageManifest
-	)
-	if _, isCanonical := ref.(reference.Canonical); isCanonical {
-		// Allowing fallback, because HTTPS v1 is before HTTP v2
-		return nil, fallbackError{err: dockerdistribution.ErrNoSupport{errors.New("Cannot pull by digest with v1 registry")}}
-	}
-	tlsConfig, err := mf.service.TLSConfig(mf.repoInfo.Index.Name)
-	if err != nil {
-		return nil, err
-	}
-	// Adds Docker-specific headers as well as user-specified headers (metaHeaders)
-	tr := transport.NewTransport(
-		registry.NewTransport(tlsConfig),
-		//registry.DockerHeaders(mf.config.MetaHeaders)...,
-		registry.DockerHeaders(dockerversion.DockerUserAgent(), nil)...,
-	)
-	client := registry.HTTPClient(tr)
-	//v1Endpoint, err := mf.endpoint.ToV1Endpoint(mf.config.MetaHeaders)
-	v1Endpoint, err := mf.endpoint.ToV1Endpoint(dockerversion.DockerUserAgent(), nil)
-	if err != nil {
-		logrus.Debugf("Could not get v1 endpoint: %v", err)
-		return nil, fallbackError{err: err}
-	}
-	mf.session, err = registry.NewSession(client, &mf.authConfig, v1Endpoint)
-	if err != nil {
-		logrus.Debugf("Fallback from error: %s", err)
-		return nil, fallbackError{err: err}
-	}
-	imgInspect, err = mf.fetchWithSession(ctx, ref)
-	if err != nil {
-		return nil, err
-	}
-	return imgInspect, nil
-}
-
-func (mf *v1ManifestFetcher) fetchWithSession(ctx context.Context, ref reference.Named) (types.ImageManifest, error) {
-	repoData, err := mf.session.GetRepositoryData(mf.repoInfo)
-	if err != nil {
-		if strings.Contains(err.Error(), "HTTP code: 404") {
-			return nil, fmt.Errorf("Error: image %s not found", mf.repoInfo.RemoteName())
-		}
-		// Unexpected HTTP error
-		return nil, err
-	}
-
-	var tagsList map[string]string
-	tagsList, err = mf.session.GetRemoteTags(repoData.Endpoints, mf.repoInfo)
-	if err != nil {
-		logrus.Errorf("unable to get remote tags: %s", err)
-		return nil, err
-	}
-
-	logrus.Debugf("Retrieving the tag list")
-	tagged, isTagged := ref.(reference.NamedTagged)
-	var tagID, tag string
-	if isTagged {
-		tag = tagged.Tag()
-		tagsList[tagged.Tag()] = tagID
-	} else {
-		ref, err = reference.WithTag(ref, reference.DefaultTag)
-		if err != nil {
-			return nil, err
-		}
-		tagged, _ := ref.(reference.NamedTagged)
-		tag = tagged.Tag()
-		tagsList[tagged.Tag()] = tagID
-	}
-	tagID, err = mf.session.GetRemoteTag(repoData.Endpoints, mf.repoInfo, tag)
-	if err == registry.ErrRepoNotFound {
-		return nil, fmt.Errorf("Tag %s not found in repository %s", tag, mf.repoInfo.FullName())
-	}
-	if err != nil {
-		logrus.Errorf("unable to get remote tags: %s", err)
-		return nil, err
-	}
-
-	tagList := []string{}
-	for tag := range tagsList {
-		tagList = append(tagList, tag)
-	}
-
-	img := repoData.ImgList[tagID]
-
-	var pulledImg *image.Image
-	for _, ep := range mf.repoInfo.Index.Mirrors {
-		if pulledImg, err = mf.pullImageJSON(img.ID, ep, repoData.Tokens); err != nil {
-			// Don't report errors when pulling from mirrors.
-			logrus.Debugf("Error pulling image json of %s:%s, mirror: %s, %s", mf.repoInfo.FullName(), img.Tag, ep, err)
-			continue
-		}
-		break
-	}
-	if pulledImg == nil {
-		for _, ep := range repoData.Endpoints {
-			if pulledImg, err = mf.pullImageJSON(img.ID, ep, repoData.Tokens); err != nil {
-				// It's not ideal that only the last error is returned, it would be better to concatenate the errors.
-				logrus.Infof("Error pulling image json of %s:%s, endpoint: %s, %v", mf.repoInfo.FullName(), img.Tag, ep, err)
-				continue
-			}
-			break
-		}
-	}
-	if err != nil {
-		return nil, fmt.Errorf("Error pulling image (%s) from %s, %v", img.Tag, mf.repoInfo.FullName(), err)
-	}
-	if pulledImg == nil {
-		return nil, fmt.Errorf("No such image %s:%s", mf.repoInfo.FullName(), tag)
-	}
-
-	return makeImageManifest(pulledImg, tag, "", tagList), nil
-}
-
-func (mf *v1ManifestFetcher) pullImageJSON(imgID, endpoint string, token []string) (*image.Image, error) {
-	imgJSON, _, err := mf.session.GetRemoteImageJSON(imgID, endpoint)
-	if err != nil {
-		return nil, err
-	}
-	h, err := v1.HistoryFromConfig(imgJSON, false)
-	if err != nil {
-		return nil, err
-	}
-	configRaw, err := makeRawConfigFromV1Config(imgJSON, image.NewRootFS(), []image.History{h})
-	if err != nil {
-		return nil, err
-	}
-	config, err := json.Marshal(configRaw)
-	if err != nil {
-		return nil, err
-	}
-	img, err := image.NewFromJSON(config)
-	if err != nil {
-		return nil, err
-	}
-	return img, nil
-}

docker/inspect/inspect_v2.go

@@ -1,486 +0,0 @@
-package inspect
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"runtime"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/manifest/manifestlist"
-	"github.com/docker/distribution/manifest/schema1"
-	"github.com/docker/distribution/manifest/schema2"
-	"github.com/docker/distribution/registry/api/errcode"
-	"github.com/docker/distribution/registry/client"
-	dockerdistribution "github.com/docker/docker/distribution"
-	"github.com/docker/docker/image"
-	"github.com/docker/docker/image/v1"
-	"github.com/docker/docker/reference"
-	"github.com/docker/docker/registry"
-	engineTypes "github.com/docker/engine-api/types"
-	"github.com/projectatomic/skopeo/types"
-	"golang.org/x/net/context"
-)
-
-type v2ManifestFetcher struct {
-	endpoint    registry.APIEndpoint
-	repoInfo    *registry.RepositoryInfo
-	repo        distribution.Repository
-	confirmedV2 bool
-	// wrap in a config?
-	authConfig engineTypes.AuthConfig
-	service    *registry.Service
-}
-
-func (mf *v2ManifestFetcher) Fetch(ctx context.Context, ref reference.Named) (types.ImageManifest, error) {
-	var (
-		imgInspect types.ImageManifest
-		err        error
-	)
-
-	//mf.repo, mf.confirmedV2, err = distribution.NewV2Repository(ctx, mf.repoInfo, mf.endpoint, mf.config.MetaHeaders, mf.config.AuthConfig, "pull")
-	mf.repo, mf.confirmedV2, err = dockerdistribution.NewV2Repository(ctx, mf.repoInfo, mf.endpoint, nil, &mf.authConfig, "pull")
-	if err != nil {
-		logrus.Debugf("Error getting v2 registry: %v", err)
-		return nil, err
-	}
-
-	imgInspect, err = mf.fetchWithRepository(ctx, ref)
-	if err != nil {
-		if _, ok := err.(fallbackError); ok {
-			return nil, err
-		}
-		if continueOnError(err) {
-			logrus.Errorf("Error trying v2 registry: %v", err)
-			return nil, fallbackError{err: err, confirmedV2: mf.confirmedV2, transportOK: true}
-		}
-	}
-	return imgInspect, err
-}
-
-func (mf *v2ManifestFetcher) fetchWithRepository(ctx context.Context, ref reference.Named) (types.ImageManifest, error) {
-	var (
-		manifest    distribution.Manifest
-		tagOrDigest string // Used for logging/progress only
-		tagList     = []string{}
-	)
-
-	manSvc, err := mf.repo.Manifests(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if _, isTagged := ref.(reference.NamedTagged); !isTagged {
-		ref, err = reference.WithTag(ref, reference.DefaultTag)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if tagged, isTagged := ref.(reference.NamedTagged); isTagged {
-		// NOTE: not using TagService.Get, since it uses HEAD requests
-		// against the manifests endpoint, which are not supported by
-		// all registry versions.
-		manifest, err = manSvc.Get(ctx, "", client.WithTag(tagged.Tag()))
-		if err != nil {
-			return nil, allowV1Fallback(err)
-		}
-		tagOrDigest = tagged.Tag()
-	} else if digested, isDigested := ref.(reference.Canonical); isDigested {
-		manifest, err = manSvc.Get(ctx, digested.Digest())
-		if err != nil {
-			return nil, err
-		}
-		tagOrDigest = digested.Digest().String()
-	} else {
-		return nil, fmt.Errorf("internal error: reference has neither a tag nor a digest: %s", ref.String())
-	}
-
-	if manifest == nil {
-		return nil, fmt.Errorf("image manifest does not exist for tag or digest %q", tagOrDigest)
-	}
-
-	// If manSvc.Get succeeded, we can be confident that the registry on
-	// the other side speaks the v2 protocol.
-	mf.confirmedV2 = true
-
-	tagList, err = mf.repo.Tags(ctx).All(ctx)
-	if err != nil {
-		// If this repository doesn't exist on V2, we should
-		// permit a fallback to V1.
-		return nil, allowV1Fallback(err)
-	}
-
-	var (
-		image          *image.Image
-		manifestDigest digest.Digest
-	)
-
-	switch v := manifest.(type) {
-	case *schema1.SignedManifest:
-		image, manifestDigest, err = mf.pullSchema1(ctx, ref, v)
-		if err != nil {
-			return nil, err
-		}
-	case *schema2.DeserializedManifest:
-		image, manifestDigest, err = mf.pullSchema2(ctx, ref, v)
-		if err != nil {
-			return nil, err
-		}
-	case *manifestlist.DeserializedManifestList:
-		image, manifestDigest, err = mf.pullManifestList(ctx, ref, v)
-		if err != nil {
-			return nil, err
-		}
-	default:
-		return nil, errors.New("unsupported manifest format")
-	}
-
-	// TODO(runcom)
-	//var showTags bool
-	//if reference.IsNameOnly(ref) {
-	//showTags = true
-	//logrus.Debug("Using default tag: latest")
-	//ref = reference.WithDefaultTag(ref)
-	//}
-	//_ = showTags
-	return makeImageManifest(image, tagOrDigest, manifestDigest, tagList), nil
-}
-
-func (mf *v2ManifestFetcher) pullSchema1(ctx context.Context, ref reference.Named, unverifiedManifest *schema1.SignedManifest) (img *image.Image, manifestDigest digest.Digest, err error) {
-	var verifiedManifest *schema1.Manifest
-	verifiedManifest, err = verifySchema1Manifest(unverifiedManifest, ref)
-	if err != nil {
-		return nil, "", err
-	}
-
-	// remove duplicate layers and check parent chain validity
-	err = fixManifestLayers(verifiedManifest)
-	if err != nil {
-		return nil, "", err
-	}
-
-	// Image history converted to the new format
-	var history []image.History
-
-	// Note that the order of this loop is in the direction of bottom-most
-	// to top-most, so that the downloads slice gets ordered correctly.
-	for i := len(verifiedManifest.FSLayers) - 1; i >= 0; i-- {
-		var throwAway struct {
-			ThrowAway bool `json:"throwaway,omitempty"`
-		}
-		if err := json.Unmarshal([]byte(verifiedManifest.History[i].V1Compatibility), &throwAway); err != nil {
-			return nil, "", err
-		}
-
-		h, err := v1.HistoryFromConfig([]byte(verifiedManifest.History[i].V1Compatibility), throwAway.ThrowAway)
-		if err != nil {
-			return nil, "", err
-		}
-		history = append(history, h)
-	}
-
-	rootFS := image.NewRootFS()
-	configRaw, err := makeRawConfigFromV1Config([]byte(verifiedManifest.History[0].V1Compatibility), rootFS, history)
-
-	config, err := json.Marshal(configRaw)
-	if err != nil {
-		return nil, "", err
-	}
-
-	img, err = image.NewFromJSON(config)
-	if err != nil {
-		return nil, "", err
-	}
-
-	manifestDigest = digest.FromBytes(unverifiedManifest.Canonical)
-
-	return img, manifestDigest, nil
-}
-
-func verifySchema1Manifest(signedManifest *schema1.SignedManifest, ref reference.Named) (m *schema1.Manifest, err error) {
-	// If pull by digest, then verify the manifest digest. NOTE: It is
-	// important to do this first, before any other content validation. If the
-	// digest cannot be verified, don't even bother with those other things.
-	if digested, isCanonical := ref.(reference.Canonical); isCanonical {
-		verifier, err := digest.NewDigestVerifier(digested.Digest())
-		if err != nil {
-			return nil, err
-		}
-		if _, err := verifier.Write(signedManifest.Canonical); err != nil {
-			return nil, err
-		}
-		if !verifier.Verified() {
-			err := fmt.Errorf("image verification failed for digest %s", digested.Digest())
-			logrus.Error(err)
-			return nil, err
-		}
-	}
-	m = &signedManifest.Manifest
-
-	if m.SchemaVersion != 1 {
-		return nil, fmt.Errorf("unsupported schema version %d for %q", m.SchemaVersion, ref.String())
-	}
-	if len(m.FSLayers) != len(m.History) {
-		return nil, fmt.Errorf("length of history not equal to number of layers for %q", ref.String())
-	}
-	if len(m.FSLayers) == 0 {
-		return nil, fmt.Errorf("no FSLayers in manifest for %q", ref.String())
-	}
-	return m, nil
-}
-
-func fixManifestLayers(m *schema1.Manifest) error {
-	imgs := make([]*image.V1Image, len(m.FSLayers))
-	for i := range m.FSLayers {
-		img := &image.V1Image{}
-
-		if err := json.Unmarshal([]byte(m.History[i].V1Compatibility), img); err != nil {
-			return err
-		}
-
-		imgs[i] = img
-		if err := v1.ValidateID(img.ID); err != nil {
-			return err
-		}
-	}
-
-	if imgs[len(imgs)-1].Parent != "" && runtime.GOOS != "windows" {
-		// Windows base layer can point to a base layer parent that is not in manifest.
-		return errors.New("Invalid parent ID in the base layer of the image.")
-	}
-
-	// check general duplicates to error instead of a deadlock
-	idmap := make(map[string]struct{})
-
-	var lastID string
-	for _, img := range imgs {
-		// skip IDs that appear after each other, we handle those later
-		if _, exists := idmap[img.ID]; img.ID != lastID && exists {
-			return fmt.Errorf("ID %+v appears multiple times in manifest", img.ID)
-		}
-		lastID = img.ID
-		idmap[lastID] = struct{}{}
-	}
-
-	// backwards loop so that we keep the remaining indexes after removing items
-	for i := len(imgs) - 2; i >= 0; i-- {
-		if imgs[i].ID == imgs[i+1].ID { // repeated ID. remove and continue
-			m.FSLayers = append(m.FSLayers[:i], m.FSLayers[i+1:]...)
-			m.History = append(m.History[:i], m.History[i+1:]...)
-		} else if imgs[i].Parent != imgs[i+1].ID {
-			return fmt.Errorf("Invalid parent ID. Expected %v, got %v.", imgs[i+1].ID, imgs[i].Parent)
-		}
-	}
-
-	return nil
-}
-
-func (mf *v2ManifestFetcher) pullSchema2(ctx context.Context, ref reference.Named, mfst *schema2.DeserializedManifest) (img *image.Image, manifestDigest digest.Digest, err error) {
-	manifestDigest, err = schema2ManifestDigest(ref, mfst)
-	if err != nil {
-		return nil, "", err
-	}
-
-	target := mfst.Target()
-
-	configChan := make(chan []byte, 1)
-	errChan := make(chan error, 1)
-	var cancel func()
-	ctx, cancel = context.WithCancel(ctx)
-
-	// Pull the image config
-	go func() {
-		configJSON, err := mf.pullSchema2ImageConfig(ctx, target.Digest)
-		if err != nil {
-			errChan <- ImageConfigPullError{Err: err}
-			cancel()
-			return
-		}
-		configChan <- configJSON
-	}()
-
-	var (
-		configJSON         []byte      // raw serialized image config
-		unmarshalledConfig image.Image // deserialized image config
-	)
-	if runtime.GOOS == "windows" {
-		configJSON, unmarshalledConfig, err = receiveConfig(configChan, errChan)
-		if err != nil {
-			return nil, "", err
-		}
-		if unmarshalledConfig.RootFS == nil {
-			return nil, "", errors.New("image config has no rootfs section")
-		}
-	}
-
-	if configJSON == nil {
-		configJSON, unmarshalledConfig, err = receiveConfig(configChan, errChan)
-		if err != nil {
-			return nil, "", err
-		}
-	}
-
-	img, err = image.NewFromJSON(configJSON)
-	if err != nil {
-		return nil, "", err
-	}
-
-	return img, manifestDigest, nil
-}
-
-func (mf *v2ManifestFetcher) pullSchema2ImageConfig(ctx context.Context, dgst digest.Digest) (configJSON []byte, err error) {
-	blobs := mf.repo.Blobs(ctx)
-	configJSON, err = blobs.Get(ctx, dgst)
-	if err != nil {
-		return nil, err
-	}
-
-	// Verify image config digest
-	verifier, err := digest.NewDigestVerifier(dgst)
-	if err != nil {
-		return nil, err
-	}
-	if _, err := verifier.Write(configJSON); err != nil {
-		return nil, err
-	}
-	if !verifier.Verified() {
-		err := fmt.Errorf("image config verification failed for digest %s", dgst)
-		logrus.Error(err)
-		return nil, err
-	}
-
-	return configJSON, nil
-}
-
-func receiveConfig(configChan <-chan []byte, errChan <-chan error) ([]byte, image.Image, error) {
-	select {
-	case configJSON := <-configChan:
-		var unmarshalledConfig image.Image
-		if err := json.Unmarshal(configJSON, &unmarshalledConfig); err != nil {
-			return nil, image.Image{}, err
-		}
-		return configJSON, unmarshalledConfig, nil
-	case err := <-errChan:
-		return nil, image.Image{}, err
-		// Don't need a case for ctx.Done in the select because cancellation
-		// will trigger an error in p.pullSchema2ImageConfig.
-	}
-}
-
-// ImageConfigPullError is an error pulling the image config blob
-// (only applies to schema2).
-type ImageConfigPullError struct {
-	Err error
-}
-
-// Error returns the error string for ImageConfigPullError.
-func (e ImageConfigPullError) Error() string {
-	return "error pulling image configuration: " + e.Err.Error()
-}
-
-// allowV1Fallback checks if the error is a possible reason to fallback to v1
-// (even if confirmedV2 has been set already), and if so, wraps the error in
-// a fallbackError with confirmedV2 set to false. Otherwise, it returns the
-// error unmodified.
-func allowV1Fallback(err error) error {
-	switch v := err.(type) {
-	case errcode.Errors:
-		if len(v) != 0 {
-			if v0, ok := v[0].(errcode.Error); ok && shouldV2Fallback(v0) {
-				return fallbackError{err: err, confirmedV2: false, transportOK: true}
-			}
-		}
-	case errcode.Error:
-		if shouldV2Fallback(v) {
-			return fallbackError{err: err, confirmedV2: false, transportOK: true}
-		}
-	}
-	return err
-}
-
-// schema2ManifestDigest computes the manifest digest, and, if pulling by
-// digest, ensures that it matches the requested digest.
-func schema2ManifestDigest(ref reference.Named, mfst distribution.Manifest) (digest.Digest, error) {
-	_, canonical, err := mfst.Payload()
-	if err != nil {
-		return "", err
-	}
-
-	// If pull by digest, then verify the manifest digest.
-	if digested, isDigested := ref.(reference.Canonical); isDigested {
-		verifier, err := digest.NewDigestVerifier(digested.Digest())
-		if err != nil {
-			return "", err
-		}
-		if _, err := verifier.Write(canonical); err != nil {
-			return "", err
-		}
-		if !verifier.Verified() {
-			err := fmt.Errorf("manifest verification failed for digest %s", digested.Digest())
-			logrus.Error(err)
-			return "", err
-		}
-		return digested.Digest(), nil
-	}
-
-	return digest.FromBytes(canonical), nil
-}
-
-// pullManifestList handles "manifest lists" which point to various
-// platform-specifc manifests.
-func (mf *v2ManifestFetcher) pullManifestList(ctx context.Context, ref reference.Named, mfstList *manifestlist.DeserializedManifestList) (img *image.Image, manifestListDigest digest.Digest, err error) {
-	manifestListDigest, err = schema2ManifestDigest(ref, mfstList)
-	if err != nil {
-		return nil, "", err
-	}
-
-	var manifestDigest digest.Digest
-	for _, manifestDescriptor := range mfstList.Manifests {
-		// TODO(aaronl): The manifest list spec supports optional
-		// "features" and "variant" fields. These are not yet used.
-		// Once they are, their values should be interpreted here.
-		if manifestDescriptor.Platform.Architecture == runtime.GOARCH && manifestDescriptor.Platform.OS == runtime.GOOS {
-			manifestDigest = manifestDescriptor.Digest
-			break
-		}
-	}
-
-	if manifestDigest == "" {
-		return nil, "", errors.New("no supported platform found in manifest list")
-	}
-
-	manSvc, err := mf.repo.Manifests(ctx)
-	if err != nil {
-		return nil, "", err
-	}
-
-	manifest, err := manSvc.Get(ctx, manifestDigest)
-	if err != nil {
-		return nil, "", err
-	}
-
-	manifestRef, err := reference.WithDigest(ref, manifestDigest)
-	if err != nil {
-		return nil, "", err
-	}
-
-	switch v := manifest.(type) {
-	case *schema1.SignedManifest:
-		img, _, err = mf.pullSchema1(ctx, manifestRef, v)
-		if err != nil {
-			return nil, "", err
-		}
-	case *schema2.DeserializedManifest:
-		img, _, err = mf.pullSchema2(ctx, manifestRef, v)
-		if err != nil {
-			return nil, "", err
-		}
-	default:
-		return nil, "", errors.New("unsupported manifest format")
-	}
-
-	return img, manifestListDigest, err
-}

hack/vendor.sh

@@ -5,22 +5,15 @@ cd "$(dirname "$BASH_SOURCE")/.."
 rm -rf vendor/
 source 'hack/.vendor-helpers.sh'
 
-clone git github.com/codegangsta/cli master
-clone git github.com/Sirupsen/logrus v0.8.7
-clone git github.com/vbatts/tar-split v0.9.11
-clone git github.com/gorilla/mux master
-clone git github.com/gorilla/context master
-clone git golang.org/x/net master https://github.com/golang/net.git
+clone git github.com/codegangsta/cli v1.2.0
+clone git github.com/Sirupsen/logrus v0.10.0
 clone git github.com/go-check/check v1
-
-clone git github.com/docker/docker 9e2c4de0dea695411f8df2efd116594eaf4602aa
-clone git github.com/docker/engine-api 8193a3a11c076ef0d80da8f98ef99a2c53a51320
-clone git github.com/docker/distribution 7b66c50bb7e0e4b3b83f8fd134a9f6ea4be08b57
-
+clone git github.com/docker/docker master
+clone git github.com/docker/distribution master
+clone git github.com/docker/engine-api master
+clone git github.com/opencontainers/runc master
 clone git github.com/docker/go-connections master
 clone git github.com/docker/go-units master
-clone git github.com/docker/libtrust master
-clone git github.com/opencontainers/runc master
 
 clean
 

integration/check_test.go

@@ -81,10 +81,14 @@ func (s *SkopeoSuite) TestVersion(c *check.C) {
 	}
 }
 
+var (
+	errFetchManifest = "error fetching manifest: status code: %s"
+)
+
 func (s *SkopeoSuite) TestCanAuthToPrivateRegistryV2WithoutDockerCfg(c *check.C) {
 	out, err := exec.Command(skopeoBinary, "--docker-cfg=''", "--username="+s.regV2WithAuth.username, "--password="+s.regV2WithAuth.password, "inspect", fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url)).CombinedOutput()
 	c.Assert(err, check.NotNil, check.Commentf(string(out)))
-	wanted := "Error: image busybox not found"
+	wanted := fmt.Sprintf(errFetchManifest, "401")
 	if !strings.Contains(string(out), wanted) {
 		c.Fatalf("wanted %s, got %s", wanted, string(out))
 	}
@@ -93,7 +97,7 @@ func (s *SkopeoSuite) TestCanAuthToPrivateRegistryV2WithoutDockerCfg(c *check.C)
 func (s *SkopeoSuite) TestNeedAuthToPrivateRegistryV2WithoutDockerCfg(c *check.C) {
 	out, err := exec.Command(skopeoBinary, "--docker-cfg=''", "inspect", fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url)).CombinedOutput()
 	c.Assert(err, check.NotNil, check.Commentf(string(out)))
-	wanted := "no basic auth credentials"
+	wanted := fmt.Sprintf(errFetchManifest, "401")
 	if !strings.Contains(string(out), wanted) {
 		c.Fatalf("wanted %s, got %s", wanted, string(out))
 	}
@@ -104,11 +108,11 @@ func (s *SkopeoSuite) TestNeedAuthToPrivateRegistryV2WithoutDockerCfg(c *check.C
 func (s *SkopeoSuite) TestNoNeedAuthToPrivateRegistryV2ImageNotFound(c *check.C) {
 	out, err := exec.Command(skopeoBinary, "inspect", fmt.Sprintf("docker://%s/busybox:latest", s.regV2.url)).CombinedOutput()
 	c.Assert(err, check.NotNil, check.Commentf(string(out)))
-	wanted := "Error: image busybox not found"
+	wanted := fmt.Sprintf(errFetchManifest, "404")
 	if !strings.Contains(string(out), wanted) {
 		c.Fatalf("wanted %s, got %s", wanted, string(out))
 	}
-	wanted = "no basic auth credentials"
+	wanted = fmt.Sprintf(errFetchManifest, "401")
 	if strings.Contains(string(out), wanted) {
 		c.Fatalf("not wanted %s, got %s", wanted, string(out))
 	}

reference/reference.go

@@ -1,5 +1,4 @@
-// COPY FROM DOCKER/DOCKER
-package reference
+package reference // COPY WITH EDITS FROM DOCKER/DOCKER
 
 import (
 	"errors"

types/types.go

@@ -1,52 +1,58 @@
 package types
 
 import (
-	containerTypes "github.com/docker/engine-api/types/container"
+	"fmt"
+	"time"
 )
 
 const (
+	// DockerPrefix is the URL-like schema prefix used for Docker image references.
 	DockerPrefix = "docker://"
 )
 
+// Registry is a service providing repositories.
 type Registry interface {
 	Repositories() []Repository
 	Repository(ref string) Repository
 	Lookup(term string) []Image // docker registry v1 only AFAICT, v2 can be built hacking with Images()
 }
 
+// Repository is a set of images.
 type Repository interface {
 	Images() []Image
 	Image(ref string) Image // ref == image name w/o registry part
 }
 
+// Image is a Docker image in a repository.
 type Image interface {
 	// ref to repository?
 	Layers(layers ...string) error // configure download directory? Call it DownloadLayers?
-	Manifest(version string) (ImageManifest, error)
+	Manifest() (ImageManifest, error)
 	RawManifest(version string) ([]byte, error)
 	DockerTar() ([]byte, error) // ??? also, configure output directory
 }
 
+// ImageManifest is the interesting subset of metadata about an Image.
 // TODO(runcom)
 type ImageManifest interface {
-	Labels() map[string]string
+	String() string
 }
 
+// DockerImageManifest is a set of metadata describing Docker images and their manifest.json files.
+// Note that this is not exactly manifest.json, e.g. some fields have been added.
 type DockerImageManifest struct {
+	Name          string
 	Tag           string
 	Digest        string
 	RepoTags      []string
-	Comment         string
-	Created         string
-	ContainerConfig *containerTypes.Config // remove docker/docker code, this isn't needed
+	Created       time.Time
 	DockerVersion string
-	Author          string
-	Config          *containerTypes.Config // remove docker/docker code, needs just Labels here for now, maybe Cmd? Hostname?
+	Labels        map[string]string
 	Architecture  string
 	Os            string
-	Layers          []string // ???
+	Layers        []string
 }
 
-func (m *DockerImageManifest) Labels() map[string]string {
-	return m.Config.Labels
+func (m *DockerImageManifest) String() string {
+	return fmt.Sprintf("%s:%s", m.Name, m.Tag)
 }

utils.go

@@ -7,6 +7,7 @@ import (
 	"github.com/projectatomic/skopeo/types"
 )
 
+// ParseImage converts image URL-like string to an initialized handler for that image.
 func ParseImage(img string) (types.Image, error) {
 	switch {
 	case strings.HasPrefix(img, types.DockerPrefix):

vendor/github.com/Sirupsen/logrus/.travis.yml

@@ -1,8 +1,9 @@
 language: go
 go:
-  - 1.2
   - 1.3
   - 1.4
+  - 1.5
   - tip
 install:
   - go get -t ./...
+script: GOMAXPROCS=4 GORACE="halt_on_error=1" go test -race -v ./...

vendor/github.com/Sirupsen/logrus/CHANGELOG.md

@@ -1,3 +1,22 @@
+# 0.10.0
+
+* feature: Add a test hook (#180)
+* feature: `ParseLevel` is now case-insensitive (#326)
+* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308)
+* performance: avoid re-allocations on `WithFields` (#335)
+
+# 0.9.0
+
+* logrus/text_formatter: don't emit empty msg
+* logrus/hooks/airbrake: move out of main repository
+* logrus/hooks/sentry: move out of main repository
+* logrus/hooks/papertrail: move out of main repository
+* logrus/hooks/bugsnag: move out of main repository
+* logrus/core: run tests with `-race`
+* logrus/core: detect TTY based on `stderr`
+* logrus/core: support `WithError` on logger
+* logrus/core: Solaris support
+
 # 0.8.7
 
 * logrus/core: fix possible race (#216)

vendor/github.com/Sirupsen/logrus/README.md

@@ -1,4 +1,4 @@
-# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus)&nbsp;[![godoc reference](https://godoc.org/github.com/Sirupsen/logrus?status.png)][godoc]
+# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus)&nbsp;[![GoDoc](https://godoc.org/github.com/Sirupsen/logrus?status.svg)](https://godoc.org/github.com/Sirupsen/logrus)
 
 Logrus is a structured logger for Go (golang), completely API compatible with
 the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not
@@ -12,7 +12,7 @@ plain text):
 
 ![Colored](http://i.imgur.com/PY7qMwd.png)
 
-With `log.Formatter = new(logrus.JSONFormatter)`, for easy parsing by logstash
+With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash
 or Splunk:
 
 ```json
@@ -32,7 +32,7 @@ ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
 "time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
 ```
 
-With the default `log.Formatter = new(&log.TextFormatter{})` when a TTY is not
+With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not
 attached, the output is compatible with the
 [logfmt](http://godoc.org/github.com/kr/logfmt) format:
 
@@ -75,17 +75,12 @@ package main
 import (
   "os"
   log "github.com/Sirupsen/logrus"
-  "github.com/Sirupsen/logrus/hooks/airbrake"
 )
 
 func init() {
   // Log as JSON instead of the default ASCII formatter.
   log.SetFormatter(&log.JSONFormatter{})
 
-  // Use the Airbrake hook to report errors that have Error severity or above to
-  // an exception tracker. You can create custom hooks, see the Hooks section.
-  log.AddHook(airbrake.NewHook("https://example.com", "xyz", "development"))
-
   // Output to stderr instead of stdout, could also be a file.
   log.SetOutput(os.Stderr)
 
@@ -182,13 +177,16 @@ Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
 ```go
 import (
   log "github.com/Sirupsen/logrus"
-  "github.com/Sirupsen/logrus/hooks/airbrake"
+  "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "aibrake"
   logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
   "log/syslog"
 )
 
 func init() {
-  log.AddHook(airbrake.NewHook("https://example.com", "xyz", "development"))
+
+  // Use the Airbrake hook to report errors that have Error severity or above to
+  // an exception tracker. You can create custom hooks, see the Hooks section.
+  log.AddHook(airbrake.NewHook(123, "xyz", "production"))
 
   hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
   if err != nil {
@@ -198,20 +196,21 @@ func init() {
   }
 }
 ```
-
+Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
 
 | Hook  | Description |
 | ----- | ----------- |
-| [Airbrake](https://github.com/Sirupsen/logrus/blob/master/hooks/airbrake/airbrake.go) | Send errors to an exception tracking service compatible with the Airbrake API. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. |
-| [Papertrail](https://github.com/Sirupsen/logrus/blob/master/hooks/papertrail/papertrail.go) | Send errors to the Papertrail hosted logging service via UDP. |
+| [Airbrake](https://github.com/gemnasium/logrus-airbrake-hook) | Send errors to the Airbrake API V3. Uses the official [`gobrake`](https://github.com/airbrake/gobrake) behind the scenes. |
+| [Airbrake "legacy"](https://github.com/gemnasium/logrus-airbrake-legacy-hook) | Send errors to an exception tracking service compatible with the Airbrake API V2. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. |
+| [Papertrail](https://github.com/polds/logrus-papertrail-hook) | Send errors to the [Papertrail](https://papertrailapp.com) hosted logging service via UDP. |
 | [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. |
-| [BugSnag](https://github.com/Sirupsen/logrus/blob/master/hooks/bugsnag/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |
-| [Sentry](https://github.com/Sirupsen/logrus/blob/master/hooks/sentry/sentry.go) | Send errors to the Sentry error logging and aggregation service. |
+| [Bugsnag](https://github.com/Shopify/logrus-bugsnag/blob/master/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |
+| [Sentry](https://github.com/evalphobia/logrus_sentry) | Send errors to the Sentry error logging and aggregation service. |
 | [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. |
 | [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) |
 | [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. |
 | [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` |
-| [Graylog](https://github.com/gemnasium/logrus-hooks/tree/master/graylog) | Hook for logging to [Graylog](http://graylog2.org/) |
+| [Graylog](https://github.com/gemnasium/logrus-graylog-hook) | Hook for logging to [Graylog](http://graylog2.org/) |
 | [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) |
 | [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem |
 | [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger |
@@ -219,6 +218,15 @@ func init() {
 | [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar |
 | [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd |
 | [Mongodb](https://github.com/weekface/mgorus) | Hook for logging to mongodb |
+| [InfluxDB](https://github.com/Abramovic/logrus_influxdb) | Hook for logging to influxdb |
+| [Octokit](https://github.com/dorajistyle/logrus-octokit-hook) | Hook for logging to github via octokit |
+| [DeferPanic](https://github.com/deferpanic/dp-logrus) | Hook for logging to DeferPanic |
+| [Redis-Hook](https://github.com/rogierlommers/logrus-redis-hook) | Hook for logging to a ELK stack (through Redis) |
+| [Amqp-Hook](https://github.com/vladoatanasov/logrus_amqp) | Hook for logging to Amqp broker (Like RabbitMQ) |
+| [KafkaLogrus](https://github.com/goibibo/KafkaLogrus) | Hook for logging to kafka |
+| [Typetalk](https://github.com/dragon3/logrus-typetalk-hook) | Hook for logging to [Typetalk](https://www.typetalk.in/) |
+| [ElasticSearch](https://github.com/sohlich/elogrus) | Hook for logging to ElasticSearch|
+
 
 #### Level logging
 
@@ -296,15 +304,16 @@ The built-in logging formatters are:
     field to `true`.  To force no colored output even if there is a TTY  set the
     `DisableColors` field to `true`
 * `logrus.JSONFormatter`. Logs fields as JSON.
-* `logrus_logstash.LogstashFormatter`. Logs fields as Logstash Events (http://logstash.net).
+* `logrus/formatters/logstash.LogstashFormatter`. Logs fields as [Logstash](http://logstash.net) Events.
 
     ```go
-      logrus.SetFormatter(&logrus_logstash.LogstashFormatter{Type: “application_name"})
+      logrus.SetFormatter(&logstash.LogstashFormatter{Type: "application_name"})
     ```
 
 Third party logging formatters:
 
-* [`zalgo`](https://github.com/aybabtme/logzalgo): invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
+* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
+* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
 
 You can define your formatter by implementing the `Formatter` interface,
 requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
@@ -353,5 +362,27 @@ Log rotation is not provided with Logrus. Log rotation should be done by an
 external program (like `logrotate(8)`) that can compress and delete old log
 entries. It should not be a feature of the application-level logger.
 
+#### Tools
 
-[godoc]: https://godoc.org/github.com/Sirupsen/logrus
+| Tool | Description |
+| ---- | ----------- |
+|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|
+
+#### Testing
+
+Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:
+
+* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook
+* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):
+
+```go
+logger, hook := NewNullLogger()
+logger.Error("Hello error")
+
+assert.Equal(1, len(hook.Entries))
+assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)
+assert.Equal("Hello error", hook.LastEntry().Message)
+
+hook.Reset()
+assert.Nil(hook.LastEntry())
+```

vendor/github.com/Sirupsen/logrus/entry.go

@@ -68,7 +68,7 @@ func (entry *Entry) WithField(key string, value interface{}) *Entry {
 
 // Add a map of fields to the Entry.
 func (entry *Entry) WithFields(fields Fields) *Entry {
-	data := Fields{}
+	data := make(Fields, len(entry.Data)+len(fields))
 	for k, v := range entry.Data {
 		data[k] = v
 	}

vendor/github.com/Sirupsen/logrus/logger.go

@@ -64,6 +64,12 @@ func (logger *Logger) WithFields(fields Fields) *Entry {
 	return NewEntry(logger).WithFields(fields)
 }
 
+// Add an error as single field to the log entry.  All it does is call
+// `WithError` for the given `error`.
+func (logger *Logger) WithError(err error) *Entry {
+	return NewEntry(logger).WithError(err)
+}
+
 func (logger *Logger) Debugf(format string, args ...interface{}) {
 	if logger.Level >= DebugLevel {
 		NewEntry(logger).Debugf(format, args...)

vendor/github.com/Sirupsen/logrus/logrus.go

@@ -3,6 +3,7 @@ package logrus
 import (
 	"fmt"
 	"log"
+	"strings"
 )
 
 // Fields type, used to pass to `WithFields`.
@@ -33,7 +34,7 @@ func (level Level) String() string {
 
 // ParseLevel takes a string level and returns the Logrus log level constant.
 func ParseLevel(lvl string) (Level, error) {
-	switch lvl {
+	switch strings.ToLower(lvl) {
 	case "panic":
 		return PanicLevel, nil
 	case "fatal":
@@ -52,6 +53,16 @@ func ParseLevel(lvl string) (Level, error) {
 	return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
 }
 
+// A constant exposing all logging levels
+var AllLevels = []Level{
+	PanicLevel,
+	FatalLevel,
+	ErrorLevel,
+	WarnLevel,
+	InfoLevel,
+	DebugLevel,
+}
+
 // These are the different logging levels. You can set the logging level to log
 // on your instance of logger, obtained with `logrus.New()`.
 const (
@@ -96,3 +107,37 @@ type StdLogger interface {
 	Panicf(string, ...interface{})
 	Panicln(...interface{})
 }
+
+// The FieldLogger interface generalizes the Entry and Logger types
+type FieldLogger interface {
+	WithField(key string, value interface{}) *Entry
+	WithFields(fields Fields) *Entry
+	WithError(err error) *Entry
+
+	Debugf(format string, args ...interface{})
+	Infof(format string, args ...interface{})
+	Printf(format string, args ...interface{})
+	Warnf(format string, args ...interface{})
+	Warningf(format string, args ...interface{})
+	Errorf(format string, args ...interface{})
+	Fatalf(format string, args ...interface{})
+	Panicf(format string, args ...interface{})
+
+	Debug(args ...interface{})
+	Info(args ...interface{})
+	Print(args ...interface{})
+	Warn(args ...interface{})
+	Warning(args ...interface{})
+	Error(args ...interface{})
+	Fatal(args ...interface{})
+	Panic(args ...interface{})
+
+	Debugln(args ...interface{})
+	Infoln(args ...interface{})
+	Println(args ...interface{})
+	Warnln(args ...interface{})
+	Warningln(args ...interface{})
+	Errorln(args ...interface{})
+	Fatalln(args ...interface{})
+	Panicln(args ...interface{})
+}

vendor/github.com/Sirupsen/logrus/terminal_notwindows.go

@@ -12,9 +12,9 @@ import (
 	"unsafe"
 )
 
-// IsTerminal returns true if the given file descriptor is a terminal.
+// IsTerminal returns true if stderr's file descriptor is a terminal.
 func IsTerminal() bool {
-	fd := syscall.Stdout
+	fd := syscall.Stderr
 	var termios Termios
 	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
 	return err == 0

vendor/github.com/Sirupsen/logrus/terminal_solaris.go

@@ -0,0 +1,15 @@
+// +build solaris
+
+package logrus
+
+import (
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func IsTerminal() bool {
+	_, err := unix.IoctlGetTermios(int(os.Stdout.Fd()), unix.TCGETA)
+	return err == nil
+}

vendor/github.com/Sirupsen/logrus/terminal_windows.go

@@ -18,9 +18,9 @@ var (
 	procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
 )
 
-// IsTerminal returns true if the given file descriptor is a terminal.
+// IsTerminal returns true if stderr's file descriptor is a terminal.
 func IsTerminal() bool {
-	fd := syscall.Stdout
+	fd := syscall.Stderr
 	var st uint32
 	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
 	return r != 0 && e == 0

vendor/github.com/Sirupsen/logrus/text_formatter.go

@@ -84,7 +84,9 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
 			f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))
 		}
 		f.appendKeyValue(b, "level", entry.Level.String())
+		if entry.Message != "" {
 			f.appendKeyValue(b, "msg", entry.Message)
+		}
 		for _, key := range keys {
 			f.appendKeyValue(b, key, entry.Data[key])
 		}

vendor/github.com/codegangsta/cli/.travis.yml

@@ -1,17 +1,5 @@
 language: go
-sudo: false
-
-go:
-- 1.1.2
-- 1.2.2
-- 1.3.3
-- 1.4.2
-- 1.5.1
-- tip
-
-matrix:
-  allow_failures:
-    - go: tip
+go: 1.1
 
 script:
 - go vet ./...

vendor/github.com/codegangsta/cli/README.md

@@ -1,35 +1,31 @@
-[![Coverage](http://gocover.io/_badge/github.com/codegangsta/cli?0)](http://gocover.io/github.com/codegangsta/cli)
-[![Build Status](https://travis-ci.org/codegangsta/cli.svg?branch=master)](https://travis-ci.org/codegangsta/cli)
-[![GoDoc](https://godoc.org/github.com/codegangsta/cli?status.svg)](https://godoc.org/github.com/codegangsta/cli)
-[![codebeat](https://codebeat.co/badges/0a8f30aa-f975-404b-b878-5fab3ae1cc5f)](https://codebeat.co/projects/github-com-codegangsta-cli)
+[![Build Status](https://travis-ci.org/codegangsta/cli.png?branch=master)](https://travis-ci.org/codegangsta/cli)
 
 # cli.go
+cli.go is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
 
-`cli.go` is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
+You can view the API docs here:
+http://godoc.org/github.com/codegangsta/cli
 
 ## Overview
-
 Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
 
-**This is where `cli.go` comes into play.** `cli.go` makes command line programming fun, organized, and expressive!
+This is where cli.go comes into play. cli.go makes command line programming fun, organized, and expressive!
 
 ## Installation
+Make sure you have a working Go environment (go 1.1 is *required*). [See the install instructions](http://golang.org/doc/install.html).
 
-Make sure you have a working Go environment (go 1.1+ is *required*). [See the install instructions](http://golang.org/doc/install.html).
-
-To install `cli.go`, simply run:
+To install cli.go, simply run:
 ```
 $ go get github.com/codegangsta/cli
 ```
 
-Make sure your `PATH` includes to the `$GOPATH/bin` directory so your commands can be easily used:
+Make sure your PATH includes to the `$GOPATH/bin` directory so your commands can be easily used:
 ```
 export PATH=$PATH:$GOPATH/bin
 ```
 
 ## Getting Started
-
-One of the philosophies behind `cli.go` is that an API should be playful and full of discovery. So a `cli.go` app can be as little as one line of code in `main()`.
+One of the philosophies behind cli.go is that an API should be playful and full of discovery. So a cli.go app can be as little as one line of code in `main()`. 
 
 ``` go
 package main
@@ -72,9 +68,8 @@ Running this already gives you a ton of functionality, plus support for things l
 
 Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!
 
-Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
-
 ``` go
+/* greet.go */
 package main
 
 import (
@@ -107,8 +102,7 @@ $ greet
 Hello friend!
 ```
 
-`cli.go` also generates neat help text:
-
+cli.go also generates some bitchass help text:
 ```
 $ greet help
 NAME:
@@ -128,8 +122,7 @@ GLOBAL OPTIONS
 ```
 
 ### Arguments
-
-You can lookup arguments by calling the `Args` function on `cli.Context`.
+You can lookup arguments by calling the `Args` function on cli.Context.
 
 ``` go
 ...
@@ -140,9 +133,7 @@ app.Action = func(c *cli.Context) {
 ```
 
 ### Flags
-
 Setting and querying flags is simple.
-
 ``` go
 ...
 app.Flags = []cli.Flag {
@@ -154,7 +145,7 @@ app.Flags = []cli.Flag {
 }
 app.Action = func(c *cli.Context) {
   name := "someone"
-  if c.NArg() > 0 {
+  if len(c.Args()) > 0 {
     name = c.Args()[0]
   }
   if c.String("lang") == "spanish" {
@@ -166,38 +157,9 @@ app.Action = func(c *cli.Context) {
 ...
 ```
 
-You can also set a destination variable for a flag, to which the content will be scanned.
-
-``` go
-...
-var language string
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name:        "lang",
-    Value:       "english",
-    Usage:       "language for the greeting",
-    Destination: &language,
-  },
-}
-app.Action = func(c *cli.Context) {
-  name := "someone"
-  if c.NArg() > 0 {
-    name = c.Args()[0]
-  }
-  if language == "spanish" {
-    println("Hola", name)
-  } else {
-    println("Hello", name)
-  }
-}
-...
-```
-
-See full list of flags at http://godoc.org/github.com/codegangsta/cli
-
 #### Alternate Names
 
-You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
+You can set alternate (or short) names for flags by providing a comma-delimited list for the Name. e.g.
 
 ``` go
 app.Flags = []cli.Flag {
@@ -209,11 +171,9 @@ app.Flags = []cli.Flag {
 }
 ```
 
-That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
-
 #### Values from the Environment
 
-You can also have the default value set from the environment via `EnvVar`.  e.g.
+You can also have the default value set from the environment via EnvVar.  e.g.
 
 ``` go
 app.Flags = []cli.Flag {
@@ -226,71 +186,17 @@ app.Flags = []cli.Flag {
 }
 ```
 
-The `EnvVar` may also be given as a comma-delimited "cascade", where the first environment variable that resolves is used as the default.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-    EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",
-  },
-}
-```
-
-#### Values from alternate input sources (YAML and others)
-
-There is a separate package altsrc that adds support for getting flag values from other input sources like YAML.
-
-In order to get values for a flag from an alternate input source the following code would be added to wrap an existing cli.Flag like below:
-
-``` go
-  altsrc.NewIntFlag(cli.IntFlag{Name: "test"})
-```
-
-Initialization must also occur for these flags. Below is an example initializing getting data from a yaml file below.
-
-``` go
-  command.Before = altsrc.InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-```
-
-The code above will use the "load" string as a flag name to get the file name of a yaml file from the cli.Context. 
-It will then use that file name to initialize the yaml input source for any flags that are defined on that command. 
-As a note the "load" flag used would also have to be defined on the command flags in order for this code snipped to work.
-
-Currently only YAML files are supported but developers can add support for other input sources by implementing the
-altsrc.InputSourceContext for their given sources.
-
-Here is a more complete sample of a command using YAML support:
-
-``` go
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) {
-			// Action to run
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(cli.IntFlag{Name: "test"}),
-			cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-```
+That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
 
 ### Subcommands
 
 Subcommands can be defined for a more git-like command line app.
-
 ```go
 ...
 app.Commands = []cli.Command{
   {
     Name:      "add",
-    Aliases:     []string{"a"},
+    ShortName: "a",
     Usage:     "add a task to the list",
     Action: func(c *cli.Context) {
       println("added task: ", c.Args().First())
@@ -298,7 +204,7 @@ app.Commands = []cli.Command{
   },
   {
     Name:      "complete",
-    Aliases:     []string{"c"},
+    ShortName: "c",
     Usage:     "complete a task on the list",
     Action: func(c *cli.Context) {
       println("completed task: ", c.Args().First())
@@ -306,7 +212,7 @@ app.Commands = []cli.Command{
   },
   {
     Name:      "template",
-    Aliases:     []string{"r"},
+    ShortName: "r",
     Usage:     "options for task templates",
     Subcommands: []cli.Command{
       {
@@ -331,11 +237,10 @@ app.Commands = []cli.Command{
 
 ### Bash Completion
 
-You can enable completion commands by setting the `EnableBashCompletion`
-flag on the `App` object.  By default, this setting will only auto-complete to
+You can enable completion commands by setting the EnableBashCompletion
+flag on the App object.  By default, this setting will only auto-complete to
 show an app's subcommands, but you can write your own completion methods for
 the App or its subcommands.
-
 ```go
 ...
 var tasks = []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
@@ -344,18 +249,18 @@ app.EnableBashCompletion = true
 app.Commands = []cli.Command{
   {
     Name: "complete",
-    Aliases: []string{"c"},
+    ShortName: "c",
     Usage: "complete a task on the list",
     Action: func(c *cli.Context) {
        println("completed task: ", c.Args().First())
     },
     BashComplete: func(c *cli.Context) {
       // This will complete if no args are passed
-      if c.NArg() > 0 {
+      if len(c.Args()) > 0 {
         return
       }
       for _, t := range tasks {
-        fmt.Println(t)
+        println(t)
       }
     },
   }
@@ -365,31 +270,11 @@ app.Commands = []cli.Command{
 
 #### To Enable
 
-Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
-setting the `PROG` variable to the name of your program:
+Source the autocomplete/bash_autocomplete file in your .bashrc file while
+setting the PROG variable to the name of your program:
 
 `PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
 
-#### To Distribute
 
-Copy `autocomplete/bash_autocomplete` into `/etc/bash_completion.d/` and rename
-it to the name of the program you wish to add autocomplete support for (or
-automatically install it there if you are distributing a package). Don't forget
-to source the file to make it active in the current shell.
-
-```
-sudo cp src/bash_autocomplete /etc/bash_completion.d/<myprogram>
-source /etc/bash_completion.d/<myprogram>
-```
-
-Alternatively, you can just document that users should source the generic
-`autocomplete/bash_autocomplete` in their bash configuration with `$PROG` set
-to the name of their program (as above).
-
-## Contribution Guidelines
-
-Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
-
-If you have contributed something significant to the project, I will most likely add you as a collaborator. As a collaborator you are given the ability to merge others pull requests. It is very important that new code does not break existing code, so be careful about what code you do choose to merge. If you have any questions feel free to link @codegangsta to the issue in question and we can review it together.
-
-If you feel like you have contributed to the project but have not yet been added as a collaborator, I probably forgot to add you. Hit @codegangsta up over email and we will get it figured out.
+## About
+cli.go is written by none other than the [Code Gangsta](http://codegangsta.io)

vendor/github.com/codegangsta/cli/app.go

@@ -2,26 +2,18 @@ package cli
 
 import (
 	"fmt"
-	"io"
 	"io/ioutil"
 	"os"
-	"path"
 	"time"
 )
 
-// App is the main structure of a cli application. It is recommended that
-// an app be created with the cli.NewApp() function
+// App is the main structure of a cli application. It is recomended that
+// and app be created with the cli.NewApp() function
 type App struct {
-	// The name of the program. Defaults to path.Base(os.Args[0])
+	// The name of the program. Defaults to os.Args[0]
 	Name string
-	// Full name of command for help, defaults to Name
-	HelpName string
 	// Description of the program.
 	Usage string
-	// Text to override the USAGE section of help
-	UsageText string
-	// Description of the program argument format.
-	ArgsUsage string
 	// Version of the program
 	Version string
 	// List of commands to execute
@@ -32,36 +24,21 @@ type App struct {
 	EnableBashCompletion bool
 	// Boolean to hide built-in help command
 	HideHelp bool
-	// Boolean to hide built-in version flag and the VERSION section of help
-	HideVersion bool
 	// An action to execute when the bash-completion flag is set
 	BashComplete func(context *Context)
 	// An action to execute before any subcommands are run, but after the context is ready
 	// If a non-nil error is returned, no subcommands are run
 	Before func(context *Context) error
-	// An action to execute after any subcommands are run, but after the subcommand has finished
-	// It is run even if Action() panics
-	After func(context *Context) error
 	// The action to execute when no subcommands are specified
 	Action func(context *Context)
 	// Execute this function if the proper command cannot be found
 	CommandNotFound func(context *Context, command string)
-	// Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
-	// This function is able to replace the original error messages.
-	// If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
-	OnUsageError func(context *Context, err error, isSubcommand bool) error
 	// Compilation date
 	Compiled time.Time
-	// List of all authors who contributed
-	Authors []Author
-	// Copyright of the binary if any
-	Copyright string
-	// Name of Author (Note: Use App.Authors, this is deprecated)
+	// Author
 	Author string
-	// Email of Author (Note: Use App.Authors, this is deprecated)
+	// Author e-mail
 	Email string
-	// Writer writer to write output to
-	Writer io.Writer
 }
 
 // Tries to find out when this binary was compiled.
@@ -77,104 +54,67 @@ func compileTime() time.Time {
 // Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
 func NewApp() *App {
 	return &App{
-		Name:         path.Base(os.Args[0]),
-		HelpName:     path.Base(os.Args[0]),
+		Name:         os.Args[0],
 		Usage:        "A new cli application",
-		UsageText:    "",
 		Version:      "0.0.0",
 		BashComplete: DefaultAppComplete,
 		Action:       helpCommand.Action,
 		Compiled:     compileTime(),
-		Writer:       os.Stdout,
+		Author:       "Author",
+		Email:        "unknown@email",
 	}
 }
 
 // Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
-func (a *App) Run(arguments []string) (err error) {
-	if a.Author != "" || a.Email != "" {
-		a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
-	}
-
-	newCmds := []Command{}
-	for _, c := range a.Commands {
-		if c.HelpName == "" {
-			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
-		}
-		newCmds = append(newCmds, c)
-	}
-	a.Commands = newCmds
-
+func (a *App) Run(arguments []string) error {
 	// append help to commands
 	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
 		a.Commands = append(a.Commands, helpCommand)
-		if (HelpFlag != BoolFlag{}) {
 		a.appendFlag(HelpFlag)
 	}
-	}
 
 	//append version/help flags
 	if a.EnableBashCompletion {
 		a.appendFlag(BashCompletionFlag)
 	}
-
-	if !a.HideVersion {
 	a.appendFlag(VersionFlag)
-	}
 
 	// parse flags
 	set := flagSet(a.Name, a.Flags)
 	set.SetOutput(ioutil.Discard)
-	err = set.Parse(arguments[1:])
+	err := set.Parse(arguments[1:])
 	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, nil)
 	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
+		fmt.Println(nerr)
+		context := NewContext(a, set, set)
 		ShowAppHelp(context)
+		fmt.Println("")
 		return nerr
 	}
+	context := NewContext(a, set, set)
+
+	if err != nil {
+		fmt.Printf("Incorrect Usage.\n\n")
+		ShowAppHelp(context)
+		fmt.Println("")
+		return err
+	}
 
 	if checkCompletions(context) {
 		return nil
 	}
 
-	if err != nil {
-		if a.OnUsageError != nil {
-			err := a.OnUsageError(context, err, false)
-			return err
-		} else {
-			fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
-			ShowAppHelp(context)
-			return err
-		}
-	}
-
-	if !a.HideHelp && checkHelp(context) {
-		ShowAppHelp(context)
+	if checkHelp(context) {
 		return nil
 	}
 
-	if !a.HideVersion && checkVersion(context) {
-		ShowVersion(context)
+	if checkVersion(context) {
 		return nil
 	}
 
-	if a.After != nil {
-		defer func() {
-			if afterErr := a.After(context); afterErr != nil {
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
 	if a.Before != nil {
-		err = a.Before(context)
+		err := a.Before(context)
 		if err != nil {
-			fmt.Fprintf(a.Writer, "%v\n\n", err)
-			ShowAppHelp(context)
 			return err
 		}
 	}
@@ -196,31 +136,20 @@ func (a *App) Run(arguments []string) (err error) {
 // Another entry point to the cli app, takes care of passing arguments and error handling
 func (a *App) RunAndExitOnError() {
 	if err := a.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
+		os.Stderr.WriteString(fmt.Sprintln(err))
 		os.Exit(1)
 	}
 }
 
 // Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
-func (a *App) RunAsSubcommand(ctx *Context) (err error) {
+func (a *App) RunAsSubcommand(ctx *Context) error {
 	// append help to commands
 	if len(a.Commands) > 0 {
 		if a.Command(helpCommand.Name) == nil && !a.HideHelp {
 			a.Commands = append(a.Commands, helpCommand)
-			if (HelpFlag != BoolFlag{}) {
 			a.appendFlag(HelpFlag)
 		}
 	}
-	}
-
-	newCmds := []Command{}
-	for _, c := range a.Commands {
-		if c.HelpName == "" {
-			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
-		}
-		newCmds = append(newCmds, c)
-	}
-	a.Commands = newCmds
 
 	// append flags
 	if a.EnableBashCompletion {
@@ -230,36 +159,31 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	// parse flags
 	set := flagSet(a.Name, a.Flags)
 	set.SetOutput(ioutil.Discard)
-	err = set.Parse(ctx.Args().Tail())
+	err := set.Parse(ctx.Args().Tail())
 	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, ctx)
+	context := NewContext(a, set, ctx.globalSet)
 
 	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		fmt.Fprintln(a.Writer)
+		fmt.Println(nerr)
 		if len(a.Commands) > 0 {
 			ShowSubcommandHelp(context)
 		} else {
 			ShowCommandHelp(ctx, context.Args().First())
 		}
+		fmt.Println("")
 		return nerr
 	}
 
+	if err != nil {
+		fmt.Printf("Incorrect Usage.\n\n")
+		ShowSubcommandHelp(context)
+		return err
+	}
+
 	if checkCompletions(context) {
 		return nil
 	}
 
-	if err != nil {
-		if a.OnUsageError != nil {
-			err = a.OnUsageError(context, err, true)
-			return err
-		} else {
-			fmt.Fprintf(a.Writer, "%s\n\n", "Incorrect Usage.")
-			ShowSubcommandHelp(context)
-			return err
-		}
-	}
-
 	if len(a.Commands) > 0 {
 		if checkSubcommandHelp(context) {
 			return nil
@@ -270,19 +194,6 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 		}
 	}
 
-	if a.After != nil {
-		defer func() {
-			afterErr := a.After(context)
-			if afterErr != nil {
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
 	if a.Before != nil {
 		err := a.Before(context)
 		if err != nil {
@@ -300,7 +211,11 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	}
 
 	// Run default Action
+	if len(a.Commands) > 0 {
 		a.Action(context)
+	} else {
+		a.Action(ctx)
+	}
 
 	return nil
 }
@@ -331,19 +246,3 @@ func (a *App) appendFlag(flag Flag) {
 		a.Flags = append(a.Flags, flag)
 	}
 }
-
-// Author represents someone who has contributed to a cli project.
-type Author struct {
-	Name  string // The Authors name
-	Email string // The Authors email
-}
-
-// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
-func (a Author) String() string {
-	e := ""
-	if a.Email != "" {
-		e = "<" + a.Email + "> "
-	}
-
-	return fmt.Sprintf("%v %v", a.Name, e)
-}

vendor/github.com/codegangsta/cli/appveyor.yml

@@ -1,16 +0,0 @@
-version: "{build}"
-
-os: Windows Server 2012 R2
-
-install:
-  - go version
-  - go env
-
-build_script:
-  - cd %APPVEYOR_BUILD_FOLDER%
-  - go vet ./...
-  - go test -v ./...
-
-test: off
-
-deploy: off

vendor/github.com/codegangsta/cli/cli.go

@@ -17,24 +17,3 @@
 //     app.Run(os.Args)
 //   }
 package cli
-
-import (
-	"strings"
-)
-
-type MultiError struct {
-	Errors []error
-}
-
-func NewMultiError(err ...error) MultiError {
-	return MultiError{Errors: err}
-}
-
-func (m MultiError) Error() string {
-	errs := make([]string, len(m.Errors))
-	for i, err := range m.Errors {
-		errs[i] = err.Error()
-	}
-
-	return strings.Join(errs, "\n")
-}

vendor/github.com/codegangsta/cli/command.go

@@ -10,32 +10,19 @@ import (
 type Command struct {
 	// The name of the command
 	Name string
-	// short name of the command. Typically one character (deprecated, use `Aliases`)
+	// short name of the command. Typically one character
 	ShortName string
-	// A list of aliases for the command
-	Aliases []string
 	// A short description of the usage of this command
 	Usage string
-	// Custom text to show on USAGE section of help
-	UsageText string
 	// A longer explanation of how the command works
 	Description string
-	// A short description of the arguments of this command
-	ArgsUsage string
 	// The function to call when checking for bash command completions
 	BashComplete func(context *Context)
 	// An action to execute before any sub-subcommands are run, but after the context is ready
 	// If a non-nil error is returned, no sub-subcommands are run
 	Before func(context *Context) error
-	// An action to execute after any subcommands are run, but before the subcommand has finished
-	// It is run even if Action() panics
-	After func(context *Context) error
 	// The function to call when this command is invoked
 	Action func(context *Context)
-	// Execute this function, if an usage error occurs. This is useful for displaying customized usage error messages.
-	// This function is able to replace the original error messages.
-	// If this function is not set, the "Incorrect usage" is displayed and the execution is interrupted.
-	OnUsageError func(context *Context, err error) error
 	// List of child commands
 	Subcommands []Command
 	// List of flags to parse
@@ -44,28 +31,16 @@ type Command struct {
 	SkipFlagParsing bool
 	// Boolean to hide built-in help command
 	HideHelp bool
-
-	// Full name of command for help, defaults to full command name, including parent commands.
-	HelpName        string
-	commandNamePath []string
-}
-
-// Returns the full name of the command.
-// For subcommands this ensures that parent commands are part of the command path
-func (c Command) FullName() string {
-	if c.commandNamePath == nil {
-		return c.Name
-	}
-	return strings.Join(c.commandNamePath, " ")
 }
 
 // Invokes the command given the context, parses ctx.Args() to generate command-specific flags
-func (c Command) Run(ctx *Context) (err error) {
-	if len(c.Subcommands) > 0 {
+func (c Command) Run(ctx *Context) error {
+
+	if len(c.Subcommands) > 0 || c.Before != nil {
 		return c.startApp(ctx)
 	}
 
-	if !c.HideHelp && (HelpFlag != BoolFlag{}) {
+	if !c.HideHelp {
 		// append help to flags
 		c.Flags = append(
 			c.Flags,
@@ -80,64 +55,40 @@ func (c Command) Run(ctx *Context) (err error) {
 	set := flagSet(c.Name, c.Flags)
 	set.SetOutput(ioutil.Discard)
 
-	if !c.SkipFlagParsing {
 	firstFlagIndex := -1
-		terminatorIndex := -1
 	for index, arg := range ctx.Args() {
-			if arg == "--" {
-				terminatorIndex = index
-				break
-			} else if arg == "-" {
-				// Do nothing. A dash alone is not really a flag.
-				continue
-			} else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
+		if strings.HasPrefix(arg, "-") {
 			firstFlagIndex = index
+			break
 		}
 	}
 
-		if firstFlagIndex > -1 {
+	var err error
+	if firstFlagIndex > -1 && !c.SkipFlagParsing {
 		args := ctx.Args()
-			regularArgs := make([]string, len(args[1:firstFlagIndex]))
-			copy(regularArgs, args[1:firstFlagIndex])
-
-			var flagArgs []string
-			if terminatorIndex > -1 {
-				flagArgs = args[firstFlagIndex:terminatorIndex]
-				regularArgs = append(regularArgs, args[terminatorIndex:]...)
-			} else {
-				flagArgs = args[firstFlagIndex:]
-			}
-
+		regularArgs := args[1:firstFlagIndex]
+		flagArgs := args[firstFlagIndex:]
 		err = set.Parse(append(flagArgs, regularArgs...))
 	} else {
 		err = set.Parse(ctx.Args().Tail())
 	}
-	} else {
-		if c.SkipFlagParsing {
-			err = set.Parse(append([]string{"--"}, ctx.Args().Tail()...))
-		}
-	}
 
 	if err != nil {
-		if c.OnUsageError != nil {
-			err := c.OnUsageError(ctx, err)
-			return err
-		} else {
-			fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
-			fmt.Fprintln(ctx.App.Writer)
+		fmt.Printf("Incorrect Usage.\n\n")
 		ShowCommandHelp(ctx, c.Name)
+		fmt.Println("")
 		return err
 	}
-	}
 
 	nerr := normalizeFlags(c.Flags, set)
 	if nerr != nil {
-		fmt.Fprintln(ctx.App.Writer, nerr)
-		fmt.Fprintln(ctx.App.Writer)
+		fmt.Println(nerr)
+		fmt.Println("")
 		ShowCommandHelp(ctx, c.Name)
+		fmt.Println("")
 		return nerr
 	}
-	context := NewContext(ctx.App, set, ctx)
+	context := NewContext(ctx.App, set, ctx.globalSet)
 
 	if checkCommandCompletions(context, c.Name) {
 		return nil
@@ -146,53 +97,14 @@ func (c Command) Run(ctx *Context) (err error) {
 	if checkCommandHelp(context, c.Name) {
 		return nil
 	}
-
-	if c.After != nil {
-		defer func() {
-			afterErr := c.After(context)
-			if afterErr != nil {
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
-	if c.Before != nil {
-		err := c.Before(context)
-		if err != nil {
-			fmt.Fprintln(ctx.App.Writer, err)
-			fmt.Fprintln(ctx.App.Writer)
-			ShowCommandHelp(ctx, c.Name)
-			return err
-		}
-	}
-
 	context.Command = c
 	c.Action(context)
 	return nil
 }
 
-func (c Command) Names() []string {
-	names := []string{c.Name}
-
-	if c.ShortName != "" {
-		names = append(names, c.ShortName)
-	}
-
-	return append(names, c.Aliases...)
-}
-
 // Returns true if Command.Name or Command.ShortName matches given name
 func (c Command) HasName(name string) bool {
-	for _, n := range c.Names() {
-		if n == name {
-			return true
-		}
-	}
-	return false
+	return c.Name == name || c.ShortName == name
 }
 
 func (c Command) startApp(ctx *Context) error {
@@ -200,33 +112,17 @@ func (c Command) startApp(ctx *Context) error {
 
 	// set the name and usage
 	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
-	if c.HelpName == "" {
-		app.HelpName = c.HelpName
-	} else {
-		app.HelpName = app.Name
-	}
-
 	if c.Description != "" {
 		app.Usage = c.Description
 	} else {
 		app.Usage = c.Usage
 	}
 
-	// set CommandNotFound
-	app.CommandNotFound = ctx.App.CommandNotFound
-
 	// set the flags and commands
 	app.Commands = c.Subcommands
 	app.Flags = c.Flags
 	app.HideHelp = c.HideHelp
 
-	app.Version = ctx.App.Version
-	app.HideVersion = ctx.App.HideVersion
-	app.Compiled = ctx.App.Compiled
-	app.Author = ctx.App.Author
-	app.Email = ctx.App.Email
-	app.Writer = ctx.App.Writer
-
 	// bash completion
 	app.EnableBashCompletion = ctx.App.EnableBashCompletion
 	if c.BashComplete != nil {
@@ -235,16 +131,11 @@ func (c Command) startApp(ctx *Context) error {
 
 	// set the actions
 	app.Before = c.Before
-	app.After = c.After
 	if c.Action != nil {
 		app.Action = c.Action
 	} else {
 		app.Action = helpSubcommand.Action
 	}
 
-	for index, cc := range app.Commands {
-		app.Commands[index].commandNamePath = []string{c.Name, cc.Name}
-	}
-
 	return app.RunAsSubcommand(ctx)
 }

vendor/github.com/codegangsta/cli/context.go

@@ -5,7 +5,6 @@ import (
 	"flag"
 	"strconv"
 	"strings"
-	"time"
 )
 
 // Context is a type that is passed through to
@@ -16,14 +15,13 @@ type Context struct {
 	App       *App
 	Command   Command
 	flagSet   *flag.FlagSet
+	globalSet *flag.FlagSet
 	setFlags  map[string]bool
-	globalSetFlags map[string]bool
-	parentContext  *Context
 }
 
 // Creates a new context. For use in when invoking an App or Command action.
-func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
-	return &Context{App: app, flagSet: set, parentContext: parentCtx}
+func NewContext(app *App, set *flag.FlagSet, globalSet *flag.FlagSet) *Context {
+	return &Context{App: app, flagSet: set, globalSet: globalSet}
 }
 
 // Looks up the value of a local int flag, returns 0 if no int flag exists
@@ -31,11 +29,6 @@ func (c *Context) Int(name string) int {
 	return lookupInt(name, c.flagSet)
 }
 
-// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) Duration(name string) time.Duration {
-	return lookupDuration(name, c.flagSet)
-}
-
 // Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
 func (c *Context) Float64(name string) float64 {
 	return lookupFloat64(name, c.flagSet)
@@ -73,66 +66,35 @@ func (c *Context) Generic(name string) interface{} {
 
 // Looks up the value of a global int flag, returns 0 if no int flag exists
 func (c *Context) GlobalInt(name string) int {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupInt(name, fs)
-	}
-	return 0
-}
-
-// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) GlobalDuration(name string) time.Duration {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupDuration(name, fs)
-	}
-	return 0
+	return lookupInt(name, c.globalSet)
 }
 
 // Looks up the value of a global bool flag, returns false if no bool flag exists
 func (c *Context) GlobalBool(name string) bool {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupBool(name, fs)
-	}
-	return false
+	return lookupBool(name, c.globalSet)
 }
 
 // Looks up the value of a global string flag, returns "" if no string flag exists
 func (c *Context) GlobalString(name string) string {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupString(name, fs)
-	}
-	return ""
+	return lookupString(name, c.globalSet)
 }
 
 // Looks up the value of a global string slice flag, returns nil if no string slice flag exists
 func (c *Context) GlobalStringSlice(name string) []string {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupStringSlice(name, fs)
-	}
-	return nil
+	return lookupStringSlice(name, c.globalSet)
 }
 
 // Looks up the value of a global int slice flag, returns nil if no int slice flag exists
 func (c *Context) GlobalIntSlice(name string) []int {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupIntSlice(name, fs)
-	}
-	return nil
+	return lookupIntSlice(name, c.globalSet)
 }
 
 // Looks up the value of a global generic flag, returns nil if no generic flag exists
 func (c *Context) GlobalGeneric(name string) interface{} {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupGeneric(name, fs)
-	}
-	return nil
+	return lookupGeneric(name, c.globalSet)
 }
 
-// Returns the number of flags set
-func (c *Context) NumFlags() int {
-	return c.flagSet.NFlag()
-}
-
-// Determines if the flag was actually set
+// Determines if the flag was actually set exists
 func (c *Context) IsSet(name string) bool {
 	if c.setFlags == nil {
 		c.setFlags = make(map[string]bool)
@@ -143,52 +105,6 @@ func (c *Context) IsSet(name string) bool {
 	return c.setFlags[name] == true
 }
 
-// Determines if the global flag was actually set
-func (c *Context) GlobalIsSet(name string) bool {
-	if c.globalSetFlags == nil {
-		c.globalSetFlags = make(map[string]bool)
-		ctx := c
-		if ctx.parentContext != nil {
-			ctx = ctx.parentContext
-		}
-		for ; ctx != nil && c.globalSetFlags[name] == false; ctx = ctx.parentContext {
-			ctx.flagSet.Visit(func(f *flag.Flag) {
-				c.globalSetFlags[f.Name] = true
-			})
-		}
-	}
-	return c.globalSetFlags[name]
-}
-
-// Returns a slice of flag names used in this context.
-func (c *Context) FlagNames() (names []string) {
-	for _, flag := range c.Command.Flags {
-		name := strings.Split(flag.GetName(), ",")[0]
-		if name == "help" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// Returns a slice of global flag names used by the app.
-func (c *Context) GlobalFlagNames() (names []string) {
-	for _, flag := range c.App.Flags {
-		name := strings.Split(flag.GetName(), ",")[0]
-		if name == "help" || name == "version" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// Returns the parent context, if any
-func (c *Context) Parent() *Context {
-	return c.parentContext
-}
-
 type Args []string
 
 // Returns the command line arguments associated with the context.
@@ -197,11 +113,6 @@ func (c *Context) Args() Args {
 	return args
 }
 
-// Returns the number of the command line arguments.
-func (c *Context) NArg() int {
-	return len(c.Args())
-}
-
 // Returns the nth argument, or else a blank string
 func (a Args) Get(n int) string {
 	if len(a) > n {
@@ -238,18 +149,6 @@ func (a Args) Swap(from, to int) error {
 	return nil
 }
 
-func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
-	if ctx.parentContext != nil {
-		ctx = ctx.parentContext
-	}
-	for ; ctx != nil; ctx = ctx.parentContext {
-		if f := ctx.flagSet.Lookup(name); f != nil {
-			return ctx.flagSet
-		}
-	}
-	return nil
-}
-
 func lookupInt(name string, set *flag.FlagSet) int {
 	f := set.Lookup(name)
 	if f != nil {
@@ -263,18 +162,6 @@ func lookupInt(name string, set *flag.FlagSet) int {
 	return 0
 }
 
-func lookupDuration(name string, set *flag.FlagSet) time.Duration {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := time.ParseDuration(f.Value.String())
-		if err == nil {
-			return val
-		}
-	}
-
-	return 0
-}
-
 func lookupFloat64(name string, set *flag.FlagSet) float64 {
 	f := set.Lookup(name)
 	if f != nil {
@@ -365,7 +252,7 @@ func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
 		visited[f.Name] = true
 	})
 	for _, f := range flags {
-		parts := strings.Split(f.GetName(), ",")
+		parts := strings.Split(f.getName(), ",")
 		if len(parts) == 1 {
 			continue
 		}

vendor/github.com/codegangsta/cli/flag.go

@@ -4,10 +4,8 @@ import (
 	"flag"
 	"fmt"
 	"os"
-	"runtime"
 	"strconv"
 	"strings"
-	"time"
 )
 
 // This flag enables bash-completion for all commands and subcommands
@@ -22,21 +20,19 @@ var VersionFlag = BoolFlag{
 }
 
 // This flag prints the help for all commands and subcommands
-// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
-// unless HideHelp is set to true)
 var HelpFlag = BoolFlag{
 	Name:  "help, h",
 	Usage: "show help",
 }
 
 // Flag is a common interface related to parsing flags in cli.
-// For more advanced flag parsing techniques, it is recommended that
+// For more advanced flag parsing techniques, it is recomended that
 // this interface be implemented.
 type Flag interface {
 	fmt.Stringer
 	// Apply Flag settings to the given flag set
 	Apply(*flag.FlagSet)
-	GetName() string
+	getName() string
 }
 
 func flagSet(name string, flags []Flag) *flag.FlagSet {
@@ -70,35 +66,15 @@ type GenericFlag struct {
 	EnvVar string
 }
 
-// String returns the string representation of the generic flag to display the
-// help text to the user (uses the String() method of the generic flag to show
-// the value)
 func (f GenericFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s %v\t%v", prefixedNames(f.Name), f.FormatValueHelp(), f.Usage))
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s%s %v\t`%v` %s", prefixFor(f.Name), f.Name, f.Value, "-"+f.Name+" option -"+f.Name+" option", f.Usage))
 }
 
-func (f GenericFlag) FormatValueHelp() string {
-	if f.Value == nil {
-		return ""
-	}
-	s := f.Value.String()
-	if len(s) == 0 {
-		return ""
-	}
-	return fmt.Sprintf("\"%s\"", s)
-}
-
-// Apply takes the flagset and calls Set on the generic flag with the value
-// provided by the user for parsing by the flag
 func (f GenericFlag) Apply(set *flag.FlagSet) {
 	val := f.Value
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
 			val.Set(envVal)
-				break
-			}
 		}
 	}
 
@@ -107,31 +83,25 @@ func (f GenericFlag) Apply(set *flag.FlagSet) {
 	})
 }
 
-func (f GenericFlag) GetName() string {
+func (f GenericFlag) getName() string {
 	return f.Name
 }
 
-// StringSlice is an opaque type for []string to satisfy flag.Value
 type StringSlice []string
 
-// Set appends the string value to the list of values
 func (f *StringSlice) Set(value string) error {
 	*f = append(*f, value)
 	return nil
 }
 
-// String returns a readable representation of this value (for usage defaults)
 func (f *StringSlice) String() string {
 	return fmt.Sprintf("%s", *f)
 }
 
-// Value returns the slice of strings set by this flag
 func (f *StringSlice) Value() []string {
 	return *f
 }
 
-// StringSlice is a string flag that can be specified multiple times on the
-// command-line
 type StringSliceFlag struct {
 	Name   string
 	Value  *StringSlice
@@ -139,47 +109,36 @@ type StringSliceFlag struct {
 	EnvVar string
 }
 
-// String returns the usage
 func (f StringSliceFlag) String() string {
 	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
 	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
 }
 
-// Apply populates the flag given the flag set and environment
 func (f StringSliceFlag) Apply(set *flag.FlagSet) {
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
 			newVal := &StringSlice{}
 			for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
 				newVal.Set(s)
 			}
 			f.Value = newVal
-				break
-			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
-		if f.Value == nil {
-			f.Value = &StringSlice{}
-		}
 		set.Var(f.Value, name, f.Usage)
 	})
 }
 
-func (f StringSliceFlag) GetName() string {
+func (f StringSliceFlag) getName() string {
 	return f.Name
 }
 
-// StringSlice is an opaque type for []int to satisfy flag.Value
 type IntSlice []int
 
-// Set parses the value into an integer and appends it to the list of values
 func (f *IntSlice) Set(value string) error {
+
 	tmp, err := strconv.Atoi(value)
 	if err != nil {
 		return err
@@ -189,18 +148,14 @@ func (f *IntSlice) Set(value string) error {
 	return nil
 }
 
-// String returns a readable representation of this value (for usage defaults)
 func (f *IntSlice) String() string {
 	return fmt.Sprintf("%d", *f)
 }
 
-// Value returns the slice of ints set by this flag
 func (f *IntSlice) Value() []int {
 	return *f
 }
 
-// IntSliceFlag is an int flag that can be specified multiple times on the
-// command-line
 type IntSliceFlag struct {
 	Name   string
 	Value  *IntSlice
@@ -208,302 +163,188 @@ type IntSliceFlag struct {
 	EnvVar string
 }
 
-// String returns the usage
 func (f IntSliceFlag) String() string {
 	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
 	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
 }
 
-// Apply populates the flag given the flag set and environment
 func (f IntSliceFlag) Apply(set *flag.FlagSet) {
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
 			newVal := &IntSlice{}
 			for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
 				err := newVal.Set(s)
 				if err != nil {
 					fmt.Fprintf(os.Stderr, err.Error())
 				}
 			}
 			f.Value = newVal
-				break
-			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
-		if f.Value == nil {
-			f.Value = &IntSlice{}
-		}
 		set.Var(f.Value, name, f.Usage)
 	})
 }
 
-func (f IntSliceFlag) GetName() string {
+func (f IntSliceFlag) getName() string {
 	return f.Name
 }
 
-// BoolFlag is a switch that defaults to false
 type BoolFlag struct {
 	Name   string
 	Usage  string
 	EnvVar string
-	Destination *bool
 }
 
-// String returns a readable representation of this value (for usage defaults)
 func (f BoolFlag) String() string {
 	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
 }
 
-// Apply populates the flag given the flag set and environment
 func (f BoolFlag) Apply(set *flag.FlagSet) {
 	val := false
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
 			envValBool, err := strconv.ParseBool(envVal)
 			if err == nil {
 				val = envValBool
 			}
-				break
-			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.BoolVar(f.Destination, name, val, f.Usage)
-			return
-		}
 		set.Bool(name, val, f.Usage)
 	})
 }
 
-func (f BoolFlag) GetName() string {
+func (f BoolFlag) getName() string {
 	return f.Name
 }
 
-// BoolTFlag this represents a boolean flag that is true by default, but can
-// still be set to false by --some-flag=false
 type BoolTFlag struct {
 	Name   string
 	Usage  string
 	EnvVar string
-	Destination *bool
 }
 
-// String returns a readable representation of this value (for usage defaults)
 func (f BoolTFlag) String() string {
 	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
 }
 
-// Apply populates the flag given the flag set and environment
 func (f BoolTFlag) Apply(set *flag.FlagSet) {
 	val := true
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
 			envValBool, err := strconv.ParseBool(envVal)
 			if err == nil {
 				val = envValBool
-					break
-				}
 			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.BoolVar(f.Destination, name, val, f.Usage)
-			return
-		}
 		set.Bool(name, val, f.Usage)
 	})
 }
 
-func (f BoolTFlag) GetName() string {
+func (f BoolTFlag) getName() string {
 	return f.Name
 }
 
-// StringFlag represents a flag that takes as string value
 type StringFlag struct {
 	Name   string
 	Value  string
 	Usage  string
 	EnvVar string
-	Destination *string
 }
 
-// String returns the usage
 func (f StringFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s %v\t%v", prefixedNames(f.Name), f.FormatValueHelp(), f.Usage))
-}
+	var fmtString string
+	fmtString = "%s %v\t%v"
 
-func (f StringFlag) FormatValueHelp() string {
-	s := f.Value
-	if len(s) == 0 {
-		return ""
+	if len(f.Value) > 0 {
+		fmtString = "%s '%v'\t%v"
+	} else {
+		fmtString = "%s %v\t%v"
 	}
-	return fmt.Sprintf("\"%s\"", s)
+
+	return withEnvHint(f.EnvVar, fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage))
 }
 
-// Apply populates the flag given the flag set and environment
 func (f StringFlag) Apply(set *flag.FlagSet) {
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
 			f.Value = envVal
-				break
-			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.StringVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
 		set.String(name, f.Value, f.Usage)
 	})
 }
 
-func (f StringFlag) GetName() string {
+func (f StringFlag) getName() string {
 	return f.Name
 }
 
-// IntFlag is a flag that takes an integer
-// Errors if the value provided cannot be parsed
 type IntFlag struct {
 	Name   string
 	Value  int
 	Usage  string
 	EnvVar string
-	Destination *int
 }
 
-// String returns the usage
 func (f IntFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage))
 }
 
-// Apply populates the flag given the flag set and environment
 func (f IntFlag) Apply(set *flag.FlagSet) {
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValInt, err := strconv.ParseInt(envVal, 0, 64)
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			envValInt, err := strconv.ParseUint(envVal, 10, 64)
 			if err == nil {
 				f.Value = int(envValInt)
-					break
-				}
 			}
 		}
 	}
 
 	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.IntVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
 		set.Int(name, f.Value, f.Usage)
 	})
 }
 
-func (f IntFlag) GetName() string {
+func (f IntFlag) getName() string {
 	return f.Name
 }
 
-// DurationFlag is a flag that takes a duration specified in Go's duration
-// format: https://golang.org/pkg/time/#ParseDuration
-type DurationFlag struct {
-	Name        string
-	Value       time.Duration
-	Usage       string
-	EnvVar      string
-	Destination *time.Duration
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f DurationFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f DurationFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValDuration, err := time.ParseDuration(envVal)
-				if err == nil {
-					f.Value = envValDuration
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.DurationVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Duration(name, f.Value, f.Usage)
-	})
-}
-
-func (f DurationFlag) GetName() string {
-	return f.Name
-}
-
-// Float64Flag is a flag that takes an float value
-// Errors if the value provided cannot be parsed
 type Float64Flag struct {
 	Name   string
 	Value  float64
 	Usage  string
 	EnvVar string
-	Destination *float64
 }
 
-// String returns the usage
 func (f Float64Flag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage))
 }
 
-// Apply populates the flag given the flag set and environment
 func (f Float64Flag) Apply(set *flag.FlagSet) {
 	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
 			envValFloat, err := strconv.ParseFloat(envVal, 10)
 			if err == nil {
 				f.Value = float64(envValFloat)
 			}
 		}
 	}
-	}
 
 	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.Float64Var(f.Destination, name, f.Value, f.Usage)
-			return
-		}
 		set.Float64(name, f.Value, f.Usage)
 	})
 }
 
-func (f Float64Flag) GetName() string {
+func (f Float64Flag) getName() string {
 	return f.Name
 }
 
@@ -532,15 +373,7 @@ func prefixedNames(fullName string) (prefixed string) {
 func withEnvHint(envVar, str string) string {
 	envText := ""
 	if envVar != "" {
-		prefix := "$"
-		suffix := ""
-		sep := ", $"
-		if runtime.GOOS == "windows" {
-			prefix = "%"
-			suffix = "%"
-			sep = "%, %"
-		}
-		envText = fmt.Sprintf(" [%s%s%s]", prefix, strings.Join(strings.Split(envVar, ","), sep), suffix)
+		envText = fmt.Sprintf(" [$%s]", envVar)
 	}
 	return str + envText
 }

vendor/github.com/codegangsta/cli/help.go

@@ -2,8 +2,7 @@ package cli
 
 import (
 	"fmt"
-	"io"
-	"strings"
+	"os"
 	"text/tabwriter"
 	"text/template"
 )
@@ -15,36 +14,30 @@ var AppHelpTemplate = `NAME:
    {{.Name}} - {{.Usage}}
 
 USAGE:
-   {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .Flags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}
-   {{if .Version}}{{if not .HideVersion}}
+   {{.Name}} {{ if .Flags }}[global options] {{ end }}command{{ if .Flags }} [command options]{{ end }} [arguments...]
+
 VERSION:
    {{.Version}}
-   {{end}}{{end}}{{if len .Authors}}
-AUTHOR(S):
-   {{range .Authors}}{{ . }}{{end}}
-   {{end}}{{if .Commands}}
+
 COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{end}}{{if .Flags}}
+   {{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
+   {{end}}{{ if .Flags }}
 GLOBAL OPTIONS:
    {{range .Flags}}{{.}}
-   {{end}}{{end}}{{if .Copyright }}
-COPYRIGHT:
-   {{.Copyright}}
-   {{end}}
+   {{end}}{{ end }}
 `
 
 // The text template for the command help topic.
 // cli.go uses text/template to render templates. You can
 // render custom help text by setting this variable.
 var CommandHelpTemplate = `NAME:
-   {{.HelpName}} - {{.Usage}}
+   {{.Name}} - {{.Usage}}
 
 USAGE:
-   {{.HelpName}}{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Description}}
+   command {{.Name}}{{ if .Flags }} [command options]{{ end }} [arguments...]
 
 DESCRIPTION:
-   {{.Description}}{{end}}{{if .Flags}}
+   {{.Description}}{{ if .Flags }}
 
 OPTIONS:
    {{range .Flags}}{{.}}
@@ -55,24 +48,23 @@ OPTIONS:
 // cli.go uses text/template to render templates. You can
 // render custom help text by setting this variable.
 var SubcommandHelpTemplate = `NAME:
-   {{.HelpName}} - {{.Usage}}
+   {{.Name}} - {{.Usage}}
 
 USAGE:
-   {{.HelpName}} command{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
+   {{.Name}} command{{ if .Flags }} [command options]{{ end }} [arguments...]
 
 COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{if .Flags}}
+   {{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
+   {{end}}{{ if .Flags }}
 OPTIONS:
    {{range .Flags}}{{.}}
-   {{end}}{{end}}
+   {{end}}{{ end }}
 `
 
 var helpCommand = Command{
 	Name:      "help",
-	Aliases:   []string{"h"},
+	ShortName: "h",
 	Usage:     "Shows a list of commands or help for one command",
-	ArgsUsage: "[command]",
 	Action: func(c *Context) {
 		args := c.Args()
 		if args.Present() {
@@ -85,9 +77,8 @@ var helpCommand = Command{
 
 var helpSubcommand = Command{
 	Name:      "help",
-	Aliases:   []string{"h"},
+	ShortName: "h",
 	Usage:     "Shows a list of commands or help for one command",
-	ArgsUsage: "[command]",
 	Action: func(c *Context) {
 		args := c.Args()
 		if args.Present() {
@@ -98,61 +89,47 @@ var helpSubcommand = Command{
 	},
 }
 
-// Prints help for the App or Command
-type helpPrinter func(w io.Writer, templ string, data interface{})
-
-var HelpPrinter helpPrinter = printHelp
-
-// Prints version for the App
-var VersionPrinter = printVersion
+// Prints help for the App
+var HelpPrinter = printHelp
 
 func ShowAppHelp(c *Context) {
-	HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
+	HelpPrinter(AppHelpTemplate, c.App)
 }
 
 // Prints the list of subcommands as the default app completion method
 func DefaultAppComplete(c *Context) {
 	for _, command := range c.App.Commands {
-		for _, name := range command.Names() {
-			fmt.Fprintln(c.App.Writer, name)
+		fmt.Println(command.Name)
+		if command.ShortName != "" {
+			fmt.Println(command.ShortName)
 		}
 	}
 }
 
 // Prints help for the given command
-func ShowCommandHelp(ctx *Context, command string) {
-	// show the subcommand help for a command with subcommands
-	if command == "" {
-		HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
-		return
-	}
-
-	for _, c := range ctx.App.Commands {
+func ShowCommandHelp(c *Context, command string) {
+	for _, c := range c.App.Commands {
 		if c.HasName(command) {
-			HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
+			HelpPrinter(CommandHelpTemplate, c)
 			return
 		}
 	}
 
-	if ctx.App.CommandNotFound != nil {
-		ctx.App.CommandNotFound(ctx, command)
+	if c.App.CommandNotFound != nil {
+		c.App.CommandNotFound(c, command)
 	} else {
-		fmt.Fprintf(ctx.App.Writer, "No help topic for '%v'\n", command)
+		fmt.Printf("No help topic for '%v'\n", command)
 	}
 }
 
 // Prints help for the given subcommand
 func ShowSubcommandHelp(c *Context) {
-	ShowCommandHelp(c, c.Command.Name)
+	HelpPrinter(SubcommandHelpTemplate, c.App)
 }
 
 // Prints the version number of the App
 func ShowVersion(c *Context) {
-	VersionPrinter(c)
-}
-
-func printVersion(c *Context) {
-	fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
+	fmt.Printf("%v version %v\n", c.App.Name, c.App.Version)
 }
 
 // Prints the lists of commands within a given context
@@ -171,44 +148,32 @@ func ShowCommandCompletions(ctx *Context, command string) {
 	}
 }
 
-func printHelp(out io.Writer, templ string, data interface{}) {
-	funcMap := template.FuncMap{
-		"join": strings.Join,
-	}
-
-	w := tabwriter.NewWriter(out, 0, 8, 1, '\t', 0)
-	t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
+func printHelp(templ string, data interface{}) {
+	w := tabwriter.NewWriter(os.Stdout, 0, 8, 1, '\t', 0)
+	t := template.Must(template.New("help").Parse(templ))
 	err := t.Execute(w, data)
 	if err != nil {
-		// If the writer is closed, t.Execute will fail, and there's nothing
-		// we can do to recover. We could send this to os.Stderr if we need.
-		return
+		panic(err)
 	}
 	w.Flush()
 }
 
 func checkVersion(c *Context) bool {
-	found := false
-	if VersionFlag.Name != "" {
-		eachName(VersionFlag.Name, func(name string) {
-			if c.GlobalBool(name) || c.Bool(name) {
-				found = true
+	if c.GlobalBool("version") {
+		ShowVersion(c)
+		return true
 	}
-		})
-	}
-	return found
+
+	return false
 }
 
 func checkHelp(c *Context) bool {
-	found := false
-	if HelpFlag.Name != "" {
-		eachName(HelpFlag.Name, func(name string) {
-			if c.GlobalBool(name) || c.Bool(name) {
-				found = true
+	if c.GlobalBool("h") || c.GlobalBool("help") {
+		ShowAppHelp(c)
+		return true
 	}
-		})
-	}
-	return found
+
+	return false
 }
 
 func checkCommandHelp(c *Context, name string) bool {
@@ -230,7 +195,7 @@ func checkSubcommandHelp(c *Context) bool {
 }
 
 func checkCompletions(c *Context) bool {
-	if (c.GlobalBool(BashCompletionFlag.Name) || c.Bool(BashCompletionFlag.Name)) && c.App.EnableBashCompletion {
+	if c.GlobalBool(BashCompletionFlag.Name) && c.App.EnableBashCompletion {
 		ShowCompletions(c)
 		return true
 	}

vendor/github.com/docker/distribution/.drone.yml

@@ -1,38 +0,0 @@
-image: dmp42/go:stable
-
-script:
-  # To be spoofed back into the test image
-  - go get github.com/modocache/gover
-
-  - go get -t ./...
-
-  # Go fmt
-  - test -z "$(gofmt -s -l -w .     | tee /dev/stderr)"
-  # Go lint
-  - test -z "$(golint ./...          | tee /dev/stderr)"
-  # Go vet
-  - go vet ./...
-  # Go test
-  - go test -v -race -cover ./...
-  # Helper to concatenate reports
-  - gover
-  # Send to coverall
-  - goveralls -service drone.io -coverprofile=gover.coverprofile -repotoken {{COVERALLS_TOKEN}}
-
-  # Do we want these as well?
-  # - go get code.google.com/p/go.tools/cmd/goimports
-  # - test -z "$(goimports -l -w ./... | tee /dev/stderr)"
-  # http://labix.org/gocheck
-
-notify:
-    email:
-        recipients:
-            - distribution@docker.com
-
-    slack:
-        team: docker
-        channel: "#dt"
-        username: mom
-        token: {{SLACK_TOKEN}}
-        on_success: true
-        on_failure: true

vendor/github.com/docker/distribution/.gitignore

@@ -1,37 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof
-
-# never checkin from the bin file (for now)
-bin/*
-
-# Test key files
-*.pem
-
-# Cover profiles
-*.out
-
-# Editor/IDE specific files.
-*.sublime-project
-*.sublime-workspace

vendor/github.com/docker/distribution/.mailmap

@@ -1,15 +0,0 @@
-Stephen J Day <stephen.day@docker.com>  Stephen Day <stevvooe@users.noreply.github.com>
-Stephen J Day <stephen.day@docker.com>  Stephen Day <stevvooe@gmail.com>
-Olivier Gambier <olivier@docker.com>    Olivier Gambier <dmp42@users.noreply.github.com>
-Brian Bland <brian.bland@docker.com>    Brian Bland <r4nd0m1n4t0r@gmail.com>
-Brian Bland <brian.bland@docker.com> Brian Bland <brian.t.bland@gmail.com>
-Josh Hawn <josh.hawn@docker.com>        Josh Hawn <jlhawn@berkeley.edu>
-Richard Scothern <richard.scothern@docker.com> Richard <richard.scothern@gmail.com>
-Richard Scothern <richard.scothern@docker.com> Richard Scothern <richard.scothern@gmail.com>
-Andrew Meredith <andymeredith@gmail.com> Andrew Meredith <kendru@users.noreply.github.com>
-harche <p.harshal@gmail.com> harche <harche@users.noreply.github.com>
-Jessie Frazelle <jessie@docker.com>  <jfrazelle@users.noreply.github.com>
-Sharif Nassar <sharif@mrwacky.com> Sharif Nassar <mrwacky42@users.noreply.github.com>
-Sven Dowideit <SvenDowideit@home.org.au> Sven Dowideit <SvenDowideit@users.noreply.github.com>
-Vincent Giersch <vincent.giersch@ovh.net> Vincent Giersch <vincent@giersch.fr>
-davidli <wenquan.li@hp.com> davidli <wenquan.li@hpe.com>

vendor/github.com/docker/distribution/AUTHORS

@@ -1,113 +0,0 @@
-Aaron Lehmann <aaron.lehmann@docker.com>
-Aaron Vinson <avinson.public@gmail.com>
-Adam Enger <adamenger@gmail.com>
-Adrian Mouat <adrian.mouat@gmail.com>
-Ahmet Alp Balkan <ahmetalpbalkan@gmail.com>
-Alex Chan <alex.chan@metaswitch.com>
-Alex Elman <aelman@indeed.com>
-amitshukla <ashukla73@hotmail.com>
-Amy Lindburg <amy.lindburg@docker.com>
-Andrew Meredith <andymeredith@gmail.com>
-Andrey Kostov <kostov.andrey@gmail.com>
-Andy Goldstein <agoldste@redhat.com>
-Anton Tiurin <noxiouz@yandex.ru>
-Antonio Mercado <amercado@thinknode.com>
-Arnaud Porterie <arnaud.porterie@docker.com>
-Arthur Baars <arthur@semmle.com>
-Avi Miller <avi.miller@oracle.com>
-Ayose Cazorla <ayosec@gmail.com>
-BadZen <dave.trombley@gmail.com>
-Ben Firshman <ben@firshman.co.uk>
-bin liu <liubin0329@gmail.com>
-Brian Bland <brian.bland@docker.com>
-burnettk <burnettk@gmail.com>
-Carson A <ca@carsonoid.net>
-Chris Dillon <squarism@gmail.com>
-Daisuke Fujita <dtanshi45@gmail.com>
-Darren Shepherd <darren@rancher.com>
-Dave Trombley <dave.trombley@gmail.com>
-Dave Tucker <dt@docker.com>
-David Lawrence <david.lawrence@docker.com>
-David Verhasselt <david@crowdway.com>
-David Xia <dxia@spotify.com>
-davidli <wenquan.li@hp.com>
-Dejan Golja <dejan@golja.org>
-Derek McGowan <derek@mcgstyle.net>
-Diogo Mónica <diogo.monica@gmail.com>
-DJ Enriquez <dj.enriquez@infospace.com>
-Donald Huang <don.hcd@gmail.com>
-Doug Davis <dug@us.ibm.com>
-farmerworking <farmerworking@gmail.com>
-Florentin Raud <florentin.raud@gmail.com>
-Frederick F. Kautz IV <fkautz@alumni.cmu.edu>
-gabriell nascimento <gabriell@bluesoft.com.br>
-harche <p.harshal@gmail.com>
-Henri Gomez <henri.gomez@gmail.com>
-Hu Keping <hukeping@huawei.com>
-Hua Wang <wanghua.humble@gmail.com>
-Ian Babrou <ibobrik@gmail.com>
-Jack Griffin <jackpg14@gmail.com>
-Jason Freidman <jason.freidman@gmail.com>
-Jeff Nickoloff <jeff@allingeek.com>
-Jessie Frazelle <jessie@docker.com>
-Jianqing Wang <tsing@jianqing.org>
-Jon Poler <jonathan.poler@apcera.com>
-Jonathan Boulle <jonathanboulle@gmail.com>
-Jordan Liggitt <jliggitt@redhat.com>
-Josh Hawn <josh.hawn@docker.com>
-Julien Fernandez <julien.fernandez@gmail.com>
-Kelsey Hightower <kelsey.hightower@gmail.com>
-Kenneth Lim <kennethlimcp@gmail.com>
-Kenny Leung <kleung@google.com>
-Li Yi <denverdino@gmail.com>
-Liu Hua <sdu.liu@huawei.com>
-Louis Kottmann <louis.kottmann@gmail.com>
-Luke Carpenter <x@rubynerd.net>
-Mary Anthony <mary@docker.com>
-Matt Bentley <mbentley@mbentley.net>
-Matt Moore <mattmoor@google.com>
-Matt Robenolt <matt@ydekproductions.com>
-Michael Prokop <mika@grml.org>
-Miquel Sabaté <msabate@suse.com>
-Morgan Bauer <mbauer@us.ibm.com>
-moxiegirl <mary@docker.com>
-Nathan Sullivan <nathan@nightsys.net>
-nevermosby <robolwq@qq.com>
-Nghia Tran <tcnghia@gmail.com>
-Nuutti Kotivuori <nuutti.kotivuori@poplatek.fi>
-Oilbeater <liumengxinfly@gmail.com>
-Olivier Gambier <olivier@docker.com>
-Olivier Jacques <olivier.jacques@hp.com>
-Patrick Devine <patrick.devine@docker.com>
-Philip Misiowiec <philip@atlashealth.com>
-Richard Scothern <richard.scothern@docker.com>
-Rodolfo Carvalho <rhcarvalho@gmail.com>
-Rusty Conover <rusty@luckydinosaur.com>
-Sean Boran <Boran@users.noreply.github.com>
-Sebastiaan van Stijn <github@gone.nl>
-Sharif Nassar <sharif@mrwacky.com>
-Shawn Falkner-Horine <dreadpirateshawn@gmail.com>
-Shreyas Karnik <karnik.shreyas@gmail.com>
-Simon Thulbourn <simon+github@thulbourn.com>
-Spencer Rinehart <anubis@overthemonkey.com>
-Stephen J Day <stephen.day@docker.com>
-Sungho Moon <sungho.moon@navercorp.com>
-Sven Dowideit <SvenDowideit@home.org.au>
-Sylvain Baubeau <sbaubeau@redhat.com>
-Ted Reed <ted.reed@gmail.com>
-tgic <farmer1992@gmail.com>
-Thomas Sjögren <konstruktoid@users.noreply.github.com>
-Tianon Gravi <admwiggin@gmail.com>
-Tibor Vass <teabee89@gmail.com>
-Tonis Tiigi <tonistiigi@gmail.com>
-Trevor Pounds <trevor.pounds@gmail.com>
-Troels Thomsen <troels@thomsen.io>
-Vincent Batts <vbatts@redhat.com>
-Vincent Demeester <vincent@sbr.pm>
-Vincent Giersch <vincent.giersch@ovh.net>
-W. Trevor King <wking@tremily.us>
-weiyuan.yl <weiyuan.yl@alibaba-inc.com>
-xg.song <xg.song@venusource.com>
-xiekeyang <xiekeyang@huawei.com>
-Yann ROBERT <yann.robert@anantaplex.fr>
-yuzou <zouyu7@huawei.com>

vendor/github.com/docker/distribution/CONTRIBUTING.md

@@ -1,140 +0,0 @@
-# Contributing to the registry
-
-## Before reporting an issue...
-
-### If your problem is with...
-
- - automated builds
- - your account on the [Docker Hub](https://hub.docker.com/)
- - any other [Docker Hub](https://hub.docker.com/) issue
-
-Then please do not report your issue here - you should instead report it to [https://support.docker.com](https://support.docker.com)
-
-### If you...
-
- - need help setting up your registry
- - can't figure out something
- - are not sure what's going on or what your problem is
-
-Then please do not open an issue here yet - you should first try one of the following support forums:
-
- - irc: #docker-distribution on freenode
- - mailing-list: <distribution@dockerproject.org> or https://groups.google.com/a/dockerproject.org/forum/#!forum/distribution
-
-## Reporting an issue properly
-
-By following these simple rules you will get better and faster feedback on your issue.
-
- - search the bugtracker for an already reported issue
-
-### If you found an issue that describes your problem:
-
- - please read other user comments first, and confirm this is the same issue: a given error condition might be indicative of different problems - you may also find a workaround in the comments
- - please refrain from adding "same thing here" or "+1" comments
- - you don't need to comment on an issue to get notified of updates: just hit the "subscribe" button
- - comment if you have some new, technical and relevant information to add to the case
- - __DO NOT__ comment on closed issues or merged PRs. If you think you have a related problem, open up a new issue and reference the PR or issue.
-
-### If you have not found an existing issue that describes your problem:
-
- 1. create a new issue, with a succinct title that describes your issue:
-   - bad title: "It doesn't work with my docker"
-   - good title: "Private registry push fail: 400 error with E_INVALID_DIGEST"
- 2. copy the output of:
-   - `docker version`
-   - `docker info`
-   - `docker exec <registry-container> registry -version`
- 3. copy the command line you used to launch your Registry
- 4. restart your docker daemon in debug mode (add `-D` to the daemon launch arguments)
- 5. reproduce your problem and get your docker daemon logs showing the error
- 6. if relevant, copy your registry logs that show the error
- 7. provide any relevant detail about your specific Registry configuration (e.g., storage backend used)
- 8. indicate if you are using an enterprise proxy, Nginx, or anything else between you and your Registry
-
-## Contributing a patch for a known bug, or a small correction
-
-You should follow the basic GitHub workflow:
-
- 1. fork
- 2. commit a change
- 3. make sure the tests pass
- 4. PR
-
-Additionally, you must [sign your commits](https://github.com/docker/docker/blob/master/CONTRIBUTING.md#sign-your-work). It's very simple:
-
- - configure your name with git: `git config user.name "Real Name" && git config user.email mail@example.com`
- - sign your commits using `-s`: `git commit -s -m "My commit"`
-
-Some simple rules to ensure quick merge:
-
- - clearly point to the issue(s) you want to fix in your PR comment (e.g., `closes #12345`)
- - prefer multiple (smaller) PRs addressing individual issues over a big one trying to address multiple issues at once
- - if you need to amend your PR following comments, please squash instead of adding more commits
-
-## Contributing new features
-
-You are heavily encouraged to first discuss what you want to do. You can do so on the irc channel, or by opening an issue that clearly describes the use case you want to fulfill, or the problem you are trying to solve.
-
-If this is a major new feature, you should then submit a proposal that describes your technical solution and reasoning.
-If you did discuss it first, this will likely be greenlighted very fast. It's advisable to address all feedback on this proposal before starting actual work. 
-
-Then you should submit your implementation, clearly linking to the issue (and possible proposal).
-
-Your PR will be reviewed by the community, then ultimately by the project maintainers, before being merged.
-
-It's mandatory to:
-
- - interact respectfully with other community members and maintainers - more generally, you are expected to abide by the [Docker community rules](https://github.com/docker/docker/blob/master/CONTRIBUTING.md#docker-community-guidelines)
- - address maintainers' comments and modify your submission accordingly
- - write tests for any new code
-
-Complying to these simple rules will greatly accelerate the review process, and will ensure you have a pleasant experience in contributing code to the Registry.
-
-Have a look at a great, succesful contribution: the [Ceph driver PR](https://github.com/docker/distribution/pull/443)
-
-## Coding Style
-
-Unless explicitly stated, we follow all coding guidelines from the Go
-community. While some of these standards may seem arbitrary, they somehow seem
-to result in a solid, consistent codebase.
-
-It is possible that the code base does not currently comply with these
-guidelines. We are not looking for a massive PR that fixes this, since that
-goes against the spirit of the guidelines. All new contributions should make a
-best effort to clean up and make the code base better than they left it.
-Obviously, apply your best judgement. Remember, the goal here is to make the
-code base easier for humans to navigate and understand. Always keep that in
-mind when nudging others to comply.
-
-The rules:
-
-1. All code should be formatted with `gofmt -s`.
-2. All code should pass the default levels of
-   [`golint`](https://github.com/golang/lint).
-3. All code should follow the guidelines covered in [Effective
-   Go](http://golang.org/doc/effective_go.html) and [Go Code Review
-   Comments](https://github.com/golang/go/wiki/CodeReviewComments).
-4. Comment the code. Tell us the why, the history and the context.
-5. Document _all_ declarations and methods, even private ones. Declare
-   expectations, caveats and anything else that may be important. If a type
-   gets exported, having the comments already there will ensure it's ready.
-6. Variable name length should be proportional to its context and no longer.
-   `noCommaALongVariableNameLikeThisIsNotMoreClearWhenASimpleCommentWouldDo`.
-   In practice, short methods will have short variable names and globals will
-   have longer names.
-7. No underscores in package names. If you need a compound name, step back,
-   and re-examine why you need a compound name. If you still think you need a
-   compound name, lose the underscore.
-8. No utils or helpers packages. If a function is not general enough to
-   warrant its own package, it has not been written generally enough to be a
-   part of a util package. Just leave it unexported and well-documented.
-9. All tests should run with `go test` and outside tooling should not be
-   required. No, we don't need another unit testing framework. Assertion
-   packages are acceptable if they provide _real_ incremental value.
-10. Even though we call these "rules" above, they are actually just
-    guidelines. Since you've read all the rules, you now know that.
-
-If you are having trouble getting into the mood of idiomatic Go, we recommend
-reading through [Effective Go](http://golang.org/doc/effective_go.html). The
-[Go Blog](http://blog.golang.org/) is also a great resource. Drinking the
-kool-aid is a lot easier than going thirsty.

vendor/github.com/docker/distribution/Dockerfile

@@ -1,19 +0,0 @@
-FROM golang:1.5.3
-
-RUN apt-get update && \
-    apt-get install -y librados-dev apache2-utils && \
-    rm -rf /var/lib/apt/lists/*
-
-ENV DISTRIBUTION_DIR /go/src/github.com/docker/distribution
-ENV GOPATH $DISTRIBUTION_DIR/Godeps/_workspace:$GOPATH
-ENV DOCKER_BUILDTAGS include_rados include_oss include_gcs
-
-WORKDIR $DISTRIBUTION_DIR
-COPY . $DISTRIBUTION_DIR
-COPY cmd/registry/config-dev.yml /etc/docker/registry/config.yml
-RUN make PREFIX=/go clean binaries
-
-VOLUME ["/var/lib/registry"]
-EXPOSE 5000
-ENTRYPOINT ["registry"]
-CMD ["/etc/docker/registry/config.yml"]

vendor/github.com/docker/distribution/MAINTAINERS

@@ -1,63 +0,0 @@
-# Distribution maintainers file
-#
-# This file describes who runs the docker/distribution project and how.
-# This is a living document - if you see something out of date or missing, speak up!
-#
-# It is structured to be consumable by both humans and programs.
-# To extract its contents programmatically, use any TOML-compliant parser.
-#
-# This file is compiled into the MAINTAINERS file in docker/opensource.
-#
-[Org]
-	[Org."Core maintainers"]
-		people = [
-			"aaronlehmann",
-			"dmcgowan",
-			"dmp42",
-			"richardscothern",
-			"shykes",
-			"stevvooe",
-		]
-
-[people]
-
-# A reference list of all people associated with the project.
-# All other sections should refer to people by their canonical key
-# in the people section.
-
-	# ADD YOURSELF HERE IN ALPHABETICAL ORDER
-
-	[people.aaronlehmann]
-	Name = "Aaron Lehmann"
-	Email = "aaron.lehmann@docker.com"
-	GitHub = "aaronlehmann"
-
-	[people.brianbland]
-	Name = "Brian Bland"
-	Email = "brian.bland@docker.com"
-	GitHub = "BrianBland"
-
-	[people.dmcgowan]
-	Name = "Derek McGowan"
-	Email = "derek@mcgstyle.net"
-	GitHub = "dmcgowan"
-
-	[people.dmp42]
-	Name = "Olivier Gambier"
-	Email = "olivier@docker.com"
-	GitHub = "dmp42"
-
-	[people.richardscothern]
-	Name = "Richard Scothern"
-	Email = "richard.scothern@gmail.com"
-	GitHub = "richardscothern"
-
-	[people.shykes]
-	Name = "Solomon Hykes"
-	Email = "solomon@docker.com"
-	GitHub = "shykes"
-
-	[people.stevvooe]
-	Name = "Stephen Day"
-	Email = "stephen.day@docker.com"
-	GitHub = "stevvooe"

vendor/github.com/docker/distribution/Makefile

@@ -1,74 +0,0 @@
-# Set an output prefix, which is the local directory if not specified
-PREFIX?=$(shell pwd)
-
-
-# Used to populate version variable in main package.
-VERSION=$(shell git describe --match 'v[0-9]*' --dirty='.m' --always)
-
-# Allow turning off function inlining and variable registerization
-ifeq (${DISABLE_OPTIMIZATION},true)
-	GO_GCFLAGS=-gcflags "-N -l"
-	VERSION:="$(VERSION)-noopt"
-endif
-
-GO_LDFLAGS=-ldflags "-X `go list ./version`.Version=$(VERSION)"
-
-.PHONY: clean all fmt vet lint build test binaries
-.DEFAULT: default
-all: AUTHORS clean fmt vet fmt lint build test binaries
-
-AUTHORS: .mailmap .git/HEAD
-	 git log --format='%aN <%aE>' | sort -fu > $@
-
-# This only needs to be generated by hand when cutting full releases.
-version/version.go:
-	./version/version.sh > $@
-
-${PREFIX}/bin/registry: version/version.go $(shell find . -type f -name '*.go')
-	@echo "+ $@"
-	@go build -tags "${DOCKER_BUILDTAGS}" -o $@ ${GO_LDFLAGS}  ${GO_GCFLAGS} ./cmd/registry
-
-${PREFIX}/bin/digest: version/version.go $(shell find . -type f -name '*.go')
-	@echo "+ $@"
-	@go build -tags "${DOCKER_BUILDTAGS}" -o $@ ${GO_LDFLAGS}  ${GO_GCFLAGS} ./cmd/digest
-
-${PREFIX}/bin/registry-api-descriptor-template: version/version.go $(shell find . -type f -name '*.go')
-	@echo "+ $@"
-	@go build -o $@ ${GO_LDFLAGS} ${GO_GCFLAGS} ./cmd/registry-api-descriptor-template
-
-docs/spec/api.md: docs/spec/api.md.tmpl ${PREFIX}/bin/registry-api-descriptor-template
-	./bin/registry-api-descriptor-template $< > $@
-
-# Depends on binaries because vet will silently fail if it can't load compiled
-# imports
-vet: binaries
-	@echo "+ $@"
-	@go vet ./...
-
-fmt:
-	@echo "+ $@"
-	@test -z "$$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)" || \
-		echo "+ please format Go code with 'gofmt -s'"
-
-lint:
-	@echo "+ $@"
-	@test -z "$$(golint ./... | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"
-
-build:
-	@echo "+ $@"
-	@go build -tags "${DOCKER_BUILDTAGS}" -v ${GO_LDFLAGS} ./...
-
-test:
-	@echo "+ $@"
-	@go test -test.short -tags "${DOCKER_BUILDTAGS}" ./...
-
-test-full:
-	@echo "+ $@"
-	@go test ./...
-
-binaries: ${PREFIX}/bin/registry ${PREFIX}/bin/digest ${PREFIX}/bin/registry-api-descriptor-template
-	@echo "+ $@"
-
-clean:
-	@echo "+ $@"
-	@rm -rf "${PREFIX}/bin/registry" "${PREFIX}/bin/registry-api-descriptor-template"

vendor/github.com/docker/distribution/README.md

@@ -1,131 +0,0 @@
-# Distribution
-
-The Docker toolset to pack, ship, store, and deliver content.
-
-This repository's main product is the Docker Registry 2.0 implementation
-for storing and distributing Docker images. It supersedes the
-[docker/docker-registry](https://github.com/docker/docker-registry)
-project with a new API design, focused around security and performance.
-
-<img src="https://www.docker.com/sites/default/files/oyster-registry-3.png" width=200px/>
-
-[![Circle CI](https://circleci.com/gh/docker/distribution/tree/master.svg?style=svg)](https://circleci.com/gh/docker/distribution/tree/master)
-[![GoDoc](https://godoc.org/github.com/docker/distribution?status.svg)](https://godoc.org/github.com/docker/distribution)
-
-This repository contains the following components:
-
-|**Component**       |Description                                                                                                                                                                                         |
-|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| **registry**       | An implementation of the [Docker Registry HTTP API V2](docs/spec/api.md) for use with docker 1.6+.                                                                                                  |
-| **libraries**      | A rich set of libraries for interacting with,distribution components. Please see [godoc](https://godoc.org/github.com/docker/distribution) for details. **Note**: These libraries are **unstable**. |
-| **specifications** | _Distribution_ related specifications are available in [docs/spec](docs/spec)                                                                                                                        |
-| **documentation**  | Docker's full documentation set is available at [docs.docker.com](https://docs.docker.com). This repository [contains the subset](docs/index.md) related just to the registry.                                                                                                                                          |
-
-### How does this integrate with Docker engine?
-
-This project should provide an implementation to a V2 API for use in the [Docker
-core project](https://github.com/docker/docker). The API should be embeddable
-and simplify the process of securely pulling and pushing content from `docker`
-daemons.
-
-### What are the long term goals of the Distribution project?
-
-The _Distribution_ project has the further long term goal of providing a
-secure tool chain for distributing content. The specifications, APIs and tools
-should be as useful with Docker as they are without.
-
-Our goal is to design a professional grade and extensible content distribution
-system that allow users to:
-
-* Enjoy an efficient, secured and reliable way to store, manage, package and
-  exchange content
-* Hack/roll their own on top of healthy open-source components
-* Implement their own home made solution through good specs, and solid
-  extensions mechanism.
-
-## More about Registry 2.0
-
-The new registry implementation provides the following benefits:
-
-- faster push and pull
-- new, more efficient implementation
-- simplified deployment
-- pluggable storage backend
-- webhook notifications
-
-For information on upcoming functionality, please see [ROADMAP.md](ROADMAP.md).
-
-### Who needs to deploy a registry?
-
-By default, Docker users pull images from Docker's public registry instance.
-[Installing Docker](https://docs.docker.com/engine/installation/) gives users this
-ability. Users can also push images to a repository on Docker's public registry,
-if they have a [Docker Hub](https://hub.docker.com/) account. 
-
-For some users and even companies, this default behavior is sufficient. For
-others, it is not. 
-
-For example, users with their own software products may want to maintain a
-registry for private, company images. Also, you may wish to deploy your own
-image repository for images used to test or in continuous integration. For these
-use cases and others, [deploying your own registry instance](docs/deploying.md)
-may be the better choice.
-
-### Migration to Registry 2.0
-
-For those who have previously deployed their own registry based on the Registry
-1.0 implementation and wish to deploy a Registry 2.0 while retaining images,
-data migration is required. A tool to assist with migration efforts has been
-created. For more information see [docker/migrator]
-(https://github.com/docker/migrator).
-
-## Contribute
-
-Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute
-issues, fixes, and patches to this project. If you are contributing code, see
-the instructions for [building a development environment](docs/building.md).
-
-## Support
-
-If any issues are encountered while using the _Distribution_ project, several
-avenues are available for support:
-
-<table>
-<tr>
-	<th align="left">
-	IRC
-	</th>
-	<td>
-	#docker-distribution on FreeNode
-	</td>
-</tr>
-<tr>
-	<th align="left">
-	Issue Tracker
-	</th>
-	<td>
-	github.com/docker/distribution/issues
-	</td>
-</tr>
-<tr>
-	<th align="left">
-	Google Groups
-	</th>
-	<td>
-	https://groups.google.com/a/dockerproject.org/forum/#!forum/distribution
-	</td>
-</tr>
-<tr>
-	<th align="left">
-	Mailing List
-	</th>
-	<td>
-	docker@dockerproject.org
-	</td>
-</tr>
-</table>
-
-
-## License
-
-This project is distributed under [Apache License, Version 2.0](LICENSE.md).

vendor/github.com/docker/distribution/ROADMAP.md

@@ -1,267 +0,0 @@
-# Roadmap
-
-The Distribution Project consists of several components, some of which are
-still being defined. This document defines the high-level goals of the
-project, identifies the current components, and defines the release-
-relationship to the Docker Platform.
-
-* [Distribution Goals](#distribution-goals)
-* [Distribution Components](#distribution-components)
-* [Project Planning](#project-planning): release-relationship to the Docker Platform.
-
-This road map is a living document, providing an overview of the goals and
-considerations made in respect of the future of the project.
-
-## Distribution Goals
-
-- Replace the existing [docker registry](github.com/docker/docker-registry)
-  implementation as the primary implementation.
-- Replace the existing push and pull code in the docker engine with the
-  distribution package.
-- Define a strong data model for distributing docker images
-- Provide a flexible distribution tool kit for use in the docker platform
-- Unlock new distribution models
-
-## Distribution Components
-
-Components of the Distribution Project are managed via github [milestones](https://github.com/docker/distribution/milestones). Upcoming
-features and bugfixes for a component will be added to the relevant milestone. If a feature or
-bugfix is not part of a milestone, it is currently unscheduled for
-implementation. 
-
-* [Registry](#registry)
-* [Distribution Package](#distribution-package)
-
-***
-
-### Registry
-
-The new Docker registry is the main portion of the distribution repository.
-Registry 2.0 is the first release of the next-generation registry. This was
-primarily focused on implementing the [new registry
-API](https://github.com/docker/distribution/blob/master/docs/spec/api.md),
-with a focus on security and performance. 
-
-Following from the Distribution project goals above, we have a set of goals
-for registry v2 that we would like to follow in the design. New features
-should be compared against these goals.
-
-#### Data Storage and Distribution First
-
-The registry's first goal is to provide a reliable, consistent storage
-location for Docker images. The registry should only provide the minimal
-amount of indexing required to fetch image data and no more.
-
-This means we should be selective in new features and API additions, including
-those that may require expensive, ever growing indexes. Requests should be
-servable in "constant time".
-
-#### Content Addressability
-
-All data objects used in the registry API should be content addressable.
-Content identifiers should be secure and verifiable. This provides a secure,
-reliable base from which to build more advanced content distribution systems.
-
-#### Content Agnostic
-
-In the past, changes to the image format would require large changes in Docker
-and the Registry. By decoupling the distribution and image format, we can
-allow the formats to progress without having to coordinate between the two.
-This means that we should be focused on decoupling Docker from the registry
-just as much as decoupling the registry from Docker. Such an approach will
-allow us to unlock new distribution models that haven't been possible before.
-
-We can take this further by saying that the new registry should be content
-agnostic. The registry provides a model of names, tags, manifests and content
-addresses and that model can be used to work with content.
-
-#### Simplicity
-
-The new registry should be closer to a microservice component than its
-predecessor. This means it should have a narrower API and a low number of
-service dependencies. It should be easy to deploy.
-
-This means that other solutions should be explored before changing the API or
-adding extra dependencies. If functionality is required, can it be added as an
-extension or companion service.
-
-#### Extensibility
-
-The registry should provide extension points to add functionality. By keeping
-the scope narrow, but providing the ability to add functionality.
-
-Features like search, indexing, synchronization and registry explorers fall
-into this category. No such feature should be added unless we've found it
-impossible to do through an extension.
-
-#### Active Feature Discussions
-
-The following are feature discussions that are currently active.
-
-If you don't see your favorite, unimplemented feature, feel free to contact us
-via IRC or the mailing list and we can talk about adding it. The goal here is
-to make sure that new features go through a rigid design process before
-landing in the registry.
-
-##### Proxying to other Registries
-
-A _pull-through caching_ mode exists for the registry, but is restricted from 
-within the docker client to only mirror the official Docker Hub.  This functionality
-can be expanded when image provenance has been specified and implemented in the 
-distribution project.
-
-##### Metadata storage
-
-Metadata for the registry is currently stored with the manifest and layer data on
-the storage backend.  While this is a big win for simplicity and reliably maintaining
-state, it comes with the cost of consistency and high latency.  The mutable registry
-metadata operations should be abstracted behind an API which will allow ACID compliant
-storage systems to handle metadata.
-
-##### Peer to Peer transfer
-
-Discussion has started here: https://docs.google.com/document/d/1rYDpSpJiQWmCQy8Cuiaa3NH-Co33oK_SC9HeXYo87QA/edit
-
-##### Indexing, Search and Discovery
-
-The original registry provided some implementation of search for use with
-private registries. Support has been elided from V2 since we'd like to both
-decouple search functionality from the registry. The makes the registry
-simpler to deploy, especially in use cases where search is not needed, and
-let's us decouple the image format from the registry.
-
-There are explorations into using the catalog API and notification system to
-build external indexes. The current line of thought is that we will define a
-common search API to index and query docker images. Such a system could be run
-as a companion to a registry or set of registries to power discovery.
-
-The main issue with search and discovery is that there are so many ways to
-accomplish it. There are two aspects to this project. The first is deciding on
-how it will be done, including an API definition that can work with changing
-data formats. The second is the process of integrating with `docker search`.
-We expect that someone attempts to address the problem with the existing tools
-and propose it as a standard search API or uses it to inform a standardization
-process. Once this has been explored, we integrate with the docker client.
-
-Please see the following for more detail:
-
-- https://github.com/docker/distribution/issues/206
-
-##### Deletes
-
-> __NOTE:__ Deletes are a much asked for feature. Before requesting this
-feature or participating in discussion, we ask that you read this section in
-full and understand the problems behind deletes.
-
-While, at first glance, implementing deleting seems simple, there are a number
-mitigating factors that make many solutions not ideal or even pathological in
-the context of a registry. The following paragraph discuss the background and
-approaches that could be applied to a arrive at a solution.
-
-The goal of deletes in any system is to remove unused or unneeded data. Only
-data requested for deletion should be removed and no other data. Removing
-unintended data is worse than _not_ removing data that was requested for
-removal but ideally, both are supported. Generally, according to this rule, we
-err on holding data longer than needed, ensuring that it is only removed when
-we can be certain that it can be removed. With the current behavior, we opt to
-hold onto the data forever, ensuring that data cannot be incorrectly removed.
-
-To understand the problems with implementing deletes, one must understand the
-data model. All registry data is stored in a filesystem layout, implemented on
-a "storage driver", effectively a _virtual file system_ (VFS). The storage
-system must assume that this VFS layer will be eventually consistent and has
-poor read- after-write consistency, since this is the lower common denominator
-among the storage drivers. This is mitigated by writing values in reverse-
-dependent order, but makes wider transactional operations unsafe.
-
-Layered on the VFS model is a content-addressable _directed, acyclic graph_
-(DAG) made up of blobs. Manifests reference layers. Tags reference manifests.
-Since the same data can be referenced by multiple manifests, we only store
-data once, even if it is in different repositories. Thus, we have a set of
-blobs, referenced by tags and manifests. If we want to delete a blob we need
-to be certain that it is no longer referenced by another manifest or tag. When
-we delete a manifest, we also can try to delete the referenced blobs. Deciding
-whether or not a blob has an active reference is the crux of the problem.
-
-Conceptually, deleting a manifest and its resources is quite simple. Just find
-all the manifests, enumerate the referenced blobs and delete the blobs not in
-that set. An astute observer will recognize this as a garbage collection
-problem. As with garbage collection in programming languages, this is very
-simple when one always has a consistent view. When one adds parallelism and an
-inconsistent view of data, it becomes very challenging.
-
-A simple example can demonstrate this. Let's say we are deleting a manifest
-_A_ in one process. We scan the manifest and decide that all the blobs are
-ready for deletion. Concurrently, we have another process accepting a new
-manifest _B_ referencing one or more blobs from the manifest _A_. Manifest _B_
-is accepted and all the blobs are considered present, so the operation
-proceeds. The original process then deletes the referenced blobs, assuming
-they were unreferenced. The manifest _B_, which we thought had all of its data
-present, can no longer be served by the registry, since the dependent data has
-been deleted.
-
-Deleting data from the registry safely requires some way to coordinate this
-operation. The following approaches are being considered:
-
-- _Reference Counting_ - Maintain a count of references to each blob. This is
-  challenging for a number of reasons: 1. maintaining a consistent consensus
-  of reference counts across a set of Registries and 2. Building the initial
-  list of reference counts for an existing registry. These challenges can be
-  met with a consensus protocol like Paxos or Raft in the first case and a
-  necessary but simple scan in the second..
-- _Lock the World GC_ - Halt all writes to the data store. Walk the data store
-  and find all blob references. Delete all unreferenced blobs. This approach
-  is very simple but requires disabling writes for a period of time while the
-  service reads all data. This is slow and expensive but very accurate and
-  effective.
-- _Generational GC_ - Do something similar to above but instead of blocking
-  writes, writes are sent to another storage backend while reads are broadcast
-  to the new and old backends. GC is then performed on the read-only portion.
-  Because writes land in the new backend, the data in the read-only section
-  can be safely deleted. The main drawbacks of this approach are complexity
-  and coordination.
-- _Centralized Oracle_ - Using a centralized, transactional database, we can
-  know exactly which data is referenced at any given time. This avoids
-  coordination problem by managing this data in a single location. We trade
-  off metadata scalability for simplicity and performance. This is a very good
-  option for most registry deployments. This would create a bottleneck for
-  registry metadata. However, metadata is generally not the main bottleneck
-  when serving images.
-
-Please let us know if other solutions exist that we have yet to enumerate.
-Note that for any approach, implementation is a massive consideration. For
-example, a mark-sweep based solution may seem simple but the amount of work in
-coordination offset the extra work it might take to build a _Centralized
-Oracle_. We'll accept proposals for any solution but please coordinate with us
-before dropping code.
-
-At this time, we have traded off simplicity and ease of deployment for disk
-space. Simplicity and ease of deployment tend to reduce developer involvement,
-which is currently the most expensive resource in software engineering. Taking
-on any solution for deletes will greatly effect these factors, trading off
-very cheap disk space for a complex deployment and operational story.
-
-Please see the following issues for more detail:
-
-- https://github.com/docker/distribution/issues/422
-- https://github.com/docker/distribution/issues/461
-- https://github.com/docker/distribution/issues/462
-
-### Distribution Package 
-
-At its core, the Distribution Project is a set of Go packages that make up
-Distribution Components. At this time, most of these packages make up the
-Registry implementation. 
-
-The package itself is considered unstable. If you're using it, please take care to vendor the dependent version. 
-
-For feature additions, please see the Registry section. In the future, we may break out a
-separate Roadmap for distribution-specific features that apply to more than
-just the registry.
-
-***
-
-### Project Planning
-
-An [Open-Source Planning Process](https://github.com/docker/distribution/wiki/Open-Source-Planning-Process) is used to define the Roadmap. [Project Pages](https://github.com/docker/distribution/wiki) define the goals for each Milestone and identify current progress.
-

vendor/github.com/docker/distribution/blobs.go

@@ -1,233 +0,0 @@
-package distribution
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"time"
-
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/reference"
-)
-
-var (
-	// ErrBlobExists returned when blob already exists
-	ErrBlobExists = errors.New("blob exists")
-
-	// ErrBlobDigestUnsupported when blob digest is an unsupported version.
-	ErrBlobDigestUnsupported = errors.New("unsupported blob digest")
-
-	// ErrBlobUnknown when blob is not found.
-	ErrBlobUnknown = errors.New("unknown blob")
-
-	// ErrBlobUploadUnknown returned when upload is not found.
-	ErrBlobUploadUnknown = errors.New("blob upload unknown")
-
-	// ErrBlobInvalidLength returned when the blob has an expected length on
-	// commit, meaning mismatched with the descriptor or an invalid value.
-	ErrBlobInvalidLength = errors.New("blob invalid length")
-)
-
-// ErrBlobInvalidDigest returned when digest check fails.
-type ErrBlobInvalidDigest struct {
-	Digest digest.Digest
-	Reason error
-}
-
-func (err ErrBlobInvalidDigest) Error() string {
-	return fmt.Sprintf("invalid digest for referenced layer: %v, %v",
-		err.Digest, err.Reason)
-}
-
-// ErrBlobMounted returned when a blob is mounted from another repository
-// instead of initiating an upload session.
-type ErrBlobMounted struct {
-	From       reference.Canonical
-	Descriptor Descriptor
-}
-
-func (err ErrBlobMounted) Error() string {
-	return fmt.Sprintf("blob mounted from: %v to: %v",
-		err.From, err.Descriptor)
-}
-
-// Descriptor describes targeted content. Used in conjunction with a blob
-// store, a descriptor can be used to fetch, store and target any kind of
-// blob. The struct also describes the wire protocol format. Fields should
-// only be added but never changed.
-type Descriptor struct {
-	// MediaType describe the type of the content. All text based formats are
-	// encoded as utf-8.
-	MediaType string `json:"mediaType,omitempty"`
-
-	// Size in bytes of content.
-	Size int64 `json:"size,omitempty"`
-
-	// Digest uniquely identifies the content. A byte stream can be verified
-	// against against this digest.
-	Digest digest.Digest `json:"digest,omitempty"`
-
-	// NOTE: Before adding a field here, please ensure that all
-	// other options have been exhausted. Much of the type relationships
-	// depend on the simplicity of this type.
-}
-
-// Descriptor returns the descriptor, to make it satisfy the Describable
-// interface. Note that implementations of Describable are generally objects
-// which can be described, not simply descriptors; this exception is in place
-// to make it more convenient to pass actual descriptors to functions that
-// expect Describable objects.
-func (d Descriptor) Descriptor() Descriptor {
-	return d
-}
-
-// BlobStatter makes blob descriptors available by digest. The service may
-// provide a descriptor of a different digest if the provided digest is not
-// canonical.
-type BlobStatter interface {
-	// Stat provides metadata about a blob identified by the digest. If the
-	// blob is unknown to the describer, ErrBlobUnknown will be returned.
-	Stat(ctx context.Context, dgst digest.Digest) (Descriptor, error)
-}
-
-// BlobDeleter enables deleting blobs from storage.
-type BlobDeleter interface {
-	Delete(ctx context.Context, dgst digest.Digest) error
-}
-
-// BlobDescriptorService manages metadata about a blob by digest. Most
-// implementations will not expose such an interface explicitly. Such mappings
-// should be maintained by interacting with the BlobIngester. Hence, this is
-// left off of BlobService and BlobStore.
-type BlobDescriptorService interface {
-	BlobStatter
-
-	// SetDescriptor assigns the descriptor to the digest. The provided digest and
-	// the digest in the descriptor must map to identical content but they may
-	// differ on their algorithm. The descriptor must have the canonical
-	// digest of the content and the digest algorithm must match the
-	// annotators canonical algorithm.
-	//
-	// Such a facility can be used to map blobs between digest domains, with
-	// the restriction that the algorithm of the descriptor must match the
-	// canonical algorithm (ie sha256) of the annotator.
-	SetDescriptor(ctx context.Context, dgst digest.Digest, desc Descriptor) error
-
-	// Clear enables descriptors to be unlinked
-	Clear(ctx context.Context, dgst digest.Digest) error
-}
-
-// ReadSeekCloser is the primary reader type for blob data, combining
-// io.ReadSeeker with io.Closer.
-type ReadSeekCloser interface {
-	io.ReadSeeker
-	io.Closer
-}
-
-// BlobProvider describes operations for getting blob data.
-type BlobProvider interface {
-	// Get returns the entire blob identified by digest along with the descriptor.
-	Get(ctx context.Context, dgst digest.Digest) ([]byte, error)
-
-	// Open provides a ReadSeekCloser to the blob identified by the provided
-	// descriptor. If the blob is not known to the service, an error will be
-	// returned.
-	Open(ctx context.Context, dgst digest.Digest) (ReadSeekCloser, error)
-}
-
-// BlobServer can serve blobs via http.
-type BlobServer interface {
-	// ServeBlob attempts to serve the blob, identifed by dgst, via http. The
-	// service may decide to redirect the client elsewhere or serve the data
-	// directly.
-	//
-	// This handler only issues successful responses, such as 2xx or 3xx,
-	// meaning it serves data or issues a redirect. If the blob is not
-	// available, an error will be returned and the caller may still issue a
-	// response.
-	//
-	// The implementation may serve the same blob from a different digest
-	// domain. The appropriate headers will be set for the blob, unless they
-	// have already been set by the caller.
-	ServeBlob(ctx context.Context, w http.ResponseWriter, r *http.Request, dgst digest.Digest) error
-}
-
-// BlobIngester ingests blob data.
-type BlobIngester interface {
-	// Put inserts the content p into the blob service, returning a descriptor
-	// or an error.
-	Put(ctx context.Context, mediaType string, p []byte) (Descriptor, error)
-
-	// Create allocates a new blob writer to add a blob to this service. The
-	// returned handle can be written to and later resumed using an opaque
-	// identifier. With this approach, one can Close and Resume a BlobWriter
-	// multiple times until the BlobWriter is committed or cancelled.
-	Create(ctx context.Context, options ...BlobCreateOption) (BlobWriter, error)
-
-	// Resume attempts to resume a write to a blob, identified by an id.
-	Resume(ctx context.Context, id string) (BlobWriter, error)
-}
-
-// BlobCreateOption is a general extensible function argument for blob creation
-// methods. A BlobIngester may choose to honor any or none of the given
-// BlobCreateOptions, which can be specific to the implementation of the
-// BlobIngester receiving them.
-// TODO (brianbland): unify this with ManifestServiceOption in the future
-type BlobCreateOption interface {
-	Apply(interface{}) error
-}
-
-// BlobWriter provides a handle for inserting data into a blob store.
-// Instances should be obtained from BlobWriteService.Writer and
-// BlobWriteService.Resume. If supported by the store, a writer can be
-// recovered with the id.
-type BlobWriter interface {
-	io.WriteSeeker
-	io.ReaderFrom
-	io.Closer
-
-	// ID returns the identifier for this writer. The ID can be used with the
-	// Blob service to later resume the write.
-	ID() string
-
-	// StartedAt returns the time this blob write was started.
-	StartedAt() time.Time
-
-	// Commit completes the blob writer process. The content is verified
-	// against the provided provisional descriptor, which may result in an
-	// error. Depending on the implementation, written data may be validated
-	// against the provisional descriptor fields. If MediaType is not present,
-	// the implementation may reject the commit or assign "application/octet-
-	// stream" to the blob. The returned descriptor may have a different
-	// digest depending on the blob store, referred to as the canonical
-	// descriptor.
-	Commit(ctx context.Context, provisional Descriptor) (canonical Descriptor, err error)
-
-	// Cancel ends the blob write without storing any data and frees any
-	// associated resources. Any data written thus far will be lost. Cancel
-	// implementations should allow multiple calls even after a commit that
-	// result in a no-op. This allows use of Cancel in a defer statement,
-	// increasing the assurance that it is correctly called.
-	Cancel(ctx context.Context) error
-
-	// Get a reader to the blob being written by this BlobWriter
-	Reader() (io.ReadCloser, error)
-}
-
-// BlobService combines the operations to access, read and write blobs. This
-// can be used to describe remote blob services.
-type BlobService interface {
-	BlobStatter
-	BlobProvider
-	BlobIngester
-}
-
-// BlobStore represent the entire suite of blob related operations. Such an
-// implementation can access, read, write, delete and serve blobs.
-type BlobStore interface {
-	BlobService
-	BlobServer
-	BlobDeleter
-}

vendor/github.com/docker/distribution/circle.yml

@@ -1,90 +0,0 @@
-# Pony-up!
-machine:
-  pre:
-  # Install gvm
-    - bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/1.0.22/binscripts/gvm-installer)
-  # Install ceph to test rados driver & create pool
-    - sudo -i ~/distribution/contrib/ceph/ci-setup.sh
-    - ceph osd pool create docker-distribution 1
-  # Install codecov for coverage
-    - pip install --user codecov
-
-  post:
-  # go
-    - gvm install go1.5.3 --prefer-binary --name=stable
-
-  environment:
-  # Convenient shortcuts to "common" locations
-    CHECKOUT: /home/ubuntu/$CIRCLE_PROJECT_REPONAME
-    BASE_DIR: src/github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME
-  # Trick circle brainflat "no absolute path" behavior
-    BASE_STABLE: ../../../$HOME/.gvm/pkgsets/stable/global/$BASE_DIR
-    DOCKER_BUILDTAGS: "include_rados include_oss include_gcs"
-  # Workaround Circle parsing dumb bugs and/or YAML wonkyness
-    CIRCLE_PAIN: "mode: set"
-  # Ceph config
-    RADOS_POOL: "docker-distribution"
-
-  hosts:
-  # Not used yet
-    fancy: 127.0.0.1
-
-dependencies:
-  pre:
-  # Copy the code to the gopath of all go versions
-    - >
-      gvm use stable &&
-      mkdir -p "$(dirname $BASE_STABLE)" &&
-      cp -R "$CHECKOUT" "$BASE_STABLE"
-
-  override:
-  # Install dependencies for every copied clone/go version
-    - gvm use stable && go get github.com/tools/godep:
-        pwd: $BASE_STABLE
-
-  post:
-  # For the stable go version, additionally install linting tools
-    - >
-      gvm use stable &&
-      go get github.com/axw/gocov/gocov github.com/golang/lint/golint
-
-test:
-  pre:
-  # Output the go versions we are going to test
-    # - gvm use old && go version
-    - gvm use stable && go version
-
-  # First thing: build everything. This will catch compile errors, and it's
-  # also necessary for go vet to work properly (see #807).
-    - gvm use stable && godep go install ./...:
-        pwd: $BASE_STABLE
-
-  # FMT
-    - gvm use stable && test -z "$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)":
-        pwd: $BASE_STABLE
-
-   # VET
-    - gvm use stable && go vet ./...:
-        pwd: $BASE_STABLE
-
-  # LINT
-    - gvm use stable && test -z "$(golint ./... | grep -v Godeps/_workspace/src/ | tee /dev/stderr)":
-        pwd: $BASE_STABLE
-
-  override:
-  # Test stable, and report
-     - gvm use stable; export ROOT_PACKAGE=$(go list .); go list -tags "$DOCKER_BUILDTAGS" ./... | xargs -L 1 -I{} bash -c 'export PACKAGE={}; godep go test -tags "$DOCKER_BUILDTAGS" -test.short -coverprofile=$GOPATH/src/$PACKAGE/coverage.out -coverpkg=$(./coverpkg.sh $PACKAGE $ROOT_PACKAGE) $PACKAGE':
-         timeout: 600
-         pwd: $BASE_STABLE
-
-  post:
-  # Report to codecov
-    - bash <(curl -s https://codecov.io/bash):
-        pwd: $BASE_STABLE
-
-  ## Notes
-  # Disabled the -race detector due to massive memory usage.
-  # Do we want these as well?
-  # - go get code.google.com/p/go.tools/cmd/goimports
-  # - test -z "$(goimports -l -w ./... | tee /dev/stderr)"
-  # http://labix.org/gocheck

vendor/github.com/docker/distribution/context/context.go

@@ -1,85 +0,0 @@
-package context
-
-import (
-	"sync"
-
-	"github.com/docker/distribution/uuid"
-	"golang.org/x/net/context"
-)
-
-// Context is a copy of Context from the golang.org/x/net/context package.
-type Context interface {
-	context.Context
-}
-
-// instanceContext is a context that provides only an instance id. It is
-// provided as the main background context.
-type instanceContext struct {
-	Context
-	id   string    // id of context, logged as "instance.id"
-	once sync.Once // once protect generation of the id
-}
-
-func (ic *instanceContext) Value(key interface{}) interface{} {
-	if key == "instance.id" {
-		ic.once.Do(func() {
-			// We want to lazy initialize the UUID such that we don't
-			// call a random generator from the package initialization
-			// code. For various reasons random could not be available
-			// https://github.com/docker/distribution/issues/782
-			ic.id = uuid.Generate().String()
-		})
-		return ic.id
-	}
-
-	return ic.Context.Value(key)
-}
-
-var background = &instanceContext{
-	Context: context.Background(),
-}
-
-// Background returns a non-nil, empty Context. The background context
-// provides a single key, "instance.id" that is globally unique to the
-// process.
-func Background() Context {
-	return background
-}
-
-// WithValue returns a copy of parent in which the value associated with key is
-// val. Use context Values only for request-scoped data that transits processes
-// and APIs, not for passing optional parameters to functions.
-func WithValue(parent Context, key, val interface{}) Context {
-	return context.WithValue(parent, key, val)
-}
-
-// stringMapContext is a simple context implementation that checks a map for a
-// key, falling back to a parent if not present.
-type stringMapContext struct {
-	context.Context
-	m map[string]interface{}
-}
-
-// WithValues returns a context that proxies lookups through a map. Only
-// supports string keys.
-func WithValues(ctx context.Context, m map[string]interface{}) context.Context {
-	mo := make(map[string]interface{}, len(m)) // make our own copy.
-	for k, v := range m {
-		mo[k] = v
-	}
-
-	return stringMapContext{
-		Context: ctx,
-		m:       mo,
-	}
-}
-
-func (smc stringMapContext) Value(key interface{}) interface{} {
-	if ks, ok := key.(string); ok {
-		if v, ok := smc.m[ks]; ok {
-			return v
-		}
-	}
-
-	return smc.Context.Value(key)
-}

vendor/github.com/docker/distribution/context/doc.go

@@ -1,89 +0,0 @@
-// Package context provides several utilities for working with
-// golang.org/x/net/context in http requests. Primarily, the focus is on
-// logging relevant request information but this package is not limited to
-// that purpose.
-//
-// The easiest way to get started is to get the background context:
-//
-// 	ctx := context.Background()
-//
-// The returned context should be passed around your application and be the
-// root of all other context instances. If the application has a version, this
-// line should be called before anything else:
-//
-// 	ctx := context.WithVersion(context.Background(), version)
-//
-// The above will store the version in the context and will be available to
-// the logger.
-//
-// Logging
-//
-// The most useful aspect of this package is GetLogger. This function takes
-// any context.Context interface and returns the current logger from the
-// context. Canonical usage looks like this:
-//
-// 	GetLogger(ctx).Infof("something interesting happened")
-//
-// GetLogger also takes optional key arguments. The keys will be looked up in
-// the context and reported with the logger. The following example would
-// return a logger that prints the version with each log message:
-//
-// 	ctx := context.Context(context.Background(), "version", version)
-// 	GetLogger(ctx, "version").Infof("this log message has a version field")
-//
-// The above would print out a log message like this:
-//
-// 	INFO[0000] this log message has a version field        version=v2.0.0-alpha.2.m
-//
-// When used with WithLogger, we gain the ability to decorate the context with
-// loggers that have information from disparate parts of the call stack.
-// Following from the version example, we can build a new context with the
-// configured logger such that we always print the version field:
-//
-// 	ctx = WithLogger(ctx, GetLogger(ctx, "version"))
-//
-// Since the logger has been pushed to the context, we can now get the version
-// field for free with our log messages. Future calls to GetLogger on the new
-// context will have the version field:
-//
-// 	GetLogger(ctx).Infof("this log message has a version field")
-//
-// This becomes more powerful when we start stacking loggers. Let's say we
-// have the version logger from above but also want a request id. Using the
-// context above, in our request scoped function, we place another logger in
-// the context:
-//
-// 	ctx = context.WithValue(ctx, "http.request.id", "unique id") // called when building request context
-// 	ctx = WithLogger(ctx, GetLogger(ctx, "http.request.id"))
-//
-// When GetLogger is called on the new context, "http.request.id" will be
-// included as a logger field, along with the original "version" field:
-//
-// 	INFO[0000] this log message has a version field        http.request.id=unique id version=v2.0.0-alpha.2.m
-//
-// Note that this only affects the new context, the previous context, with the
-// version field, can be used independently. Put another way, the new logger,
-// added to the request context, is unique to that context and can have
-// request scoped varaibles.
-//
-// HTTP Requests
-//
-// This package also contains several methods for working with http requests.
-// The concepts are very similar to those described above. We simply place the
-// request in the context using WithRequest. This makes the request variables
-// available. GetRequestLogger can then be called to get request specific
-// variables in a log line:
-//
-// 	ctx = WithRequest(ctx, req)
-// 	GetRequestLogger(ctx).Infof("request variables")
-//
-// Like above, if we want to include the request data in all log messages in
-// the context, we push the logger to a new context and use that one:
-//
-// 	ctx = WithLogger(ctx, GetRequestLogger(ctx))
-//
-// The concept is fairly powerful and ensures that calls throughout the stack
-// can be traced in log messages. Using the fields like "http.request.id", one
-// can analyze call flow for a particular request with a simple grep of the
-// logs.
-package context

vendor/github.com/docker/distribution/context/http.go

@@ -1,364 +0,0 @@
-package context
-
-import (
-	"errors"
-	"net"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	log "github.com/Sirupsen/logrus"
-	"github.com/docker/distribution/uuid"
-	"github.com/gorilla/mux"
-)
-
-// Common errors used with this package.
-var (
-	ErrNoRequestContext        = errors.New("no http request in context")
-	ErrNoResponseWriterContext = errors.New("no http response in context")
-)
-
-func parseIP(ipStr string) net.IP {
-	ip := net.ParseIP(ipStr)
-	if ip == nil {
-		log.Warnf("invalid remote IP address: %q", ipStr)
-	}
-	return ip
-}
-
-// RemoteAddr extracts the remote address of the request, taking into
-// account proxy headers.
-func RemoteAddr(r *http.Request) string {
-	if prior := r.Header.Get("X-Forwarded-For"); prior != "" {
-		proxies := strings.Split(prior, ",")
-		if len(proxies) > 0 {
-			remoteAddr := strings.Trim(proxies[0], " ")
-			if parseIP(remoteAddr) != nil {
-				return remoteAddr
-			}
-		}
-	}
-	// X-Real-Ip is less supported, but worth checking in the
-	// absence of X-Forwarded-For
-	if realIP := r.Header.Get("X-Real-Ip"); realIP != "" {
-		if parseIP(realIP) != nil {
-			return realIP
-		}
-	}
-
-	return r.RemoteAddr
-}
-
-// RemoteIP extracts the remote IP of the request, taking into
-// account proxy headers.
-func RemoteIP(r *http.Request) string {
-	addr := RemoteAddr(r)
-
-	// Try parsing it as "IP:port"
-	if ip, _, err := net.SplitHostPort(addr); err == nil {
-		return ip
-	}
-
-	return addr
-}
-
-// WithRequest places the request on the context. The context of the request
-// is assigned a unique id, available at "http.request.id". The request itself
-// is available at "http.request". Other common attributes are available under
-// the prefix "http.request.". If a request is already present on the context,
-// this method will panic.
-func WithRequest(ctx Context, r *http.Request) Context {
-	if ctx.Value("http.request") != nil {
-		// NOTE(stevvooe): This needs to be considered a programming error. It
-		// is unlikely that we'd want to have more than one request in
-		// context.
-		panic("only one request per context")
-	}
-
-	return &httpRequestContext{
-		Context:   ctx,
-		startedAt: time.Now(),
-		id:        uuid.Generate().String(),
-		r:         r,
-	}
-}
-
-// GetRequest returns the http request in the given context. Returns
-// ErrNoRequestContext if the context does not have an http request associated
-// with it.
-func GetRequest(ctx Context) (*http.Request, error) {
-	if r, ok := ctx.Value("http.request").(*http.Request); r != nil && ok {
-		return r, nil
-	}
-	return nil, ErrNoRequestContext
-}
-
-// GetRequestID attempts to resolve the current request id, if possible. An
-// error is return if it is not available on the context.
-func GetRequestID(ctx Context) string {
-	return GetStringValue(ctx, "http.request.id")
-}
-
-// WithResponseWriter returns a new context and response writer that makes
-// interesting response statistics available within the context.
-func WithResponseWriter(ctx Context, w http.ResponseWriter) (Context, http.ResponseWriter) {
-	irw := instrumentedResponseWriter{
-		ResponseWriter: w,
-		Context:        ctx,
-	}
-
-	if closeNotifier, ok := w.(http.CloseNotifier); ok {
-		irwCN := &instrumentedResponseWriterCN{
-			instrumentedResponseWriter: irw,
-			CloseNotifier:              closeNotifier,
-		}
-
-		return irwCN, irwCN
-	}
-
-	return &irw, &irw
-}
-
-// GetResponseWriter returns the http.ResponseWriter from the provided
-// context. If not present, ErrNoResponseWriterContext is returned. The
-// returned instance provides instrumentation in the context.
-func GetResponseWriter(ctx Context) (http.ResponseWriter, error) {
-	v := ctx.Value("http.response")
-
-	rw, ok := v.(http.ResponseWriter)
-	if !ok || rw == nil {
-		return nil, ErrNoResponseWriterContext
-	}
-
-	return rw, nil
-}
-
-// getVarsFromRequest let's us change request vars implementation for testing
-// and maybe future changes.
-var getVarsFromRequest = mux.Vars
-
-// WithVars extracts gorilla/mux vars and makes them available on the returned
-// context. Variables are available at keys with the prefix "vars.". For
-// example, if looking for the variable "name", it can be accessed as
-// "vars.name". Implementations that are accessing values need not know that
-// the underlying context is implemented with gorilla/mux vars.
-func WithVars(ctx Context, r *http.Request) Context {
-	return &muxVarsContext{
-		Context: ctx,
-		vars:    getVarsFromRequest(r),
-	}
-}
-
-// GetRequestLogger returns a logger that contains fields from the request in
-// the current context. If the request is not available in the context, no
-// fields will display. Request loggers can safely be pushed onto the context.
-func GetRequestLogger(ctx Context) Logger {
-	return GetLogger(ctx,
-		"http.request.id",
-		"http.request.method",
-		"http.request.host",
-		"http.request.uri",
-		"http.request.referer",
-		"http.request.useragent",
-		"http.request.remoteaddr",
-		"http.request.contenttype")
-}
-
-// GetResponseLogger reads the current response stats and builds a logger.
-// Because the values are read at call time, pushing a logger returned from
-// this function on the context will lead to missing or invalid data. Only
-// call this at the end of a request, after the response has been written.
-func GetResponseLogger(ctx Context) Logger {
-	l := getLogrusLogger(ctx,
-		"http.response.written",
-		"http.response.status",
-		"http.response.contenttype")
-
-	duration := Since(ctx, "http.request.startedat")
-
-	if duration > 0 {
-		l = l.WithField("http.response.duration", duration.String())
-	}
-
-	return l
-}
-
-// httpRequestContext makes information about a request available to context.
-type httpRequestContext struct {
-	Context
-
-	startedAt time.Time
-	id        string
-	r         *http.Request
-}
-
-// Value returns a keyed element of the request for use in the context. To get
-// the request itself, query "request". For other components, access them as
-// "request.<component>". For example, r.RequestURI
-func (ctx *httpRequestContext) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "http.request" {
-			return ctx.r
-		}
-
-		if !strings.HasPrefix(keyStr, "http.request.") {
-			goto fallback
-		}
-
-		parts := strings.Split(keyStr, ".")
-
-		if len(parts) != 3 {
-			goto fallback
-		}
-
-		switch parts[2] {
-		case "uri":
-			return ctx.r.RequestURI
-		case "remoteaddr":
-			return RemoteAddr(ctx.r)
-		case "method":
-			return ctx.r.Method
-		case "host":
-			return ctx.r.Host
-		case "referer":
-			referer := ctx.r.Referer()
-			if referer != "" {
-				return referer
-			}
-		case "useragent":
-			return ctx.r.UserAgent()
-		case "id":
-			return ctx.id
-		case "startedat":
-			return ctx.startedAt
-		case "contenttype":
-			ct := ctx.r.Header.Get("Content-Type")
-			if ct != "" {
-				return ct
-			}
-		}
-	}
-
-fallback:
-	return ctx.Context.Value(key)
-}
-
-type muxVarsContext struct {
-	Context
-	vars map[string]string
-}
-
-func (ctx *muxVarsContext) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "vars" {
-			return ctx.vars
-		}
-
-		if strings.HasPrefix(keyStr, "vars.") {
-			keyStr = strings.TrimPrefix(keyStr, "vars.")
-		}
-
-		if v, ok := ctx.vars[keyStr]; ok {
-			return v
-		}
-	}
-
-	return ctx.Context.Value(key)
-}
-
-// instrumentedResponseWriterCN provides response writer information in a
-// context. It implements http.CloseNotifier so that users can detect
-// early disconnects.
-type instrumentedResponseWriterCN struct {
-	instrumentedResponseWriter
-	http.CloseNotifier
-}
-
-// instrumentedResponseWriter provides response writer information in a
-// context. This variant is only used in the case where CloseNotifier is not
-// implemented by the parent ResponseWriter.
-type instrumentedResponseWriter struct {
-	http.ResponseWriter
-	Context
-
-	mu      sync.Mutex
-	status  int
-	written int64
-}
-
-func (irw *instrumentedResponseWriter) Write(p []byte) (n int, err error) {
-	n, err = irw.ResponseWriter.Write(p)
-
-	irw.mu.Lock()
-	irw.written += int64(n)
-
-	// Guess the likely status if not set.
-	if irw.status == 0 {
-		irw.status = http.StatusOK
-	}
-
-	irw.mu.Unlock()
-
-	return
-}
-
-func (irw *instrumentedResponseWriter) WriteHeader(status int) {
-	irw.ResponseWriter.WriteHeader(status)
-
-	irw.mu.Lock()
-	irw.status = status
-	irw.mu.Unlock()
-}
-
-func (irw *instrumentedResponseWriter) Flush() {
-	if flusher, ok := irw.ResponseWriter.(http.Flusher); ok {
-		flusher.Flush()
-	}
-}
-
-func (irw *instrumentedResponseWriter) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "http.response" {
-			return irw
-		}
-
-		if !strings.HasPrefix(keyStr, "http.response.") {
-			goto fallback
-		}
-
-		parts := strings.Split(keyStr, ".")
-
-		if len(parts) != 3 {
-			goto fallback
-		}
-
-		irw.mu.Lock()
-		defer irw.mu.Unlock()
-
-		switch parts[2] {
-		case "written":
-			return irw.written
-		case "status":
-			return irw.status
-		case "contenttype":
-			contentType := irw.Header().Get("Content-Type")
-			if contentType != "" {
-				return contentType
-			}
-		}
-	}
-
-fallback:
-	return irw.Context.Value(key)
-}
-
-func (irw *instrumentedResponseWriterCN) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "http.response" {
-			return irw
-		}
-	}
-
-	return irw.instrumentedResponseWriter.Value(key)
-}

vendor/github.com/docker/distribution/context/logger.go

@@ -1,116 +0,0 @@
-package context
-
-import (
-	"fmt"
-
-	"github.com/Sirupsen/logrus"
-	"runtime"
-)
-
-// Logger provides a leveled-logging interface.
-type Logger interface {
-	// standard logger methods
-	Print(args ...interface{})
-	Printf(format string, args ...interface{})
-	Println(args ...interface{})
-
-	Fatal(args ...interface{})
-	Fatalf(format string, args ...interface{})
-	Fatalln(args ...interface{})
-
-	Panic(args ...interface{})
-	Panicf(format string, args ...interface{})
-	Panicln(args ...interface{})
-
-	// Leveled methods, from logrus
-	Debug(args ...interface{})
-	Debugf(format string, args ...interface{})
-	Debugln(args ...interface{})
-
-	Error(args ...interface{})
-	Errorf(format string, args ...interface{})
-	Errorln(args ...interface{})
-
-	Info(args ...interface{})
-	Infof(format string, args ...interface{})
-	Infoln(args ...interface{})
-
-	Warn(args ...interface{})
-	Warnf(format string, args ...interface{})
-	Warnln(args ...interface{})
-}
-
-// WithLogger creates a new context with provided logger.
-func WithLogger(ctx Context, logger Logger) Context {
-	return WithValue(ctx, "logger", logger)
-}
-
-// GetLoggerWithField returns a logger instance with the specified field key
-// and value without affecting the context. Extra specified keys will be
-// resolved from the context.
-func GetLoggerWithField(ctx Context, key, value interface{}, keys ...interface{}) Logger {
-	return getLogrusLogger(ctx, keys...).WithField(fmt.Sprint(key), value)
-}
-
-// GetLoggerWithFields returns a logger instance with the specified fields
-// without affecting the context. Extra specified keys will be resolved from
-// the context.
-func GetLoggerWithFields(ctx Context, fields map[interface{}]interface{}, keys ...interface{}) Logger {
-	// must convert from interface{} -> interface{} to string -> interface{} for logrus.
-	lfields := make(logrus.Fields, len(fields))
-	for key, value := range fields {
-		lfields[fmt.Sprint(key)] = value
-	}
-
-	return getLogrusLogger(ctx, keys...).WithFields(lfields)
-}
-
-// GetLogger returns the logger from the current context, if present. If one
-// or more keys are provided, they will be resolved on the context and
-// included in the logger. While context.Value takes an interface, any key
-// argument passed to GetLogger will be passed to fmt.Sprint when expanded as
-// a logging key field. If context keys are integer constants, for example,
-// its recommended that a String method is implemented.
-func GetLogger(ctx Context, keys ...interface{}) Logger {
-	return getLogrusLogger(ctx, keys...)
-}
-
-// GetLogrusLogger returns the logrus logger for the context. If one more keys
-// are provided, they will be resolved on the context and included in the
-// logger. Only use this function if specific logrus functionality is
-// required.
-func getLogrusLogger(ctx Context, keys ...interface{}) *logrus.Entry {
-	var logger *logrus.Entry
-
-	// Get a logger, if it is present.
-	loggerInterface := ctx.Value("logger")
-	if loggerInterface != nil {
-		if lgr, ok := loggerInterface.(*logrus.Entry); ok {
-			logger = lgr
-		}
-	}
-
-	if logger == nil {
-		fields := logrus.Fields{}
-
-		// Fill in the instance id, if we have it.
-		instanceID := ctx.Value("instance.id")
-		if instanceID != nil {
-			fields["instance.id"] = instanceID
-		}
-
-		fields["go.version"] = runtime.Version()
-		// If no logger is found, just return the standard logger.
-		logger = logrus.StandardLogger().WithFields(fields)
-	}
-
-	fields := logrus.Fields{}
-	for _, key := range keys {
-		v := ctx.Value(key)
-		if v != nil {
-			fields[fmt.Sprint(key)] = v
-		}
-	}
-
-	return logger.WithFields(fields)
-}

vendor/github.com/docker/distribution/context/trace.go

@@ -1,104 +0,0 @@
-package context
-
-import (
-	"runtime"
-	"time"
-
-	"github.com/docker/distribution/uuid"
-)
-
-// WithTrace allocates a traced timing span in a new context. This allows a
-// caller to track the time between calling WithTrace and the returned done
-// function. When the done function is called, a log message is emitted with a
-// "trace.duration" field, corresponding to the elapsed time and a
-// "trace.func" field, corresponding to the function that called WithTrace.
-//
-// The logging keys "trace.id" and "trace.parent.id" are provided to implement
-// dapper-like tracing. This function should be complemented with a WithSpan
-// method that could be used for tracing distributed RPC calls.
-//
-// The main benefit of this function is to post-process log messages or
-// intercept them in a hook to provide timing data. Trace ids and parent ids
-// can also be linked to provide call tracing, if so required.
-//
-// Here is an example of the usage:
-//
-// 	func timedOperation(ctx Context) {
-// 		ctx, done := WithTrace(ctx)
-// 		defer done("this will be the log message")
-// 		// ... function body ...
-// 	}
-//
-// If the function ran for roughly 1s, such a usage would emit a log message
-// as follows:
-//
-// 	INFO[0001] this will be the log message  trace.duration=1.004575763s trace.func=github.com/docker/distribution/context.traceOperation trace.id=<id> ...
-//
-// Notice that the function name is automatically resolved, along with the
-// package and a trace id is emitted that can be linked with parent ids.
-func WithTrace(ctx Context) (Context, func(format string, a ...interface{})) {
-	if ctx == nil {
-		ctx = Background()
-	}
-
-	pc, file, line, _ := runtime.Caller(1)
-	f := runtime.FuncForPC(pc)
-	ctx = &traced{
-		Context: ctx,
-		id:      uuid.Generate().String(),
-		start:   time.Now(),
-		parent:  GetStringValue(ctx, "trace.id"),
-		fnname:  f.Name(),
-		file:    file,
-		line:    line,
-	}
-
-	return ctx, func(format string, a ...interface{}) {
-		GetLogger(ctx,
-			"trace.duration",
-			"trace.id",
-			"trace.parent.id",
-			"trace.func",
-			"trace.file",
-			"trace.line").
-			Debugf(format, a...)
-	}
-}
-
-// traced represents a context that is traced for function call timing. It
-// also provides fast lookup for the various attributes that are available on
-// the trace.
-type traced struct {
-	Context
-	id     string
-	parent string
-	start  time.Time
-	fnname string
-	file   string
-	line   int
-}
-
-func (ts *traced) Value(key interface{}) interface{} {
-	switch key {
-	case "trace.start":
-		return ts.start
-	case "trace.duration":
-		return time.Since(ts.start)
-	case "trace.id":
-		return ts.id
-	case "trace.parent.id":
-		if ts.parent == "" {
-			return nil // must return nil to signal no parent.
-		}
-
-		return ts.parent
-	case "trace.func":
-		return ts.fnname
-	case "trace.file":
-		return ts.file
-	case "trace.line":
-		return ts.line
-	}
-
-	return ts.Context.Value(key)
-}

vendor/github.com/docker/distribution/context/util.go

@@ -1,32 +0,0 @@
-package context
-
-import (
-	"time"
-)
-
-// Since looks up key, which should be a time.Time, and returns the duration
-// since that time. If the key is not found, the value returned will be zero.
-// This is helpful when inferring metrics related to context execution times.
-func Since(ctx Context, key interface{}) time.Duration {
-	startedAtI := ctx.Value(key)
-	if startedAtI != nil {
-		if startedAt, ok := startedAtI.(time.Time); ok {
-			return time.Since(startedAt)
-		}
-	}
-
-	return 0
-}
-
-// GetStringValue returns a string value from the context. The empty string
-// will be returned if not found.
-func GetStringValue(ctx Context, key interface{}) (value string) {
-	stringi := ctx.Value(key)
-	if stringi != nil {
-		if valuev, ok := stringi.(string); ok {
-			value = valuev
-		}
-	}
-
-	return value
-}

vendor/github.com/docker/distribution/context/version.go

@@ -1,16 +0,0 @@
-package context
-
-// WithVersion stores the application version in the context. The new context
-// gets a logger to ensure log messages are marked with the application
-// version.
-func WithVersion(ctx Context, version string) Context {
-	ctx = WithValue(ctx, "version", version)
-	// push a new logger onto the stack
-	return WithLogger(ctx, GetLogger(ctx, "version"))
-}
-
-// GetVersion returns the application version from the context. An empty
-// string may returned if the version was not set on the context.
-func GetVersion(ctx Context) string {
-	return GetStringValue(ctx, "version")
-}

vendor/github.com/docker/distribution/coverpkg.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-# Given a subpackage and the containing package, figures out which packages
-# need to be passed to `go test -coverpkg`:  this includes all of the
-# subpackage's dependencies within the containing package, as well as the
-# subpackage itself.
-DEPENDENCIES="$(go list -f $'{{range $f := .Deps}}{{$f}}\n{{end}}' ${1} | grep ${2})"
-echo "${1} ${DEPENDENCIES}" | xargs echo -n | tr ' ' ','

vendor/github.com/docker/distribution/doc.go

@@ -1,7 +0,0 @@
-// Package distribution will define the interfaces for the components of
-// docker distribution. The goal is to allow users to reliably package, ship
-// and store content related to docker images.
-//
-// This is currently a work in progress. More details are available in the
-// README.md.
-package distribution

vendor/github.com/docker/distribution/errors.go

@@ -1,111 +0,0 @@
-package distribution
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/docker/distribution/digest"
-)
-
-// ErrManifestNotModified is returned when a conditional manifest GetByTag
-// returns nil due to the client indicating it has the latest version
-var ErrManifestNotModified = errors.New("manifest not modified")
-
-// ErrUnsupported is returned when an unimplemented or unsupported action is
-// performed
-var ErrUnsupported = errors.New("operation unsupported")
-
-// ErrTagUnknown is returned if the given tag is not known by the tag service
-type ErrTagUnknown struct {
-	Tag string
-}
-
-func (err ErrTagUnknown) Error() string {
-	return fmt.Sprintf("unknown tag=%s", err.Tag)
-}
-
-// ErrRepositoryUnknown is returned if the named repository is not known by
-// the registry.
-type ErrRepositoryUnknown struct {
-	Name string
-}
-
-func (err ErrRepositoryUnknown) Error() string {
-	return fmt.Sprintf("unknown repository name=%s", err.Name)
-}
-
-// ErrRepositoryNameInvalid should be used to denote an invalid repository
-// name. Reason may set, indicating the cause of invalidity.
-type ErrRepositoryNameInvalid struct {
-	Name   string
-	Reason error
-}
-
-func (err ErrRepositoryNameInvalid) Error() string {
-	return fmt.Sprintf("repository name %q invalid: %v", err.Name, err.Reason)
-}
-
-// ErrManifestUnknown is returned if the manifest is not known by the
-// registry.
-type ErrManifestUnknown struct {
-	Name string
-	Tag  string
-}
-
-func (err ErrManifestUnknown) Error() string {
-	return fmt.Sprintf("unknown manifest name=%s tag=%s", err.Name, err.Tag)
-}
-
-// ErrManifestUnknownRevision is returned when a manifest cannot be found by
-// revision within a repository.
-type ErrManifestUnknownRevision struct {
-	Name     string
-	Revision digest.Digest
-}
-
-func (err ErrManifestUnknownRevision) Error() string {
-	return fmt.Sprintf("unknown manifest name=%s revision=%s", err.Name, err.Revision)
-}
-
-// ErrManifestUnverified is returned when the registry is unable to verify
-// the manifest.
-type ErrManifestUnverified struct{}
-
-func (ErrManifestUnverified) Error() string {
-	return fmt.Sprintf("unverified manifest")
-}
-
-// ErrManifestVerification provides a type to collect errors encountered
-// during manifest verification. Currently, it accepts errors of all types,
-// but it may be narrowed to those involving manifest verification.
-type ErrManifestVerification []error
-
-func (errs ErrManifestVerification) Error() string {
-	var parts []string
-	for _, err := range errs {
-		parts = append(parts, err.Error())
-	}
-
-	return fmt.Sprintf("errors verifying manifest: %v", strings.Join(parts, ","))
-}
-
-// ErrManifestBlobUnknown returned when a referenced blob cannot be found.
-type ErrManifestBlobUnknown struct {
-	Digest digest.Digest
-}
-
-func (err ErrManifestBlobUnknown) Error() string {
-	return fmt.Sprintf("unknown blob %v on manifest", err.Digest)
-}
-
-// ErrManifestNameInvalid should be used to denote an invalid manifest
-// name. Reason may set, indicating the cause of invalidity.
-type ErrManifestNameInvalid struct {
-	Name   string
-	Reason error
-}
-
-func (err ErrManifestNameInvalid) Error() string {
-	return fmt.Sprintf("manifest name %q invalid: %v", err.Name, err.Reason)
-}

vendor/github.com/docker/distribution/manifest/doc.go

@@ -1 +0,0 @@
-package manifest

vendor/github.com/docker/distribution/manifest/manifestlist/manifestlist.go

@@ -1,147 +0,0 @@
-package manifestlist
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/manifest"
-)
-
-// MediaTypeManifestList specifies the mediaType for manifest lists.
-const MediaTypeManifestList = "application/vnd.docker.distribution.manifest.list.v2+json"
-
-// SchemaVersion provides a pre-initialized version structure for this
-// packages version of the manifest.
-var SchemaVersion = manifest.Versioned{
-	SchemaVersion: 2,
-	MediaType:     MediaTypeManifestList,
-}
-
-func init() {
-	manifestListFunc := func(b []byte) (distribution.Manifest, distribution.Descriptor, error) {
-		m := new(DeserializedManifestList)
-		err := m.UnmarshalJSON(b)
-		if err != nil {
-			return nil, distribution.Descriptor{}, err
-		}
-
-		dgst := digest.FromBytes(b)
-		return m, distribution.Descriptor{Digest: dgst, Size: int64(len(b)), MediaType: MediaTypeManifestList}, err
-	}
-	err := distribution.RegisterManifestSchema(MediaTypeManifestList, manifestListFunc)
-	if err != nil {
-		panic(fmt.Sprintf("Unable to register manifest: %s", err))
-	}
-}
-
-// PlatformSpec specifies a platform where a particular image manifest is
-// applicable.
-type PlatformSpec struct {
-	// Architecture field specifies the CPU architecture, for example
-	// `amd64` or `ppc64`.
-	Architecture string `json:"architecture"`
-
-	// OS specifies the operating system, for example `linux` or `windows`.
-	OS string `json:"os"`
-
-	// Variant is an optional field specifying a variant of the CPU, for
-	// example `ppc64le` to specify a little-endian version of a PowerPC CPU.
-	Variant string `json:"variant,omitempty"`
-
-	// Features is an optional field specifuing an array of strings, each
-	// listing a required CPU feature (for example `sse4` or `aes`).
-	Features []string `json:"features,omitempty"`
-}
-
-// A ManifestDescriptor references a platform-specific manifest.
-type ManifestDescriptor struct {
-	distribution.Descriptor
-
-	// Platform specifies which platform the manifest pointed to by the
-	// descriptor runs on.
-	Platform PlatformSpec `json:"platform"`
-}
-
-// ManifestList references manifests for various platforms.
-type ManifestList struct {
-	manifest.Versioned
-
-	// Config references the image configuration as a blob.
-	Manifests []ManifestDescriptor `json:"manifests"`
-}
-
-// References returnes the distribution descriptors for the referenced image
-// manifests.
-func (m ManifestList) References() []distribution.Descriptor {
-	dependencies := make([]distribution.Descriptor, len(m.Manifests))
-	for i := range m.Manifests {
-		dependencies[i] = m.Manifests[i].Descriptor
-	}
-
-	return dependencies
-}
-
-// DeserializedManifestList wraps ManifestList with a copy of the original
-// JSON.
-type DeserializedManifestList struct {
-	ManifestList
-
-	// canonical is the canonical byte representation of the Manifest.
-	canonical []byte
-}
-
-// FromDescriptors takes a slice of descriptors, and returns a
-// DeserializedManifestList which contains the resulting manifest list
-// and its JSON representation.
-func FromDescriptors(descriptors []ManifestDescriptor) (*DeserializedManifestList, error) {
-	m := ManifestList{
-		Versioned: SchemaVersion,
-	}
-
-	m.Manifests = make([]ManifestDescriptor, len(descriptors), len(descriptors))
-	copy(m.Manifests, descriptors)
-
-	deserialized := DeserializedManifestList{
-		ManifestList: m,
-	}
-
-	var err error
-	deserialized.canonical, err = json.MarshalIndent(&m, "", "   ")
-	return &deserialized, err
-}
-
-// UnmarshalJSON populates a new ManifestList struct from JSON data.
-func (m *DeserializedManifestList) UnmarshalJSON(b []byte) error {
-	m.canonical = make([]byte, len(b), len(b))
-	// store manifest list in canonical
-	copy(m.canonical, b)
-
-	// Unmarshal canonical JSON into ManifestList object
-	var manifestList ManifestList
-	if err := json.Unmarshal(m.canonical, &manifestList); err != nil {
-		return err
-	}
-
-	m.ManifestList = manifestList
-
-	return nil
-}
-
-// MarshalJSON returns the contents of canonical. If canonical is empty,
-// marshals the inner contents.
-func (m *DeserializedManifestList) MarshalJSON() ([]byte, error) {
-	if len(m.canonical) > 0 {
-		return m.canonical, nil
-	}
-
-	return nil, errors.New("JSON representation not initialized in DeserializedManifestList")
-}
-
-// Payload returns the raw content of the manifest list. The contents can be
-// used to calculate the content identifier.
-func (m DeserializedManifestList) Payload() (string, []byte, error) {
-	return m.MediaType, m.canonical, nil
-}

vendor/github.com/docker/distribution/manifest/schema1/config_builder.go

@@ -1,281 +0,0 @@
-package schema1
-
-import (
-	"crypto/sha512"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/libtrust"
-
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/manifest"
-)
-
-type diffID digest.Digest
-
-// gzippedEmptyTar is a gzip-compressed version of an empty tar file
-// (1024 NULL bytes)
-var gzippedEmptyTar = []byte{
-	31, 139, 8, 0, 0, 9, 110, 136, 0, 255, 98, 24, 5, 163, 96, 20, 140, 88,
-	0, 8, 0, 0, 255, 255, 46, 175, 181, 239, 0, 4, 0, 0,
-}
-
-// digestSHA256GzippedEmptyTar is the canonical sha256 digest of
-// gzippedEmptyTar
-const digestSHA256GzippedEmptyTar = digest.Digest("sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4")
-
-// configManifestBuilder is a type for constructing manifests from an image
-// configuration and generic descriptors.
-type configManifestBuilder struct {
-	// bs is a BlobService used to create empty layer tars in the
-	// blob store if necessary.
-	bs distribution.BlobService
-	// pk is the libtrust private key used to sign the final manifest.
-	pk libtrust.PrivateKey
-	// configJSON is configuration supplied when the ManifestBuilder was
-	// created.
-	configJSON []byte
-	// ref contains the name and optional tag provided to NewConfigManifestBuilder.
-	ref reference.Named
-	// descriptors is the set of descriptors referencing the layers.
-	descriptors []distribution.Descriptor
-	// emptyTarDigest is set to a valid digest if an empty tar has been
-	// put in the blob store; otherwise it is empty.
-	emptyTarDigest digest.Digest
-}
-
-// NewConfigManifestBuilder is used to build new manifests for the current
-// schema version from an image configuration and a set of descriptors.
-// It takes a BlobService so that it can add an empty tar to the blob store
-// if the resulting manifest needs empty layers.
-func NewConfigManifestBuilder(bs distribution.BlobService, pk libtrust.PrivateKey, ref reference.Named, configJSON []byte) distribution.ManifestBuilder {
-	return &configManifestBuilder{
-		bs:         bs,
-		pk:         pk,
-		configJSON: configJSON,
-		ref:        ref,
-	}
-}
-
-// Build produces a final manifest from the given references
-func (mb *configManifestBuilder) Build(ctx context.Context) (m distribution.Manifest, err error) {
-	type imageRootFS struct {
-		Type      string   `json:"type"`
-		DiffIDs   []diffID `json:"diff_ids,omitempty"`
-		BaseLayer string   `json:"base_layer,omitempty"`
-	}
-
-	type imageHistory struct {
-		Created    time.Time `json:"created"`
-		Author     string    `json:"author,omitempty"`
-		CreatedBy  string    `json:"created_by,omitempty"`
-		Comment    string    `json:"comment,omitempty"`
-		EmptyLayer bool      `json:"empty_layer,omitempty"`
-	}
-
-	type imageConfig struct {
-		RootFS       *imageRootFS   `json:"rootfs,omitempty"`
-		History      []imageHistory `json:"history,omitempty"`
-		Architecture string         `json:"architecture,omitempty"`
-	}
-
-	var img imageConfig
-
-	if err := json.Unmarshal(mb.configJSON, &img); err != nil {
-		return nil, err
-	}
-
-	if len(img.History) == 0 {
-		return nil, errors.New("empty history when trying to create schema1 manifest")
-	}
-
-	if len(img.RootFS.DiffIDs) != len(mb.descriptors) {
-		return nil, errors.New("number of descriptors and number of layers in rootfs must match")
-	}
-
-	// Generate IDs for each layer
-	// For non-top-level layers, create fake V1Compatibility strings that
-	// fit the format and don't collide with anything else, but don't
-	// result in runnable images on their own.
-	type v1Compatibility struct {
-		ID              string    `json:"id"`
-		Parent          string    `json:"parent,omitempty"`
-		Comment         string    `json:"comment,omitempty"`
-		Created         time.Time `json:"created"`
-		ContainerConfig struct {
-			Cmd []string
-		} `json:"container_config,omitempty"`
-		ThrowAway bool `json:"throwaway,omitempty"`
-	}
-
-	fsLayerList := make([]FSLayer, len(img.History))
-	history := make([]History, len(img.History))
-
-	parent := ""
-	layerCounter := 0
-	for i, h := range img.History[:len(img.History)-1] {
-		var blobsum digest.Digest
-		if h.EmptyLayer {
-			if blobsum, err = mb.emptyTar(ctx); err != nil {
-				return nil, err
-			}
-		} else {
-			if len(img.RootFS.DiffIDs) <= layerCounter {
-				return nil, errors.New("too many non-empty layers in History section")
-			}
-			blobsum = mb.descriptors[layerCounter].Digest
-			layerCounter++
-		}
-
-		v1ID := digest.FromBytes([]byte(blobsum.Hex() + " " + parent)).Hex()
-
-		if i == 0 && img.RootFS.BaseLayer != "" {
-			// windows-only baselayer setup
-			baseID := sha512.Sum384([]byte(img.RootFS.BaseLayer))
-			parent = fmt.Sprintf("%x", baseID[:32])
-		}
-
-		v1Compatibility := v1Compatibility{
-			ID:      v1ID,
-			Parent:  parent,
-			Comment: h.Comment,
-			Created: h.Created,
-		}
-		v1Compatibility.ContainerConfig.Cmd = []string{img.History[i].CreatedBy}
-		if h.EmptyLayer {
-			v1Compatibility.ThrowAway = true
-		}
-		jsonBytes, err := json.Marshal(&v1Compatibility)
-		if err != nil {
-			return nil, err
-		}
-
-		reversedIndex := len(img.History) - i - 1
-		history[reversedIndex].V1Compatibility = string(jsonBytes)
-		fsLayerList[reversedIndex] = FSLayer{BlobSum: blobsum}
-
-		parent = v1ID
-	}
-
-	latestHistory := img.History[len(img.History)-1]
-
-	var blobsum digest.Digest
-	if latestHistory.EmptyLayer {
-		if blobsum, err = mb.emptyTar(ctx); err != nil {
-			return nil, err
-		}
-	} else {
-		if len(img.RootFS.DiffIDs) <= layerCounter {
-			return nil, errors.New("too many non-empty layers in History section")
-		}
-		blobsum = mb.descriptors[layerCounter].Digest
-	}
-
-	fsLayerList[0] = FSLayer{BlobSum: blobsum}
-	dgst := digest.FromBytes([]byte(blobsum.Hex() + " " + parent + " " + string(mb.configJSON)))
-
-	// Top-level v1compatibility string should be a modified version of the
-	// image config.
-	transformedConfig, err := MakeV1ConfigFromConfig(mb.configJSON, dgst.Hex(), parent, latestHistory.EmptyLayer)
-	if err != nil {
-		return nil, err
-	}
-
-	history[0].V1Compatibility = string(transformedConfig)
-
-	tag := ""
-	if tagged, isTagged := mb.ref.(reference.Tagged); isTagged {
-		tag = tagged.Tag()
-	}
-
-	mfst := Manifest{
-		Versioned: manifest.Versioned{
-			SchemaVersion: 1,
-		},
-		Name:         mb.ref.Name(),
-		Tag:          tag,
-		Architecture: img.Architecture,
-		FSLayers:     fsLayerList,
-		History:      history,
-	}
-
-	return Sign(&mfst, mb.pk)
-}
-
-// emptyTar pushes a compressed empty tar to the blob store if one doesn't
-// already exist, and returns its blobsum.
-func (mb *configManifestBuilder) emptyTar(ctx context.Context) (digest.Digest, error) {
-	if mb.emptyTarDigest != "" {
-		// Already put an empty tar
-		return mb.emptyTarDigest, nil
-	}
-
-	descriptor, err := mb.bs.Stat(ctx, digestSHA256GzippedEmptyTar)
-	switch err {
-	case nil:
-		mb.emptyTarDigest = descriptor.Digest
-		return descriptor.Digest, nil
-	case distribution.ErrBlobUnknown:
-		// nop
-	default:
-		return "", err
-	}
-
-	// Add gzipped empty tar to the blob store
-	descriptor, err = mb.bs.Put(ctx, "", gzippedEmptyTar)
-	if err != nil {
-		return "", err
-	}
-
-	mb.emptyTarDigest = descriptor.Digest
-
-	return descriptor.Digest, nil
-}
-
-// AppendReference adds a reference to the current ManifestBuilder
-func (mb *configManifestBuilder) AppendReference(d distribution.Describable) error {
-	// todo: verification here?
-	mb.descriptors = append(mb.descriptors, d.Descriptor())
-	return nil
-}
-
-// References returns the current references added to this builder
-func (mb *configManifestBuilder) References() []distribution.Descriptor {
-	return mb.descriptors
-}
-
-// MakeV1ConfigFromConfig creates an legacy V1 image config from image config JSON
-func MakeV1ConfigFromConfig(configJSON []byte, v1ID, parentV1ID string, throwaway bool) ([]byte, error) {
-	// Top-level v1compatibility string should be a modified version of the
-	// image config.
-	var configAsMap map[string]*json.RawMessage
-	if err := json.Unmarshal(configJSON, &configAsMap); err != nil {
-		return nil, err
-	}
-
-	// Delete fields that didn't exist in old manifest
-	delete(configAsMap, "rootfs")
-	delete(configAsMap, "history")
-	configAsMap["id"] = rawJSON(v1ID)
-	if parentV1ID != "" {
-		configAsMap["parent"] = rawJSON(parentV1ID)
-	}
-	if throwaway {
-		configAsMap["throwaway"] = rawJSON(true)
-	}
-
-	return json.Marshal(configAsMap)
-}
-
-func rawJSON(value interface{}) *json.RawMessage {
-	jsonval, err := json.Marshal(value)
-	if err != nil {
-		return nil
-	}
-	return (*json.RawMessage)(&jsonval)
-}

vendor/github.com/docker/distribution/manifest/schema1/manifest.go

@@ -1,184 +0,0 @@
-package schema1
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/manifest"
-	"github.com/docker/libtrust"
-)
-
-const (
-	// MediaTypeManifest specifies the mediaType for the current version. Note
-	// that for schema version 1, the the media is optionally "application/json".
-	MediaTypeManifest = "application/vnd.docker.distribution.manifest.v1+json"
-	// MediaTypeSignedManifest specifies the mediatype for current SignedManifest version
-	MediaTypeSignedManifest = "application/vnd.docker.distribution.manifest.v1+prettyjws"
-	// MediaTypeManifestLayer specifies the media type for manifest layers
-	MediaTypeManifestLayer = "application/vnd.docker.container.image.rootfs.diff+x-gtar"
-)
-
-var (
-	// SchemaVersion provides a pre-initialized version structure for this
-	// packages version of the manifest.
-	SchemaVersion = manifest.Versioned{
-		SchemaVersion: 1,
-	}
-)
-
-func init() {
-	schema1Func := func(b []byte) (distribution.Manifest, distribution.Descriptor, error) {
-		sm := new(SignedManifest)
-		err := sm.UnmarshalJSON(b)
-		if err != nil {
-			return nil, distribution.Descriptor{}, err
-		}
-
-		desc := distribution.Descriptor{
-			Digest:    digest.FromBytes(sm.Canonical),
-			Size:      int64(len(sm.Canonical)),
-			MediaType: MediaTypeSignedManifest,
-		}
-		return sm, desc, err
-	}
-	err := distribution.RegisterManifestSchema(MediaTypeSignedManifest, schema1Func)
-	if err != nil {
-		panic(fmt.Sprintf("Unable to register manifest: %s", err))
-	}
-	err = distribution.RegisterManifestSchema("", schema1Func)
-	if err != nil {
-		panic(fmt.Sprintf("Unable to register manifest: %s", err))
-	}
-	err = distribution.RegisterManifestSchema("application/json", schema1Func)
-	if err != nil {
-		panic(fmt.Sprintf("Unable to register manifest: %s", err))
-	}
-}
-
-// FSLayer is a container struct for BlobSums defined in an image manifest
-type FSLayer struct {
-	// BlobSum is the tarsum of the referenced filesystem image layer
-	BlobSum digest.Digest `json:"blobSum"`
-}
-
-// History stores unstructured v1 compatibility information
-type History struct {
-	// V1Compatibility is the raw v1 compatibility information
-	V1Compatibility string `json:"v1Compatibility"`
-}
-
-// Manifest provides the base accessible fields for working with V2 image
-// format in the registry.
-type Manifest struct {
-	manifest.Versioned
-
-	// Name is the name of the image's repository
-	Name string `json:"name"`
-
-	// Tag is the tag of the image specified by this manifest
-	Tag string `json:"tag"`
-
-	// Architecture is the host architecture on which this image is intended to
-	// run
-	Architecture string `json:"architecture"`
-
-	// FSLayers is a list of filesystem layer blobSums contained in this image
-	FSLayers []FSLayer `json:"fsLayers"`
-
-	// History is a list of unstructured historical data for v1 compatibility
-	History []History `json:"history"`
-}
-
-// SignedManifest provides an envelope for a signed image manifest, including
-// the format sensitive raw bytes.
-type SignedManifest struct {
-	Manifest
-
-	// Canonical is the canonical byte representation of the ImageManifest,
-	// without any attached signatures. The manifest byte
-	// representation cannot change or it will have to be re-signed.
-	Canonical []byte `json:"-"`
-
-	// all contains the byte representation of the Manifest including signatures
-	// and is returned by Payload()
-	all []byte
-}
-
-// UnmarshalJSON populates a new SignedManifest struct from JSON data.
-func (sm *SignedManifest) UnmarshalJSON(b []byte) error {
-	sm.all = make([]byte, len(b), len(b))
-	// store manifest and signatures in all
-	copy(sm.all, b)
-
-	jsig, err := libtrust.ParsePrettySignature(b, "signatures")
-	if err != nil {
-		return err
-	}
-
-	// Resolve the payload in the manifest.
-	bytes, err := jsig.Payload()
-	if err != nil {
-		return err
-	}
-
-	// sm.Canonical stores the canonical manifest JSON
-	sm.Canonical = make([]byte, len(bytes), len(bytes))
-	copy(sm.Canonical, bytes)
-
-	// Unmarshal canonical JSON into Manifest object
-	var manifest Manifest
-	if err := json.Unmarshal(sm.Canonical, &manifest); err != nil {
-		return err
-	}
-
-	sm.Manifest = manifest
-
-	return nil
-}
-
-// References returnes the descriptors of this manifests references
-func (sm SignedManifest) References() []distribution.Descriptor {
-	dependencies := make([]distribution.Descriptor, len(sm.FSLayers))
-	for i, fsLayer := range sm.FSLayers {
-		dependencies[i] = distribution.Descriptor{
-			MediaType: "application/vnd.docker.container.image.rootfs.diff+x-gtar",
-			Digest:    fsLayer.BlobSum,
-		}
-	}
-
-	return dependencies
-
-}
-
-// MarshalJSON returns the contents of raw. If Raw is nil, marshals the inner
-// contents. Applications requiring a marshaled signed manifest should simply
-// use Raw directly, since the the content produced by json.Marshal will be
-// compacted and will fail signature checks.
-func (sm *SignedManifest) MarshalJSON() ([]byte, error) {
-	if len(sm.all) > 0 {
-		return sm.all, nil
-	}
-
-	// If the raw data is not available, just dump the inner content.
-	return json.Marshal(&sm.Manifest)
-}
-
-// Payload returns the signed content of the signed manifest.
-func (sm SignedManifest) Payload() (string, []byte, error) {
-	return MediaTypeSignedManifest, sm.all, nil
-}
-
-// Signatures returns the signatures as provided by
-// (*libtrust.JSONSignature).Signatures. The byte slices are opaque jws
-// signatures.
-func (sm *SignedManifest) Signatures() ([][]byte, error) {
-	jsig, err := libtrust.ParsePrettySignature(sm.all, "signatures")
-	if err != nil {
-		return nil, err
-	}
-
-	// Resolve the payload in the manifest.
-	return jsig.Signatures()
-}

vendor/github.com/docker/distribution/manifest/schema1/reference_builder.go

@@ -1,98 +0,0 @@
-package schema1
-
-import (
-	"fmt"
-
-	"errors"
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/manifest"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/libtrust"
-)
-
-// referenceManifestBuilder is a type for constructing manifests from schema1
-// dependencies.
-type referenceManifestBuilder struct {
-	Manifest
-	pk libtrust.PrivateKey
-}
-
-// NewReferenceManifestBuilder is used to build new manifests for the current
-// schema version using schema1 dependencies.
-func NewReferenceManifestBuilder(pk libtrust.PrivateKey, ref reference.Named, architecture string) distribution.ManifestBuilder {
-	tag := ""
-	if tagged, isTagged := ref.(reference.Tagged); isTagged {
-		tag = tagged.Tag()
-	}
-
-	return &referenceManifestBuilder{
-		Manifest: Manifest{
-			Versioned: manifest.Versioned{
-				SchemaVersion: 1,
-			},
-			Name:         ref.Name(),
-			Tag:          tag,
-			Architecture: architecture,
-		},
-		pk: pk,
-	}
-}
-
-func (mb *referenceManifestBuilder) Build(ctx context.Context) (distribution.Manifest, error) {
-	m := mb.Manifest
-	if len(m.FSLayers) == 0 {
-		return nil, errors.New("cannot build manifest with zero layers or history")
-	}
-
-	m.FSLayers = make([]FSLayer, len(mb.Manifest.FSLayers))
-	m.History = make([]History, len(mb.Manifest.History))
-	copy(m.FSLayers, mb.Manifest.FSLayers)
-	copy(m.History, mb.Manifest.History)
-
-	return Sign(&m, mb.pk)
-}
-
-// AppendReference adds a reference to the current ManifestBuilder
-func (mb *referenceManifestBuilder) AppendReference(d distribution.Describable) error {
-	r, ok := d.(Reference)
-	if !ok {
-		return fmt.Errorf("Unable to add non-reference type to v1 builder")
-	}
-
-	// Entries need to be prepended
-	mb.Manifest.FSLayers = append([]FSLayer{{BlobSum: r.Digest}}, mb.Manifest.FSLayers...)
-	mb.Manifest.History = append([]History{r.History}, mb.Manifest.History...)
-	return nil
-
-}
-
-// References returns the current references added to this builder
-func (mb *referenceManifestBuilder) References() []distribution.Descriptor {
-	refs := make([]distribution.Descriptor, len(mb.Manifest.FSLayers))
-	for i := range mb.Manifest.FSLayers {
-		layerDigest := mb.Manifest.FSLayers[i].BlobSum
-		history := mb.Manifest.History[i]
-		ref := Reference{layerDigest, 0, history}
-		refs[i] = ref.Descriptor()
-	}
-	return refs
-}
-
-// Reference describes a manifest v2, schema version 1 dependency.
-// An FSLayer associated with a history entry.
-type Reference struct {
-	Digest  digest.Digest
-	Size    int64 // if we know it, set it for the descriptor.
-	History History
-}
-
-// Descriptor describes a reference
-func (r Reference) Descriptor() distribution.Descriptor {
-	return distribution.Descriptor{
-		MediaType: MediaTypeManifestLayer,
-		Digest:    r.Digest,
-		Size:      r.Size,
-	}
-}

vendor/github.com/docker/distribution/manifest/schema1/sign.go

@@ -1,68 +0,0 @@
-package schema1
-
-import (
-	"crypto/x509"
-	"encoding/json"
-
-	"github.com/docker/libtrust"
-)
-
-// Sign signs the manifest with the provided private key, returning a
-// SignedManifest. This typically won't be used within the registry, except
-// for testing.
-func Sign(m *Manifest, pk libtrust.PrivateKey) (*SignedManifest, error) {
-	p, err := json.MarshalIndent(m, "", "   ")
-	if err != nil {
-		return nil, err
-	}
-
-	js, err := libtrust.NewJSONSignature(p)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := js.Sign(pk); err != nil {
-		return nil, err
-	}
-
-	pretty, err := js.PrettySignature("signatures")
-	if err != nil {
-		return nil, err
-	}
-
-	return &SignedManifest{
-		Manifest:  *m,
-		all:       pretty,
-		Canonical: p,
-	}, nil
-}
-
-// SignWithChain signs the manifest with the given private key and x509 chain.
-// The public key of the first element in the chain must be the public key
-// corresponding with the sign key.
-func SignWithChain(m *Manifest, key libtrust.PrivateKey, chain []*x509.Certificate) (*SignedManifest, error) {
-	p, err := json.MarshalIndent(m, "", "   ")
-	if err != nil {
-		return nil, err
-	}
-
-	js, err := libtrust.NewJSONSignature(p)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := js.SignWithChain(key, chain); err != nil {
-		return nil, err
-	}
-
-	pretty, err := js.PrettySignature("signatures")
-	if err != nil {
-		return nil, err
-	}
-
-	return &SignedManifest{
-		Manifest:  *m,
-		all:       pretty,
-		Canonical: p,
-	}, nil
-}

vendor/github.com/docker/distribution/manifest/schema1/verify.go

@@ -1,32 +0,0 @@
-package schema1
-
-import (
-	"crypto/x509"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/libtrust"
-)
-
-// Verify verifies the signature of the signed manifest returning the public
-// keys used during signing.
-func Verify(sm *SignedManifest) ([]libtrust.PublicKey, error) {
-	js, err := libtrust.ParsePrettySignature(sm.all, "signatures")
-	if err != nil {
-		logrus.WithField("err", err).Debugf("(*SignedManifest).Verify")
-		return nil, err
-	}
-
-	return js.Verify()
-}
-
-// VerifyChains verifies the signature of the signed manifest against the
-// certificate pool returning the list of verified chains. Signatures without
-// an x509 chain are not checked.
-func VerifyChains(sm *SignedManifest, ca *x509.CertPool) ([][]*x509.Certificate, error) {
-	js, err := libtrust.ParsePrettySignature(sm.all, "signatures")
-	if err != nil {
-		return nil, err
-	}
-
-	return js.VerifyChains(ca)
-}

vendor/github.com/docker/distribution/manifest/schema2/builder.go

@@ -1,74 +0,0 @@
-package schema2
-
-import (
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/digest"
-)
-
-// builder is a type for constructing manifests.
-type builder struct {
-	// bs is a BlobService used to publish the configuration blob.
-	bs distribution.BlobService
-
-	// configJSON references
-	configJSON []byte
-
-	// layers is a list of layer descriptors that gets built by successive
-	// calls to AppendReference.
-	layers []distribution.Descriptor
-}
-
-// NewManifestBuilder is used to build new manifests for the current schema
-// version. It takes a BlobService so it can publish the configuration blob
-// as part of the Build process.
-func NewManifestBuilder(bs distribution.BlobService, configJSON []byte) distribution.ManifestBuilder {
-	mb := &builder{
-		bs:         bs,
-		configJSON: make([]byte, len(configJSON)),
-	}
-	copy(mb.configJSON, configJSON)
-
-	return mb
-}
-
-// Build produces a final manifest from the given references.
-func (mb *builder) Build(ctx context.Context) (distribution.Manifest, error) {
-	m := Manifest{
-		Versioned: SchemaVersion,
-		Layers:    make([]distribution.Descriptor, len(mb.layers)),
-	}
-	copy(m.Layers, mb.layers)
-
-	configDigest := digest.FromBytes(mb.configJSON)
-
-	var err error
-	m.Config, err = mb.bs.Stat(ctx, configDigest)
-	switch err {
-	case nil:
-		return FromStruct(m)
-	case distribution.ErrBlobUnknown:
-		// nop
-	default:
-		return nil, err
-	}
-
-	// Add config to the blob store
-	m.Config, err = mb.bs.Put(ctx, MediaTypeConfig, mb.configJSON)
-	if err != nil {
-		return nil, err
-	}
-
-	return FromStruct(m)
-}
-
-// AppendReference adds a reference to the current ManifestBuilder.
-func (mb *builder) AppendReference(d distribution.Describable) error {
-	mb.layers = append(mb.layers, d.Descriptor())
-	return nil
-}
-
-// References returns the current references added to this builder.
-func (mb *builder) References() []distribution.Descriptor {
-	return mb.layers
-}

vendor/github.com/docker/distribution/manifest/schema2/manifest.go

@@ -1,125 +0,0 @@
-package schema2
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/manifest"
-)
-
-const (
-	// MediaTypeManifest specifies the mediaType for the current version.
-	MediaTypeManifest = "application/vnd.docker.distribution.manifest.v2+json"
-
-	// MediaTypeConfig specifies the mediaType for the image configuration.
-	MediaTypeConfig = "application/vnd.docker.container.image.v1+json"
-
-	// MediaTypeLayer is the mediaType used for layers referenced by the
-	// manifest.
-	MediaTypeLayer = "application/vnd.docker.image.rootfs.diff.tar.gzip"
-)
-
-var (
-	// SchemaVersion provides a pre-initialized version structure for this
-	// packages version of the manifest.
-	SchemaVersion = manifest.Versioned{
-		SchemaVersion: 2,
-		MediaType:     MediaTypeManifest,
-	}
-)
-
-func init() {
-	schema2Func := func(b []byte) (distribution.Manifest, distribution.Descriptor, error) {
-		m := new(DeserializedManifest)
-		err := m.UnmarshalJSON(b)
-		if err != nil {
-			return nil, distribution.Descriptor{}, err
-		}
-
-		dgst := digest.FromBytes(b)
-		return m, distribution.Descriptor{Digest: dgst, Size: int64(len(b)), MediaType: MediaTypeManifest}, err
-	}
-	err := distribution.RegisterManifestSchema(MediaTypeManifest, schema2Func)
-	if err != nil {
-		panic(fmt.Sprintf("Unable to register manifest: %s", err))
-	}
-}
-
-// Manifest defines a schema2 manifest.
-type Manifest struct {
-	manifest.Versioned
-
-	// Config references the image configuration as a blob.
-	Config distribution.Descriptor `json:"config"`
-
-	// Layers lists descriptors for the layers referenced by the
-	// configuration.
-	Layers []distribution.Descriptor `json:"layers"`
-}
-
-// References returnes the descriptors of this manifests references.
-func (m Manifest) References() []distribution.Descriptor {
-	return m.Layers
-
-}
-
-// Target returns the target of this signed manifest.
-func (m Manifest) Target() distribution.Descriptor {
-	return m.Config
-}
-
-// DeserializedManifest wraps Manifest with a copy of the original JSON.
-// It satisfies the distribution.Manifest interface.
-type DeserializedManifest struct {
-	Manifest
-
-	// canonical is the canonical byte representation of the Manifest.
-	canonical []byte
-}
-
-// FromStruct takes a Manifest structure, marshals it to JSON, and returns a
-// DeserializedManifest which contains the manifest and its JSON representation.
-func FromStruct(m Manifest) (*DeserializedManifest, error) {
-	var deserialized DeserializedManifest
-	deserialized.Manifest = m
-
-	var err error
-	deserialized.canonical, err = json.MarshalIndent(&m, "", "   ")
-	return &deserialized, err
-}
-
-// UnmarshalJSON populates a new Manifest struct from JSON data.
-func (m *DeserializedManifest) UnmarshalJSON(b []byte) error {
-	m.canonical = make([]byte, len(b), len(b))
-	// store manifest in canonical
-	copy(m.canonical, b)
-
-	// Unmarshal canonical JSON into Manifest object
-	var manifest Manifest
-	if err := json.Unmarshal(m.canonical, &manifest); err != nil {
-		return err
-	}
-
-	m.Manifest = manifest
-
-	return nil
-}
-
-// MarshalJSON returns the contents of canonical. If canonical is empty,
-// marshals the inner contents.
-func (m *DeserializedManifest) MarshalJSON() ([]byte, error) {
-	if len(m.canonical) > 0 {
-		return m.canonical, nil
-	}
-
-	return nil, errors.New("JSON representation not initialized in DeserializedManifest")
-}
-
-// Payload returns the raw content of the manifest. The contents can be used to
-// calculate the content identifier.
-func (m DeserializedManifest) Payload() (string, []byte, error) {
-	return m.MediaType, m.canonical, nil
-}

vendor/github.com/docker/distribution/manifest/versioned.go

@@ -1,12 +0,0 @@
-package manifest
-
-// Versioned provides a struct with the manifest schemaVersion and . Incoming
-// content with unknown schema version can be decoded against this struct to
-// check the version.
-type Versioned struct {
-	// SchemaVersion is the image manifest schema that this image follows
-	SchemaVersion int `json:"schemaVersion"`
-
-	// MediaType is the media type of this schema.
-	MediaType string `json:"mediaType,omitempty"`
-}

vendor/github.com/docker/distribution/manifests.go

@@ -1,117 +0,0 @@
-package distribution
-
-import (
-	"fmt"
-	"mime"
-
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/digest"
-)
-
-// Manifest represents a registry object specifying a set of
-// references and an optional target
-type Manifest interface {
-	// References returns a list of objects which make up this manifest.
-	// The references are strictly ordered from base to head. A reference
-	// is anything which can be represented by a distribution.Descriptor
-	References() []Descriptor
-
-	// Payload provides the serialized format of the manifest, in addition to
-	// the mediatype.
-	Payload() (mediatype string, payload []byte, err error)
-}
-
-// ManifestBuilder creates a manifest allowing one to include dependencies.
-// Instances can be obtained from a version-specific manifest package.  Manifest
-// specific data is passed into the function which creates the builder.
-type ManifestBuilder interface {
-	// Build creates the manifest from his builder.
-	Build(ctx context.Context) (Manifest, error)
-
-	// References returns a list of objects which have been added to this
-	// builder. The dependencies are returned in the order they were added,
-	// which should be from base to head.
-	References() []Descriptor
-
-	// AppendReference includes the given object in the manifest after any
-	// existing dependencies. If the add fails, such as when adding an
-	// unsupported dependency, an error may be returned.
-	AppendReference(dependency Describable) error
-}
-
-// ManifestService describes operations on image manifests.
-type ManifestService interface {
-	// Exists returns true if the manifest exists.
-	Exists(ctx context.Context, dgst digest.Digest) (bool, error)
-
-	// Get retrieves the manifest specified by the given digest
-	Get(ctx context.Context, dgst digest.Digest, options ...ManifestServiceOption) (Manifest, error)
-
-	// Put creates or updates the given manifest returning the manifest digest
-	Put(ctx context.Context, manifest Manifest, options ...ManifestServiceOption) (digest.Digest, error)
-
-	// Delete removes the manifest specified by the given digest. Deleting
-	// a manifest that doesn't exist will return ErrManifestNotFound
-	Delete(ctx context.Context, dgst digest.Digest) error
-
-	// Enumerate fills 'manifests' with the manifests in this service up
-	// to the size of 'manifests' and returns 'n' for the number of entries
-	// which were filled.  'last' contains an offset in the manifest set
-	// and can be used to resume iteration.
-	//Enumerate(ctx context.Context, manifests []Manifest, last Manifest) (n int, err error)
-}
-
-// Describable is an interface for descriptors
-type Describable interface {
-	Descriptor() Descriptor
-}
-
-// ManifestMediaTypes returns the supported media types for manifests.
-func ManifestMediaTypes() (mediaTypes []string) {
-	for t := range mappings {
-		if t != "" {
-			mediaTypes = append(mediaTypes, t)
-		}
-	}
-	return
-}
-
-// UnmarshalFunc implements manifest unmarshalling a given MediaType
-type UnmarshalFunc func([]byte) (Manifest, Descriptor, error)
-
-var mappings = make(map[string]UnmarshalFunc, 0)
-
-// UnmarshalManifest looks up manifest unmarshal functions based on
-// MediaType
-func UnmarshalManifest(ctHeader string, p []byte) (Manifest, Descriptor, error) {
-	// Need to look up by the actual media type, not the raw contents of
-	// the header. Strip semicolons and anything following them.
-	var mediatype string
-	if ctHeader != "" {
-		var err error
-		mediatype, _, err = mime.ParseMediaType(ctHeader)
-		if err != nil {
-			return nil, Descriptor{}, err
-		}
-	}
-
-	unmarshalFunc, ok := mappings[mediatype]
-	if !ok {
-		unmarshalFunc, ok = mappings[""]
-		if !ok {
-			return nil, Descriptor{}, fmt.Errorf("unsupported manifest mediatype and no default available: %s", mediatype)
-		}
-	}
-
-	return unmarshalFunc(p)
-}
-
-// RegisterManifestSchema registers an UnmarshalFunc for a given schema type.  This
-// should be called from specific
-func RegisterManifestSchema(mediatype string, u UnmarshalFunc) error {
-	if _, ok := mappings[mediatype]; ok {
-		return fmt.Errorf("manifest mediatype registration would overwrite existing: %s", mediatype)
-	}
-	mappings[mediatype] = u
-	return nil
-}

vendor/github.com/docker/distribution/reference/reference.go

@@ -3,7 +3,7 @@
 //
 // Grammar
 //
-// 	reference                       := repository [ ":" tag ] [ "@" digest ]
+// 	reference                       := name [ ":" tag ] [ "@" digest ]
 //	name                            := [hostname '/'] component ['/' component]*
 //	hostname                        := hostcomponent ['.' hostcomponent]* [':' port-number]
 //	hostcomponent                   := /([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])/

vendor/github.com/docker/distribution/registry.go

@@ -1,72 +0,0 @@
-package distribution
-
-import (
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/reference"
-)
-
-// Scope defines the set of items that match a namespace.
-type Scope interface {
-	// Contains returns true if the name belongs to the namespace.
-	Contains(name string) bool
-}
-
-type fullScope struct{}
-
-func (f fullScope) Contains(string) bool {
-	return true
-}
-
-// GlobalScope represents the full namespace scope which contains
-// all other scopes.
-var GlobalScope = Scope(fullScope{})
-
-// Namespace represents a collection of repositories, addressable by name.
-// Generally, a namespace is backed by a set of one or more services,
-// providing facilities such as registry access, trust, and indexing.
-type Namespace interface {
-	// Scope describes the names that can be used with this Namespace. The
-	// global namespace will have a scope that matches all names. The scope
-	// effectively provides an identity for the namespace.
-	Scope() Scope
-
-	// Repository should return a reference to the named repository. The
-	// registry may or may not have the repository but should always return a
-	// reference.
-	Repository(ctx context.Context, name reference.Named) (Repository, error)
-
-	// Repositories fills 'repos' with a lexigraphically sorted catalog of repositories
-	// up to the size of 'repos' and returns the value 'n' for the number of entries
-	// which were filled.  'last' contains an offset in the catalog, and 'err' will be
-	// set to io.EOF if there are no more entries to obtain.
-	Repositories(ctx context.Context, repos []string, last string) (n int, err error)
-}
-
-// ManifestServiceOption is a function argument for Manifest Service methods
-type ManifestServiceOption interface {
-	Apply(ManifestService) error
-}
-
-// Repository is a named collection of manifests and layers.
-type Repository interface {
-	// Named returns the name of the repository.
-	Named() reference.Named
-
-	// Manifests returns a reference to this repository's manifest service.
-	// with the supplied options applied.
-	Manifests(ctx context.Context, options ...ManifestServiceOption) (ManifestService, error)
-
-	// Blobs returns a reference to this repository's blob service.
-	Blobs(ctx context.Context) BlobStore
-
-	// TODO(stevvooe): The above BlobStore return can probably be relaxed to
-	// be a BlobService for use with clients. This will allow such
-	// implementations to avoid implementing ServeBlob.
-
-	// Tags returns a reference to this repositories tag service
-	Tags(ctx context.Context) TagService
-}
-
-// TODO(stevvooe): Must add close methods to all these. May want to change the
-// way instances are created to better reflect internal dependency
-// relationships.

vendor/github.com/docker/distribution/registry/api/errcode/errors.go

@@ -1,267 +0,0 @@
-package errcode
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-)
-
-// ErrorCoder is the base interface for ErrorCode and Error allowing
-// users of each to just call ErrorCode to get the real ID of each
-type ErrorCoder interface {
-	ErrorCode() ErrorCode
-}
-
-// ErrorCode represents the error type. The errors are serialized via strings
-// and the integer format may change and should *never* be exported.
-type ErrorCode int
-
-var _ error = ErrorCode(0)
-
-// ErrorCode just returns itself
-func (ec ErrorCode) ErrorCode() ErrorCode {
-	return ec
-}
-
-// Error returns the ID/Value
-func (ec ErrorCode) Error() string {
-	// NOTE(stevvooe): Cannot use message here since it may have unpopulated args.
-	return strings.ToLower(strings.Replace(ec.String(), "_", " ", -1))
-}
-
-// Descriptor returns the descriptor for the error code.
-func (ec ErrorCode) Descriptor() ErrorDescriptor {
-	d, ok := errorCodeToDescriptors[ec]
-
-	if !ok {
-		return ErrorCodeUnknown.Descriptor()
-	}
-
-	return d
-}
-
-// String returns the canonical identifier for this error code.
-func (ec ErrorCode) String() string {
-	return ec.Descriptor().Value
-}
-
-// Message returned the human-readable error message for this error code.
-func (ec ErrorCode) Message() string {
-	return ec.Descriptor().Message
-}
-
-// MarshalText encodes the receiver into UTF-8-encoded text and returns the
-// result.
-func (ec ErrorCode) MarshalText() (text []byte, err error) {
-	return []byte(ec.String()), nil
-}
-
-// UnmarshalText decodes the form generated by MarshalText.
-func (ec *ErrorCode) UnmarshalText(text []byte) error {
-	desc, ok := idToDescriptors[string(text)]
-
-	if !ok {
-		desc = ErrorCodeUnknown.Descriptor()
-	}
-
-	*ec = desc.Code
-
-	return nil
-}
-
-// WithMessage creates a new Error struct based on the passed-in info and
-// overrides the Message property.
-func (ec ErrorCode) WithMessage(message string) Error {
-	return Error{
-		Code:    ec,
-		Message: message,
-	}
-}
-
-// WithDetail creates a new Error struct based on the passed-in info and
-// set the Detail property appropriately
-func (ec ErrorCode) WithDetail(detail interface{}) Error {
-	return Error{
-		Code:    ec,
-		Message: ec.Message(),
-	}.WithDetail(detail)
-}
-
-// WithArgs creates a new Error struct and sets the Args slice
-func (ec ErrorCode) WithArgs(args ...interface{}) Error {
-	return Error{
-		Code:    ec,
-		Message: ec.Message(),
-	}.WithArgs(args...)
-}
-
-// Error provides a wrapper around ErrorCode with extra Details provided.
-type Error struct {
-	Code    ErrorCode   `json:"code"`
-	Message string      `json:"message"`
-	Detail  interface{} `json:"detail,omitempty"`
-
-	// TODO(duglin): See if we need an "args" property so we can do the
-	// variable substitution right before showing the message to the user
-}
-
-var _ error = Error{}
-
-// ErrorCode returns the ID/Value of this Error
-func (e Error) ErrorCode() ErrorCode {
-	return e.Code
-}
-
-// Error returns a human readable representation of the error.
-func (e Error) Error() string {
-	return fmt.Sprintf("%s: %s", e.Code.Error(), e.Message)
-}
-
-// WithDetail will return a new Error, based on the current one, but with
-// some Detail info added
-func (e Error) WithDetail(detail interface{}) Error {
-	return Error{
-		Code:    e.Code,
-		Message: e.Message,
-		Detail:  detail,
-	}
-}
-
-// WithArgs uses the passed-in list of interface{} as the substitution
-// variables in the Error's Message string, but returns a new Error
-func (e Error) WithArgs(args ...interface{}) Error {
-	return Error{
-		Code:    e.Code,
-		Message: fmt.Sprintf(e.Code.Message(), args...),
-		Detail:  e.Detail,
-	}
-}
-
-// ErrorDescriptor provides relevant information about a given error code.
-type ErrorDescriptor struct {
-	// Code is the error code that this descriptor describes.
-	Code ErrorCode
-
-	// Value provides a unique, string key, often captilized with
-	// underscores, to identify the error code. This value is used as the
-	// keyed value when serializing api errors.
-	Value string
-
-	// Message is a short, human readable decription of the error condition
-	// included in API responses.
-	Message string
-
-	// Description provides a complete account of the errors purpose, suitable
-	// for use in documentation.
-	Description string
-
-	// HTTPStatusCode provides the http status code that is associated with
-	// this error condition.
-	HTTPStatusCode int
-}
-
-// ParseErrorCode returns the value by the string error code.
-// `ErrorCodeUnknown` will be returned if the error is not known.
-func ParseErrorCode(value string) ErrorCode {
-	ed, ok := idToDescriptors[value]
-	if ok {
-		return ed.Code
-	}
-
-	return ErrorCodeUnknown
-}
-
-// Errors provides the envelope for multiple errors and a few sugar methods
-// for use within the application.
-type Errors []error
-
-var _ error = Errors{}
-
-func (errs Errors) Error() string {
-	switch len(errs) {
-	case 0:
-		return "<nil>"
-	case 1:
-		return errs[0].Error()
-	default:
-		msg := "errors:\n"
-		for _, err := range errs {
-			msg += err.Error() + "\n"
-		}
-		return msg
-	}
-}
-
-// Len returns the current number of errors.
-func (errs Errors) Len() int {
-	return len(errs)
-}
-
-// MarshalJSON converts slice of error, ErrorCode or Error into a
-// slice of Error - then serializes
-func (errs Errors) MarshalJSON() ([]byte, error) {
-	var tmpErrs struct {
-		Errors []Error `json:"errors,omitempty"`
-	}
-
-	for _, daErr := range errs {
-		var err Error
-
-		switch daErr.(type) {
-		case ErrorCode:
-			err = daErr.(ErrorCode).WithDetail(nil)
-		case Error:
-			err = daErr.(Error)
-		default:
-			err = ErrorCodeUnknown.WithDetail(daErr)
-
-		}
-
-		// If the Error struct was setup and they forgot to set the
-		// Message field (meaning its "") then grab it from the ErrCode
-		msg := err.Message
-		if msg == "" {
-			msg = err.Code.Message()
-		}
-
-		tmpErrs.Errors = append(tmpErrs.Errors, Error{
-			Code:    err.Code,
-			Message: msg,
-			Detail:  err.Detail,
-		})
-	}
-
-	return json.Marshal(tmpErrs)
-}
-
-// UnmarshalJSON deserializes []Error and then converts it into slice of
-// Error or ErrorCode
-func (errs *Errors) UnmarshalJSON(data []byte) error {
-	var tmpErrs struct {
-		Errors []Error
-	}
-
-	if err := json.Unmarshal(data, &tmpErrs); err != nil {
-		return err
-	}
-
-	var newErrs Errors
-	for _, daErr := range tmpErrs.Errors {
-		// If Message is empty or exactly matches the Code's message string
-		// then just use the Code, no need for a full Error struct
-		if daErr.Detail == nil && (daErr.Message == "" || daErr.Message == daErr.Code.Message()) {
-			// Error's w/o details get converted to ErrorCode
-			newErrs = append(newErrs, daErr.Code)
-		} else {
-			// Error's w/ details are untouched
-			newErrs = append(newErrs, Error{
-				Code:    daErr.Code,
-				Message: daErr.Message,
-				Detail:  daErr.Detail,
-			})
-		}
-	}
-
-	*errs = newErrs
-	return nil
-}

vendor/github.com/docker/distribution/registry/api/errcode/handler.go

@@ -1,44 +0,0 @@
-package errcode
-
-import (
-	"encoding/json"
-	"net/http"
-)
-
-// ServeJSON attempts to serve the errcode in a JSON envelope. It marshals err
-// and sets the content-type header to 'application/json'. It will handle
-// ErrorCoder and Errors, and if necessary will create an envelope.
-func ServeJSON(w http.ResponseWriter, err error) error {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	var sc int
-
-	switch errs := err.(type) {
-	case Errors:
-		if len(errs) < 1 {
-			break
-		}
-
-		if err, ok := errs[0].(ErrorCoder); ok {
-			sc = err.ErrorCode().Descriptor().HTTPStatusCode
-		}
-	case ErrorCoder:
-		sc = errs.ErrorCode().Descriptor().HTTPStatusCode
-		err = Errors{err} // create an envelope.
-	default:
-		// We just have an unhandled error type, so just place in an envelope
-		// and move along.
-		err = Errors{err}
-	}
-
-	if sc == 0 {
-		sc = http.StatusInternalServerError
-	}
-
-	w.WriteHeader(sc)
-
-	if err := json.NewEncoder(w).Encode(err); err != nil {
-		return err
-	}
-
-	return nil
-}

vendor/github.com/docker/distribution/registry/api/errcode/register.go

@@ -1,128 +0,0 @@
-package errcode
-
-import (
-	"fmt"
-	"net/http"
-	"sort"
-	"sync"
-)
-
-var (
-	errorCodeToDescriptors = map[ErrorCode]ErrorDescriptor{}
-	idToDescriptors        = map[string]ErrorDescriptor{}
-	groupToDescriptors     = map[string][]ErrorDescriptor{}
-)
-
-var (
-	// ErrorCodeUnknown is a generic error that can be used as a last
-	// resort if there is no situation-specific error message that can be used
-	ErrorCodeUnknown = Register("errcode", ErrorDescriptor{
-		Value:   "UNKNOWN",
-		Message: "unknown error",
-		Description: `Generic error returned when the error does not have an
-			                                            API classification.`,
-		HTTPStatusCode: http.StatusInternalServerError,
-	})
-
-	// ErrorCodeUnsupported is returned when an operation is not supported.
-	ErrorCodeUnsupported = Register("errcode", ErrorDescriptor{
-		Value:   "UNSUPPORTED",
-		Message: "The operation is unsupported.",
-		Description: `The operation was unsupported due to a missing
-		implementation or invalid set of parameters.`,
-		HTTPStatusCode: http.StatusMethodNotAllowed,
-	})
-
-	// ErrorCodeUnauthorized is returned if a request requires
-	// authentication.
-	ErrorCodeUnauthorized = Register("errcode", ErrorDescriptor{
-		Value:   "UNAUTHORIZED",
-		Message: "authentication required",
-		Description: `The access controller was unable to authenticate
-		the client. Often this will be accompanied by a
-		Www-Authenticate HTTP response header indicating how to
-		authenticate.`,
-		HTTPStatusCode: http.StatusUnauthorized,
-	})
-
-	// ErrorCodeDenied is returned if a client does not have sufficient
-	// permission to perform an action.
-	ErrorCodeDenied = Register("errcode", ErrorDescriptor{
-		Value:   "DENIED",
-		Message: "requested access to the resource is denied",
-		Description: `The access controller denied access for the
-		operation on a resource.`,
-		HTTPStatusCode: http.StatusForbidden,
-	})
-
-	// ErrorCodeUnavailable provides a common error to report unavialability
-	// of a service or endpoint.
-	ErrorCodeUnavailable = Register("errcode", ErrorDescriptor{
-		Value:          "UNAVAILABLE",
-		Message:        "service unavailable",
-		Description:    "Returned when a service is not available",
-		HTTPStatusCode: http.StatusServiceUnavailable,
-	})
-)
-
-var nextCode = 1000
-var registerLock sync.Mutex
-
-// Register will make the passed-in error known to the environment and
-// return a new ErrorCode
-func Register(group string, descriptor ErrorDescriptor) ErrorCode {
-	registerLock.Lock()
-	defer registerLock.Unlock()
-
-	descriptor.Code = ErrorCode(nextCode)
-
-	if _, ok := idToDescriptors[descriptor.Value]; ok {
-		panic(fmt.Sprintf("ErrorValue %q is already registered", descriptor.Value))
-	}
-	if _, ok := errorCodeToDescriptors[descriptor.Code]; ok {
-		panic(fmt.Sprintf("ErrorCode %v is already registered", descriptor.Code))
-	}
-
-	groupToDescriptors[group] = append(groupToDescriptors[group], descriptor)
-	errorCodeToDescriptors[descriptor.Code] = descriptor
-	idToDescriptors[descriptor.Value] = descriptor
-
-	nextCode++
-	return descriptor.Code
-}
-
-type byValue []ErrorDescriptor
-
-func (a byValue) Len() int           { return len(a) }
-func (a byValue) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-func (a byValue) Less(i, j int) bool { return a[i].Value < a[j].Value }
-
-// GetGroupNames returns the list of Error group names that are registered
-func GetGroupNames() []string {
-	keys := []string{}
-
-	for k := range groupToDescriptors {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-// GetErrorCodeGroup returns the named group of error descriptors
-func GetErrorCodeGroup(name string) []ErrorDescriptor {
-	desc := groupToDescriptors[name]
-	sort.Sort(byValue(desc))
-	return desc
-}
-
-// GetErrorAllDescriptors returns a slice of all ErrorDescriptors that are
-// registered, irrespective of what group they're in
-func GetErrorAllDescriptors() []ErrorDescriptor {
-	result := []ErrorDescriptor{}
-
-	for _, group := range GetGroupNames() {
-		result = append(result, GetErrorCodeGroup(group)...)
-	}
-	sort.Sort(byValue(result))
-	return result
-}

vendor/github.com/docker/distribution/registry/api/v2/doc.go

@@ -1,9 +0,0 @@
-// Package v2 describes routes, urls and the error codes used in the Docker
-// Registry JSON HTTP API V2. In addition to declarations, descriptors are
-// provided for routes and error codes that can be used for implementation and
-// automatically generating documentation.
-//
-// Definitions here are considered to be locked down for the V2 registry api.
-// Any changes must be considered carefully and should not proceed without a
-// change proposal in docker core.
-package v2

vendor/github.com/docker/distribution/registry/api/v2/errors.go

@@ -1,136 +0,0 @@
-package v2
-
-import (
-	"net/http"
-
-	"github.com/docker/distribution/registry/api/errcode"
-)
-
-const errGroup = "registry.api.v2"
-
-var (
-	// ErrorCodeDigestInvalid is returned when uploading a blob if the
-	// provided digest does not match the blob contents.
-	ErrorCodeDigestInvalid = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "DIGEST_INVALID",
-		Message: "provided digest did not match uploaded content",
-		Description: `When a blob is uploaded, the registry will check that
-		the content matches the digest provided by the client. The error may
-		include a detail structure with the key "digest", including the
-		invalid digest string. This error may also be returned when a manifest
-		includes an invalid layer digest.`,
-		HTTPStatusCode: http.StatusBadRequest,
-	})
-
-	// ErrorCodeSizeInvalid is returned when uploading a blob if the provided
-	ErrorCodeSizeInvalid = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "SIZE_INVALID",
-		Message: "provided length did not match content length",
-		Description: `When a layer is uploaded, the provided size will be
-		checked against the uploaded content. If they do not match, this error
-		will be returned.`,
-		HTTPStatusCode: http.StatusBadRequest,
-	})
-
-	// ErrorCodeNameInvalid is returned when the name in the manifest does not
-	// match the provided name.
-	ErrorCodeNameInvalid = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "NAME_INVALID",
-		Message: "invalid repository name",
-		Description: `Invalid repository name encountered either during
-		manifest validation or any API operation.`,
-		HTTPStatusCode: http.StatusBadRequest,
-	})
-
-	// ErrorCodeTagInvalid is returned when the tag in the manifest does not
-	// match the provided tag.
-	ErrorCodeTagInvalid = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "TAG_INVALID",
-		Message: "manifest tag did not match URI",
-		Description: `During a manifest upload, if the tag in the manifest
-		does not match the uri tag, this error will be returned.`,
-		HTTPStatusCode: http.StatusBadRequest,
-	})
-
-	// ErrorCodeNameUnknown when the repository name is not known.
-	ErrorCodeNameUnknown = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "NAME_UNKNOWN",
-		Message: "repository name not known to registry",
-		Description: `This is returned if the name used during an operation is
-		unknown to the registry.`,
-		HTTPStatusCode: http.StatusNotFound,
-	})
-
-	// ErrorCodeManifestUnknown returned when image manifest is unknown.
-	ErrorCodeManifestUnknown = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "MANIFEST_UNKNOWN",
-		Message: "manifest unknown",
-		Description: `This error is returned when the manifest, identified by
-		name and tag is unknown to the repository.`,
-		HTTPStatusCode: http.StatusNotFound,
-	})
-
-	// ErrorCodeManifestInvalid returned when an image manifest is invalid,
-	// typically during a PUT operation. This error encompasses all errors
-	// encountered during manifest validation that aren't signature errors.
-	ErrorCodeManifestInvalid = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "MANIFEST_INVALID",
-		Message: "manifest invalid",
-		Description: `During upload, manifests undergo several checks ensuring
-		validity. If those checks fail, this error may be returned, unless a
-		more specific error is included. The detail will contain information
-		the failed validation.`,
-		HTTPStatusCode: http.StatusBadRequest,
-	})
-
-	// ErrorCodeManifestUnverified is returned when the manifest fails
-	// signature verification.
-	ErrorCodeManifestUnverified = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "MANIFEST_UNVERIFIED",
-		Message: "manifest failed signature verification",
-		Description: `During manifest upload, if the manifest fails signature
-		verification, this error will be returned.`,
-		HTTPStatusCode: http.StatusBadRequest,
-	})
-
-	// ErrorCodeManifestBlobUnknown is returned when a manifest blob is
-	// unknown to the registry.
-	ErrorCodeManifestBlobUnknown = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "MANIFEST_BLOB_UNKNOWN",
-		Message: "blob unknown to registry",
-		Description: `This error may be returned when a manifest blob is 
-		unknown to the registry.`,
-		HTTPStatusCode: http.StatusBadRequest,
-	})
-
-	// ErrorCodeBlobUnknown is returned when a blob is unknown to the
-	// registry. This can happen when the manifest references a nonexistent
-	// layer or the result is not found by a blob fetch.
-	ErrorCodeBlobUnknown = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "BLOB_UNKNOWN",
-		Message: "blob unknown to registry",
-		Description: `This error may be returned when a blob is unknown to the
-		registry in a specified repository. This can be returned with a
-		standard get or if a manifest references an unknown layer during
-		upload.`,
-		HTTPStatusCode: http.StatusNotFound,
-	})
-
-	// ErrorCodeBlobUploadUnknown is returned when an upload is unknown.
-	ErrorCodeBlobUploadUnknown = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "BLOB_UPLOAD_UNKNOWN",
-		Message: "blob upload unknown to registry",
-		Description: `If a blob upload has been cancelled or was never
-		started, this error code may be returned.`,
-		HTTPStatusCode: http.StatusNotFound,
-	})
-
-	// ErrorCodeBlobUploadInvalid is returned when an upload is invalid.
-	ErrorCodeBlobUploadInvalid = errcode.Register(errGroup, errcode.ErrorDescriptor{
-		Value:   "BLOB_UPLOAD_INVALID",
-		Message: "blob upload invalid",
-		Description: `The blob upload encountered an error and can no
-		longer proceed.`,
-		HTTPStatusCode: http.StatusNotFound,
-	})
-)

vendor/github.com/docker/distribution/registry/api/v2/routes.go

@@ -1,49 +0,0 @@
-package v2
-
-import "github.com/gorilla/mux"
-
-// The following are definitions of the name under which all V2 routes are
-// registered. These symbols can be used to look up a route based on the name.
-const (
-	RouteNameBase            = "base"
-	RouteNameManifest        = "manifest"
-	RouteNameTags            = "tags"
-	RouteNameBlob            = "blob"
-	RouteNameBlobUpload      = "blob-upload"
-	RouteNameBlobUploadChunk = "blob-upload-chunk"
-	RouteNameCatalog         = "catalog"
-)
-
-var allEndpoints = []string{
-	RouteNameManifest,
-	RouteNameCatalog,
-	RouteNameTags,
-	RouteNameBlob,
-	RouteNameBlobUpload,
-	RouteNameBlobUploadChunk,
-}
-
-// Router builds a gorilla router with named routes for the various API
-// methods. This can be used directly by both server implementations and
-// clients.
-func Router() *mux.Router {
-	return RouterWithPrefix("")
-}
-
-// RouterWithPrefix builds a gorilla router with a configured prefix
-// on all routes.
-func RouterWithPrefix(prefix string) *mux.Router {
-	rootRouter := mux.NewRouter()
-	router := rootRouter
-	if prefix != "" {
-		router = router.PathPrefix(prefix).Subrouter()
-	}
-
-	router.StrictSlash(true)
-
-	for _, descriptor := range routeDescriptors {
-		router.Path(descriptor.Path).Name(descriptor.Name)
-	}
-
-	return rootRouter
-}

vendor/github.com/docker/distribution/registry/api/v2/urls.go

@@ -1,244 +0,0 @@
-package v2
-
-import (
-	"net/http"
-	"net/url"
-	"strings"
-
-	"github.com/docker/distribution/reference"
-	"github.com/gorilla/mux"
-)
-
-// URLBuilder creates registry API urls from a single base endpoint. It can be
-// used to create urls for use in a registry client or server.
-//
-// All urls will be created from the given base, including the api version.
-// For example, if a root of "/foo/" is provided, urls generated will be fall
-// under "/foo/v2/...". Most application will only provide a schema, host and
-// port, such as "https://localhost:5000/".
-type URLBuilder struct {
-	root   *url.URL // url root (ie http://localhost/)
-	router *mux.Router
-}
-
-// NewURLBuilder creates a URLBuilder with provided root url object.
-func NewURLBuilder(root *url.URL) *URLBuilder {
-	return &URLBuilder{
-		root:   root,
-		router: Router(),
-	}
-}
-
-// NewURLBuilderFromString workes identically to NewURLBuilder except it takes
-// a string argument for the root, returning an error if it is not a valid
-// url.
-func NewURLBuilderFromString(root string) (*URLBuilder, error) {
-	u, err := url.Parse(root)
-	if err != nil {
-		return nil, err
-	}
-
-	return NewURLBuilder(u), nil
-}
-
-// NewURLBuilderFromRequest uses information from an *http.Request to
-// construct the root url.
-func NewURLBuilderFromRequest(r *http.Request) *URLBuilder {
-	var scheme string
-
-	forwardedProto := r.Header.Get("X-Forwarded-Proto")
-
-	switch {
-	case len(forwardedProto) > 0:
-		scheme = forwardedProto
-	case r.TLS != nil:
-		scheme = "https"
-	case len(r.URL.Scheme) > 0:
-		scheme = r.URL.Scheme
-	default:
-		scheme = "http"
-	}
-
-	host := r.Host
-	forwardedHost := r.Header.Get("X-Forwarded-Host")
-	if len(forwardedHost) > 0 {
-		// According to the Apache mod_proxy docs, X-Forwarded-Host can be a
-		// comma-separated list of hosts, to which each proxy appends the
-		// requested host. We want to grab the first from this comma-separated
-		// list.
-		hosts := strings.SplitN(forwardedHost, ",", 2)
-		host = strings.TrimSpace(hosts[0])
-	}
-
-	basePath := routeDescriptorsMap[RouteNameBase].Path
-
-	requestPath := r.URL.Path
-	index := strings.Index(requestPath, basePath)
-
-	u := &url.URL{
-		Scheme: scheme,
-		Host:   host,
-	}
-
-	if index > 0 {
-		// N.B. index+1 is important because we want to include the trailing /
-		u.Path = requestPath[0 : index+1]
-	}
-
-	return NewURLBuilder(u)
-}
-
-// BuildBaseURL constructs a base url for the API, typically just "/v2/".
-func (ub *URLBuilder) BuildBaseURL() (string, error) {
-	route := ub.cloneRoute(RouteNameBase)
-
-	baseURL, err := route.URL()
-	if err != nil {
-		return "", err
-	}
-
-	return baseURL.String(), nil
-}
-
-// BuildCatalogURL constructs a url get a catalog of repositories
-func (ub *URLBuilder) BuildCatalogURL(values ...url.Values) (string, error) {
-	route := ub.cloneRoute(RouteNameCatalog)
-
-	catalogURL, err := route.URL()
-	if err != nil {
-		return "", err
-	}
-
-	return appendValuesURL(catalogURL, values...).String(), nil
-}
-
-// BuildTagsURL constructs a url to list the tags in the named repository.
-func (ub *URLBuilder) BuildTagsURL(name reference.Named) (string, error) {
-	route := ub.cloneRoute(RouteNameTags)
-
-	tagsURL, err := route.URL("name", name.Name())
-	if err != nil {
-		return "", err
-	}
-
-	return tagsURL.String(), nil
-}
-
-// BuildManifestURL constructs a url for the manifest identified by name and
-// reference. The argument reference may be either a tag or digest.
-func (ub *URLBuilder) BuildManifestURL(ref reference.Named) (string, error) {
-	route := ub.cloneRoute(RouteNameManifest)
-
-	tagOrDigest := ""
-	switch v := ref.(type) {
-	case reference.Tagged:
-		tagOrDigest = v.Tag()
-	case reference.Digested:
-		tagOrDigest = v.Digest().String()
-	}
-
-	manifestURL, err := route.URL("name", ref.Name(), "reference", tagOrDigest)
-	if err != nil {
-		return "", err
-	}
-
-	return manifestURL.String(), nil
-}
-
-// BuildBlobURL constructs the url for the blob identified by name and dgst.
-func (ub *URLBuilder) BuildBlobURL(ref reference.Canonical) (string, error) {
-	route := ub.cloneRoute(RouteNameBlob)
-
-	layerURL, err := route.URL("name", ref.Name(), "digest", ref.Digest().String())
-	if err != nil {
-		return "", err
-	}
-
-	return layerURL.String(), nil
-}
-
-// BuildBlobUploadURL constructs a url to begin a blob upload in the
-// repository identified by name.
-func (ub *URLBuilder) BuildBlobUploadURL(name reference.Named, values ...url.Values) (string, error) {
-	route := ub.cloneRoute(RouteNameBlobUpload)
-
-	uploadURL, err := route.URL("name", name.Name())
-	if err != nil {
-		return "", err
-	}
-
-	return appendValuesURL(uploadURL, values...).String(), nil
-}
-
-// BuildBlobUploadChunkURL constructs a url for the upload identified by uuid,
-// including any url values. This should generally not be used by clients, as
-// this url is provided by server implementations during the blob upload
-// process.
-func (ub *URLBuilder) BuildBlobUploadChunkURL(name reference.Named, uuid string, values ...url.Values) (string, error) {
-	route := ub.cloneRoute(RouteNameBlobUploadChunk)
-
-	uploadURL, err := route.URL("name", name.Name(), "uuid", uuid)
-	if err != nil {
-		return "", err
-	}
-
-	return appendValuesURL(uploadURL, values...).String(), nil
-}
-
-// clondedRoute returns a clone of the named route from the router. Routes
-// must be cloned to avoid modifying them during url generation.
-func (ub *URLBuilder) cloneRoute(name string) clonedRoute {
-	route := new(mux.Route)
-	root := new(url.URL)
-
-	*route = *ub.router.GetRoute(name) // clone the route
-	*root = *ub.root
-
-	return clonedRoute{Route: route, root: root}
-}
-
-type clonedRoute struct {
-	*mux.Route
-	root *url.URL
-}
-
-func (cr clonedRoute) URL(pairs ...string) (*url.URL, error) {
-	routeURL, err := cr.Route.URL(pairs...)
-	if err != nil {
-		return nil, err
-	}
-
-	if routeURL.Scheme == "" && routeURL.User == nil && routeURL.Host == "" {
-		routeURL.Path = routeURL.Path[1:]
-	}
-
-	url := cr.root.ResolveReference(routeURL)
-	url.Scheme = cr.root.Scheme
-	return url, nil
-}
-
-// appendValuesURL appends the parameters to the url.
-func appendValuesURL(u *url.URL, values ...url.Values) *url.URL {
-	merged := u.Query()
-
-	for _, v := range values {
-		for k, vv := range v {
-			merged[k] = append(merged[k], vv...)
-		}
-	}
-
-	u.RawQuery = merged.Encode()
-	return u
-}
-
-// appendValues appends the parameters to the url. Panics if the string is not
-// a url.
-func appendValues(u string, values ...url.Values) string {
-	up, err := url.Parse(u)
-
-	if err != nil {
-		panic(err) // should never happen
-	}
-
-	return appendValuesURL(up, values...).String()
-}

vendor/github.com/docker/distribution/registry/client/auth/api_version.go

@@ -1,58 +0,0 @@
-package auth
-
-import (
-	"net/http"
-	"strings"
-)
-
-// APIVersion represents a version of an API including its
-// type and version number.
-type APIVersion struct {
-	// Type refers to the name of a specific API specification
-	// such as "registry"
-	Type string
-
-	// Version is the version of the API specification implemented,
-	// This may omit the revision number and only include
-	// the major and minor version, such as "2.0"
-	Version string
-}
-
-// String returns the string formatted API Version
-func (v APIVersion) String() string {
-	return v.Type + "/" + v.Version
-}
-
-// APIVersions gets the API versions out of an HTTP response using the provided
-// version header as the key for the HTTP header.
-func APIVersions(resp *http.Response, versionHeader string) []APIVersion {
-	versions := []APIVersion{}
-	if versionHeader != "" {
-		for _, supportedVersions := range resp.Header[http.CanonicalHeaderKey(versionHeader)] {
-			for _, version := range strings.Fields(supportedVersions) {
-				versions = append(versions, ParseAPIVersion(version))
-			}
-		}
-	}
-	return versions
-}
-
-// ParseAPIVersion parses an API version string into an APIVersion
-// Format (Expected, not enforced):
-// API version string = <API type> '/' <API version>
-// API type = [a-z][a-z0-9]*
-// API version = [0-9]+(\.[0-9]+)?
-// TODO(dmcgowan): Enforce format, add error condition, remove unknown type
-func ParseAPIVersion(versionStr string) APIVersion {
-	idx := strings.IndexRune(versionStr, '/')
-	if idx == -1 {
-		return APIVersion{
-			Type:    "unknown",
-			Version: versionStr,
-		}
-	}
-	return APIVersion{
-		Type:    strings.ToLower(versionStr[:idx]),
-		Version: versionStr[idx+1:],
-	}
-}

vendor/github.com/docker/distribution/registry/client/auth/authchallenge.go

@@ -1,219 +0,0 @@
-package auth
-
-import (
-	"fmt"
-	"net/http"
-	"net/url"
-	"strings"
-)
-
-// Challenge carries information from a WWW-Authenticate response header.
-// See RFC 2617.
-type Challenge struct {
-	// Scheme is the auth-scheme according to RFC 2617
-	Scheme string
-
-	// Parameters are the auth-params according to RFC 2617
-	Parameters map[string]string
-}
-
-// ChallengeManager manages the challenges for endpoints.
-// The challenges are pulled out of HTTP responses. Only
-// responses which expect challenges should be added to
-// the manager, since a non-unauthorized request will be
-// viewed as not requiring challenges.
-type ChallengeManager interface {
-	// GetChallenges returns the challenges for the given
-	// endpoint URL.
-	GetChallenges(endpoint string) ([]Challenge, error)
-
-	// AddResponse adds the response to the challenge
-	// manager. The challenges will be parsed out of
-	// the WWW-Authenicate headers and added to the
-	// URL which was produced the response. If the
-	// response was authorized, any challenges for the
-	// endpoint will be cleared.
-	AddResponse(resp *http.Response) error
-}
-
-// NewSimpleChallengeManager returns an instance of
-// ChallengeManger which only maps endpoints to challenges
-// based on the responses which have been added the
-// manager. The simple manager will make no attempt to
-// perform requests on the endpoints or cache the responses
-// to a backend.
-func NewSimpleChallengeManager() ChallengeManager {
-	return simpleChallengeManager{}
-}
-
-type simpleChallengeManager map[string][]Challenge
-
-func (m simpleChallengeManager) GetChallenges(endpoint string) ([]Challenge, error) {
-	challenges := m[endpoint]
-	return challenges, nil
-}
-
-func (m simpleChallengeManager) AddResponse(resp *http.Response) error {
-	challenges := ResponseChallenges(resp)
-	if resp.Request == nil {
-		return fmt.Errorf("missing request reference")
-	}
-	urlCopy := url.URL{
-		Path:   resp.Request.URL.Path,
-		Host:   resp.Request.URL.Host,
-		Scheme: resp.Request.URL.Scheme,
-	}
-	m[urlCopy.String()] = challenges
-
-	return nil
-}
-
-// Octet types from RFC 2616.
-type octetType byte
-
-var octetTypes [256]octetType
-
-const (
-	isToken octetType = 1 << iota
-	isSpace
-)
-
-func init() {
-	// OCTET      = <any 8-bit sequence of data>
-	// CHAR       = <any US-ASCII character (octets 0 - 127)>
-	// CTL        = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
-	// CR         = <US-ASCII CR, carriage return (13)>
-	// LF         = <US-ASCII LF, linefeed (10)>
-	// SP         = <US-ASCII SP, space (32)>
-	// HT         = <US-ASCII HT, horizontal-tab (9)>
-	// <">        = <US-ASCII double-quote mark (34)>
-	// CRLF       = CR LF
-	// LWS        = [CRLF] 1*( SP | HT )
-	// TEXT       = <any OCTET except CTLs, but including LWS>
-	// separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <">
-	//              | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT
-	// token      = 1*<any CHAR except CTLs or separators>
-	// qdtext     = <any TEXT except <">>
-
-	for c := 0; c < 256; c++ {
-		var t octetType
-		isCtl := c <= 31 || c == 127
-		isChar := 0 <= c && c <= 127
-		isSeparator := strings.IndexRune(" \t\"(),/:;<=>?@[]\\{}", rune(c)) >= 0
-		if strings.IndexRune(" \t\r\n", rune(c)) >= 0 {
-			t |= isSpace
-		}
-		if isChar && !isCtl && !isSeparator {
-			t |= isToken
-		}
-		octetTypes[c] = t
-	}
-}
-
-// ResponseChallenges returns a list of authorization challenges
-// for the given http Response. Challenges are only checked if
-// the response status code was a 401.
-func ResponseChallenges(resp *http.Response) []Challenge {
-	if resp.StatusCode == http.StatusUnauthorized {
-		// Parse the WWW-Authenticate Header and store the challenges
-		// on this endpoint object.
-		return parseAuthHeader(resp.Header)
-	}
-
-	return nil
-}
-
-func parseAuthHeader(header http.Header) []Challenge {
-	challenges := []Challenge{}
-	for _, h := range header[http.CanonicalHeaderKey("WWW-Authenticate")] {
-		v, p := parseValueAndParams(h)
-		if v != "" {
-			challenges = append(challenges, Challenge{Scheme: v, Parameters: p})
-		}
-	}
-	return challenges
-}
-
-func parseValueAndParams(header string) (value string, params map[string]string) {
-	params = make(map[string]string)
-	value, s := expectToken(header)
-	if value == "" {
-		return
-	}
-	value = strings.ToLower(value)
-	s = "," + skipSpace(s)
-	for strings.HasPrefix(s, ",") {
-		var pkey string
-		pkey, s = expectToken(skipSpace(s[1:]))
-		if pkey == "" {
-			return
-		}
-		if !strings.HasPrefix(s, "=") {
-			return
-		}
-		var pvalue string
-		pvalue, s = expectTokenOrQuoted(s[1:])
-		if pvalue == "" {
-			return
-		}
-		pkey = strings.ToLower(pkey)
-		params[pkey] = pvalue
-		s = skipSpace(s)
-	}
-	return
-}
-
-func skipSpace(s string) (rest string) {
-	i := 0
-	for ; i < len(s); i++ {
-		if octetTypes[s[i]]&isSpace == 0 {
-			break
-		}
-	}
-	return s[i:]
-}
-
-func expectToken(s string) (token, rest string) {
-	i := 0
-	for ; i < len(s); i++ {
-		if octetTypes[s[i]]&isToken == 0 {
-			break
-		}
-	}
-	return s[:i], s[i:]
-}
-
-func expectTokenOrQuoted(s string) (value string, rest string) {
-	if !strings.HasPrefix(s, "\"") {
-		return expectToken(s)
-	}
-	s = s[1:]
-	for i := 0; i < len(s); i++ {
-		switch s[i] {
-		case '"':
-			return s[:i], s[i+1:]
-		case '\\':
-			p := make([]byte, len(s)-1)
-			j := copy(p, s[:i])
-			escape := true
-			for i = i + 1; i < len(s); i++ {
-				b := s[i]
-				switch {
-				case escape:
-					escape = false
-					p[j] = b
-					j++
-				case b == '\\':
-					escape = true
-				case b == '"':
-					return string(p[:j]), s[i+1:]
-				default:
-					p[j] = b
-					j++
-				}
-			}
-			return "", ""
-		}
-	}
-	return "", ""
-}

vendor/github.com/docker/distribution/registry/client/auth/session.go

@@ -1,330 +0,0 @@
-package auth
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/distribution/registry/client"
-	"github.com/docker/distribution/registry/client/transport"
-)
-
-// ErrNoBasicAuthCredentials is returned if a request can't be authorized with
-// basic auth due to lack of credentials.
-var ErrNoBasicAuthCredentials = errors.New("no basic auth credentials")
-
-// AuthenticationHandler is an interface for authorizing a request from
-// params from a "WWW-Authenicate" header for a single scheme.
-type AuthenticationHandler interface {
-	// Scheme returns the scheme as expected from the "WWW-Authenicate" header.
-	Scheme() string
-
-	// AuthorizeRequest adds the authorization header to a request (if needed)
-	// using the parameters from "WWW-Authenticate" method. The parameters
-	// values depend on the scheme.
-	AuthorizeRequest(req *http.Request, params map[string]string) error
-}
-
-// CredentialStore is an interface for getting credentials for
-// a given URL
-type CredentialStore interface {
-	// Basic returns basic auth for the given URL
-	Basic(*url.URL) (string, string)
-}
-
-// NewAuthorizer creates an authorizer which can handle multiple authentication
-// schemes. The handlers are tried in order, the higher priority authentication
-// methods should be first. The challengeMap holds a list of challenges for
-// a given root API endpoint (for example "https://registry-1.docker.io/v2/").
-func NewAuthorizer(manager ChallengeManager, handlers ...AuthenticationHandler) transport.RequestModifier {
-	return &endpointAuthorizer{
-		challenges: manager,
-		handlers:   handlers,
-	}
-}
-
-type endpointAuthorizer struct {
-	challenges ChallengeManager
-	handlers   []AuthenticationHandler
-	transport  http.RoundTripper
-}
-
-func (ea *endpointAuthorizer) ModifyRequest(req *http.Request) error {
-	v2Root := strings.Index(req.URL.Path, "/v2/")
-	if v2Root == -1 {
-		return nil
-	}
-
-	ping := url.URL{
-		Host:   req.URL.Host,
-		Scheme: req.URL.Scheme,
-		Path:   req.URL.Path[:v2Root+4],
-	}
-
-	pingEndpoint := ping.String()
-
-	challenges, err := ea.challenges.GetChallenges(pingEndpoint)
-	if err != nil {
-		return err
-	}
-
-	if len(challenges) > 0 {
-		for _, handler := range ea.handlers {
-			for _, challenge := range challenges {
-				if challenge.Scheme != handler.Scheme() {
-					continue
-				}
-				if err := handler.AuthorizeRequest(req, challenge.Parameters); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-// This is the minimum duration a token can last (in seconds).
-// A token must not live less than 60 seconds because older versions
-// of the Docker client didn't read their expiration from the token
-// response and assumed 60 seconds.  So to remain compatible with
-// those implementations, a token must live at least this long.
-const minimumTokenLifetimeSeconds = 60
-
-// Private interface for time used by this package to enable tests to provide their own implementation.
-type clock interface {
-	Now() time.Time
-}
-
-type tokenHandler struct {
-	header    http.Header
-	creds     CredentialStore
-	scope     tokenScope
-	transport http.RoundTripper
-	clock     clock
-
-	tokenLock       sync.Mutex
-	tokenCache      string
-	tokenExpiration time.Time
-
-	additionalScopes map[string]struct{}
-}
-
-// tokenScope represents the scope at which a token will be requested.
-// This represents a specific action on a registry resource.
-type tokenScope struct {
-	Resource string
-	Scope    string
-	Actions  []string
-}
-
-func (ts tokenScope) String() string {
-	return fmt.Sprintf("%s:%s:%s", ts.Resource, ts.Scope, strings.Join(ts.Actions, ","))
-}
-
-// An implementation of clock for providing real time data.
-type realClock struct{}
-
-// Now implements clock
-func (realClock) Now() time.Time { return time.Now() }
-
-// NewTokenHandler creates a new AuthenicationHandler which supports
-// fetching tokens from a remote token server.
-func NewTokenHandler(transport http.RoundTripper, creds CredentialStore, scope string, actions ...string) AuthenticationHandler {
-	return newTokenHandler(transport, creds, realClock{}, scope, actions...)
-}
-
-// newTokenHandler exposes the option to provide a clock to manipulate time in unit testing.
-func newTokenHandler(transport http.RoundTripper, creds CredentialStore, c clock, scope string, actions ...string) AuthenticationHandler {
-	return &tokenHandler{
-		transport: transport,
-		creds:     creds,
-		clock:     c,
-		scope: tokenScope{
-			Resource: "repository",
-			Scope:    scope,
-			Actions:  actions,
-		},
-		additionalScopes: map[string]struct{}{},
-	}
-}
-
-func (th *tokenHandler) client() *http.Client {
-	return &http.Client{
-		Transport: th.transport,
-		Timeout:   15 * time.Second,
-	}
-}
-
-func (th *tokenHandler) Scheme() string {
-	return "bearer"
-}
-
-func (th *tokenHandler) AuthorizeRequest(req *http.Request, params map[string]string) error {
-	var additionalScopes []string
-	if fromParam := req.URL.Query().Get("from"); fromParam != "" {
-		additionalScopes = append(additionalScopes, tokenScope{
-			Resource: "repository",
-			Scope:    fromParam,
-			Actions:  []string{"pull"},
-		}.String())
-	}
-	if err := th.refreshToken(params, additionalScopes...); err != nil {
-		return err
-	}
-
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", th.tokenCache))
-
-	return nil
-}
-
-func (th *tokenHandler) refreshToken(params map[string]string, additionalScopes ...string) error {
-	th.tokenLock.Lock()
-	defer th.tokenLock.Unlock()
-	var addedScopes bool
-	for _, scope := range additionalScopes {
-		if _, ok := th.additionalScopes[scope]; !ok {
-			th.additionalScopes[scope] = struct{}{}
-			addedScopes = true
-		}
-	}
-	now := th.clock.Now()
-	if now.After(th.tokenExpiration) || addedScopes {
-		tr, err := th.fetchToken(params)
-		if err != nil {
-			return err
-		}
-		th.tokenCache = tr.Token
-		th.tokenExpiration = tr.IssuedAt.Add(time.Duration(tr.ExpiresIn) * time.Second)
-	}
-
-	return nil
-}
-
-type tokenResponse struct {
-	Token       string    `json:"token"`
-	AccessToken string    `json:"access_token"`
-	ExpiresIn   int       `json:"expires_in"`
-	IssuedAt    time.Time `json:"issued_at"`
-}
-
-func (th *tokenHandler) fetchToken(params map[string]string) (token *tokenResponse, err error) {
-	//log.Debugf("Getting bearer token with %s for %s", challenge.Parameters, ta.auth.Username)
-	realm, ok := params["realm"]
-	if !ok {
-		return nil, errors.New("no realm specified for token auth challenge")
-	}
-
-	// TODO(dmcgowan): Handle empty scheme
-
-	realmURL, err := url.Parse(realm)
-	if err != nil {
-		return nil, fmt.Errorf("invalid token auth challenge realm: %s", err)
-	}
-
-	req, err := http.NewRequest("GET", realmURL.String(), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	reqParams := req.URL.Query()
-	service := params["service"]
-	scope := th.scope.String()
-
-	if service != "" {
-		reqParams.Add("service", service)
-	}
-
-	for _, scopeField := range strings.Fields(scope) {
-		reqParams.Add("scope", scopeField)
-	}
-
-	for scope := range th.additionalScopes {
-		reqParams.Add("scope", scope)
-	}
-
-	if th.creds != nil {
-		username, password := th.creds.Basic(realmURL)
-		if username != "" && password != "" {
-			reqParams.Add("account", username)
-			req.SetBasicAuth(username, password)
-		}
-	}
-
-	req.URL.RawQuery = reqParams.Encode()
-
-	resp, err := th.client().Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if !client.SuccessStatus(resp.StatusCode) {
-		err := client.HandleErrorResponse(resp)
-		return nil, err
-	}
-
-	decoder := json.NewDecoder(resp.Body)
-
-	tr := new(tokenResponse)
-	if err = decoder.Decode(tr); err != nil {
-		return nil, fmt.Errorf("unable to decode token response: %s", err)
-	}
-
-	// `access_token` is equivalent to `token` and if both are specified
-	// the choice is undefined.  Canonicalize `access_token` by sticking
-	// things in `token`.
-	if tr.AccessToken != "" {
-		tr.Token = tr.AccessToken
-	}
-
-	if tr.Token == "" {
-		return nil, errors.New("authorization server did not include a token in the response")
-	}
-
-	if tr.ExpiresIn < minimumTokenLifetimeSeconds {
-		// The default/minimum lifetime.
-		tr.ExpiresIn = minimumTokenLifetimeSeconds
-		logrus.Debugf("Increasing token expiration to: %d seconds", tr.ExpiresIn)
-	}
-
-	if tr.IssuedAt.IsZero() {
-		// issued_at is optional in the token response.
-		tr.IssuedAt = th.clock.Now()
-	}
-
-	return tr, nil
-}
-
-type basicHandler struct {
-	creds CredentialStore
-}
-
-// NewBasicHandler creaters a new authentiation handler which adds
-// basic authentication credentials to a request.
-func NewBasicHandler(creds CredentialStore) AuthenticationHandler {
-	return &basicHandler{
-		creds: creds,
-	}
-}
-
-func (*basicHandler) Scheme() string {
-	return "basic"
-}
-
-func (bh *basicHandler) AuthorizeRequest(req *http.Request, params map[string]string) error {
-	if bh.creds != nil {
-		username, password := bh.creds.Basic(req.URL)
-		if username != "" && password != "" {
-			req.SetBasicAuth(username, password)
-			return nil
-		}
-	}
-	return ErrNoBasicAuthCredentials
-}

vendor/github.com/docker/distribution/registry/client/blob_writer.go

@@ -1,176 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/context"
-)
-
-type httpBlobUpload struct {
-	statter distribution.BlobStatter
-	client  *http.Client
-
-	uuid      string
-	startedAt time.Time
-
-	location string // always the last value of the location header.
-	offset   int64
-	closed   bool
-}
-
-func (hbu *httpBlobUpload) Reader() (io.ReadCloser, error) {
-	panic("Not implemented")
-}
-
-func (hbu *httpBlobUpload) handleErrorResponse(resp *http.Response) error {
-	if resp.StatusCode == http.StatusNotFound {
-		return distribution.ErrBlobUploadUnknown
-	}
-	return HandleErrorResponse(resp)
-}
-
-func (hbu *httpBlobUpload) ReadFrom(r io.Reader) (n int64, err error) {
-	req, err := http.NewRequest("PATCH", hbu.location, ioutil.NopCloser(r))
-	if err != nil {
-		return 0, err
-	}
-	defer req.Body.Close()
-
-	resp, err := hbu.client.Do(req)
-	if err != nil {
-		return 0, err
-	}
-
-	if !SuccessStatus(resp.StatusCode) {
-		return 0, hbu.handleErrorResponse(resp)
-	}
-
-	hbu.uuid = resp.Header.Get("Docker-Upload-UUID")
-	hbu.location, err = sanitizeLocation(resp.Header.Get("Location"), hbu.location)
-	if err != nil {
-		return 0, err
-	}
-	rng := resp.Header.Get("Range")
-	var start, end int64
-	if n, err := fmt.Sscanf(rng, "%d-%d", &start, &end); err != nil {
-		return 0, err
-	} else if n != 2 || end < start {
-		return 0, fmt.Errorf("bad range format: %s", rng)
-	}
-
-	return (end - start + 1), nil
-
-}
-
-func (hbu *httpBlobUpload) Write(p []byte) (n int, err error) {
-	req, err := http.NewRequest("PATCH", hbu.location, bytes.NewReader(p))
-	if err != nil {
-		return 0, err
-	}
-	req.Header.Set("Content-Range", fmt.Sprintf("%d-%d", hbu.offset, hbu.offset+int64(len(p)-1)))
-	req.Header.Set("Content-Length", fmt.Sprintf("%d", len(p)))
-	req.Header.Set("Content-Type", "application/octet-stream")
-
-	resp, err := hbu.client.Do(req)
-	if err != nil {
-		return 0, err
-	}
-
-	if !SuccessStatus(resp.StatusCode) {
-		return 0, hbu.handleErrorResponse(resp)
-	}
-
-	hbu.uuid = resp.Header.Get("Docker-Upload-UUID")
-	hbu.location, err = sanitizeLocation(resp.Header.Get("Location"), hbu.location)
-	if err != nil {
-		return 0, err
-	}
-	rng := resp.Header.Get("Range")
-	var start, end int
-	if n, err := fmt.Sscanf(rng, "%d-%d", &start, &end); err != nil {
-		return 0, err
-	} else if n != 2 || end < start {
-		return 0, fmt.Errorf("bad range format: %s", rng)
-	}
-
-	return (end - start + 1), nil
-
-}
-
-func (hbu *httpBlobUpload) Seek(offset int64, whence int) (int64, error) {
-	newOffset := hbu.offset
-
-	switch whence {
-	case os.SEEK_CUR:
-		newOffset += int64(offset)
-	case os.SEEK_END:
-		newOffset += int64(offset)
-	case os.SEEK_SET:
-		newOffset = int64(offset)
-	}
-
-	hbu.offset = newOffset
-
-	return hbu.offset, nil
-}
-
-func (hbu *httpBlobUpload) ID() string {
-	return hbu.uuid
-}
-
-func (hbu *httpBlobUpload) StartedAt() time.Time {
-	return hbu.startedAt
-}
-
-func (hbu *httpBlobUpload) Commit(ctx context.Context, desc distribution.Descriptor) (distribution.Descriptor, error) {
-	// TODO(dmcgowan): Check if already finished, if so just fetch
-	req, err := http.NewRequest("PUT", hbu.location, nil)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-
-	values := req.URL.Query()
-	values.Set("digest", desc.Digest.String())
-	req.URL.RawQuery = values.Encode()
-
-	resp, err := hbu.client.Do(req)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	defer resp.Body.Close()
-
-	if !SuccessStatus(resp.StatusCode) {
-		return distribution.Descriptor{}, hbu.handleErrorResponse(resp)
-	}
-
-	return hbu.statter.Stat(ctx, desc.Digest)
-}
-
-func (hbu *httpBlobUpload) Cancel(ctx context.Context) error {
-	req, err := http.NewRequest("DELETE", hbu.location, nil)
-	if err != nil {
-		return err
-	}
-	resp, err := hbu.client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode == http.StatusNotFound || SuccessStatus(resp.StatusCode) {
-		return nil
-	}
-	return hbu.handleErrorResponse(resp)
-}
-
-func (hbu *httpBlobUpload) Close() error {
-	hbu.closed = true
-	return nil
-}

vendor/github.com/docker/distribution/registry/client/errors.go

@@ -1,85 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/docker/distribution/registry/api/errcode"
-)
-
-// UnexpectedHTTPStatusError is returned when an unexpected HTTP status is
-// returned when making a registry api call.
-type UnexpectedHTTPStatusError struct {
-	Status string
-}
-
-func (e *UnexpectedHTTPStatusError) Error() string {
-	return fmt.Sprintf("Received unexpected HTTP status: %s", e.Status)
-}
-
-// UnexpectedHTTPResponseError is returned when an expected HTTP status code
-// is returned, but the content was unexpected and failed to be parsed.
-type UnexpectedHTTPResponseError struct {
-	ParseErr error
-	Response []byte
-}
-
-func (e *UnexpectedHTTPResponseError) Error() string {
-	return fmt.Sprintf("Error parsing HTTP response: %s: %q", e.ParseErr.Error(), string(e.Response))
-}
-
-func parseHTTPErrorResponse(statusCode int, r io.Reader) error {
-	var errors errcode.Errors
-	body, err := ioutil.ReadAll(r)
-	if err != nil {
-		return err
-	}
-
-	// For backward compatibility, handle irregularly formatted
-	// messages that contain a "details" field.
-	var detailsErr struct {
-		Details string `json:"details"`
-	}
-	err = json.Unmarshal(body, &detailsErr)
-	if err == nil && detailsErr.Details != "" {
-		if statusCode == http.StatusUnauthorized {
-			return errcode.ErrorCodeUnauthorized.WithMessage(detailsErr.Details)
-		}
-		return errcode.ErrorCodeUnknown.WithMessage(detailsErr.Details)
-	}
-
-	if err := json.Unmarshal(body, &errors); err != nil {
-		return &UnexpectedHTTPResponseError{
-			ParseErr: err,
-			Response: body,
-		}
-	}
-	return errors
-}
-
-// HandleErrorResponse returns error parsed from HTTP response for an
-// unsuccessful HTTP response code (in the range 400 - 499 inclusive). An
-// UnexpectedHTTPStatusError returned for response code outside of expected
-// range.
-func HandleErrorResponse(resp *http.Response) error {
-	if resp.StatusCode == 401 {
-		err := parseHTTPErrorResponse(resp.StatusCode, resp.Body)
-		if uErr, ok := err.(*UnexpectedHTTPResponseError); ok {
-			return errcode.ErrorCodeUnauthorized.WithDetail(uErr.Response)
-		}
-		return err
-	}
-	if resp.StatusCode >= 400 && resp.StatusCode < 500 {
-		return parseHTTPErrorResponse(resp.StatusCode, resp.Body)
-	}
-	return &UnexpectedHTTPStatusError{Status: resp.Status}
-}
-
-// SuccessStatus returns true if the argument is a successful HTTP response
-// code (in the range 200 - 399 inclusive).
-func SuccessStatus(status int) bool {
-	return status >= 200 && status <= 399
-}

vendor/github.com/docker/distribution/registry/client/repository.go

@@ -1,828 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"strconv"
-	"time"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/distribution/registry/api/v2"
-	"github.com/docker/distribution/registry/client/transport"
-	"github.com/docker/distribution/registry/storage/cache"
-	"github.com/docker/distribution/registry/storage/cache/memory"
-)
-
-// Registry provides an interface for calling Repositories, which returns a catalog of repositories.
-type Registry interface {
-	Repositories(ctx context.Context, repos []string, last string) (n int, err error)
-}
-
-// checkHTTPRedirect is a callback that can manipulate redirected HTTP
-// requests. It is used to preserve Accept and Range headers.
-func checkHTTPRedirect(req *http.Request, via []*http.Request) error {
-	if len(via) >= 10 {
-		return errors.New("stopped after 10 redirects")
-	}
-
-	if len(via) > 0 {
-		for headerName, headerVals := range via[0].Header {
-			if headerName != "Accept" && headerName != "Range" {
-				continue
-			}
-			for _, val := range headerVals {
-				// Don't add to redirected request if redirected
-				// request already has a header with the same
-				// name and value.
-				hasValue := false
-				for _, existingVal := range req.Header[headerName] {
-					if existingVal == val {
-						hasValue = true
-						break
-					}
-				}
-				if !hasValue {
-					req.Header.Add(headerName, val)
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-// NewRegistry creates a registry namespace which can be used to get a listing of repositories
-func NewRegistry(ctx context.Context, baseURL string, transport http.RoundTripper) (Registry, error) {
-	ub, err := v2.NewURLBuilderFromString(baseURL)
-	if err != nil {
-		return nil, err
-	}
-
-	client := &http.Client{
-		Transport:     transport,
-		Timeout:       1 * time.Minute,
-		CheckRedirect: checkHTTPRedirect,
-	}
-
-	return &registry{
-		client:  client,
-		ub:      ub,
-		context: ctx,
-	}, nil
-}
-
-type registry struct {
-	client  *http.Client
-	ub      *v2.URLBuilder
-	context context.Context
-}
-
-// Repositories returns a lexigraphically sorted catalog given a base URL.  The 'entries' slice will be filled up to the size
-// of the slice, starting at the value provided in 'last'.  The number of entries will be returned along with io.EOF if there
-// are no more entries
-func (r *registry) Repositories(ctx context.Context, entries []string, last string) (int, error) {
-	var numFilled int
-	var returnErr error
-
-	values := buildCatalogValues(len(entries), last)
-	u, err := r.ub.BuildCatalogURL(values)
-	if err != nil {
-		return 0, err
-	}
-
-	resp, err := r.client.Get(u)
-	if err != nil {
-		return 0, err
-	}
-	defer resp.Body.Close()
-
-	if SuccessStatus(resp.StatusCode) {
-		var ctlg struct {
-			Repositories []string `json:"repositories"`
-		}
-		decoder := json.NewDecoder(resp.Body)
-
-		if err := decoder.Decode(&ctlg); err != nil {
-			return 0, err
-		}
-
-		for cnt := range ctlg.Repositories {
-			entries[cnt] = ctlg.Repositories[cnt]
-		}
-		numFilled = len(ctlg.Repositories)
-
-		link := resp.Header.Get("Link")
-		if link == "" {
-			returnErr = io.EOF
-		}
-	} else {
-		return 0, HandleErrorResponse(resp)
-	}
-
-	return numFilled, returnErr
-}
-
-// NewRepository creates a new Repository for the given repository name and base URL.
-func NewRepository(ctx context.Context, name reference.Named, baseURL string, transport http.RoundTripper) (distribution.Repository, error) {
-	ub, err := v2.NewURLBuilderFromString(baseURL)
-	if err != nil {
-		return nil, err
-	}
-
-	client := &http.Client{
-		Transport:     transport,
-		CheckRedirect: checkHTTPRedirect,
-		// TODO(dmcgowan): create cookie jar
-	}
-
-	return &repository{
-		client:  client,
-		ub:      ub,
-		name:    name,
-		context: ctx,
-	}, nil
-}
-
-type repository struct {
-	client  *http.Client
-	ub      *v2.URLBuilder
-	context context.Context
-	name    reference.Named
-}
-
-func (r *repository) Named() reference.Named {
-	return r.name
-}
-
-func (r *repository) Blobs(ctx context.Context) distribution.BlobStore {
-	statter := &blobStatter{
-		name:   r.name,
-		ub:     r.ub,
-		client: r.client,
-	}
-	return &blobs{
-		name:    r.name,
-		ub:      r.ub,
-		client:  r.client,
-		statter: cache.NewCachedBlobStatter(memory.NewInMemoryBlobDescriptorCacheProvider(), statter),
-	}
-}
-
-func (r *repository) Manifests(ctx context.Context, options ...distribution.ManifestServiceOption) (distribution.ManifestService, error) {
-	// todo(richardscothern): options should be sent over the wire
-	return &manifests{
-		name:   r.name,
-		ub:     r.ub,
-		client: r.client,
-		etags:  make(map[string]string),
-	}, nil
-}
-
-func (r *repository) Tags(ctx context.Context) distribution.TagService {
-	return &tags{
-		client:  r.client,
-		ub:      r.ub,
-		context: r.context,
-		name:    r.Named(),
-	}
-}
-
-// tags implements remote tagging operations.
-type tags struct {
-	client  *http.Client
-	ub      *v2.URLBuilder
-	context context.Context
-	name    reference.Named
-}
-
-// All returns all tags
-func (t *tags) All(ctx context.Context) ([]string, error) {
-	var tags []string
-
-	u, err := t.ub.BuildTagsURL(t.name)
-	if err != nil {
-		return tags, err
-	}
-
-	resp, err := t.client.Get(u)
-	if err != nil {
-		return tags, err
-	}
-	defer resp.Body.Close()
-
-	if SuccessStatus(resp.StatusCode) {
-		b, err := ioutil.ReadAll(resp.Body)
-		if err != nil {
-			return tags, err
-		}
-
-		tagsResponse := struct {
-			Tags []string `json:"tags"`
-		}{}
-		if err := json.Unmarshal(b, &tagsResponse); err != nil {
-			return tags, err
-		}
-		tags = tagsResponse.Tags
-		return tags, nil
-	}
-	return tags, HandleErrorResponse(resp)
-}
-
-func descriptorFromResponse(response *http.Response) (distribution.Descriptor, error) {
-	desc := distribution.Descriptor{}
-	headers := response.Header
-
-	ctHeader := headers.Get("Content-Type")
-	if ctHeader == "" {
-		return distribution.Descriptor{}, errors.New("missing or empty Content-Type header")
-	}
-	desc.MediaType = ctHeader
-
-	digestHeader := headers.Get("Docker-Content-Digest")
-	if digestHeader == "" {
-		bytes, err := ioutil.ReadAll(response.Body)
-		if err != nil {
-			return distribution.Descriptor{}, err
-		}
-		_, desc, err := distribution.UnmarshalManifest(ctHeader, bytes)
-		if err != nil {
-			return distribution.Descriptor{}, err
-		}
-		return desc, nil
-	}
-
-	dgst, err := digest.ParseDigest(digestHeader)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	desc.Digest = dgst
-
-	lengthHeader := headers.Get("Content-Length")
-	if lengthHeader == "" {
-		return distribution.Descriptor{}, errors.New("missing or empty Content-Length header")
-	}
-	length, err := strconv.ParseInt(lengthHeader, 10, 64)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	desc.Size = length
-
-	return desc, nil
-
-}
-
-// Get issues a HEAD request for a Manifest against its named endpoint in order
-// to construct a descriptor for the tag.  If the registry doesn't support HEADing
-// a manifest, fallback to GET.
-func (t *tags) Get(ctx context.Context, tag string) (distribution.Descriptor, error) {
-	ref, err := reference.WithTag(t.name, tag)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	u, err := t.ub.BuildManifestURL(ref)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	var attempts int
-	resp, err := t.client.Head(u)
-
-check:
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-
-	switch {
-	case resp.StatusCode >= 200 && resp.StatusCode < 400:
-		return descriptorFromResponse(resp)
-	case resp.StatusCode == http.StatusMethodNotAllowed:
-		resp, err = t.client.Get(u)
-		attempts++
-		if attempts > 1 {
-			return distribution.Descriptor{}, err
-		}
-		goto check
-	default:
-		return distribution.Descriptor{}, HandleErrorResponse(resp)
-	}
-}
-
-func (t *tags) Lookup(ctx context.Context, digest distribution.Descriptor) ([]string, error) {
-	panic("not implemented")
-}
-
-func (t *tags) Tag(ctx context.Context, tag string, desc distribution.Descriptor) error {
-	panic("not implemented")
-}
-
-func (t *tags) Untag(ctx context.Context, tag string) error {
-	panic("not implemented")
-}
-
-type manifests struct {
-	name   reference.Named
-	ub     *v2.URLBuilder
-	client *http.Client
-	etags  map[string]string
-}
-
-func (ms *manifests) Exists(ctx context.Context, dgst digest.Digest) (bool, error) {
-	ref, err := reference.WithDigest(ms.name, dgst)
-	if err != nil {
-		return false, err
-	}
-	u, err := ms.ub.BuildManifestURL(ref)
-	if err != nil {
-		return false, err
-	}
-
-	resp, err := ms.client.Head(u)
-	if err != nil {
-		return false, err
-	}
-
-	if SuccessStatus(resp.StatusCode) {
-		return true, nil
-	} else if resp.StatusCode == http.StatusNotFound {
-		return false, nil
-	}
-	return false, HandleErrorResponse(resp)
-}
-
-// AddEtagToTag allows a client to supply an eTag to Get which will be
-// used for a conditional HTTP request.  If the eTag matches, a nil manifest
-// and ErrManifestNotModified error will be returned. etag is automatically
-// quoted when added to this map.
-func AddEtagToTag(tag, etag string) distribution.ManifestServiceOption {
-	return etagOption{tag, etag}
-}
-
-type etagOption struct{ tag, etag string }
-
-func (o etagOption) Apply(ms distribution.ManifestService) error {
-	if ms, ok := ms.(*manifests); ok {
-		ms.etags[o.tag] = fmt.Sprintf(`"%s"`, o.etag)
-		return nil
-	}
-	return fmt.Errorf("etag options is a client-only option")
-}
-
-func (ms *manifests) Get(ctx context.Context, dgst digest.Digest, options ...distribution.ManifestServiceOption) (distribution.Manifest, error) {
-	var (
-		digestOrTag string
-		ref         reference.Named
-		err         error
-	)
-
-	for _, option := range options {
-		if opt, ok := option.(withTagOption); ok {
-			digestOrTag = opt.tag
-			ref, err = reference.WithTag(ms.name, opt.tag)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			err := option.Apply(ms)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	if digestOrTag == "" {
-		digestOrTag = dgst.String()
-		ref, err = reference.WithDigest(ms.name, dgst)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	u, err := ms.ub.BuildManifestURL(ref)
-	if err != nil {
-		return nil, err
-	}
-
-	req, err := http.NewRequest("GET", u, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, t := range distribution.ManifestMediaTypes() {
-		req.Header.Add("Accept", t)
-	}
-
-	if _, ok := ms.etags[digestOrTag]; ok {
-		req.Header.Set("If-None-Match", ms.etags[digestOrTag])
-	}
-
-	resp, err := ms.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode == http.StatusNotModified {
-		return nil, distribution.ErrManifestNotModified
-	} else if SuccessStatus(resp.StatusCode) {
-		mt := resp.Header.Get("Content-Type")
-		body, err := ioutil.ReadAll(resp.Body)
-
-		if err != nil {
-			return nil, err
-		}
-		m, _, err := distribution.UnmarshalManifest(mt, body)
-		if err != nil {
-			return nil, err
-		}
-		return m, nil
-	}
-	return nil, HandleErrorResponse(resp)
-}
-
-// WithTag allows a tag to be passed into Put which enables the client
-// to build a correct URL.
-func WithTag(tag string) distribution.ManifestServiceOption {
-	return withTagOption{tag}
-}
-
-type withTagOption struct{ tag string }
-
-func (o withTagOption) Apply(m distribution.ManifestService) error {
-	if _, ok := m.(*manifests); ok {
-		return nil
-	}
-	return fmt.Errorf("withTagOption is a client-only option")
-}
-
-// Put puts a manifest.  A tag can be specified using an options parameter which uses some shared state to hold the
-// tag name in order to build the correct upload URL.
-func (ms *manifests) Put(ctx context.Context, m distribution.Manifest, options ...distribution.ManifestServiceOption) (digest.Digest, error) {
-	ref := ms.name
-	var tagged bool
-
-	for _, option := range options {
-		if opt, ok := option.(withTagOption); ok {
-			var err error
-			ref, err = reference.WithTag(ref, opt.tag)
-			if err != nil {
-				return "", err
-			}
-			tagged = true
-		} else {
-			err := option.Apply(ms)
-			if err != nil {
-				return "", err
-			}
-		}
-	}
-	mediaType, p, err := m.Payload()
-	if err != nil {
-		return "", err
-	}
-
-	if !tagged {
-		// generate a canonical digest and Put by digest
-		_, d, err := distribution.UnmarshalManifest(mediaType, p)
-		if err != nil {
-			return "", err
-		}
-		ref, err = reference.WithDigest(ref, d.Digest)
-		if err != nil {
-			return "", err
-		}
-	}
-
-	manifestURL, err := ms.ub.BuildManifestURL(ref)
-	if err != nil {
-		return "", err
-	}
-
-	putRequest, err := http.NewRequest("PUT", manifestURL, bytes.NewReader(p))
-	if err != nil {
-		return "", err
-	}
-
-	putRequest.Header.Set("Content-Type", mediaType)
-
-	resp, err := ms.client.Do(putRequest)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if SuccessStatus(resp.StatusCode) {
-		dgstHeader := resp.Header.Get("Docker-Content-Digest")
-		dgst, err := digest.ParseDigest(dgstHeader)
-		if err != nil {
-			return "", err
-		}
-
-		return dgst, nil
-	}
-
-	return "", HandleErrorResponse(resp)
-}
-
-func (ms *manifests) Delete(ctx context.Context, dgst digest.Digest) error {
-	ref, err := reference.WithDigest(ms.name, dgst)
-	if err != nil {
-		return err
-	}
-	u, err := ms.ub.BuildManifestURL(ref)
-	if err != nil {
-		return err
-	}
-	req, err := http.NewRequest("DELETE", u, nil)
-	if err != nil {
-		return err
-	}
-
-	resp, err := ms.client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if SuccessStatus(resp.StatusCode) {
-		return nil
-	}
-	return HandleErrorResponse(resp)
-}
-
-// todo(richardscothern): Restore interface and implementation with merge of #1050
-/*func (ms *manifests) Enumerate(ctx context.Context, manifests []distribution.Manifest, last distribution.Manifest) (n int, err error) {
-	panic("not supported")
-}*/
-
-type blobs struct {
-	name   reference.Named
-	ub     *v2.URLBuilder
-	client *http.Client
-
-	statter distribution.BlobDescriptorService
-	distribution.BlobDeleter
-}
-
-func sanitizeLocation(location, base string) (string, error) {
-	baseURL, err := url.Parse(base)
-	if err != nil {
-		return "", err
-	}
-
-	locationURL, err := url.Parse(location)
-	if err != nil {
-		return "", err
-	}
-
-	return baseURL.ResolveReference(locationURL).String(), nil
-}
-
-func (bs *blobs) Stat(ctx context.Context, dgst digest.Digest) (distribution.Descriptor, error) {
-	return bs.statter.Stat(ctx, dgst)
-
-}
-
-func (bs *blobs) Get(ctx context.Context, dgst digest.Digest) ([]byte, error) {
-	reader, err := bs.Open(ctx, dgst)
-	if err != nil {
-		return nil, err
-	}
-	defer reader.Close()
-
-	return ioutil.ReadAll(reader)
-}
-
-func (bs *blobs) Open(ctx context.Context, dgst digest.Digest) (distribution.ReadSeekCloser, error) {
-	ref, err := reference.WithDigest(bs.name, dgst)
-	if err != nil {
-		return nil, err
-	}
-	blobURL, err := bs.ub.BuildBlobURL(ref)
-	if err != nil {
-		return nil, err
-	}
-
-	return transport.NewHTTPReadSeeker(bs.client, blobURL,
-		func(resp *http.Response) error {
-			if resp.StatusCode == http.StatusNotFound {
-				return distribution.ErrBlobUnknown
-			}
-			return HandleErrorResponse(resp)
-		}), nil
-}
-
-func (bs *blobs) ServeBlob(ctx context.Context, w http.ResponseWriter, r *http.Request, dgst digest.Digest) error {
-	panic("not implemented")
-}
-
-func (bs *blobs) Put(ctx context.Context, mediaType string, p []byte) (distribution.Descriptor, error) {
-	writer, err := bs.Create(ctx)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	dgstr := digest.Canonical.New()
-	n, err := io.Copy(writer, io.TeeReader(bytes.NewReader(p), dgstr.Hash()))
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	if n < int64(len(p)) {
-		return distribution.Descriptor{}, fmt.Errorf("short copy: wrote %d of %d", n, len(p))
-	}
-
-	desc := distribution.Descriptor{
-		MediaType: mediaType,
-		Size:      int64(len(p)),
-		Digest:    dgstr.Digest(),
-	}
-
-	return writer.Commit(ctx, desc)
-}
-
-// createOptions is a collection of blob creation modifiers relevant to general
-// blob storage intended to be configured by the BlobCreateOption.Apply method.
-type createOptions struct {
-	Mount struct {
-		ShouldMount bool
-		From        reference.Canonical
-	}
-}
-
-type optionFunc func(interface{}) error
-
-func (f optionFunc) Apply(v interface{}) error {
-	return f(v)
-}
-
-// WithMountFrom returns a BlobCreateOption which designates that the blob should be
-// mounted from the given canonical reference.
-func WithMountFrom(ref reference.Canonical) distribution.BlobCreateOption {
-	return optionFunc(func(v interface{}) error {
-		opts, ok := v.(*createOptions)
-		if !ok {
-			return fmt.Errorf("unexpected options type: %T", v)
-		}
-
-		opts.Mount.ShouldMount = true
-		opts.Mount.From = ref
-
-		return nil
-	})
-}
-
-func (bs *blobs) Create(ctx context.Context, options ...distribution.BlobCreateOption) (distribution.BlobWriter, error) {
-	var opts createOptions
-
-	for _, option := range options {
-		err := option.Apply(&opts)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	var values []url.Values
-
-	if opts.Mount.ShouldMount {
-		values = append(values, url.Values{"from": {opts.Mount.From.Name()}, "mount": {opts.Mount.From.Digest().String()}})
-	}
-
-	u, err := bs.ub.BuildBlobUploadURL(bs.name, values...)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := bs.client.Post(u, "", nil)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	switch resp.StatusCode {
-	case http.StatusCreated:
-		desc, err := bs.statter.Stat(ctx, opts.Mount.From.Digest())
-		if err != nil {
-			return nil, err
-		}
-		return nil, distribution.ErrBlobMounted{From: opts.Mount.From, Descriptor: desc}
-	case http.StatusAccepted:
-		// TODO(dmcgowan): Check for invalid UUID
-		uuid := resp.Header.Get("Docker-Upload-UUID")
-		location, err := sanitizeLocation(resp.Header.Get("Location"), u)
-		if err != nil {
-			return nil, err
-		}
-
-		return &httpBlobUpload{
-			statter:   bs.statter,
-			client:    bs.client,
-			uuid:      uuid,
-			startedAt: time.Now(),
-			location:  location,
-		}, nil
-	default:
-		return nil, HandleErrorResponse(resp)
-	}
-}
-
-func (bs *blobs) Resume(ctx context.Context, id string) (distribution.BlobWriter, error) {
-	panic("not implemented")
-}
-
-func (bs *blobs) Delete(ctx context.Context, dgst digest.Digest) error {
-	return bs.statter.Clear(ctx, dgst)
-}
-
-type blobStatter struct {
-	name   reference.Named
-	ub     *v2.URLBuilder
-	client *http.Client
-}
-
-func (bs *blobStatter) Stat(ctx context.Context, dgst digest.Digest) (distribution.Descriptor, error) {
-	ref, err := reference.WithDigest(bs.name, dgst)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	u, err := bs.ub.BuildBlobURL(ref)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-
-	resp, err := bs.client.Head(u)
-	if err != nil {
-		return distribution.Descriptor{}, err
-	}
-	defer resp.Body.Close()
-
-	if SuccessStatus(resp.StatusCode) {
-		lengthHeader := resp.Header.Get("Content-Length")
-		if lengthHeader == "" {
-			return distribution.Descriptor{}, fmt.Errorf("missing content-length header for request: %s", u)
-		}
-
-		length, err := strconv.ParseInt(lengthHeader, 10, 64)
-		if err != nil {
-			return distribution.Descriptor{}, fmt.Errorf("error parsing content-length: %v", err)
-		}
-
-		return distribution.Descriptor{
-			MediaType: resp.Header.Get("Content-Type"),
-			Size:      length,
-			Digest:    dgst,
-		}, nil
-	} else if resp.StatusCode == http.StatusNotFound {
-		return distribution.Descriptor{}, distribution.ErrBlobUnknown
-	}
-	return distribution.Descriptor{}, HandleErrorResponse(resp)
-}
-
-func buildCatalogValues(maxEntries int, last string) url.Values {
-	values := url.Values{}
-
-	if maxEntries > 0 {
-		values.Add("n", strconv.Itoa(maxEntries))
-	}
-
-	if last != "" {
-		values.Add("last", last)
-	}
-
-	return values
-}
-
-func (bs *blobStatter) Clear(ctx context.Context, dgst digest.Digest) error {
-	ref, err := reference.WithDigest(bs.name, dgst)
-	if err != nil {
-		return err
-	}
-	blobURL, err := bs.ub.BuildBlobURL(ref)
-	if err != nil {
-		return err
-	}
-
-	req, err := http.NewRequest("DELETE", blobURL, nil)
-	if err != nil {
-		return err
-	}
-
-	resp, err := bs.client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if SuccessStatus(resp.StatusCode) {
-		return nil
-	}
-	return HandleErrorResponse(resp)
-}
-
-func (bs *blobStatter) SetDescriptor(ctx context.Context, dgst digest.Digest, desc distribution.Descriptor) error {
-	return nil
-}

vendor/github.com/docker/distribution/registry/client/transport/http_reader.go

@@ -1,250 +0,0 @@
-package transport
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"regexp"
-	"strconv"
-)
-
-var (
-	contentRangeRegexp = regexp.MustCompile(`bytes ([0-9]+)-([0-9]+)/([0-9]+|\\*)`)
-
-	// ErrWrongCodeForByteRange is returned if the client sends a request
-	// with a Range header but the server returns a 2xx or 3xx code other
-	// than 206 Partial Content.
-	ErrWrongCodeForByteRange = errors.New("expected HTTP 206 from byte range request")
-)
-
-// ReadSeekCloser combines io.ReadSeeker with io.Closer.
-type ReadSeekCloser interface {
-	io.ReadSeeker
-	io.Closer
-}
-
-// NewHTTPReadSeeker handles reading from an HTTP endpoint using a GET
-// request. When seeking and starting a read from a non-zero offset
-// the a "Range" header will be added which sets the offset.
-// TODO(dmcgowan): Move this into a separate utility package
-func NewHTTPReadSeeker(client *http.Client, url string, errorHandler func(*http.Response) error) ReadSeekCloser {
-	return &httpReadSeeker{
-		client:       client,
-		url:          url,
-		errorHandler: errorHandler,
-	}
-}
-
-type httpReadSeeker struct {
-	client *http.Client
-	url    string
-
-	// errorHandler creates an error from an unsuccessful HTTP response.
-	// This allows the error to be created with the HTTP response body
-	// without leaking the body through a returned error.
-	errorHandler func(*http.Response) error
-
-	size int64
-
-	// rc is the remote read closer.
-	rc io.ReadCloser
-	// readerOffset tracks the offset as of the last read.
-	readerOffset int64
-	// seekOffset allows Seek to override the offset. Seek changes
-	// seekOffset instead of changing readOffset directly so that
-	// connection resets can be delayed and possibly avoided if the
-	// seek is undone (i.e. seeking to the end and then back to the
-	// beginning).
-	seekOffset int64
-	err        error
-}
-
-func (hrs *httpReadSeeker) Read(p []byte) (n int, err error) {
-	if hrs.err != nil {
-		return 0, hrs.err
-	}
-
-	// If we seeked to a different position, we need to reset the
-	// connection. This logic is here instead of Seek so that if
-	// a seek is undone before the next read, the connection doesn't
-	// need to be closed and reopened. A common example of this is
-	// seeking to the end to determine the length, and then seeking
-	// back to the original position.
-	if hrs.readerOffset != hrs.seekOffset {
-		hrs.reset()
-	}
-
-	hrs.readerOffset = hrs.seekOffset
-
-	rd, err := hrs.reader()
-	if err != nil {
-		return 0, err
-	}
-
-	n, err = rd.Read(p)
-	hrs.seekOffset += int64(n)
-	hrs.readerOffset += int64(n)
-
-	return n, err
-}
-
-func (hrs *httpReadSeeker) Seek(offset int64, whence int) (int64, error) {
-	if hrs.err != nil {
-		return 0, hrs.err
-	}
-
-	lastReaderOffset := hrs.readerOffset
-
-	if whence == os.SEEK_SET && hrs.rc == nil {
-		// If no request has been made yet, and we are seeking to an
-		// absolute position, set the read offset as well to avoid an
-		// unnecessary request.
-		hrs.readerOffset = offset
-	}
-
-	_, err := hrs.reader()
-	if err != nil {
-		hrs.readerOffset = lastReaderOffset
-		return 0, err
-	}
-
-	newOffset := hrs.seekOffset
-
-	switch whence {
-	case os.SEEK_CUR:
-		newOffset += offset
-	case os.SEEK_END:
-		if hrs.size < 0 {
-			return 0, errors.New("content length not known")
-		}
-		newOffset = hrs.size + offset
-	case os.SEEK_SET:
-		newOffset = offset
-	}
-
-	if newOffset < 0 {
-		err = errors.New("cannot seek to negative position")
-	} else {
-		hrs.seekOffset = newOffset
-	}
-
-	return hrs.seekOffset, err
-}
-
-func (hrs *httpReadSeeker) Close() error {
-	if hrs.err != nil {
-		return hrs.err
-	}
-
-	// close and release reader chain
-	if hrs.rc != nil {
-		hrs.rc.Close()
-	}
-
-	hrs.rc = nil
-
-	hrs.err = errors.New("httpLayer: closed")
-
-	return nil
-}
-
-func (hrs *httpReadSeeker) reset() {
-	if hrs.err != nil {
-		return
-	}
-	if hrs.rc != nil {
-		hrs.rc.Close()
-		hrs.rc = nil
-	}
-}
-
-func (hrs *httpReadSeeker) reader() (io.Reader, error) {
-	if hrs.err != nil {
-		return nil, hrs.err
-	}
-
-	if hrs.rc != nil {
-		return hrs.rc, nil
-	}
-
-	req, err := http.NewRequest("GET", hrs.url, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	if hrs.readerOffset > 0 {
-		// If we are at different offset, issue a range request from there.
-		req.Header.Add("Range", fmt.Sprintf("bytes=%d-", hrs.readerOffset))
-		// TODO: get context in here
-		// context.GetLogger(hrs.context).Infof("Range: %s", req.Header.Get("Range"))
-	}
-
-	resp, err := hrs.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	// Normally would use client.SuccessStatus, but that would be a cyclic
-	// import
-	if resp.StatusCode >= 200 && resp.StatusCode <= 399 {
-		if hrs.readerOffset > 0 {
-			if resp.StatusCode != http.StatusPartialContent {
-				return nil, ErrWrongCodeForByteRange
-			}
-
-			contentRange := resp.Header.Get("Content-Range")
-			if contentRange == "" {
-				return nil, errors.New("no Content-Range header found in HTTP 206 response")
-			}
-
-			submatches := contentRangeRegexp.FindStringSubmatch(contentRange)
-			if len(submatches) < 4 {
-				return nil, fmt.Errorf("could not parse Content-Range header: %s", contentRange)
-			}
-
-			startByte, err := strconv.ParseUint(submatches[1], 10, 64)
-			if err != nil {
-				return nil, fmt.Errorf("could not parse start of range in Content-Range header: %s", contentRange)
-			}
-
-			if startByte != uint64(hrs.readerOffset) {
-				return nil, fmt.Errorf("received Content-Range starting at offset %d instead of requested %d", startByte, hrs.readerOffset)
-			}
-
-			endByte, err := strconv.ParseUint(submatches[2], 10, 64)
-			if err != nil {
-				return nil, fmt.Errorf("could not parse end of range in Content-Range header: %s", contentRange)
-			}
-
-			if submatches[3] == "*" {
-				hrs.size = -1
-			} else {
-				size, err := strconv.ParseUint(submatches[3], 10, 64)
-				if err != nil {
-					return nil, fmt.Errorf("could not parse total size in Content-Range header: %s", contentRange)
-				}
-
-				if endByte+1 != size {
-					return nil, fmt.Errorf("range in Content-Range stops before the end of the content: %s", contentRange)
-				}
-
-				hrs.size = int64(size)
-			}
-		} else if resp.StatusCode == http.StatusOK {
-			hrs.size = resp.ContentLength
-		} else {
-			hrs.size = -1
-		}
-		hrs.rc = resp.Body
-	} else {
-		defer resp.Body.Close()
-		if hrs.errorHandler != nil {
-			return nil, hrs.errorHandler(resp)
-		}
-		return nil, fmt.Errorf("unexpected status resolving reader: %v", resp.Status)
-	}
-
-	return hrs.rc, nil
-}

vendor/github.com/docker/distribution/registry/client/transport/transport.go

@@ -1,147 +0,0 @@
-package transport
-
-import (
-	"io"
-	"net/http"
-	"sync"
-)
-
-// RequestModifier represents an object which will do an inplace
-// modification of an HTTP request.
-type RequestModifier interface {
-	ModifyRequest(*http.Request) error
-}
-
-type headerModifier http.Header
-
-// NewHeaderRequestModifier returns a new RequestModifier which will
-// add the given headers to a request.
-func NewHeaderRequestModifier(header http.Header) RequestModifier {
-	return headerModifier(header)
-}
-
-func (h headerModifier) ModifyRequest(req *http.Request) error {
-	for k, s := range http.Header(h) {
-		req.Header[k] = append(req.Header[k], s...)
-	}
-
-	return nil
-}
-
-// NewTransport creates a new transport which will apply modifiers to
-// the request on a RoundTrip call.
-func NewTransport(base http.RoundTripper, modifiers ...RequestModifier) http.RoundTripper {
-	return &transport{
-		Modifiers: modifiers,
-		Base:      base,
-	}
-}
-
-// transport is an http.RoundTripper that makes HTTP requests after
-// copying and modifying the request
-type transport struct {
-	Modifiers []RequestModifier
-	Base      http.RoundTripper
-
-	mu     sync.Mutex                      // guards modReq
-	modReq map[*http.Request]*http.Request // original -> modified
-}
-
-// RoundTrip authorizes and authenticates the request with an
-// access token. If no token exists or token is expired,
-// tries to refresh/fetch a new token.
-func (t *transport) RoundTrip(req *http.Request) (*http.Response, error) {
-	req2 := cloneRequest(req)
-	for _, modifier := range t.Modifiers {
-		if err := modifier.ModifyRequest(req2); err != nil {
-			return nil, err
-		}
-	}
-
-	t.setModReq(req, req2)
-	res, err := t.base().RoundTrip(req2)
-	if err != nil {
-		t.setModReq(req, nil)
-		return nil, err
-	}
-	res.Body = &onEOFReader{
-		rc: res.Body,
-		fn: func() { t.setModReq(req, nil) },
-	}
-	return res, nil
-}
-
-// CancelRequest cancels an in-flight request by closing its connection.
-func (t *transport) CancelRequest(req *http.Request) {
-	type canceler interface {
-		CancelRequest(*http.Request)
-	}
-	if cr, ok := t.base().(canceler); ok {
-		t.mu.Lock()
-		modReq := t.modReq[req]
-		delete(t.modReq, req)
-		t.mu.Unlock()
-		cr.CancelRequest(modReq)
-	}
-}
-
-func (t *transport) base() http.RoundTripper {
-	if t.Base != nil {
-		return t.Base
-	}
-	return http.DefaultTransport
-}
-
-func (t *transport) setModReq(orig, mod *http.Request) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	if t.modReq == nil {
-		t.modReq = make(map[*http.Request]*http.Request)
-	}
-	if mod == nil {
-		delete(t.modReq, orig)
-	} else {
-		t.modReq[orig] = mod
-	}
-}
-
-// cloneRequest returns a clone of the provided *http.Request.
-// The clone is a shallow copy of the struct and its Header map.
-func cloneRequest(r *http.Request) *http.Request {
-	// shallow copy of the struct
-	r2 := new(http.Request)
-	*r2 = *r
-	// deep copy of the Header
-	r2.Header = make(http.Header, len(r.Header))
-	for k, s := range r.Header {
-		r2.Header[k] = append([]string(nil), s...)
-	}
-
-	return r2
-}
-
-type onEOFReader struct {
-	rc io.ReadCloser
-	fn func()
-}
-
-func (r *onEOFReader) Read(p []byte) (n int, err error) {
-	n, err = r.rc.Read(p)
-	if err == io.EOF {
-		r.runFunc()
-	}
-	return
-}
-
-func (r *onEOFReader) Close() error {
-	err := r.rc.Close()
-	r.runFunc()
-	return err
-}
-
-func (r *onEOFReader) runFunc() {
-	if fn := r.fn; fn != nil {
-		fn()
-		r.fn = nil
-	}
-}

vendor/github.com/docker/distribution/registry/storage/cache/cache.go

@@ -1,35 +0,0 @@
-// Package cache provides facilities to speed up access to the storage
-// backend.
-package cache
-
-import (
-	"fmt"
-
-	"github.com/docker/distribution"
-)
-
-// BlobDescriptorCacheProvider provides repository scoped
-// BlobDescriptorService cache instances and a global descriptor cache.
-type BlobDescriptorCacheProvider interface {
-	distribution.BlobDescriptorService
-
-	RepositoryScoped(repo string) (distribution.BlobDescriptorService, error)
-}
-
-// ValidateDescriptor provides a helper function to ensure that caches have
-// common criteria for admitting descriptors.
-func ValidateDescriptor(desc distribution.Descriptor) error {
-	if err := desc.Digest.Validate(); err != nil {
-		return err
-	}
-
-	if desc.Size < 0 {
-		return fmt.Errorf("cache: invalid length in descriptor: %v < 0", desc.Size)
-	}
-
-	if desc.MediaType == "" {
-		return fmt.Errorf("cache: empty mediatype on descriptor: %v", desc)
-	}
-
-	return nil
-}

vendor/github.com/docker/distribution/registry/storage/cache/cachedblobdescriptorstore.go

@@ -1,101 +0,0 @@
-package cache
-
-import (
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/digest"
-
-	"github.com/docker/distribution"
-)
-
-// Metrics is used to hold metric counters
-// related to the number of times a cache was
-// hit or missed.
-type Metrics struct {
-	Requests uint64
-	Hits     uint64
-	Misses   uint64
-}
-
-// MetricsTracker represents a metric tracker
-// which simply counts the number of hits and misses.
-type MetricsTracker interface {
-	Hit()
-	Miss()
-	Metrics() Metrics
-}
-
-type cachedBlobStatter struct {
-	cache   distribution.BlobDescriptorService
-	backend distribution.BlobDescriptorService
-	tracker MetricsTracker
-}
-
-// NewCachedBlobStatter creates a new statter which prefers a cache and
-// falls back to a backend.
-func NewCachedBlobStatter(cache distribution.BlobDescriptorService, backend distribution.BlobDescriptorService) distribution.BlobDescriptorService {
-	return &cachedBlobStatter{
-		cache:   cache,
-		backend: backend,
-	}
-}
-
-// NewCachedBlobStatterWithMetrics creates a new statter which prefers a cache and
-// falls back to a backend. Hits and misses will send to the tracker.
-func NewCachedBlobStatterWithMetrics(cache distribution.BlobDescriptorService, backend distribution.BlobDescriptorService, tracker MetricsTracker) distribution.BlobStatter {
-	return &cachedBlobStatter{
-		cache:   cache,
-		backend: backend,
-		tracker: tracker,
-	}
-}
-
-func (cbds *cachedBlobStatter) Stat(ctx context.Context, dgst digest.Digest) (distribution.Descriptor, error) {
-	desc, err := cbds.cache.Stat(ctx, dgst)
-	if err != nil {
-		if err != distribution.ErrBlobUnknown {
-			context.GetLogger(ctx).Errorf("error retrieving descriptor from cache: %v", err)
-		}
-
-		goto fallback
-	}
-
-	if cbds.tracker != nil {
-		cbds.tracker.Hit()
-	}
-	return desc, nil
-fallback:
-	if cbds.tracker != nil {
-		cbds.tracker.Miss()
-	}
-	desc, err = cbds.backend.Stat(ctx, dgst)
-	if err != nil {
-		return desc, err
-	}
-
-	if err := cbds.cache.SetDescriptor(ctx, dgst, desc); err != nil {
-		context.GetLogger(ctx).Errorf("error adding descriptor %v to cache: %v", desc.Digest, err)
-	}
-
-	return desc, err
-
-}
-
-func (cbds *cachedBlobStatter) Clear(ctx context.Context, dgst digest.Digest) error {
-	err := cbds.cache.Clear(ctx, dgst)
-	if err != nil {
-		return err
-	}
-
-	err = cbds.backend.Clear(ctx, dgst)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (cbds *cachedBlobStatter) SetDescriptor(ctx context.Context, dgst digest.Digest, desc distribution.Descriptor) error {
-	if err := cbds.cache.SetDescriptor(ctx, dgst, desc); err != nil {
-		context.GetLogger(ctx).Errorf("error adding descriptor %v to cache: %v", desc.Digest, err)
-	}
-	return nil
-}

vendor/github.com/docker/distribution/registry/storage/cache/memory/memory.go

@@ -1,170 +0,0 @@
-package memory
-
-import (
-	"sync"
-
-	"github.com/docker/distribution"
-	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/reference"
-	"github.com/docker/distribution/registry/storage/cache"
-)
-
-type inMemoryBlobDescriptorCacheProvider struct {
-	global       *mapBlobDescriptorCache
-	repositories map[string]*mapBlobDescriptorCache
-	mu           sync.RWMutex
-}
-
-// NewInMemoryBlobDescriptorCacheProvider returns a new mapped-based cache for
-// storing blob descriptor data.
-func NewInMemoryBlobDescriptorCacheProvider() cache.BlobDescriptorCacheProvider {
-	return &inMemoryBlobDescriptorCacheProvider{
-		global:       newMapBlobDescriptorCache(),
-		repositories: make(map[string]*mapBlobDescriptorCache),
-	}
-}
-
-func (imbdcp *inMemoryBlobDescriptorCacheProvider) RepositoryScoped(repo string) (distribution.BlobDescriptorService, error) {
-	if _, err := reference.ParseNamed(repo); err != nil {
-		return nil, err
-	}
-
-	imbdcp.mu.RLock()
-	defer imbdcp.mu.RUnlock()
-
-	return &repositoryScopedInMemoryBlobDescriptorCache{
-		repo:       repo,
-		parent:     imbdcp,
-		repository: imbdcp.repositories[repo],
-	}, nil
-}
-
-func (imbdcp *inMemoryBlobDescriptorCacheProvider) Stat(ctx context.Context, dgst digest.Digest) (distribution.Descriptor, error) {
-	return imbdcp.global.Stat(ctx, dgst)
-}
-
-func (imbdcp *inMemoryBlobDescriptorCacheProvider) Clear(ctx context.Context, dgst digest.Digest) error {
-	return imbdcp.global.Clear(ctx, dgst)
-}
-
-func (imbdcp *inMemoryBlobDescriptorCacheProvider) SetDescriptor(ctx context.Context, dgst digest.Digest, desc distribution.Descriptor) error {
-	_, err := imbdcp.Stat(ctx, dgst)
-	if err == distribution.ErrBlobUnknown {
-
-		if dgst.Algorithm() != desc.Digest.Algorithm() && dgst != desc.Digest {
-			// if the digests differ, set the other canonical mapping
-			if err := imbdcp.global.SetDescriptor(ctx, desc.Digest, desc); err != nil {
-				return err
-			}
-		}
-
-		// unknown, just set it
-		return imbdcp.global.SetDescriptor(ctx, dgst, desc)
-	}
-
-	// we already know it, do nothing
-	return err
-}
-
-// repositoryScopedInMemoryBlobDescriptorCache provides the request scoped
-// repository cache. Instances are not thread-safe but the delegated
-// operations are.
-type repositoryScopedInMemoryBlobDescriptorCache struct {
-	repo       string
-	parent     *inMemoryBlobDescriptorCacheProvider // allows lazy allocation of repo's map
-	repository *mapBlobDescriptorCache
-}
-
-func (rsimbdcp *repositoryScopedInMemoryBlobDescriptorCache) Stat(ctx context.Context, dgst digest.Digest) (distribution.Descriptor, error) {
-	if rsimbdcp.repository == nil {
-		return distribution.Descriptor{}, distribution.ErrBlobUnknown
-	}
-
-	return rsimbdcp.repository.Stat(ctx, dgst)
-}
-
-func (rsimbdcp *repositoryScopedInMemoryBlobDescriptorCache) Clear(ctx context.Context, dgst digest.Digest) error {
-	if rsimbdcp.repository == nil {
-		return distribution.ErrBlobUnknown
-	}
-
-	return rsimbdcp.repository.Clear(ctx, dgst)
-}
-
-func (rsimbdcp *repositoryScopedInMemoryBlobDescriptorCache) SetDescriptor(ctx context.Context, dgst digest.Digest, desc distribution.Descriptor) error {
-	if rsimbdcp.repository == nil {
-		// allocate map since we are setting it now.
-		rsimbdcp.parent.mu.Lock()
-		var ok bool
-		// have to read back value since we may have allocated elsewhere.
-		rsimbdcp.repository, ok = rsimbdcp.parent.repositories[rsimbdcp.repo]
-		if !ok {
-			rsimbdcp.repository = newMapBlobDescriptorCache()
-			rsimbdcp.parent.repositories[rsimbdcp.repo] = rsimbdcp.repository
-		}
-
-		rsimbdcp.parent.mu.Unlock()
-	}
-
-	if err := rsimbdcp.repository.SetDescriptor(ctx, dgst, desc); err != nil {
-		return err
-	}
-
-	return rsimbdcp.parent.SetDescriptor(ctx, dgst, desc)
-}
-
-// mapBlobDescriptorCache provides a simple map-based implementation of the
-// descriptor cache.
-type mapBlobDescriptorCache struct {
-	descriptors map[digest.Digest]distribution.Descriptor
-	mu          sync.RWMutex
-}
-
-var _ distribution.BlobDescriptorService = &mapBlobDescriptorCache{}
-
-func newMapBlobDescriptorCache() *mapBlobDescriptorCache {
-	return &mapBlobDescriptorCache{
-		descriptors: make(map[digest.Digest]distribution.Descriptor),
-	}
-}
-
-func (mbdc *mapBlobDescriptorCache) Stat(ctx context.Context, dgst digest.Digest) (distribution.Descriptor, error) {
-	if err := dgst.Validate(); err != nil {
-		return distribution.Descriptor{}, err
-	}
-
-	mbdc.mu.RLock()
-	defer mbdc.mu.RUnlock()
-
-	desc, ok := mbdc.descriptors[dgst]
-	if !ok {
-		return distribution.Descriptor{}, distribution.ErrBlobUnknown
-	}
-
-	return desc, nil
-}
-
-func (mbdc *mapBlobDescriptorCache) Clear(ctx context.Context, dgst digest.Digest) error {
-	mbdc.mu.Lock()
-	defer mbdc.mu.Unlock()
-
-	delete(mbdc.descriptors, dgst)
-	return nil
-}
-
-func (mbdc *mapBlobDescriptorCache) SetDescriptor(ctx context.Context, dgst digest.Digest, desc distribution.Descriptor) error {
-	if err := dgst.Validate(); err != nil {
-		return err
-	}
-
-	if err := cache.ValidateDescriptor(desc); err != nil {
-		return err
-	}
-
-	mbdc.mu.Lock()
-	defer mbdc.mu.Unlock()
-
-	mbdc.descriptors[dgst] = desc
-	return nil
-}

vendor/github.com/docker/distribution/tags.go

@@ -1,27 +0,0 @@
-package distribution
-
-import (
-	"github.com/docker/distribution/context"
-)
-
-// TagService provides access to information about tagged objects.
-type TagService interface {
-	// Get retrieves the descriptor identified by the tag. Some
-	// implementations may differentiate between "trusted" tags and
-	// "untrusted" tags. If a tag is "untrusted", the mapping will be returned
-	// as an ErrTagUntrusted error, with the target descriptor.
-	Get(ctx context.Context, tag string) (Descriptor, error)
-
-	// Tag associates the tag with the provided descriptor, updating the
-	// current association, if needed.
-	Tag(ctx context.Context, tag string, desc Descriptor) error
-
-	// Untag removes the given tag association
-	Untag(ctx context.Context, tag string) error
-
-	// All returns the set of tags managed by this tag service
-	All(ctx context.Context) ([]string, error)
-
-	// Lookup returns the set of tags referencing the given digest.
-	Lookup(ctx context.Context, digest Descriptor) ([]string, error)
-}

vendor/github.com/docker/distribution/uuid/uuid.go

@@ -1,126 +0,0 @@
-// Package uuid provides simple UUID generation. Only version 4 style UUIDs
-// can be generated.
-//
-// Please see http://tools.ietf.org/html/rfc4122 for details on UUIDs.
-package uuid
-
-import (
-	"crypto/rand"
-	"fmt"
-	"io"
-	"os"
-	"syscall"
-	"time"
-)
-
-const (
-	// Bits is the number of bits in a UUID
-	Bits = 128
-
-	// Size is the number of bytes in a UUID
-	Size = Bits / 8
-
-	format = "%08x-%04x-%04x-%04x-%012x"
-)
-
-var (
-	// ErrUUIDInvalid indicates a parsed string is not a valid uuid.
-	ErrUUIDInvalid = fmt.Errorf("invalid uuid")
-
-	// Loggerf can be used to override the default logging destination. Such
-	// log messages in this library should be logged at warning or higher.
-	Loggerf = func(format string, args ...interface{}) {}
-)
-
-// UUID represents a UUID value. UUIDs can be compared and set to other values
-// and accessed by byte.
-type UUID [Size]byte
-
-// Generate creates a new, version 4 uuid.
-func Generate() (u UUID) {
-	const (
-		// ensures we backoff for less than 450ms total. Use the following to
-		// select new value, in units of 10ms:
-		// 	n*(n+1)/2 = d -> n^2 + n - 2d -> n = (sqrt(8d + 1) - 1)/2
-		maxretries = 9
-		backoff    = time.Millisecond * 10
-	)
-
-	var (
-		totalBackoff time.Duration
-		count        int
-		retries      int
-	)
-
-	for {
-		// This should never block but the read may fail. Because of this,
-		// we just try to read the random number generator until we get
-		// something. This is a very rare condition but may happen.
-		b := time.Duration(retries) * backoff
-		time.Sleep(b)
-		totalBackoff += b
-
-		n, err := io.ReadFull(rand.Reader, u[count:])
-		if err != nil {
-			if retryOnError(err) && retries < maxretries {
-				count += n
-				retries++
-				Loggerf("error generating version 4 uuid, retrying: %v", err)
-				continue
-			}
-
-			// Any other errors represent a system problem. What did someone
-			// do to /dev/urandom?
-			panic(fmt.Errorf("error reading random number generator, retried for %v: %v", totalBackoff.String(), err))
-		}
-
-		break
-	}
-
-	u[6] = (u[6] & 0x0f) | 0x40 // set version byte
-	u[8] = (u[8] & 0x3f) | 0x80 // set high order byte 0b10{8,9,a,b}
-
-	return u
-}
-
-// Parse attempts to extract a uuid from the string or returns an error.
-func Parse(s string) (u UUID, err error) {
-	if len(s) != 36 {
-		return UUID{}, ErrUUIDInvalid
-	}
-
-	// create stack addresses for each section of the uuid.
-	p := make([][]byte, 5)
-
-	if _, err := fmt.Sscanf(s, format, &p[0], &p[1], &p[2], &p[3], &p[4]); err != nil {
-		return u, err
-	}
-
-	copy(u[0:4], p[0])
-	copy(u[4:6], p[1])
-	copy(u[6:8], p[2])
-	copy(u[8:10], p[3])
-	copy(u[10:16], p[4])
-
-	return
-}
-
-func (u UUID) String() string {
-	return fmt.Sprintf(format, u[:4], u[4:6], u[6:8], u[8:10], u[10:])
-}
-
-// retryOnError tries to detect whether or not retrying would be fruitful.
-func retryOnError(err error) bool {
-	switch err := err.(type) {
-	case *os.PathError:
-		return retryOnError(err.Err) // unpack the target error
-	case syscall.Errno:
-		if err == syscall.EPERM {
-			// EPERM represents an entropy pool exhaustion, a condition under
-			// which we backoff and retry.
-			return true
-		}
-	}
-
-	return false
-}

vendor/github.com/docker/docker/api/README.md

@@ -1,5 +0,0 @@
-This directory contains code pertaining to the Docker API:
-
- - Used by the docker client when communicating with the docker daemon
-
- - Used by third party tools wishing to interface with the docker daemon

vendor/github.com/docker/docker/api/common.go

@@ -1,146 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"mime"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/docker/docker/pkg/system"
-	"github.com/docker/docker/pkg/version"
-	"github.com/docker/engine-api/types"
-	"github.com/docker/libtrust"
-)
-
-// Common constants for daemon and client.
-const (
-	// Version of Current REST API
-	DefaultVersion version.Version = "1.23"
-
-	// MinVersion represents Minimum REST API version supported
-	MinVersion version.Version = "1.12"
-
-	// NoBaseImageSpecifier is the symbol used by the FROM
-	// command to specify that no base image is to be used.
-	NoBaseImageSpecifier string = "scratch"
-)
-
-// byPortInfo is a temporary type used to sort types.Port by its fields
-type byPortInfo []types.Port
-
-func (r byPortInfo) Len() int      { return len(r) }
-func (r byPortInfo) Swap(i, j int) { r[i], r[j] = r[j], r[i] }
-func (r byPortInfo) Less(i, j int) bool {
-	if r[i].PrivatePort != r[j].PrivatePort {
-		return r[i].PrivatePort < r[j].PrivatePort
-	}
-
-	if r[i].IP != r[j].IP {
-		return r[i].IP < r[j].IP
-	}
-
-	if r[i].PublicPort != r[j].PublicPort {
-		return r[i].PublicPort < r[j].PublicPort
-	}
-
-	return r[i].Type < r[j].Type
-}
-
-// DisplayablePorts returns formatted string representing open ports of container
-// e.g. "0.0.0.0:80->9090/tcp, 9988/tcp"
-// it's used by command 'docker ps'
-func DisplayablePorts(ports []types.Port) string {
-	type portGroup struct {
-		first int
-		last  int
-	}
-	groupMap := make(map[string]*portGroup)
-	var result []string
-	var hostMappings []string
-	var groupMapKeys []string
-	sort.Sort(byPortInfo(ports))
-	for _, port := range ports {
-		current := port.PrivatePort
-		portKey := port.Type
-		if port.IP != "" {
-			if port.PublicPort != current {
-				hostMappings = append(hostMappings, fmt.Sprintf("%s:%d->%d/%s", port.IP, port.PublicPort, port.PrivatePort, port.Type))
-				continue
-			}
-			portKey = fmt.Sprintf("%s/%s", port.IP, port.Type)
-		}
-		group := groupMap[portKey]
-
-		if group == nil {
-			groupMap[portKey] = &portGroup{first: current, last: current}
-			// record order that groupMap keys are created
-			groupMapKeys = append(groupMapKeys, portKey)
-			continue
-		}
-		if current == (group.last + 1) {
-			group.last = current
-			continue
-		}
-
-		result = append(result, formGroup(portKey, group.first, group.last))
-		groupMap[portKey] = &portGroup{first: current, last: current}
-	}
-	for _, portKey := range groupMapKeys {
-		g := groupMap[portKey]
-		result = append(result, formGroup(portKey, g.first, g.last))
-	}
-	result = append(result, hostMappings...)
-	return strings.Join(result, ", ")
-}
-
-func formGroup(key string, start, last int) string {
-	parts := strings.Split(key, "/")
-	groupType := parts[0]
-	var ip string
-	if len(parts) > 1 {
-		ip = parts[0]
-		groupType = parts[1]
-	}
-	group := strconv.Itoa(start)
-	if start != last {
-		group = fmt.Sprintf("%s-%d", group, last)
-	}
-	if ip != "" {
-		group = fmt.Sprintf("%s:%s->%s", ip, group, group)
-	}
-	return fmt.Sprintf("%s/%s", group, groupType)
-}
-
-// MatchesContentType validates the content type against the expected one
-func MatchesContentType(contentType, expectedType string) bool {
-	mimetype, _, err := mime.ParseMediaType(contentType)
-	if err != nil {
-		logrus.Errorf("Error parsing media type: %s error: %v", contentType, err)
-	}
-	return err == nil && mimetype == expectedType
-}
-
-// LoadOrCreateTrustKey attempts to load the libtrust key at the given path,
-// otherwise generates a new one
-func LoadOrCreateTrustKey(trustKeyPath string) (libtrust.PrivateKey, error) {
-	err := system.MkdirAll(filepath.Dir(trustKeyPath), 0700)
-	if err != nil {
-		return nil, err
-	}
-	trustKey, err := libtrust.LoadKeyFile(trustKeyPath)
-	if err == libtrust.ErrKeyFileDoesNotExist {
-		trustKey, err = libtrust.GenerateECP256PrivateKey()
-		if err != nil {
-			return nil, fmt.Errorf("Error generating key: %s", err)
-		}
-		if err := libtrust.SaveKey(trustKeyPath, trustKey); err != nil {
-			return nil, fmt.Errorf("Error saving key file: %s", err)
-		}
-	} else if err != nil {
-		return nil, fmt.Errorf("Error loading key file %s: %s", trustKeyPath, err)
-	}
-	return trustKey, nil
-}

vendor/github.com/docker/docker/daemon/graphdriver/driver.go

@@ -1,236 +0,0 @@
-package graphdriver
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/vbatts/tar-split/tar/storage"
-
-	"github.com/docker/docker/pkg/archive"
-	"github.com/docker/docker/pkg/idtools"
-)
-
-// FsMagic unsigned id of the filesystem in use.
-type FsMagic uint32
-
-const (
-	// FsMagicUnsupported is a predefined constant value other than a valid filesystem id.
-	FsMagicUnsupported = FsMagic(0x00000000)
-)
-
-var (
-	// All registered drivers
-	drivers map[string]InitFunc
-
-	// ErrNotSupported returned when driver is not supported.
-	ErrNotSupported = errors.New("driver not supported")
-	// ErrPrerequisites retuned when driver does not meet prerequisites.
-	ErrPrerequisites = errors.New("prerequisites for driver not satisfied (wrong filesystem?)")
-	// ErrIncompatibleFS returned when file system is not supported.
-	ErrIncompatibleFS = fmt.Errorf("backing file system is unsupported for this graph driver")
-)
-
-// InitFunc initializes the storage driver.
-type InitFunc func(root string, options []string, uidMaps, gidMaps []idtools.IDMap) (Driver, error)
-
-// ProtoDriver defines the basic capabilities of a driver.
-// This interface exists solely to be a minimum set of methods
-// for client code which choose not to implement the entire Driver
-// interface and use the NaiveDiffDriver wrapper constructor.
-//
-// Use of ProtoDriver directly by client code is not recommended.
-type ProtoDriver interface {
-	// String returns a string representation of this driver.
-	String() string
-	// Create creates a new, empty, filesystem layer with the
-	// specified id and parent and mountLabel. Parent and mountLabel may be "".
-	Create(id, parent, mountLabel string) error
-	// Remove attempts to remove the filesystem layer with this id.
-	Remove(id string) error
-	// Get returns the mountpoint for the layered filesystem referred
-	// to by this id. You can optionally specify a mountLabel or "".
-	// Returns the absolute path to the mounted layered filesystem.
-	Get(id, mountLabel string) (dir string, err error)
-	// Put releases the system resources for the specified id,
-	// e.g, unmounting layered filesystem.
-	Put(id string) error
-	// Exists returns whether a filesystem layer with the specified
-	// ID exists on this driver.
-	Exists(id string) bool
-	// Status returns a set of key-value pairs which give low
-	// level diagnostic status about this driver.
-	Status() [][2]string
-	// Returns a set of key-value pairs which give low level information
-	// about the image/container driver is managing.
-	GetMetadata(id string) (map[string]string, error)
-	// Cleanup performs necessary tasks to release resources
-	// held by the driver, e.g., unmounting all layered filesystems
-	// known to this driver.
-	Cleanup() error
-}
-
-// Driver is the interface for layered/snapshot file system drivers.
-type Driver interface {
-	ProtoDriver
-	// Diff produces an archive of the changes between the specified
-	// layer and its parent layer which may be "".
-	Diff(id, parent string) (archive.Archive, error)
-	// Changes produces a list of changes between the specified layer
-	// and its parent layer. If parent is "", then all changes will be ADD changes.
-	Changes(id, parent string) ([]archive.Change, error)
-	// ApplyDiff extracts the changeset from the given diff into the
-	// layer with the specified id and parent, returning the size of the
-	// new layer in bytes.
-	// The archive.Reader must be an uncompressed stream.
-	ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error)
-	// DiffSize calculates the changes between the specified id
-	// and its parent and returns the size in bytes of the changes
-	// relative to its base filesystem directory.
-	DiffSize(id, parent string) (size int64, err error)
-}
-
-// DiffGetterDriver is the interface for layered file system drivers that
-// provide a specialized function for getting file contents for tar-split.
-type DiffGetterDriver interface {
-	Driver
-	// DiffGetter returns an interface to efficiently retrieve the contents
-	// of files in a layer.
-	DiffGetter(id string) (FileGetCloser, error)
-}
-
-// FileGetCloser extends the storage.FileGetter interface with a Close method
-// for cleaning up.
-type FileGetCloser interface {
-	storage.FileGetter
-	// Close cleans up any resources associated with the FileGetCloser.
-	Close() error
-}
-
-func init() {
-	drivers = make(map[string]InitFunc)
-}
-
-// Register registers a InitFunc for the driver.
-func Register(name string, initFunc InitFunc) error {
-	if _, exists := drivers[name]; exists {
-		return fmt.Errorf("Name already registered %s", name)
-	}
-	drivers[name] = initFunc
-
-	return nil
-}
-
-// GetDriver initializes and returns the registered driver
-func GetDriver(name, home string, options []string, uidMaps, gidMaps []idtools.IDMap) (Driver, error) {
-	if initFunc, exists := drivers[name]; exists {
-		return initFunc(filepath.Join(home, name), options, uidMaps, gidMaps)
-	}
-	if pluginDriver, err := lookupPlugin(name, home, options); err == nil {
-		return pluginDriver, nil
-	}
-	logrus.Errorf("Failed to GetDriver graph %s %s", name, home)
-	return nil, ErrNotSupported
-}
-
-// getBuiltinDriver initializes and returns the registered driver, but does not try to load from plugins
-func getBuiltinDriver(name, home string, options []string, uidMaps, gidMaps []idtools.IDMap) (Driver, error) {
-	if initFunc, exists := drivers[name]; exists {
-		return initFunc(filepath.Join(home, name), options, uidMaps, gidMaps)
-	}
-	logrus.Errorf("Failed to built-in GetDriver graph %s %s", name, home)
-	return nil, ErrNotSupported
-}
-
-// New creates the driver and initializes it at the specified root.
-func New(root string, name string, options []string, uidMaps, gidMaps []idtools.IDMap) (driver Driver, err error) {
-	if name != "" {
-		logrus.Debugf("[graphdriver] trying provided driver %q", name) // so the logs show specified driver
-		return GetDriver(name, root, options, uidMaps, gidMaps)
-	}
-
-	// Guess for prior driver
-	priorDrivers := scanPriorDrivers(root)
-	for _, name := range priority {
-		if name == "vfs" {
-			// don't use vfs even if there is state present.
-			continue
-		}
-		for _, prior := range priorDrivers {
-			// of the state found from prior drivers, check in order of our priority
-			// which we would prefer
-			if prior == name {
-				driver, err = getBuiltinDriver(name, root, options, uidMaps, gidMaps)
-				if err != nil {
-					// unlike below, we will return error here, because there is prior
-					// state, and now it is no longer supported/prereq/compatible, so
-					// something changed and needs attention. Otherwise the daemon's
-					// images would just "disappear".
-					logrus.Errorf("[graphdriver] prior storage driver %q failed: %s", name, err)
-					return nil, err
-				}
-				if err := checkPriorDriver(name, root); err != nil {
-					return nil, err
-				}
-				logrus.Infof("[graphdriver] using prior storage driver %q", name)
-				return driver, nil
-			}
-		}
-	}
-
-	// Check for priority drivers first
-	for _, name := range priority {
-		driver, err = getBuiltinDriver(name, root, options, uidMaps, gidMaps)
-		if err != nil {
-			if err == ErrNotSupported || err == ErrPrerequisites || err == ErrIncompatibleFS {
-				continue
-			}
-			return nil, err
-		}
-		return driver, nil
-	}
-
-	// Check all registered drivers if no priority driver is found
-	for _, initFunc := range drivers {
-		if driver, err = initFunc(root, options, uidMaps, gidMaps); err != nil {
-			if err == ErrNotSupported || err == ErrPrerequisites || err == ErrIncompatibleFS {
-				continue
-			}
-			return nil, err
-		}
-		return driver, nil
-	}
-	return nil, fmt.Errorf("No supported storage backend found")
-}
-
-// scanPriorDrivers returns an un-ordered scan of directories of prior storage drivers
-func scanPriorDrivers(root string) []string {
-	priorDrivers := []string{}
-	for driver := range drivers {
-		p := filepath.Join(root, driver)
-		if _, err := os.Stat(p); err == nil && driver != "vfs" {
-			priorDrivers = append(priorDrivers, driver)
-		}
-	}
-	return priorDrivers
-}
-
-func checkPriorDriver(name, root string) error {
-	priorDrivers := []string{}
-	for _, prior := range scanPriorDrivers(root) {
-		if prior != name && prior != "vfs" {
-			if _, err := os.Stat(filepath.Join(root, prior)); err == nil {
-				priorDrivers = append(priorDrivers, prior)
-			}
-		}
-	}
-
-	if len(priorDrivers) > 0 {
-
-		return fmt.Errorf("%q contains other graphdrivers: %s; Please cleanup or explicitly choose storage driver (-s <DRIVER>)", root, strings.Join(priorDrivers, ","))
-	}
-	return nil
-}

vendor/github.com/docker/docker/daemon/graphdriver/driver_freebsd.go

@@ -1,8 +0,0 @@
-package graphdriver
-
-var (
-	// Slice of drivers that should be used in an order
-	priority = []string{
-		"zfs",
-	}
-)

vendor/github.com/docker/docker/daemon/graphdriver/driver_linux.go

@@ -1,88 +0,0 @@
-// +build linux
-
-package graphdriver
-
-import (
-	"path/filepath"
-	"syscall"
-)
-
-const (
-	// FsMagicAufs filesystem id for Aufs
-	FsMagicAufs = FsMagic(0x61756673)
-	// FsMagicBtrfs filesystem id for Btrfs
-	FsMagicBtrfs = FsMagic(0x9123683E)
-	// FsMagicCramfs filesystem id for Cramfs
-	FsMagicCramfs = FsMagic(0x28cd3d45)
-	// FsMagicExtfs filesystem id for Extfs
-	FsMagicExtfs = FsMagic(0x0000EF53)
-	// FsMagicF2fs filesystem id for F2fs
-	FsMagicF2fs = FsMagic(0xF2F52010)
-	// FsMagicGPFS filesystem id for GPFS
-	FsMagicGPFS = FsMagic(0x47504653)
-	// FsMagicJffs2Fs filesystem if for Jffs2Fs
-	FsMagicJffs2Fs = FsMagic(0x000072b6)
-	// FsMagicJfs filesystem id for Jfs
-	FsMagicJfs = FsMagic(0x3153464a)
-	// FsMagicNfsFs filesystem id for NfsFs
-	FsMagicNfsFs = FsMagic(0x00006969)
-	// FsMagicRAMFs filesystem id for RamFs
-	FsMagicRAMFs = FsMagic(0x858458f6)
-	// FsMagicReiserFs filesystem id for ReiserFs
-	FsMagicReiserFs = FsMagic(0x52654973)
-	// FsMagicSmbFs filesystem id for SmbFs
-	FsMagicSmbFs = FsMagic(0x0000517B)
-	// FsMagicSquashFs filesystem id for SquashFs
-	FsMagicSquashFs = FsMagic(0x73717368)
-	// FsMagicTmpFs filesystem id for TmpFs
-	FsMagicTmpFs = FsMagic(0x01021994)
-	// FsMagicVxFS filesystem id for VxFs
-	FsMagicVxFS = FsMagic(0xa501fcf5)
-	// FsMagicXfs filesystem id for Xfs
-	FsMagicXfs = FsMagic(0x58465342)
-	// FsMagicZfs filesystem id for Zfs
-	FsMagicZfs = FsMagic(0x2fc12fc1)
-)
-
-var (
-	// Slice of drivers that should be used in an order
-	priority = []string{
-		"aufs",
-		"btrfs",
-		"zfs",
-		"devicemapper",
-		"overlay",
-		"vfs",
-	}
-
-	// FsNames maps filesystem id to name of the filesystem.
-	FsNames = map[FsMagic]string{
-		FsMagicAufs:        "aufs",
-		FsMagicBtrfs:       "btrfs",
-		FsMagicCramfs:      "cramfs",
-		FsMagicExtfs:       "extfs",
-		FsMagicF2fs:        "f2fs",
-		FsMagicGPFS:        "gpfs",
-		FsMagicJffs2Fs:     "jffs2",
-		FsMagicJfs:         "jfs",
-		FsMagicNfsFs:       "nfs",
-		FsMagicRAMFs:       "ramfs",
-		FsMagicReiserFs:    "reiserfs",
-		FsMagicSmbFs:       "smb",
-		FsMagicSquashFs:    "squashfs",
-		FsMagicTmpFs:       "tmpfs",
-		FsMagicUnsupported: "unsupported",
-		FsMagicVxFS:        "vxfs",
-		FsMagicXfs:         "xfs",
-		FsMagicZfs:         "zfs",
-	}
-)
-
-// GetFSMagic returns the filesystem id given the path.
-func GetFSMagic(rootpath string) (FsMagic, error) {
-	var buf syscall.Statfs_t
-	if err := syscall.Statfs(filepath.Dir(rootpath), &buf); err != nil {
-		return 0, err
-	}
-	return FsMagic(buf.Type), nil
-}

vendor/github.com/docker/docker/daemon/graphdriver/driver_unsupported.go

@@ -1,15 +0,0 @@
-// +build !linux,!windows,!freebsd
-
-package graphdriver
-
-var (
-	// Slice of drivers that should be used in an order
-	priority = []string{
-		"unsupported",
-	}
-)
-
-// GetFSMagic returns the filesystem id given the path.
-func GetFSMagic(rootpath string) (FsMagic, error) {
-	return FsMagicUnsupported, nil
-}

vendor/github.com/docker/docker/daemon/graphdriver/driver_windows.go

@@ -1,16 +0,0 @@
-package graphdriver
-
-var (
-	// Slice of drivers that should be used in order
-	priority = []string{
-		"windowsfilter",
-		"windowsdiff",
-		"vfs",
-	}
-)
-
-// GetFSMagic returns the filesystem id given the path.
-func GetFSMagic(rootpath string) (FsMagic, error) {
-	// Note it is OK to return FsMagicUnsupported on Windows.
-	return FsMagicUnsupported, nil
-}

vendor/github.com/docker/docker/daemon/graphdriver/fsdiff.go

@@ -1,162 +0,0 @@
-package graphdriver
-
-import (
-	"time"
-
-	"github.com/Sirupsen/logrus"
-
-	"github.com/docker/docker/pkg/archive"
-	"github.com/docker/docker/pkg/chrootarchive"
-	"github.com/docker/docker/pkg/idtools"
-	"github.com/docker/docker/pkg/ioutils"
-)
-
-var (
-	// ApplyUncompressedLayer defines the unpack method used by the graph
-	// driver.
-	ApplyUncompressedLayer = chrootarchive.ApplyUncompressedLayer
-)
-
-// NaiveDiffDriver takes a ProtoDriver and adds the
-// capability of the Diffing methods which it may or may not
-// support on its own. See the comment on the exported
-// NewNaiveDiffDriver function below.
-// Notably, the AUFS driver doesn't need to be wrapped like this.
-type NaiveDiffDriver struct {
-	ProtoDriver
-	uidMaps []idtools.IDMap
-	gidMaps []idtools.IDMap
-}
-
-// NewNaiveDiffDriver returns a fully functional driver that wraps the
-// given ProtoDriver and adds the capability of the following methods which
-// it may or may not support on its own:
-//     Diff(id, parent string) (archive.Archive, error)
-//     Changes(id, parent string) ([]archive.Change, error)
-//     ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error)
-//     DiffSize(id, parent string) (size int64, err error)
-func NewNaiveDiffDriver(driver ProtoDriver, uidMaps, gidMaps []idtools.IDMap) Driver {
-	return &NaiveDiffDriver{ProtoDriver: driver,
-		uidMaps: uidMaps,
-		gidMaps: gidMaps}
-}
-
-// Diff produces an archive of the changes between the specified
-// layer and its parent layer which may be "".
-func (gdw *NaiveDiffDriver) Diff(id, parent string) (arch archive.Archive, err error) {
-	driver := gdw.ProtoDriver
-
-	layerFs, err := driver.Get(id, "")
-	if err != nil {
-		return nil, err
-	}
-
-	defer func() {
-		if err != nil {
-			driver.Put(id)
-		}
-	}()
-
-	if parent == "" {
-		archive, err := archive.Tar(layerFs, archive.Uncompressed)
-		if err != nil {
-			return nil, err
-		}
-		return ioutils.NewReadCloserWrapper(archive, func() error {
-			err := archive.Close()
-			driver.Put(id)
-			return err
-		}), nil
-	}
-
-	parentFs, err := driver.Get(parent, "")
-	if err != nil {
-		return nil, err
-	}
-	defer driver.Put(parent)
-
-	changes, err := archive.ChangesDirs(layerFs, parentFs)
-	if err != nil {
-		return nil, err
-	}
-
-	archive, err := archive.ExportChanges(layerFs, changes, gdw.uidMaps, gdw.gidMaps)
-	if err != nil {
-		return nil, err
-	}
-
-	return ioutils.NewReadCloserWrapper(archive, func() error {
-		err := archive.Close()
-		driver.Put(id)
-		return err
-	}), nil
-}
-
-// Changes produces a list of changes between the specified layer
-// and its parent layer. If parent is "", then all changes will be ADD changes.
-func (gdw *NaiveDiffDriver) Changes(id, parent string) ([]archive.Change, error) {
-	driver := gdw.ProtoDriver
-
-	layerFs, err := driver.Get(id, "")
-	if err != nil {
-		return nil, err
-	}
-	defer driver.Put(id)
-
-	parentFs := ""
-
-	if parent != "" {
-		parentFs, err = driver.Get(parent, "")
-		if err != nil {
-			return nil, err
-		}
-		defer driver.Put(parent)
-	}
-
-	return archive.ChangesDirs(layerFs, parentFs)
-}
-
-// ApplyDiff extracts the changeset from the given diff into the
-// layer with the specified id and parent, returning the size of the
-// new layer in bytes.
-func (gdw *NaiveDiffDriver) ApplyDiff(id, parent string, diff archive.Reader) (size int64, err error) {
-	driver := gdw.ProtoDriver
-
-	// Mount the root filesystem so we can apply the diff/layer.
-	layerFs, err := driver.Get(id, "")
-	if err != nil {
-		return
-	}
-	defer driver.Put(id)
-
-	options := &archive.TarOptions{UIDMaps: gdw.uidMaps,
-		GIDMaps: gdw.gidMaps}
-	start := time.Now().UTC()
-	logrus.Debugf("Start untar layer")
-	if size, err = ApplyUncompressedLayer(layerFs, diff, options); err != nil {
-		return
-	}
-	logrus.Debugf("Untar time: %vs", time.Now().UTC().Sub(start).Seconds())
-
-	return
-}
-
-// DiffSize calculates the changes between the specified layer
-// and its parent and returns the size in bytes of the changes
-// relative to its base filesystem directory.
-func (gdw *NaiveDiffDriver) DiffSize(id, parent string) (size int64, err error) {
-	driver := gdw.ProtoDriver
-
-	changes, err := gdw.Changes(id, parent)
-	if err != nil {
-		return
-	}
-
-	layerFs, err := driver.Get(id, "")
-	if err != nil {
-		return
-	}
-	defer driver.Put(id)
-
-	return archive.ChangesSize(layerFs, changes), nil
-}

vendor/github.com/docker/docker/daemon/graphdriver/plugin.go

@@ -1,32 +0,0 @@
-// +build experimental
-
-package graphdriver
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/docker/docker/pkg/plugins"
-)
-
-type pluginClient interface {
-	// Call calls the specified method with the specified arguments for the plugin.
-	Call(string, interface{}, interface{}) error
-	// Stream calls the specified method with the specified arguments for the plugin and returns the response IO stream
-	Stream(string, interface{}) (io.ReadCloser, error)
-	// SendFile calls the specified method, and passes through the IO stream
-	SendFile(string, io.Reader, interface{}) error
-}
-
-func lookupPlugin(name, home string, opts []string) (Driver, error) {
-	pl, err := plugins.Get(name, "GraphDriver")
-	if err != nil {
-		return nil, fmt.Errorf("Error looking up graphdriver plugin %s: %v", name, err)
-	}
-	return newPluginDriver(name, home, opts, pl.Client)
-}
-
-func newPluginDriver(name, home string, opts []string, c pluginClient) (Driver, error) {
-	proxy := &graphDriverProxy{name, c}
-	return proxy, proxy.Init(home, opts)
-}

vendor/github.com/docker/docker/daemon/graphdriver/plugin_unsupported.go

@@ -1,7 +0,0 @@
-// +build !experimental
-
-package graphdriver
-
-func lookupPlugin(name, home string, opts []string) (Driver, error) {
-	return nil, ErrNotSupported
-}

vendor/github.com/docker/docker/daemon/graphdriver/proxy.go

@@ -1,210 +0,0 @@
-// +build experimental
-
-package graphdriver
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/docker/docker/pkg/archive"
-)
-
-type graphDriverProxy struct {
-	name   string
-	client pluginClient
-}
-
-type graphDriverRequest struct {
-	ID         string `json:",omitempty"`
-	Parent     string `json:",omitempty"`
-	MountLabel string `json:",omitempty"`
-}
-
-type graphDriverResponse struct {
-	Err      string            `json:",omitempty"`
-	Dir      string            `json:",omitempty"`
-	Exists   bool              `json:",omitempty"`
-	Status   [][2]string       `json:",omitempty"`
-	Changes  []archive.Change  `json:",omitempty"`
-	Size     int64             `json:",omitempty"`
-	Metadata map[string]string `json:",omitempty"`
-}
-
-type graphDriverInitRequest struct {
-	Home string
-	Opts []string
-}
-
-func (d *graphDriverProxy) Init(home string, opts []string) error {
-	args := &graphDriverInitRequest{
-		Home: home,
-		Opts: opts,
-	}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Init", args, &ret); err != nil {
-		return err
-	}
-	if ret.Err != "" {
-		return errors.New(ret.Err)
-	}
-	return nil
-}
-
-func (d *graphDriverProxy) String() string {
-	return d.name
-}
-
-func (d *graphDriverProxy) Create(id, parent, mountLabel string) error {
-	args := &graphDriverRequest{
-		ID:         id,
-		Parent:     parent,
-		MountLabel: mountLabel,
-	}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Create", args, &ret); err != nil {
-		return err
-	}
-	if ret.Err != "" {
-		return errors.New(ret.Err)
-	}
-	return nil
-}
-
-func (d *graphDriverProxy) Remove(id string) error {
-	args := &graphDriverRequest{ID: id}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Remove", args, &ret); err != nil {
-		return err
-	}
-	if ret.Err != "" {
-		return errors.New(ret.Err)
-	}
-	return nil
-}
-
-func (d *graphDriverProxy) Get(id, mountLabel string) (string, error) {
-	args := &graphDriverRequest{
-		ID:         id,
-		MountLabel: mountLabel,
-	}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Get", args, &ret); err != nil {
-		return "", err
-	}
-	var err error
-	if ret.Err != "" {
-		err = errors.New(ret.Err)
-	}
-	return ret.Dir, err
-}
-
-func (d *graphDriverProxy) Put(id string) error {
-	args := &graphDriverRequest{ID: id}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Put", args, &ret); err != nil {
-		return err
-	}
-	if ret.Err != "" {
-		return errors.New(ret.Err)
-	}
-	return nil
-}
-
-func (d *graphDriverProxy) Exists(id string) bool {
-	args := &graphDriverRequest{ID: id}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Exists", args, &ret); err != nil {
-		return false
-	}
-	return ret.Exists
-}
-
-func (d *graphDriverProxy) Status() [][2]string {
-	args := &graphDriverRequest{}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Status", args, &ret); err != nil {
-		return nil
-	}
-	return ret.Status
-}
-
-func (d *graphDriverProxy) GetMetadata(id string) (map[string]string, error) {
-	args := &graphDriverRequest{
-		ID: id,
-	}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.GetMetadata", args, &ret); err != nil {
-		return nil, err
-	}
-	if ret.Err != "" {
-		return nil, errors.New(ret.Err)
-	}
-	return ret.Metadata, nil
-}
-
-func (d *graphDriverProxy) Cleanup() error {
-	args := &graphDriverRequest{}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Cleanup", args, &ret); err != nil {
-		return nil
-	}
-	if ret.Err != "" {
-		return errors.New(ret.Err)
-	}
-	return nil
-}
-
-func (d *graphDriverProxy) Diff(id, parent string) (archive.Archive, error) {
-	args := &graphDriverRequest{
-		ID:     id,
-		Parent: parent,
-	}
-	body, err := d.client.Stream("GraphDriver.Diff", args)
-	if err != nil {
-		body.Close()
-		return nil, err
-	}
-	return archive.Archive(body), nil
-}
-
-func (d *graphDriverProxy) Changes(id, parent string) ([]archive.Change, error) {
-	args := &graphDriverRequest{
-		ID:     id,
-		Parent: parent,
-	}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.Changes", args, &ret); err != nil {
-		return nil, err
-	}
-	if ret.Err != "" {
-		return nil, errors.New(ret.Err)
-	}
-
-	return ret.Changes, nil
-}
-
-func (d *graphDriverProxy) ApplyDiff(id, parent string, diff archive.Reader) (int64, error) {
-	var ret graphDriverResponse
-	if err := d.client.SendFile(fmt.Sprintf("GraphDriver.ApplyDiff?id=%s&parent=%s", id, parent), diff, &ret); err != nil {
-		return -1, err
-	}
-	if ret.Err != "" {
-		return -1, errors.New(ret.Err)
-	}
-	return ret.Size, nil
-}
-
-func (d *graphDriverProxy) DiffSize(id, parent string) (int64, error) {
-	args := &graphDriverRequest{
-		ID:     id,
-		Parent: parent,
-	}
-	var ret graphDriverResponse
-	if err := d.client.Call("GraphDriver.DiffSize", args, &ret); err != nil {
-		return -1, err
-	}
-	if ret.Err != "" {
-		return -1, errors.New(ret.Err)
-	}
-	return ret.Size, nil
-}