2014-10-21 22:02:20 +00:00
|
|
|
package filesystem
|
|
|
|
|
|
|
|
import (
|
2016-02-08 22:29:21 +00:00
|
|
|
"bufio"
|
2014-12-04 00:44:20 +00:00
|
|
|
"bytes"
|
2017-08-11 22:31:16 +00:00
|
|
|
"context"
|
2014-12-04 00:44:20 +00:00
|
|
|
"fmt"
|
2014-10-21 22:02:20 +00:00
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
"path"
|
2014-12-04 00:44:20 +00:00
|
|
|
"time"
|
2014-10-21 22:02:20 +00:00
|
|
|
|
2020-08-24 11:18:39 +00:00
|
|
|
storagedriver "github.com/distribution/distribution/v3/registry/storage/driver"
|
|
|
|
"github.com/distribution/distribution/v3/registry/storage/driver/base"
|
|
|
|
"github.com/distribution/distribution/v3/registry/storage/driver/factory"
|
2014-10-21 22:02:20 +00:00
|
|
|
)
|
|
|
|
|
2016-04-26 21:36:38 +00:00
|
|
|
const (
|
|
|
|
driverName = "filesystem"
|
|
|
|
defaultRootDirectory = "/var/lib/registry"
|
|
|
|
defaultMaxThreads = uint64(100)
|
|
|
|
|
|
|
|
// minThreads is the minimum value for the maxthreads configuration
|
|
|
|
// parameter. If the driver's parameters are less than this we set
|
|
|
|
// the parameters to minThreads
|
|
|
|
minThreads = uint64(25)
|
|
|
|
)
|
|
|
|
|
|
|
|
// DriverParameters represents all configuration options available for the
|
|
|
|
// filesystem driver
|
|
|
|
type DriverParameters struct {
|
|
|
|
RootDirectory string
|
|
|
|
MaxThreads uint64
|
|
|
|
}
|
2014-10-29 01:15:40 +00:00
|
|
|
|
|
|
|
func init() {
|
2014-11-17 23:44:07 +00:00
|
|
|
factory.Register(driverName, &filesystemDriverFactory{})
|
2014-10-29 01:15:40 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 19:14:19 +00:00
|
|
|
// filesystemDriverFactory implements the factory.StorageDriverFactory interface
|
2014-10-29 01:15:40 +00:00
|
|
|
type filesystemDriverFactory struct{}
|
|
|
|
|
2014-12-18 03:06:55 +00:00
|
|
|
func (factory *filesystemDriverFactory) Create(parameters map[string]interface{}) (storagedriver.StorageDriver, error) {
|
2016-04-26 21:36:38 +00:00
|
|
|
return FromParameters(parameters)
|
2014-10-29 01:15:40 +00:00
|
|
|
}
|
|
|
|
|
2015-02-04 00:54:52 +00:00
|
|
|
type driver struct {
|
|
|
|
rootDirectory string
|
|
|
|
}
|
|
|
|
|
|
|
|
type baseEmbed struct {
|
|
|
|
base.Base
|
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// Driver is a storagedriver.StorageDriver implementation backed by a local
|
2015-02-04 00:54:52 +00:00
|
|
|
// filesystem. All provided paths will be subpaths of the RootDirectory.
|
2014-11-17 23:44:07 +00:00
|
|
|
type Driver struct {
|
2015-02-04 00:54:52 +00:00
|
|
|
baseEmbed
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// FromParameters constructs a new Driver with a given parameters map
|
2014-10-29 01:15:40 +00:00
|
|
|
// Optional Parameters:
|
|
|
|
// - rootdirectory
|
2016-04-26 21:36:38 +00:00
|
|
|
// - maxthreads
|
|
|
|
func FromParameters(parameters map[string]interface{}) (*Driver, error) {
|
|
|
|
params, err := fromParametersImpl(parameters)
|
|
|
|
if err != nil || params == nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return New(*params), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func fromParametersImpl(parameters map[string]interface{}) (*DriverParameters, error) {
|
|
|
|
var (
|
|
|
|
err error
|
|
|
|
maxThreads = defaultMaxThreads
|
|
|
|
rootDirectory = defaultRootDirectory
|
|
|
|
)
|
|
|
|
|
2014-10-29 01:15:40 +00:00
|
|
|
if parameters != nil {
|
2016-04-26 21:36:38 +00:00
|
|
|
if rootDir, ok := parameters["rootdirectory"]; ok {
|
2014-12-18 03:06:55 +00:00
|
|
|
rootDirectory = fmt.Sprint(rootDir)
|
2014-10-29 01:15:40 +00:00
|
|
|
}
|
2016-04-26 21:36:38 +00:00
|
|
|
|
2016-12-06 23:50:39 +00:00
|
|
|
maxThreads, err = base.GetLimitFromParameter(parameters["maxthreads"], minThreads, defaultMaxThreads)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("maxthreads config error: %s", err.Error())
|
2016-04-26 21:36:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params := &DriverParameters{
|
|
|
|
RootDirectory: rootDirectory,
|
|
|
|
MaxThreads: maxThreads,
|
2014-10-29 01:15:40 +00:00
|
|
|
}
|
2016-04-26 21:36:38 +00:00
|
|
|
return params, nil
|
2014-10-29 01:15:40 +00:00
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// New constructs a new Driver with a given rootDirectory
|
2016-04-26 21:36:38 +00:00
|
|
|
func New(params DriverParameters) *Driver {
|
|
|
|
fsDriver := &driver{rootDirectory: params.RootDirectory}
|
2016-02-27 23:37:07 +00:00
|
|
|
|
2015-02-04 00:54:52 +00:00
|
|
|
return &Driver{
|
|
|
|
baseEmbed: baseEmbed{
|
|
|
|
Base: base.Base{
|
2016-04-26 21:36:38 +00:00
|
|
|
StorageDriver: base.NewRegulator(fsDriver, params.MaxThreads),
|
2015-02-04 00:54:52 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 01:15:40 +00:00
|
|
|
// Implement the storagedriver.StorageDriver interface
|
|
|
|
|
2015-04-23 00:30:01 +00:00
|
|
|
func (d *driver) Name() string {
|
|
|
|
return driverName
|
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// GetContent retrieves the content stored at "path" as a []byte.
|
2015-04-27 22:58:58 +00:00
|
|
|
func (d *driver) GetContent(ctx context.Context, path string) ([]byte, error) {
|
2016-02-08 22:29:21 +00:00
|
|
|
rc, err := d.Reader(ctx, path, 0)
|
2014-12-04 00:44:20 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer rc.Close()
|
|
|
|
|
2022-11-02 21:55:22 +00:00
|
|
|
p, err := io.ReadAll(rc)
|
2014-10-21 22:02:20 +00:00
|
|
|
if err != nil {
|
2014-12-04 00:44:20 +00:00
|
|
|
return nil, err
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
2014-12-04 00:44:20 +00:00
|
|
|
|
|
|
|
return p, nil
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// PutContent stores the []byte content at a location designated by "path".
|
2015-04-27 22:58:58 +00:00
|
|
|
func (d *driver) PutContent(ctx context.Context, subPath string, contents []byte) error {
|
2016-02-08 22:29:21 +00:00
|
|
|
writer, err := d.Writer(ctx, subPath, false)
|
|
|
|
if err != nil {
|
2014-10-21 22:02:20 +00:00
|
|
|
return err
|
|
|
|
}
|
2016-02-08 22:29:21 +00:00
|
|
|
defer writer.Close()
|
|
|
|
_, err = io.Copy(writer, bytes.NewReader(contents))
|
|
|
|
if err != nil {
|
2020-02-21 03:58:17 +00:00
|
|
|
writer.Cancel(ctx)
|
2016-02-08 22:29:21 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
return writer.Commit()
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2016-02-08 22:29:21 +00:00
|
|
|
// Reader retrieves an io.ReadCloser for the content stored at "path" with a
|
2014-11-17 23:44:07 +00:00
|
|
|
// given byte offset.
|
2016-02-08 22:29:21 +00:00
|
|
|
func (d *driver) Reader(ctx context.Context, path string, offset int64) (io.ReadCloser, error) {
|
2022-11-02 21:05:45 +00:00
|
|
|
file, err := os.OpenFile(d.fullPath(path), os.O_RDONLY, 0o644)
|
2014-10-21 22:02:20 +00:00
|
|
|
if err != nil {
|
2014-12-04 00:44:20 +00:00
|
|
|
if os.IsNotExist(err) {
|
|
|
|
return nil, storagedriver.PathNotFoundError{Path: path}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, err
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2018-08-06 21:34:15 +00:00
|
|
|
seekPos, err := file.Seek(offset, io.SeekStart)
|
2014-10-21 22:02:20 +00:00
|
|
|
if err != nil {
|
|
|
|
file.Close()
|
|
|
|
return nil, err
|
2018-08-06 21:34:15 +00:00
|
|
|
} else if seekPos < offset {
|
2014-10-21 22:02:20 +00:00
|
|
|
file.Close()
|
2014-11-13 01:19:19 +00:00
|
|
|
return nil, storagedriver.InvalidOffsetError{Path: path, Offset: offset}
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return file, nil
|
|
|
|
}
|
|
|
|
|
2016-02-08 22:29:21 +00:00
|
|
|
func (d *driver) Writer(ctx context.Context, subPath string, append bool) (storagedriver.FileWriter, error) {
|
2014-12-04 00:44:20 +00:00
|
|
|
fullPath := d.fullPath(subPath)
|
2014-10-21 22:02:20 +00:00
|
|
|
parentDir := path.Dir(fullPath)
|
2022-11-02 21:05:45 +00:00
|
|
|
if err := os.MkdirAll(parentDir, 0o777); err != nil {
|
2016-02-08 22:29:21 +00:00
|
|
|
return nil, err
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2022-11-02 21:05:45 +00:00
|
|
|
fp, err := os.OpenFile(fullPath, os.O_WRONLY|os.O_CREATE, 0o666)
|
2014-12-04 00:44:20 +00:00
|
|
|
if err != nil {
|
2016-02-08 22:29:21 +00:00
|
|
|
return nil, err
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2016-02-08 22:29:21 +00:00
|
|
|
var offset int64
|
2014-12-04 00:44:20 +00:00
|
|
|
|
2016-02-08 22:29:21 +00:00
|
|
|
if !append {
|
|
|
|
err := fp.Truncate(0)
|
|
|
|
if err != nil {
|
|
|
|
fp.Close()
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
} else {
|
2018-08-06 21:34:15 +00:00
|
|
|
n, err := fp.Seek(0, io.SeekEnd)
|
2016-02-08 22:29:21 +00:00
|
|
|
if err != nil {
|
|
|
|
fp.Close()
|
|
|
|
return nil, err
|
|
|
|
}
|
2018-08-06 21:34:15 +00:00
|
|
|
offset = n
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
2014-12-04 00:44:20 +00:00
|
|
|
|
2016-02-08 22:29:21 +00:00
|
|
|
return newFileWriter(fp, offset), nil
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2014-12-04 00:44:20 +00:00
|
|
|
// Stat retrieves the FileInfo for the given path, including the current size
|
|
|
|
// in bytes and the creation time.
|
2015-04-27 22:58:58 +00:00
|
|
|
func (d *driver) Stat(ctx context.Context, subPath string) (storagedriver.FileInfo, error) {
|
2014-12-04 00:44:20 +00:00
|
|
|
fullPath := d.fullPath(subPath)
|
2014-10-21 22:02:20 +00:00
|
|
|
|
2014-12-04 00:44:20 +00:00
|
|
|
fi, err := os.Stat(fullPath)
|
|
|
|
if err != nil {
|
|
|
|
if os.IsNotExist(err) {
|
|
|
|
return nil, storagedriver.PathNotFoundError{Path: subPath}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, err
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
2014-12-04 00:44:20 +00:00
|
|
|
|
|
|
|
return fileInfo{
|
|
|
|
path: subPath,
|
|
|
|
FileInfo: fi,
|
|
|
|
}, nil
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// List returns a list of the objects that are direct descendants of the given
|
|
|
|
// path.
|
2015-04-27 22:58:58 +00:00
|
|
|
func (d *driver) List(ctx context.Context, subPath string) ([]string, error) {
|
2014-12-04 00:44:20 +00:00
|
|
|
fullPath := d.fullPath(subPath)
|
2014-10-21 22:02:20 +00:00
|
|
|
|
|
|
|
dir, err := os.Open(fullPath)
|
|
|
|
if err != nil {
|
2014-12-18 00:56:36 +00:00
|
|
|
if os.IsNotExist(err) {
|
|
|
|
return nil, storagedriver.PathNotFoundError{Path: subPath}
|
|
|
|
}
|
2014-10-21 22:02:20 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2014-12-16 20:01:27 +00:00
|
|
|
defer dir.Close()
|
|
|
|
|
2014-10-21 22:02:20 +00:00
|
|
|
fileNames, err := dir.Readdirnames(0)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
keys := make([]string, 0, len(fileNames))
|
|
|
|
for _, fileName := range fileNames {
|
2014-11-04 17:52:24 +00:00
|
|
|
keys = append(keys, path.Join(subPath, fileName))
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return keys, nil
|
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// Move moves an object stored at sourcePath to destPath, removing the original
|
|
|
|
// object.
|
2015-04-27 22:58:58 +00:00
|
|
|
func (d *driver) Move(ctx context.Context, sourcePath string, destPath string) error {
|
2014-12-04 00:44:20 +00:00
|
|
|
source := d.fullPath(sourcePath)
|
|
|
|
dest := d.fullPath(destPath)
|
2014-11-19 01:41:48 +00:00
|
|
|
|
|
|
|
if _, err := os.Stat(source); os.IsNotExist(err) {
|
|
|
|
return storagedriver.PathNotFoundError{Path: sourcePath}
|
|
|
|
}
|
|
|
|
|
2022-11-02 21:05:45 +00:00
|
|
|
if err := os.MkdirAll(path.Dir(dest), 0o777); err != nil {
|
2014-12-09 02:22:08 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-11-19 01:41:48 +00:00
|
|
|
err := os.Rename(source, dest)
|
2014-10-21 22:02:20 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-11-17 23:44:07 +00:00
|
|
|
// Delete recursively deletes all objects stored at "path" and its subpaths.
|
2015-04-27 22:58:58 +00:00
|
|
|
func (d *driver) Delete(ctx context.Context, subPath string) error {
|
2014-12-04 00:44:20 +00:00
|
|
|
fullPath := d.fullPath(subPath)
|
2014-10-21 22:02:20 +00:00
|
|
|
|
|
|
|
_, err := os.Stat(fullPath)
|
|
|
|
if err != nil && !os.IsNotExist(err) {
|
|
|
|
return err
|
|
|
|
} else if err != nil {
|
2014-11-13 01:19:19 +00:00
|
|
|
return storagedriver.PathNotFoundError{Path: subPath}
|
2014-10-21 22:02:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
err = os.RemoveAll(fullPath)
|
|
|
|
return err
|
|
|
|
}
|
2014-12-04 00:44:20 +00:00
|
|
|
|
2015-01-07 16:31:38 +00:00
|
|
|
// URLFor returns a URL which may be used to retrieve the content stored at the given path.
|
|
|
|
// May return an UnsupportedMethodErr in certain StorageDriver implementations.
|
2015-04-27 22:58:58 +00:00
|
|
|
func (d *driver) URLFor(ctx context.Context, path string, options map[string]interface{}) (string, error) {
|
2015-11-02 21:23:53 +00:00
|
|
|
return "", storagedriver.ErrUnsupportedMethod{}
|
2015-01-07 16:31:38 +00:00
|
|
|
}
|
|
|
|
|
2017-11-29 19:17:39 +00:00
|
|
|
// Walk traverses a filesystem defined within driver, starting
|
2021-06-24 18:42:02 +00:00
|
|
|
// from the given path, calling f on each file and directory
|
2017-11-29 19:17:39 +00:00
|
|
|
func (d *driver) Walk(ctx context.Context, path string, f storagedriver.WalkFn) error {
|
|
|
|
return storagedriver.WalkFallback(ctx, d, path, f)
|
|
|
|
}
|
|
|
|
|
2014-12-04 00:44:20 +00:00
|
|
|
// fullPath returns the absolute path of a key within the Driver's storage.
|
2015-02-04 00:54:52 +00:00
|
|
|
func (d *driver) fullPath(subPath string) string {
|
2014-12-04 00:44:20 +00:00
|
|
|
return path.Join(d.rootDirectory, subPath)
|
|
|
|
}
|
|
|
|
|
|
|
|
type fileInfo struct {
|
|
|
|
os.FileInfo
|
|
|
|
path string
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ storagedriver.FileInfo = fileInfo{}
|
|
|
|
|
|
|
|
// Path provides the full path of the target of this file info.
|
|
|
|
func (fi fileInfo) Path() string {
|
|
|
|
return fi.path
|
|
|
|
}
|
|
|
|
|
|
|
|
// Size returns current length in bytes of the file. The return value can
|
|
|
|
// be used to write to the end of the file at path. The value is
|
|
|
|
// meaningless if IsDir returns true.
|
|
|
|
func (fi fileInfo) Size() int64 {
|
|
|
|
if fi.IsDir() {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
return fi.FileInfo.Size()
|
|
|
|
}
|
|
|
|
|
|
|
|
// ModTime returns the modification time for the file. For backends that
|
|
|
|
// don't have a modification time, the creation time should be returned.
|
|
|
|
func (fi fileInfo) ModTime() time.Time {
|
|
|
|
return fi.FileInfo.ModTime()
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsDir returns true if the path is a directory.
|
|
|
|
func (fi fileInfo) IsDir() bool {
|
|
|
|
return fi.FileInfo.IsDir()
|
|
|
|
}
|
2016-02-08 22:29:21 +00:00
|
|
|
|
|
|
|
type fileWriter struct {
|
|
|
|
file *os.File
|
|
|
|
size int64
|
|
|
|
bw *bufio.Writer
|
|
|
|
closed bool
|
|
|
|
committed bool
|
|
|
|
cancelled bool
|
|
|
|
}
|
|
|
|
|
|
|
|
func newFileWriter(file *os.File, size int64) *fileWriter {
|
|
|
|
return &fileWriter{
|
|
|
|
file: file,
|
|
|
|
size: size,
|
|
|
|
bw: bufio.NewWriter(file),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fw *fileWriter) Write(p []byte) (int, error) {
|
|
|
|
if fw.closed {
|
|
|
|
return 0, fmt.Errorf("already closed")
|
|
|
|
} else if fw.committed {
|
|
|
|
return 0, fmt.Errorf("already committed")
|
|
|
|
} else if fw.cancelled {
|
|
|
|
return 0, fmt.Errorf("already cancelled")
|
|
|
|
}
|
|
|
|
n, err := fw.bw.Write(p)
|
|
|
|
fw.size += int64(n)
|
|
|
|
return n, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fw *fileWriter) Size() int64 {
|
|
|
|
return fw.size
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fw *fileWriter) Close() error {
|
|
|
|
if fw.closed {
|
|
|
|
return fmt.Errorf("already closed")
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := fw.bw.Flush(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := fw.file.Sync(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := fw.file.Close(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
fw.closed = true
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-02-21 03:58:17 +00:00
|
|
|
func (fw *fileWriter) Cancel(ctx context.Context) error {
|
2016-02-08 22:29:21 +00:00
|
|
|
if fw.closed {
|
|
|
|
return fmt.Errorf("already closed")
|
|
|
|
}
|
|
|
|
|
|
|
|
fw.cancelled = true
|
|
|
|
fw.file.Close()
|
|
|
|
return os.Remove(fw.file.Name())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fw *fileWriter) Commit() error {
|
|
|
|
if fw.closed {
|
|
|
|
return fmt.Errorf("already closed")
|
|
|
|
} else if fw.committed {
|
|
|
|
return fmt.Errorf("already committed")
|
|
|
|
} else if fw.cancelled {
|
|
|
|
return fmt.Errorf("already cancelled")
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := fw.bw.Flush(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := fw.file.Sync(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
fw.committed = true
|
|
|
|
return nil
|
|
|
|
}
|