2015-02-11 03:14:23 +01:00
|
|
|
// Package base provides a base implementation of the storage driver that can
|
|
|
|
// be used to implement common checks. The goal is to increase the amount of
|
|
|
|
// code sharing.
|
|
|
|
//
|
|
|
|
// The canonical approach to use this class is to embed in the exported driver
|
|
|
|
// struct such that calls are proxied through this implementation. First,
|
|
|
|
// declare the internal driver, as follows:
|
|
|
|
//
|
|
|
|
// type driver struct { ... internal ...}
|
|
|
|
//
|
|
|
|
// The resulting type should implement StorageDriver such that it can be the
|
|
|
|
// target of a Base struct. The exported type can then be declared as follows:
|
|
|
|
//
|
|
|
|
// type Driver struct {
|
|
|
|
// Base
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// Because Driver embeds Base, it effectively implements Base. If the driver
|
|
|
|
// needs to intercept a call, before going to base, Driver should implement
|
|
|
|
// that method. Effectively, Driver can intercept calls before coming in and
|
|
|
|
// driver implements the actual logic.
|
|
|
|
//
|
|
|
|
// To further shield the embed from other packages, it is recommended to
|
|
|
|
// employ a private embed struct:
|
|
|
|
//
|
|
|
|
// type baseEmbed struct {
|
|
|
|
// base.Base
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// Then, declare driver to embed baseEmbed, rather than Base directly:
|
|
|
|
//
|
|
|
|
// type Driver struct {
|
|
|
|
// baseEmbed
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// The type now implements StorageDriver, proxying through Base, without
|
2015-04-16 20:37:31 +02:00
|
|
|
// exporting an unnecessary field.
|
2015-02-11 03:14:23 +01:00
|
|
|
package base
|
|
|
|
|
|
|
|
import (
|
|
|
|
"io"
|
|
|
|
|
2015-04-10 03:50:57 +02:00
|
|
|
"github.com/docker/distribution/context"
|
2015-02-11 03:14:23 +01:00
|
|
|
storagedriver "github.com/docker/distribution/registry/storage/driver"
|
|
|
|
)
|
|
|
|
|
|
|
|
// Base provides a wrapper around a storagedriver implementation that provides
|
|
|
|
// common path and bounds checking.
|
|
|
|
type Base struct {
|
|
|
|
storagedriver.StorageDriver
|
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
// Format errors received from the storage driver
|
|
|
|
func (base *Base) setDriverName(e error) error {
|
2015-11-02 22:23:53 +01:00
|
|
|
switch actual := e.(type) {
|
|
|
|
case nil:
|
|
|
|
return nil
|
|
|
|
case storagedriver.ErrUnsupportedMethod:
|
|
|
|
actual.DriverName = base.StorageDriver.Name()
|
|
|
|
return actual
|
|
|
|
case storagedriver.PathNotFoundError:
|
|
|
|
actual.DriverName = base.StorageDriver.Name()
|
|
|
|
return actual
|
|
|
|
case storagedriver.InvalidPathError:
|
|
|
|
actual.DriverName = base.StorageDriver.Name()
|
|
|
|
return actual
|
|
|
|
case storagedriver.InvalidOffsetError:
|
|
|
|
actual.DriverName = base.StorageDriver.Name()
|
|
|
|
return actual
|
|
|
|
default:
|
|
|
|
storageError := storagedriver.Error{
|
|
|
|
DriverName: base.StorageDriver.Name(),
|
|
|
|
Enclosed: e,
|
2015-10-03 01:19:06 +02:00
|
|
|
}
|
2015-11-02 22:23:53 +01:00
|
|
|
|
|
|
|
return storageError
|
2015-10-03 01:19:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
// GetContent wraps GetContent of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) GetContent(ctx context.Context, path string) ([]byte, error) {
|
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.GetContent(%q)", base.Name(), path)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if !storagedriver.PathRegexp.MatchString(path) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return nil, storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
b, e := base.StorageDriver.GetContent(ctx, path)
|
|
|
|
return b, base.setDriverName(e)
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// PutContent wraps PutContent of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) PutContent(ctx context.Context, path string, content []byte) error {
|
2015-06-30 19:28:14 +02:00
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.PutContent(%q)", base.Name(), path)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if !storagedriver.PathRegexp.MatchString(path) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
return base.setDriverName(base.StorageDriver.PutContent(ctx, path, content))
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// ReadStream wraps ReadStream of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) ReadStream(ctx context.Context, path string, offset int64) (io.ReadCloser, error) {
|
2015-06-30 19:28:14 +02:00
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.ReadStream(%q, %d)", base.Name(), path, offset)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if offset < 0 {
|
2015-10-03 01:19:06 +02:00
|
|
|
return nil, storagedriver.InvalidOffsetError{Path: path, Offset: offset, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if !storagedriver.PathRegexp.MatchString(path) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return nil, storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
rc, e := base.StorageDriver.ReadStream(ctx, path, offset)
|
|
|
|
return rc, base.setDriverName(e)
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// WriteStream wraps WriteStream of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) WriteStream(ctx context.Context, path string, offset int64, reader io.Reader) (nn int64, err error) {
|
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.WriteStream(%q, %d)", base.Name(), path, offset)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if offset < 0 {
|
2015-10-03 01:19:06 +02:00
|
|
|
return 0, storagedriver.InvalidOffsetError{Path: path, Offset: offset, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if !storagedriver.PathRegexp.MatchString(path) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return 0, storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
i64, e := base.StorageDriver.WriteStream(ctx, path, offset, reader)
|
|
|
|
return i64, base.setDriverName(e)
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Stat wraps Stat of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) Stat(ctx context.Context, path string) (storagedriver.FileInfo, error) {
|
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.Stat(%q)", base.Name(), path)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if !storagedriver.PathRegexp.MatchString(path) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return nil, storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
fi, e := base.StorageDriver.Stat(ctx, path)
|
|
|
|
return fi, base.setDriverName(e)
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// List wraps List of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) List(ctx context.Context, path string) ([]string, error) {
|
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.List(%q)", base.Name(), path)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if !storagedriver.PathRegexp.MatchString(path) && path != "/" {
|
2015-10-03 01:19:06 +02:00
|
|
|
return nil, storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
str, e := base.StorageDriver.List(ctx, path)
|
|
|
|
return str, base.setDriverName(e)
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Move wraps Move of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) Move(ctx context.Context, sourcePath string, destPath string) error {
|
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.Move(%q, %q", base.Name(), sourcePath, destPath)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if !storagedriver.PathRegexp.MatchString(sourcePath) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return storagedriver.InvalidPathError{Path: sourcePath, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
} else if !storagedriver.PathRegexp.MatchString(destPath) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return storagedriver.InvalidPathError{Path: destPath, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
return base.setDriverName(base.StorageDriver.Move(ctx, sourcePath, destPath))
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Delete wraps Delete of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) Delete(ctx context.Context, path string) error {
|
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.Delete(%q)", base.Name(), path)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if !storagedriver.PathRegexp.MatchString(path) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
return base.setDriverName(base.StorageDriver.Delete(ctx, path))
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// URLFor wraps URLFor of underlying storage driver.
|
2015-04-28 00:58:58 +02:00
|
|
|
func (base *Base) URLFor(ctx context.Context, path string, options map[string]interface{}) (string, error) {
|
|
|
|
ctx, done := context.WithTrace(ctx)
|
2015-04-23 02:30:31 +02:00
|
|
|
defer done("%s.URLFor(%q)", base.Name(), path)
|
2015-04-10 03:50:57 +02:00
|
|
|
|
2015-02-11 03:14:23 +01:00
|
|
|
if !storagedriver.PathRegexp.MatchString(path) {
|
2015-10-03 01:19:06 +02:00
|
|
|
return "", storagedriver.InvalidPathError{Path: path, DriverName: base.StorageDriver.Name()}
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 01:19:06 +02:00
|
|
|
str, e := base.StorageDriver.URLFor(ctx, path, options)
|
|
|
|
return str, base.setDriverName(e)
|
2015-02-11 03:14:23 +01:00
|
|
|
}
|