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) 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) 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 }