83d62628fc
This change refactors the storage backend to use the new path layout. To facilitate this, manifest storage has been separated into a revision store and tag store, supported by a more general blob store. The blob store is a hybrid object, effectively providing both small object access, keyed by content address, as well as methods that can be used to manage and traverse links to underlying blobs. This covers common operations used in the revision store and tag store, such as linking and traversal. The blob store can also be updated to better support layer reading but this refactoring has been left for another day. The revision store and tag store support the manifest store's compound view of data. These underlying stores provide facilities for richer access models, such as content-addressable access and a richer tagging model. The highlight of this change is the ability to sign a manifest from different hosts and have the registry merge and serve those signatures as part of the manifest package. Various other items, such as the delegate layer handler, were updated to more directly use the blob store or other mechanism to fit with the changes. Signed-off-by: Stephen J Day <stephen.day@docker.com>
79 lines
2.3 KiB
Go
79 lines
2.3 KiB
Go
package storage
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/docker/distribution/storagedriver"
|
|
)
|
|
|
|
// delegateLayerHandler provides a simple implementation of layerHandler that
|
|
// simply issues HTTP Temporary Redirects to the URL provided by the
|
|
// storagedriver for a given Layer.
|
|
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) {
|
|
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
|
|
// Layer, or an error if not supported by the storagedriver.
|
|
func (lh *delegateLayerHandler) Resolve(layer Layer) (http.Handler, error) {
|
|
layerURL, err := lh.urlFor(layer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
http.Redirect(w, r, layerURL, http.StatusTemporaryRedirect)
|
|
}), nil
|
|
}
|
|
|
|
// urlFor returns a download URL for the given layer, or the empty string if
|
|
// unsupported.
|
|
func (lh *delegateLayerHandler) urlFor(layer Layer) (string, error) {
|
|
// Crack open the layer to get at the layerStore
|
|
layerRd, ok := layer.(*layerReader)
|
|
if !ok {
|
|
// TODO(stevvooe): We probably want to find a better way to get at the
|
|
// underlying filesystem path for a given layer. Perhaps, the layer
|
|
// handler should have its own layer store but right now, it is not
|
|
// request scoped.
|
|
return "", fmt.Errorf("unsupported layer type: cannot resolve blob path: %v", layer)
|
|
}
|
|
|
|
layerURL, err := lh.storageDriver.URLFor(layerRd.path, map[string]interface{}{"expiry": time.Now().Add(lh.duration)})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return layerURL, nil
|
|
}
|
|
|
|
// init registers the delegate layerHandler backend.
|
|
func init() {
|
|
RegisterLayerHandler("delegate", LayerHandlerInitFunc(newDelegateLayerHandler))
|
|
}
|