226 lines
4.9 KiB
Go
226 lines
4.9 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"mediarr/ident"
|
|
)
|
|
|
|
var (
|
|
ErrInvalidLocator = errors.New("locator de stockage invalide")
|
|
ErrNotFound = errors.New("objet de stockage introuvable")
|
|
)
|
|
|
|
type Staged struct {
|
|
Locator string
|
|
Size int64
|
|
Root []byte
|
|
}
|
|
|
|
type Store interface {
|
|
Stage(ctx context.Context, id ident.UUID, src io.Reader) (Staged, error)
|
|
Commit(ctx context.Context, staged Staged) (string, error)
|
|
Replace(ctx context.Context, staged Staged) (string, error)
|
|
Open(ctx context.Context, locator string) (io.ReadCloser, error)
|
|
Remove(ctx context.Context, locator string) error
|
|
}
|
|
|
|
type Local struct {
|
|
root string
|
|
}
|
|
|
|
func NewLocal(root string) (*Local, error) {
|
|
if strings.TrimSpace(root) == "" {
|
|
return nil, errors.New("racine de stockage vide")
|
|
}
|
|
|
|
absolute, err := filepath.Abs(root)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, directory := range []string{
|
|
filepath.Join(absolute, "staging"),
|
|
filepath.Join(absolute, "blobs"),
|
|
} {
|
|
if err := os.MkdirAll(directory, 0o750); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return &Local{root: absolute}, nil
|
|
}
|
|
|
|
func (l *Local) Stage(ctx context.Context, id ident.UUID, src io.Reader) (Staged, error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return Staged{}, err
|
|
}
|
|
|
|
locator := filepath.ToSlash(filepath.Join("staging", hex.EncodeToString(id[:])))
|
|
path, err := l.resolve(locator)
|
|
if err != nil {
|
|
return Staged{}, err
|
|
}
|
|
|
|
file, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o640)
|
|
if err != nil {
|
|
return Staged{}, err
|
|
}
|
|
|
|
hasher := sha256.New()
|
|
size, copyErr := io.Copy(io.MultiWriter(file, hasher), src)
|
|
closeErr := file.Close()
|
|
if copyErr != nil {
|
|
_ = os.Remove(path)
|
|
return Staged{}, copyErr
|
|
}
|
|
if closeErr != nil {
|
|
_ = os.Remove(path)
|
|
return Staged{}, closeErr
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
_ = os.Remove(path)
|
|
return Staged{}, err
|
|
}
|
|
|
|
return Staged{
|
|
Locator: locator,
|
|
Size: size,
|
|
Root: hasher.Sum(nil),
|
|
}, nil
|
|
}
|
|
|
|
func (l *Local) Commit(ctx context.Context, staged Staged) (string, error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return "", err
|
|
}
|
|
if len(staged.Root) != sha256.Size {
|
|
return "", fmt.Errorf("%w: empreinte de %d octets", ErrInvalidLocator, len(staged.Root))
|
|
}
|
|
|
|
source, err := l.resolve(staged.Locator)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
root := hex.EncodeToString(staged.Root)
|
|
locator := filepath.ToSlash(filepath.Join("blobs", root[:2], root[2:4], root))
|
|
target, err := l.resolve(locator)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(target), 0o750); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if _, err := os.Stat(target); err == nil {
|
|
if err := os.Remove(source); err != nil && !os.IsNotExist(err) {
|
|
return "", err
|
|
}
|
|
return locator, nil
|
|
} else if !os.IsNotExist(err) {
|
|
return "", err
|
|
}
|
|
|
|
if err := os.Rename(source, target); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return locator, nil
|
|
}
|
|
|
|
func (l *Local) Replace(ctx context.Context, staged Staged) (string, error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return "", err
|
|
}
|
|
if len(staged.Root) != sha256.Size {
|
|
return "", fmt.Errorf("%w: empreinte de %d octets", ErrInvalidLocator, len(staged.Root))
|
|
}
|
|
|
|
source, err := l.resolve(staged.Locator)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
root := hex.EncodeToString(staged.Root)
|
|
locator := filepath.ToSlash(filepath.Join("blobs", root[:2], root[2:4], root))
|
|
target, err := l.resolve(locator)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(target), 0o750); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if err := os.Rename(source, target); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return locator, nil
|
|
}
|
|
|
|
func (l *Local) Open(ctx context.Context, locator string) (io.ReadCloser, error) {
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
path, err := l.resolve(locator)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
file, err := os.Open(path)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("%w: %s", ErrNotFound, locator)
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return file, nil
|
|
}
|
|
|
|
func (l *Local) Remove(ctx context.Context, locator string) error {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
|
|
path, err := l.resolve(locator)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (l *Local) resolve(locator string) (string, error) {
|
|
if locator == "" || filepath.IsAbs(locator) {
|
|
return "", fmt.Errorf("%w: %q", ErrInvalidLocator, locator)
|
|
}
|
|
|
|
cleaned := filepath.Clean(filepath.FromSlash(locator))
|
|
if cleaned == "." || cleaned == ".." || strings.HasPrefix(cleaned, ".."+string(filepath.Separator)) {
|
|
return "", fmt.Errorf("%w: %q", ErrInvalidLocator, locator)
|
|
}
|
|
|
|
path := filepath.Join(l.root, cleaned)
|
|
relative, err := filepath.Rel(l.root, path)
|
|
if err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
|
|
return "", fmt.Errorf("%w: %q", ErrInvalidLocator, locator)
|
|
}
|
|
|
|
return path, nil
|
|
}
|