Files
2026-11-16 10:04:52 +01:00

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
}