|
diff --git a/Godeps/_workspace/src/github.com/docker/distribution/manifests.go b/Godeps/_workspace/src/github.com/docker/distribution/manifests.go
index 222916b8..1acb0500 100644
--- a/Godeps/_workspace/src/github.com/docker/distribution/manifests.go
+++ b/Godeps/_workspace/src/github.com/docker/distribution/manifests.go
@@ -2,7 +2,7 @@ package distribution
import (
"fmt"
- "strings"
+ "mime"
"github.com/docker/distribution/context"
"github.com/docker/distribution/digest"
@@ -84,19 +84,23 @@ var mappings = make(map[string]UnmarshalFunc, 0)
// UnmarshalManifest looks up manifest unmarshall functions based on
// MediaType
func UnmarshalManifest(ctHeader string, p []byte) (Manifest, Descriptor, error) {
- // Need to look up by the actual content type, not the raw contents of
+ // 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
- semicolonIndex := strings.Index(ctHeader, ";")
- if semicolonIndex != -1 {
- mediatype = ctHeader[:semicolonIndex]
- } else {
- mediatype = ctHeader
+ if ctHeader != "" {
+ var err error
+ mediatype, _, err = mime.ParseMediaType(ctHeader)
+ if err != nil {
+ return nil, Descriptor{}, err
+ }
}
unmarshalFunc, ok := mappings[mediatype]
if !ok {
- return nil, Descriptor{}, fmt.Errorf("unsupported manifest mediatype: %s", mediatype)
+ unmarshalFunc, ok = mappings[""]
+ if !ok {
+ return nil, Descriptor{}, fmt.Errorf("unsupported manifest mediatype and no default available: %s", mediatype)
+ }
}
return unmarshalFunc(p)
diff --git a/Godeps/_workspace/src/github.com/docker/distribution/notifications/bridge.go b/Godeps/_workspace/src/github.com/docker/distribution/notifications/bridge.go
index efaa3ac3..2133b3be 100644
--- a/Godeps/_workspace/src/github.com/docker/distribution/notifications/bridge.go
+++ b/Godeps/_workspace/src/github.com/docker/distribution/notifications/bridge.go
@@ -103,10 +103,16 @@ func (b *bridge) createManifestEvent(action string, repo string, sm distribution
return nil, err
}
+ // Ensure we have the canonical manifest descriptor here
+ _, desc, err := distribution.UnmarshalManifest(mt, p)
+ if err != nil {
+ return nil, err
+ }
+
event.Target.MediaType = mt
- event.Target.Length = int64(len(p))
- event.Target.Size = int64(len(p))
- event.Target.Digest = digest.FromBytes(p)
+ event.Target.Length = desc.Size
+ event.Target.Size = desc.Size
+ event.Target.Digest = desc.Digest
event.Target.URL, err = b.ub.BuildManifestURL(repo, event.Target.Digest.String())
if err != nil {
diff --git a/Godeps/_workspace/src/github.com/docker/docker/api/client/update.go b/Godeps/_workspace/src/github.com/docker/docker/api/client/update.go
index 764a9952..70830488 100644
--- a/Godeps/_workspace/src/github.com/docker/docker/api/client/update.go
+++ b/Godeps/_workspace/src/github.com/docker/docker/api/client/update.go
@@ -23,7 +23,7 @@ func (cli *DockerCli) CmdUpdate(args ...string) error {
flCPUShares := cmd.Int64([]string{"#c", "-cpu-shares"}, 0, "CPU shares (relative weight)")
flMemoryString := cmd.String([]string{"m", "-memory"}, "", "Memory limit")
flMemoryReservation := cmd.String([]string{"-memory-reservation"}, "", "Memory soft limit")
- flMemorySwap := cmd.String([]string{"-memory-swap"}, "", "Total memory (memory + swap), '-1' to disable swap")
+ flMemorySwap := cmd.String([]string{"-memory-swap"}, "", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap")
flKernelMemory := cmd.String([]string{"-kernel-memory"}, "", "Kernel memory limit")
cmd.Require(flag.Min, 1)
diff --git a/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/aufs/aufs.go b/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/aufs/aufs.go
index 9b8c4de9..51054fa6 100644
--- a/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/aufs/aufs.go
+++ b/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/aufs/aufs.go
@@ -374,20 +374,10 @@ func (a *Driver) DiffPath(id string) (string, func() error, error) {
}
func (a *Driver) applyDiff(id string, diff archive.Reader) error {
- dir := path.Join(a.rootPath(), "diff", id)
- if err := chrootarchive.UntarUncompressed(diff, dir, &archive.TarOptions{
+ return chrootarchive.UntarUncompressed(diff, path.Join(a.rootPath(), "diff", id), &archive.TarOptions{
UIDMaps: a.uidMaps,
GIDMaps: a.gidMaps,
- }); err != nil {
- return err
- }
-
- // show invalid whiteouts warning.
- files, err := ioutil.ReadDir(path.Join(dir, archive.WhiteoutLinkDir))
- if err == nil && len(files) > 0 {
- logrus.Warnf("Archive contains aufs hardlink references that are not supported.")
- }
- return nil
+ })
}
// DiffSize calculates the changes between the specified id
@@ -517,7 +507,7 @@ func (a *Driver) aufsMount(ro []string, rw, target, mountLabel string) (err erro
}
if firstMount {
- opts := "dio,noplink,xino=/dev/shm/aufs.xino"
+ opts := "dio,xino=/dev/shm/aufs.xino"
if useDirperm() {
opts += ",dirperm1"
}
diff --git a/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/overlay/copy.go b/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/overlay/copy.go
index def4d439..7d81a83a 100644
--- a/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/overlay/copy.go
+++ b/Godeps/_workspace/src/github.com/docker/docker/daemon/graphdriver/overlay/copy.go
@@ -4,12 +4,12 @@ package overlay
import (
"fmt"
- "io"
"os"
"path/filepath"
"syscall"
"time"
+ "github.com/docker/docker/pkg/pools"
"github.com/docker/docker/pkg/system"
)
@@ -32,7 +32,7 @@ func copyRegular(srcPath, dstPath string, mode os.FileMode) error {
}
defer dstFile.Close()
- _, err = io.Copy(dstFile, srcFile)
+ _, err = pools.Copy(dstFile, srcFile)
return err
}
diff --git a/Godeps/_workspace/src/github.com/docker/docker/distribution/registry.go b/Godeps/_workspace/src/github.com/docker/docker/distribution/registry.go
index 1d4a2c4e..1c2b4f3c 100644
--- a/Godeps/_workspace/src/github.com/docker/docker/distribution/registry.go
+++ b/Godeps/_workspace/src/github.com/docker/docker/distribution/registry.go
@@ -6,6 +6,7 @@ import (
"net/http"
"net/url"
"strings"
+ "syscall"
"time"
"github.com/docker/distribution"
@@ -145,8 +146,14 @@ func retryOnError(err error) error {
case errcode.ErrorCodeUnauthorized, errcode.ErrorCodeUnsupported, errcode.ErrorCodeDenied:
return xfer.DoNotRetry{Err: err}
}
+ case *url.Error:
+ return retryOnError(v.Err)
case *client.UnexpectedHTTPResponseError:
return xfer.DoNotRetry{Err: err}
+ case error:
+ if strings.Contains(err.Error(), strings.ToLower(syscall.ENOSPC.Error())) {
+ return xfer.DoNotRetry{Err: err}
+ }
}
// let's be nice and fallback if the error is a completely
// unexpected one.
diff --git a/Godeps/_workspace/src/github.com/docker/docker/pkg/mflag/flag.go b/Godeps/_workspace/src/github.com/docker/docker/pkg/mflag/flag.go
index 2ad299ac..04683299 100644
--- a/Godeps/_workspace/src/github.com/docker/docker/pkg/mflag/flag.go
+++ b/Godeps/_workspace/src/github.com/docker/docker/pkg/mflag/flag.go
@@ -1163,7 +1163,7 @@ func (fs *FlagSet) ReportError(str string, withHelp bool) {
str += ".\nSee '" + os.Args[0] + " " + fs.Name() + " --help'"
}
}
- fmt.Fprintf(fs.Out(), "docker: %s.\n", str)
+ fmt.Fprintf(fs.Out(), "%s: %s.\n", os.Args[0], str)
}
// Parsed reports whether fs.Parse has been called.
diff --git a/Godeps/_workspace/src/github.com/docker/docker/registry/registry.go b/Godeps/_workspace/src/github.com/docker/docker/registry/registry.go
index 643fa56e..bacc4aed 100644
--- a/Godeps/_workspace/src/github.com/docker/docker/registry/registry.go
+++ b/Godeps/_workspace/src/github.com/docker/docker/registry/registry.go
@@ -109,7 +109,7 @@ func ReadCertsDirectory(tlsConfig *tls.Config, directory string) error {
keyName := certName[:len(certName)-5] + ".key"
logrus.Debugf("cert: %s", filepath.Join(directory, f.Name()))
if !hasFile(fs, keyName) {
- return fmt.Errorf("Missing key %s for certificate %s", keyName, certName)
+ return fmt.Errorf("Missing key %s for client certificate %s. Note that CA certificates should use the extension .crt.", keyName, certName)
}
cert, err := tls.LoadX509KeyPair(filepath.Join(directory, certName), filepath.Join(directory, keyName))
if err != nil {
@@ -122,7 +122,7 @@ func ReadCertsDirectory(tlsConfig *tls.Config, directory string) error {
certName := keyName[:len(keyName)-4] + ".cert"
logrus.Debugf("key: %s", filepath.Join(directory, f.Name()))
if !hasFile(fs, certName) {
- return fmt.Errorf("Missing certificate %s for key %s", certName, keyName)
+ return fmt.Errorf("Missing client certificate %s for key %s", certName, keyName)
}
}
}
diff --git a/inspect.go b/inspect.go
index 201196c2..20eeb142 100644
--- a/inspect.go
+++ b/inspect.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"fmt"
"os"
+ "strings"
"time"
"github.com/Sirupsen/logrus"
@@ -13,7 +14,6 @@ import (
"github.com/docker/docker/api"
"github.com/docker/docker/cliconfig"
"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"
@@ -97,15 +97,16 @@ func getData(c *cli.Context, ref reference.Named) (*imageInspect, error) {
if err := validateRepoName(repoInfo.Name()); err != nil {
return nil, err
}
- options := ®istry.Options{}
- options.InsecureRegistries = opts.NewListOpts(nil)
- options.Mirrors = 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
- }
+ //options := ®istry.Options{}
+ //options.Mirrors = opts.NewListOpts(nil)
+ //options.InsecureRegistries = opts.NewListOpts(nil)
+ //options.InsecureRegistries.Set("0.0.0.0/0")
+ //registryService := registry.NewService(options)
+ registryService := registry.NewService(nil)
+ //// 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)
if err != nil {
@@ -127,7 +128,10 @@ func getData(c *cli.Context, ref reference.Named) (*imageInspect, error) {
return nil, err
}
if _, err := v1endpoint.Ping(); err != nil {
- return nil, err
+ if strings.Contains(err.Error(), "timeout") {
+ return nil, err
+ }
+ continue
}
if confirmedV2 && endpoint.Version == registry.APIVersion1 {
diff --git a/inspect_v1.go b/inspect_v1.go
index c323b461..fa1c5515 100644
--- a/inspect_v1.go
+++ b/inspect_v1.go
@@ -36,10 +36,6 @@ func (mf *v1ManifestFetcher) Fetch(ctx context.Context, ref reference.Named) (*i
// Allowing fallback, because HTTPS v1 is before HTTP v2
return nil, fallbackError{err: registry.ErrNoSupport{errors.New("Cannot pull by digest with v1 registry")}}
}
- tag := ""
- if tagged, isTagged := ref.(reference.NamedTagged); isTagged {
- tag = tagged.Tag()
- }
tlsConfig, err := mf.service.TLSConfig(mf.repoInfo.Index.Name)
if err != nil {
return nil, err
@@ -62,62 +58,60 @@ func (mf *v1ManifestFetcher) Fetch(ctx context.Context, ref reference.Named) (*i
logrus.Debugf("Fallback from error: %s", err)
return nil, fallbackError{err: err}
}
- imgInspect, err = mf.fetchWithSession(ctx, tag)
+ imgInspect, err = mf.fetchWithSession(ctx, ref)
if err != nil {
return nil, err
}
return imgInspect, nil
}
-func (mf *v1ManifestFetcher) fetchWithSession(ctx context.Context, askedTag string) (*imageInspect, error) {
+func (mf *v1ManifestFetcher) fetchWithSession(ctx context.Context, ref reference.Named) (*imageInspect, 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)
+ return nil, fmt.Errorf("Error: image %s not found", mf.repoInfo.RemoteName())
}
// Unexpected HTTP error
return nil, err
}
- logrus.Debugf("Retrieving the tag list from V1 endpoints")
- tagsList, err := mf.session.GetRemoteTags(repoData.Endpoints, mf.repoInfo)
+ 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)
+ logrus.Errorf("unable to get remote tags: %s", err)
return nil, err
}
- if len(tagsList) < 1 {
- return nil, fmt.Errorf("No tags available for remote repository %s", mf.repoInfo.FullName())
+
+ 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, id := range tagsList {
+ for tag, _ := range tagsList {
tagList = append(tagList, tag)
- repoData.ImgList[id] = ®istry.ImgData{
- ID: id,
- Tag: tag,
- Checksum: "",
- }
}
- // If no tag has been specified, choose `latest` if it exists
- if askedTag == "" {
- if _, exists := tagsList[reference.DefaultTag]; exists {
- askedTag = reference.DefaultTag
- }
- }
- if askedTag == "" {
- // fallback to any tag in the repository
- for tag := range tagsList {
- askedTag = tag
- break
- }
- }
-
- id, exists := tagsList[askedTag]
- if !exists {
- return nil, fmt.Errorf("Tag %s not found in repository %s", askedTag, mf.repoInfo.FullName())
- }
- img := repoData.ImgList[id]
+ img := repoData.ImgList[tagID]
var pulledImg *image.Image
for _, ep := range mf.repoInfo.Index.Mirrors {
@@ -142,10 +136,10 @@ func (mf *v1ManifestFetcher) fetchWithSession(ctx context.Context, askedTag stri
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(), askedTag)
+ return nil, fmt.Errorf("No such image %s:%s", mf.repoInfo.FullName(), tag)
}
- return makeImageInspect(pulledImg, askedTag, "", tagList), nil
+ return makeImageInspect(pulledImg, tag, "", tagList), nil
}
func (mf *v1ManifestFetcher) pullImageJSON(imgID, endpoint string, token []string) (*image.Image, error) {
diff --git a/inspect_v2.go b/inspect_v2.go
index 010bd4dd..bd25f0fb 100644
--- a/inspect_v2.go
+++ b/inspect_v2.go
@@ -63,8 +63,6 @@ func (mf *v2ManifestFetcher) fetchWithRepository(ctx context.Context, ref refere
manifest distribution.Manifest
tagOrDigest string // Used for logging/progress only
tagList = []string{}
-
- tag string
)
manSvc, err := mf.repo.Manifests(ctx)
@@ -72,55 +70,47 @@ func (mf *v2ManifestFetcher) fetchWithRepository(ctx context.Context, ref refere
return nil, err
}
- tagList, err = mf.repo.Tags(ctx).All(ctx)
- if err != nil {
- return nil, allowV1Fallback(err)
+ if _, isTagged := ref.(reference.NamedTagged); !isTagged {
+ ref, err = reference.WithTag(ref, reference.DefaultTag)
+ if err != nil {
+ return nil, err
+ }
}
- // The v2 registry knows about this repository, so we will not
- // allow fallback to the v1 protocol even if we encounter an
- // error later on.
- mf.confirmedV2 = true
- if digested, isDigested := ref.(reference.Canonical); isDigested {
+ 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 {
- if tagged, isTagged := ref.(reference.NamedTagged); isTagged {
- tagOrDigest = tagged.Tag()
- tag = tagOrDigest
- } else {
- for _, t := range tagList {
- if t == reference.DefaultTag {
- tag = t
- }
- }
- if tag == "" && len(tagList) > 0 {
- tag = tagList[0]
- }
- if tag == "" {
- return nil, fmt.Errorf("No tags available for remote repository %s", mf.repoInfo.FullName())
- }
- }
- // 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(tag))
- if err != nil {
- return nil, allowV1Fallback(err)
- }
-
- // If manSvc.Get succeeded, we can be confident that the registry on
- // the other side speaks the v2 protocol.
- mf.confirmedV2 = true
+ 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
@@ -154,7 +144,7 @@ func (mf *v2ManifestFetcher) fetchWithRepository(ctx context.Context, ref refere
//ref = reference.WithDefaultTag(ref)
//}
//_ = showTags
- return makeImageInspect(image, tag, manifestDigest, tagList), nil
+ return makeImageInspect(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) {
|