ba6b774aea
To smooth initial implementation, uploads were spooled to local file storage, validated, then pushed to remote storage. That approach was flawed in that it present easy clustering of registry services that share a remote storage backend. The original plan was to implement resumable hashes then implement remote upload storage. After some thought, it was found to be better to get remote spooling working, then optimize with resumable hashes. Moving to this approach has tradeoffs: after storing the complete upload remotely, the node must fetch the content and validate it before moving it to the final location. This can double bandwidth usage to the remote backend. Modifying the verification and upload code to store intermediate hashes should be trivial once the layer digest format has settled. The largest changes for users of the storage package (mostly the registry app) are the LayerService interface and the LayerUpload interface. The LayerService now takes qualified repository names to start and resume uploads. In corallry, the concept of LayerUploadState has been complete removed, exposing all aspects of that state as part of the LayerUpload object. The LayerUpload object has been modified to work as an io.WriteSeeker and includes a StartedAt time, to allow for upload timeout policies. Finish now only requires a digest, eliding the requirement for a size parameter. Resource cleanup has taken a turn for the better. Resources are cleaned up after successful uploads and during a cancel call. Admittedly, this is probably not completely where we want to be. It's recommend that we bolster this with a periodic driver utility script that scans for partial uploads and deletes the underlying data. As a small benefit, we can leave these around to better understand how and why these uploads are failing, at the cost of some extra disk space. Many other changes follow from the changes above. The webapp needs to be updated to meet the new interface requirements. Signed-off-by: Stephen J Day <stephen.day@docker.com>
97 lines
2.6 KiB
Go
97 lines
2.6 KiB
Go
package storage
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"time"
|
|
|
|
"github.com/docker/distribution/digest"
|
|
"github.com/docker/distribution/manifest"
|
|
)
|
|
|
|
// Layer provides a readable and seekable layer object. Typically,
|
|
// implementations are *not* goroutine safe.
|
|
type Layer interface {
|
|
// http.ServeContent requires an efficient implementation of
|
|
// ReadSeeker.Seek(0, os.SEEK_END).
|
|
io.ReadSeeker
|
|
io.Closer
|
|
|
|
// Name returns the repository under which this layer is linked.
|
|
Name() string // TODO(stevvooe): struggling with nomenclature: should this be "repo" or "name"?
|
|
|
|
// Digest returns the unique digest of the blob, which is the tarsum for
|
|
// layers.
|
|
Digest() digest.Digest
|
|
|
|
// CreatedAt returns the time this layer was created.
|
|
CreatedAt() time.Time
|
|
}
|
|
|
|
// LayerUpload provides a handle for working with in-progress uploads.
|
|
// Instances can be obtained from the LayerService.Upload and
|
|
// LayerService.Resume.
|
|
type LayerUpload interface {
|
|
io.WriteSeeker
|
|
io.Closer
|
|
|
|
// Name of the repository under which the layer will be linked.
|
|
Name() string
|
|
|
|
// UUID returns the identifier for this upload.
|
|
UUID() string
|
|
|
|
// StartedAt returns the time this layer upload was started.
|
|
StartedAt() time.Time
|
|
|
|
// Finish marks the upload as completed, returning a valid handle to the
|
|
// uploaded layer. The digest is validated against the contents of the
|
|
// uploaded layer.
|
|
Finish(digest digest.Digest) (Layer, error)
|
|
|
|
// Cancel the layer upload process.
|
|
Cancel() error
|
|
}
|
|
|
|
var (
|
|
// ErrLayerExists returned when layer already exists
|
|
ErrLayerExists = fmt.Errorf("layer exists")
|
|
|
|
// ErrLayerTarSumVersionUnsupported when tarsum is unsupported version.
|
|
ErrLayerTarSumVersionUnsupported = fmt.Errorf("unsupported tarsum version")
|
|
|
|
// ErrLayerUploadUnknown returned when upload is not found.
|
|
ErrLayerUploadUnknown = fmt.Errorf("layer upload unknown")
|
|
|
|
// ErrLayerClosed returned when an operation is attempted on a closed
|
|
// Layer or LayerUpload.
|
|
ErrLayerClosed = fmt.Errorf("layer closed")
|
|
)
|
|
|
|
// ErrUnknownLayer returned when layer cannot be found.
|
|
type ErrUnknownLayer struct {
|
|
FSLayer manifest.FSLayer
|
|
}
|
|
|
|
func (err ErrUnknownLayer) Error() string {
|
|
return fmt.Sprintf("unknown layer %v", err.FSLayer.BlobSum)
|
|
}
|
|
|
|
// ErrLayerInvalidDigest returned when tarsum check fails.
|
|
type ErrLayerInvalidDigest struct {
|
|
Digest digest.Digest
|
|
}
|
|
|
|
func (err ErrLayerInvalidDigest) Error() string {
|
|
return fmt.Sprintf("invalid digest for referenced layer: %v", err.Digest)
|
|
}
|
|
|
|
// ErrLayerInvalidSize returned when length check fails.
|
|
type ErrLayerInvalidSize struct {
|
|
Size int64
|
|
}
|
|
|
|
func (err ErrLayerInvalidSize) Error() string {
|
|
return fmt.Sprintf("invalid layer size: %d", err.Size)
|
|
}
|