Factors out resolveBlobPath, renames expires -> expiry

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

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)
-}

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)
+}

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 {