From f22ad79d3667197994e3075f0e37f1cda6b27af1 Mon Sep 17 00:00:00 2001 From: Brian Bland Date: Thu, 8 Jan 2015 17:45:21 -0800 Subject: [PATCH] Factors out resolveBlobPath, renames expires -> expiry --- storage/delegatelayerhandler.go | 52 +++++++++++++-------------------- storage/layerstore.go | 30 +------------------ storage/paths.go | 29 ++++++++++++++++++ storagedriver/s3/s3.go | 2 +- 4 files changed, 51 insertions(+), 62 deletions(-) diff --git a/storage/delegatelayerhandler.go b/storage/delegatelayerhandler.go index 26d6971dd..cc0622bf5 100644 --- a/storage/delegatelayerhandler.go +++ b/storage/delegatelayerhandler.go @@ -1,10 +1,10 @@ package storage import ( + "fmt" "net/http" "time" - "github.com/docker/distribution/digest" "github.com/docker/distribution/storagedriver" ) @@ -14,12 +14,28 @@ import ( type delegateLayerHandler struct { storageDriver storagedriver.StorageDriver pathMapper *pathMapper + duration time.Duration } var _ LayerHandler = &delegateLayerHandler{} func newDelegateLayerHandler(storageDriver storagedriver.StorageDriver, options map[string]interface{}) (LayerHandler, error) { - return &delegateLayerHandler{storageDriver: storageDriver, pathMapper: defaultPathMapper}, nil + duration := 20 * time.Minute + d, ok := options["duration"] + if ok { + switch d := d.(type) { + case time.Duration: + duration = d + case string: + dur, err := time.ParseDuration(d) + if err != nil { + return nil, fmt.Errorf("Invalid duration: %s", err) + } + duration = dur + } + } + + return &delegateLayerHandler{storageDriver: storageDriver, pathMapper: defaultPathMapper, duration: duration}, nil } // Resolve returns an http.Handler which can serve the contents of the given @@ -38,12 +54,12 @@ func (lh *delegateLayerHandler) Resolve(layer Layer) (http.Handler, error) { // urlFor returns a download URL for the given layer, or the empty string if // unsupported. func (lh *delegateLayerHandler) urlFor(layer Layer) (string, error) { - blobPath, err := lh.resolveBlobPath(layer.Name(), layer.Digest()) + blobPath, err := resolveBlobPath(lh.storageDriver, lh.pathMapper, layer.Name(), layer.Digest()) if err != nil { return "", err } - layerURL, err := lh.storageDriver.URLFor(blobPath, map[string]interface{}{"expires": time.Now().Add(20 * time.Minute)}) + layerURL, err := lh.storageDriver.URLFor(blobPath, map[string]interface{}{"expiry": time.Now().Add(lh.duration)}) if err != nil { return "", err } @@ -51,34 +67,6 @@ func (lh *delegateLayerHandler) urlFor(layer Layer) (string, error) { return layerURL, nil } -// resolveBlobPath looks up the blob location in the repositories from a -// layer/blob link file, returning blob path or an error on failure. -func (lh *delegateLayerHandler) resolveBlobPath(name string, dgst digest.Digest) (string, error) { - pathSpec := layerLinkPathSpec{name: name, digest: dgst} - layerLinkPath, err := lh.pathMapper.path(pathSpec) - - if err != nil { - return "", err - } - - layerLinkContent, err := lh.storageDriver.GetContent(layerLinkPath) - if err != nil { - return "", err - } - - // NOTE(stevvooe): The content of the layer link should match the digest. - // This layer of indirection is for name-based content protection. - - linked, err := digest.ParseDigest(string(layerLinkContent)) - if err != nil { - return "", err - } - - bp := blobPathSpec{digest: linked} - - return lh.pathMapper.path(bp) -} - // init registers the delegate layerHandler backend. func init() { RegisterLayerHandler("delegate", LayerHandlerInitFunc(newDelegateLayerHandler)) diff --git a/storage/layerstore.go b/storage/layerstore.go index 6b3514540..f73bef6d2 100644 --- a/storage/layerstore.go +++ b/storage/layerstore.go @@ -30,7 +30,7 @@ func (ls *layerStore) Exists(name string, digest digest.Digest) (bool, error) { } func (ls *layerStore) Fetch(name string, digest digest.Digest) (Layer, error) { - blobPath, err := ls.resolveBlobPath(name, digest) + blobPath, err := resolveBlobPath(ls.driver, ls.pathMapper, name, digest) if err != nil { switch err := err.(type) { case storagedriver.PathNotFoundError, *storagedriver.PathNotFoundError: @@ -94,31 +94,3 @@ func (ls *layerStore) newLayerUpload(lus LayerUploadState) LayerUpload { uploadStore: ls.uploadStore, } } - -// resolveBlobPath looks up the blob location in the repositories from a -// layer/blob link file, returning blob path or an error on failure. -func (ls *layerStore) resolveBlobPath(name string, dgst digest.Digest) (string, error) { - pathSpec := layerLinkPathSpec{name: name, digest: dgst} - layerLinkPath, err := ls.pathMapper.path(pathSpec) - - if err != nil { - return "", err - } - - layerLinkContent, err := ls.driver.GetContent(layerLinkPath) - if err != nil { - return "", err - } - - // NOTE(stevvooe): The content of the layer link should match the digest. - // This layer of indirection is for name-based content protection. - - linked, err := digest.ParseDigest(string(layerLinkContent)) - if err != nil { - return "", err - } - - bp := blobPathSpec{digest: linked} - - return ls.pathMapper.path(bp) -} diff --git a/storage/paths.go b/storage/paths.go index 695bfa39e..c5d6c90fc 100644 --- a/storage/paths.go +++ b/storage/paths.go @@ -6,6 +6,7 @@ import ( "strings" "github.com/docker/distribution/digest" + "github.com/docker/distribution/storagedriver" ) const storagePathVersion = "v2" @@ -209,3 +210,31 @@ func digestPathComoponents(dgst digest.Digest) ([]string, error) { return append(prefix, suffix...), nil } + +// resolveBlobPath looks up the blob location in the repositories from a +// layer/blob link file, returning blob path or an error on failure. +func resolveBlobPath(driver storagedriver.StorageDriver, pm *pathMapper, name string, dgst digest.Digest) (string, error) { + pathSpec := layerLinkPathSpec{name: name, digest: dgst} + layerLinkPath, err := pm.path(pathSpec) + + if err != nil { + return "", err + } + + layerLinkContent, err := driver.GetContent(layerLinkPath) + if err != nil { + return "", err + } + + // NOTE(stevvooe): The content of the layer link should match the digest. + // This layer of indirection is for name-based content protection. + + linked, err := digest.ParseDigest(string(layerLinkContent)) + if err != nil { + return "", err + } + + bp := blobPathSpec{digest: linked} + + return pm.path(bp) +} diff --git a/storagedriver/s3/s3.go b/storagedriver/s3/s3.go index f8a046459..0e4dd2163 100644 --- a/storagedriver/s3/s3.go +++ b/storagedriver/s3/s3.go @@ -588,7 +588,7 @@ func (d *Driver) URLFor(path string, options map[string]interface{}) (string, er } expiresTime := time.Now().Add(20 * time.Minute) - expires, ok := options["expires"] + expires, ok := options["expiry"] if ok { et, ok := expires.(time.Time) if ok {