create content version

This commit is contained in:
venture
2026-11-15 10:01:30 +01:00
parent 29a6ab40f0
commit 610192e2d5
13 changed files with 2226 additions and 3 deletions
+189 -3
View File
@@ -1,8 +1,194 @@
package storage
type Storage struct {
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
}
func NewStorage() Storage {
return Storage{}
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
}
+138
View File
@@ -0,0 +1,138 @@
package storage
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"io"
"os"
"path/filepath"
"strings"
"testing"
"mediarr/ident"
)
func TestLocalStageCommitDedupOpenRemove(t *testing.T) {
ctx := context.Background()
root := t.TempDir()
store, err := NewLocal(root)
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
payload := []byte("contenu local")
expectedRoot := sha256.Sum256(payload)
staged, err := store.Stage(ctx, mustUUID(t), bytes.NewReader(payload))
if err != nil {
t.Fatalf("Stage : %v", err)
}
if staged.Size != int64(len(payload)) {
t.Fatalf("size = %d, attendu %d", staged.Size, len(payload))
}
if !bytes.Equal(staged.Root, expectedRoot[:]) {
t.Fatalf("root = %x, attendu %x", staged.Root, expectedRoot)
}
if !strings.HasPrefix(staged.Locator, "staging/") {
t.Fatalf("locator = %q, attendu staging/...", staged.Locator)
}
locator, err := store.Commit(ctx, staged)
if err != nil {
t.Fatalf("Commit : %v", err)
}
rootHex := hex.EncodeToString(expectedRoot[:])
expectedLocator := filepath.ToSlash(filepath.Join("blobs", rootHex[:2], rootHex[2:4], rootHex))
if locator != expectedLocator {
t.Fatalf("locator = %q, attendu %q", locator, expectedLocator)
}
if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(staged.Locator))); !os.IsNotExist(err) {
t.Fatalf("fichier de staging encore présent : %v", err)
}
reader, err := store.Open(ctx, locator)
if err != nil {
t.Fatalf("Open : %v", err)
}
data, err := io.ReadAll(reader)
if err != nil {
_ = reader.Close()
t.Fatalf("ReadAll : %v", err)
}
if err := reader.Close(); err != nil {
t.Fatalf("Close : %v", err)
}
if !bytes.Equal(data, payload) {
t.Fatalf("contenu = %q, attendu %q", data, payload)
}
duplicate, err := store.Stage(ctx, mustUUID(t), bytes.NewReader(payload))
if err != nil {
t.Fatalf("Stage(doublon) : %v", err)
}
duplicateLocator, err := store.Commit(ctx, duplicate)
if err != nil {
t.Fatalf("Commit(doublon) : %v", err)
}
if duplicateLocator != locator {
t.Fatalf("locator doublon = %q, attendu %q", duplicateLocator, locator)
}
if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(duplicate.Locator))); !os.IsNotExist(err) {
t.Fatalf("staging doublon encore présent : %v", err)
}
if err := store.Remove(ctx, locator); err != nil {
t.Fatalf("Remove : %v", err)
}
if _, err := store.Open(ctx, locator); !errors.Is(err, ErrNotFound) {
t.Fatalf("Open après Remove : erreur = %v, attendu ErrNotFound", err)
}
}
func TestLocalRejectsInvalidLocators(t *testing.T) {
ctx := context.Background()
store, err := NewLocal(t.TempDir())
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
for _, locator := range []string{"", "../secret", "/etc/passwd", "staging/../../secret"} {
if _, err := store.Open(ctx, locator); !errors.Is(err, ErrInvalidLocator) {
t.Fatalf("Open(%q) : erreur = %v, attendu ErrInvalidLocator", locator, err)
}
}
if _, err := store.Commit(ctx, Staged{Locator: "staging/x", Root: []byte{1}}); !errors.Is(err, ErrInvalidLocator) {
t.Fatalf("Commit avec racine invalide : erreur = %v, attendu ErrInvalidLocator", err)
}
}
func TestLocalStageHonorsCanceledContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
store, err := NewLocal(t.TempDir())
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
if _, err := store.Stage(ctx, mustUUID(t), strings.NewReader("contenu")); !errors.Is(err, context.Canceled) {
t.Fatalf("Stage : erreur = %v, attendu context.Canceled", err)
}
}
func mustUUID(t *testing.T) ident.UUID {
t.Helper()
id, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
return id
}