create content version
This commit is contained in:
@@ -0,0 +1,72 @@
|
||||
package content
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"io"
|
||||
|
||||
"mediarr/ident"
|
||||
)
|
||||
|
||||
const (
|
||||
OriginUpload = "upload"
|
||||
OriginImport = "import"
|
||||
OriginMerge = "merge"
|
||||
OriginRestore = "restore"
|
||||
OriginSystem = "system"
|
||||
)
|
||||
|
||||
const (
|
||||
StagingStateStaged = "staged"
|
||||
StagingStateHashing = "hashing"
|
||||
StagingStateCommitted = "committed"
|
||||
StagingStateDiscarded = "discarded"
|
||||
)
|
||||
|
||||
const (
|
||||
BlobStatePresent = "present"
|
||||
BlobRoleAuthoritative = "authoritative"
|
||||
BlobTreeStateReady = "ready"
|
||||
BlobEncryptionNone = "none"
|
||||
BlobLocationPresent = "present"
|
||||
)
|
||||
|
||||
const blobUnitSize = 1024 * 1024
|
||||
|
||||
type Version struct {
|
||||
ID ident.UUID
|
||||
DocumentID ident.UUID
|
||||
Seq int64
|
||||
ContentRoot []byte
|
||||
Size int64
|
||||
Mime string
|
||||
AuthorID ident.UUID
|
||||
DeviceID *ident.UUID
|
||||
Origin string
|
||||
Message string
|
||||
Pinned bool
|
||||
ContentPurgedAt *int64
|
||||
CreatedAt int64
|
||||
}
|
||||
|
||||
type CreateVersionParams struct {
|
||||
Source io.Reader
|
||||
Mime string
|
||||
Origin string
|
||||
Message string
|
||||
Pinned bool
|
||||
DeviceID *ident.UUID
|
||||
JobRef string
|
||||
}
|
||||
|
||||
var (
|
||||
ErrStorageNotConfigured = errors.New("stockage non configuré")
|
||||
ErrStorageBackendMissing = errors.New("backend de stockage introuvable")
|
||||
ErrInvalidSource = errors.New("source de contenu invalide")
|
||||
ErrInvalidOrigin = errors.New("origine de version invalide")
|
||||
ErrNoContentKind = errors.New("type de document sans contenu")
|
||||
ErrNoStoragePolicy = errors.New("politique de stockage introuvable")
|
||||
ErrBlobUnavailable = errors.New("blob indisponible")
|
||||
ErrVersionNotFound = errors.New("version introuvable")
|
||||
ErrContentPurged = errors.New("contenu purgé")
|
||||
ErrContentUnavailable = errors.New("contenu indisponible")
|
||||
)
|
||||
@@ -0,0 +1,143 @@
|
||||
package content
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/hex"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"mediarr/database"
|
||||
"mediarr/document"
|
||||
"mediarr/ident"
|
||||
"mediarr/identity"
|
||||
"mediarr/permission"
|
||||
"mediarr/storage"
|
||||
)
|
||||
|
||||
var (
|
||||
testBackendID = ident.MustParse("00000000-0000-7000-8000-000000000201")
|
||||
testPolicyID = ident.MustParse("00000000-0000-7000-8000-000000000101")
|
||||
)
|
||||
|
||||
type testAuthorizer struct {
|
||||
allowed permission.Permission
|
||||
}
|
||||
|
||||
func allowAll() *testAuthorizer {
|
||||
return &testAuthorizer{allowed: permission.All}
|
||||
}
|
||||
|
||||
func (a *testAuthorizer) IsActive(context.Context, ident.UUID) (bool, error) {
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (a *testAuthorizer) Can(_ context.Context, _ ident.UUID, _ ident.UUID, required permission.Permission) (bool, error) {
|
||||
return a.allowed.Has(required), nil
|
||||
}
|
||||
|
||||
type testEnv struct {
|
||||
service *Service
|
||||
db *database.DatabaseClient
|
||||
store *storage.Local
|
||||
owner *identity.Principal
|
||||
libraryID ident.UUID
|
||||
videoID ident.UUID
|
||||
}
|
||||
|
||||
func newTestEnv(t *testing.T, authorizer document.Authorizer) *testEnv {
|
||||
t.Helper()
|
||||
|
||||
t.Chdir(t.TempDir())
|
||||
|
||||
err, db := database.NewDatabase(database.NewDatabaseParams{})
|
||||
if err != nil {
|
||||
t.Fatalf("NewDatabase : %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
if err := db.Close(); err != nil {
|
||||
t.Errorf("Close : %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
store, err := storage.NewLocal(filepath.Join("store"))
|
||||
if err != nil {
|
||||
t.Fatalf("NewLocal : %v", err)
|
||||
}
|
||||
|
||||
now := time.Now().UnixMilli()
|
||||
if err := db.WriteQueries.CreateStorageBackend(context.Background(), database.CreateStorageBackendParams{
|
||||
ID: testBackendID,
|
||||
Kind: "hub_fs",
|
||||
Name: "local",
|
||||
Config: `{"root":"store"}`,
|
||||
Enabled: 1,
|
||||
State: "ok",
|
||||
CreatedAt: now,
|
||||
}); err != nil {
|
||||
t.Fatalf("CreateStorageBackend : %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
owner, err := identity.NewService(*db).CreatePrincipal(ctx, identity.CreatePrincipalParams{
|
||||
Kind: identity.KindUser,
|
||||
Name: "owner",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreatePrincipal : %v", err)
|
||||
}
|
||||
|
||||
documents := document.NewService(*db, allowAll())
|
||||
library, err := documents.CreateLibrary(ctx, owner.ID, document.CreateLibraryParams{
|
||||
OwnerID: owner.ID,
|
||||
CreatedBy: owner.ID,
|
||||
Name: "Bibliothèque",
|
||||
PolicyID: testPolicyID,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateLibrary : %v", err)
|
||||
}
|
||||
|
||||
videoID := createVideo(t, db, owner, library, "film.mkv")
|
||||
|
||||
return &testEnv{
|
||||
service: NewService(*db, store, testBackendID, authorizer),
|
||||
db: db,
|
||||
store: store,
|
||||
owner: owner,
|
||||
libraryID: library.ID,
|
||||
videoID: videoID,
|
||||
}
|
||||
}
|
||||
|
||||
func createVideo(t *testing.T, db *database.DatabaseClient, owner *identity.Principal, parent *document.Document, name string) ident.UUID {
|
||||
t.Helper()
|
||||
|
||||
id, err := ident.NewV7()
|
||||
if err != nil {
|
||||
t.Fatalf("NewV7 : %v", err)
|
||||
}
|
||||
|
||||
now := time.Now().UnixMilli()
|
||||
if _, err := db.WriteQueries.CreateDocument(context.Background(), database.CreateDocumentParams{
|
||||
ID: id,
|
||||
Kind: "video",
|
||||
OwnerID: owner.ID,
|
||||
CreatedBy: owner.ID,
|
||||
ParentID: &parent.ID,
|
||||
Name: name,
|
||||
NameKey: strings.ToLower(name),
|
||||
Path: parent.Path + hex.EncodeToString(id[:]) + "/",
|
||||
Depth: parent.Depth + 1,
|
||||
Metadata: "{}",
|
||||
AclInherit: 1,
|
||||
Rev: 1,
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
}); err != nil {
|
||||
t.Fatalf("CreateDocument : %v", err)
|
||||
}
|
||||
|
||||
return id
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
package content
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"mediarr/database"
|
||||
"mediarr/document"
|
||||
"mediarr/ident"
|
||||
"mediarr/permission"
|
||||
"mediarr/storage"
|
||||
)
|
||||
|
||||
type Service struct {
|
||||
db database.DatabaseClient
|
||||
store storage.Store
|
||||
backendID ident.UUID
|
||||
authorizer document.Authorizer
|
||||
}
|
||||
|
||||
func NewService(db database.DatabaseClient, store storage.Store, backendID ident.UUID, authorizer document.Authorizer) *Service {
|
||||
return &Service{
|
||||
db: db,
|
||||
store: store,
|
||||
backendID: backendID,
|
||||
authorizer: authorizer,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Service) withTx(ctx context.Context, fn func(*database.Queries) error) error {
|
||||
tx, err := s.db.WriteDB.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() {
|
||||
_ = tx.Rollback()
|
||||
}()
|
||||
|
||||
if err := fn(s.db.WriteQueries.WithTx(tx)); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return tx.Commit()
|
||||
}
|
||||
|
||||
func (s *Service) getDocument(ctx context.Context, id ident.UUID) (*database.Document, error) {
|
||||
row, err := s.db.Queries.GetDocument(ctx, id)
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, fmt.Errorf("%w: %s", document.ErrDocumentNotFound, id)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &row, nil
|
||||
}
|
||||
|
||||
func (s *Service) getVersion(ctx context.Context, id ident.UUID) (*database.DocumentVersion, error) {
|
||||
row, err := s.db.Queries.GetDocumentVersion(ctx, id)
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, fmt.Errorf("%w: %s", ErrVersionNotFound, id)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &row, nil
|
||||
}
|
||||
|
||||
func (s *Service) can(ctx context.Context, principalID, documentID ident.UUID, required permission.Permission) error {
|
||||
allowed, err := s.authorizer.Can(ctx, principalID, documentID, required)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !allowed {
|
||||
return fmt.Errorf("%w: %s sur %s", document.ErrPermissionDenied, principalID, documentID)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) setStagingState(ctx context.Context, id ident.UUID, state string) error {
|
||||
return s.db.WriteQueries.UpdateStagingItemState(ctx, database.UpdateStagingItemStateParams{
|
||||
State: state,
|
||||
UpdatedAt: nowMillis(),
|
||||
ID: id,
|
||||
})
|
||||
}
|
||||
|
||||
func versionFromDB(version database.DocumentVersion) *Version {
|
||||
var mime string
|
||||
if version.Mime.Valid {
|
||||
mime = version.Mime.String
|
||||
}
|
||||
|
||||
var message string
|
||||
if version.Message.Valid {
|
||||
message = version.Message.String
|
||||
}
|
||||
|
||||
var purgedAt *int64
|
||||
if version.ContentPurgedAt.Valid {
|
||||
value := version.ContentPurgedAt.Int64
|
||||
purgedAt = &value
|
||||
}
|
||||
|
||||
return &Version{
|
||||
ID: version.ID,
|
||||
DocumentID: version.DocumentID,
|
||||
Seq: version.Seq,
|
||||
ContentRoot: version.ContentRoot,
|
||||
Size: version.Size,
|
||||
Mime: mime,
|
||||
AuthorID: version.AuthorID,
|
||||
DeviceID: version.DeviceID,
|
||||
Origin: version.Origin,
|
||||
Message: message,
|
||||
Pinned: version.Pinned != 0,
|
||||
ContentPurgedAt: purgedAt,
|
||||
CreatedAt: version.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
func validOrigin(origin string) bool {
|
||||
switch origin {
|
||||
case OriginUpload, OriginImport, OriginMerge, OriginRestore, OriginSystem:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func stagingOrigin(origin string) string {
|
||||
if origin == OriginImport {
|
||||
return OriginImport
|
||||
}
|
||||
return OriginUpload
|
||||
}
|
||||
|
||||
func nowMillis() int64 {
|
||||
return time.Now().UnixMilli()
|
||||
}
|
||||
@@ -0,0 +1,341 @@
|
||||
package content
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"mediarr/database"
|
||||
"mediarr/document"
|
||||
"mediarr/ident"
|
||||
"mediarr/permission"
|
||||
"mediarr/storage"
|
||||
)
|
||||
|
||||
func (s *Service) CreateVersion(ctx context.Context, actorID, documentID ident.UUID, params CreateVersionParams) (*Version, error) {
|
||||
if s.store == nil {
|
||||
return nil, ErrStorageNotConfigured
|
||||
}
|
||||
if params.Source == nil {
|
||||
return nil, ErrInvalidSource
|
||||
}
|
||||
|
||||
origin := params.Origin
|
||||
if origin == "" {
|
||||
origin = OriginUpload
|
||||
}
|
||||
if !validOrigin(origin) {
|
||||
return nil, fmt.Errorf("%w: %q", ErrInvalidOrigin, origin)
|
||||
}
|
||||
|
||||
documentRow, err := s.getDocument(ctx, documentID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if documentRow.DeletedAt.Valid {
|
||||
return nil, fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentID)
|
||||
}
|
||||
|
||||
kind, err := s.db.Queries.GetDocumentKind(ctx, documentRow.Kind)
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, fmt.Errorf("%w: %s", ErrNoContentKind, documentRow.Kind)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
if kind.HasContent == 0 {
|
||||
return nil, fmt.Errorf("%w: %s", ErrNoContentKind, documentRow.Kind)
|
||||
}
|
||||
|
||||
if err := s.can(ctx, actorID, documentID, permission.Write); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
policyBytes, err := s.db.Queries.GetEffectiveDocumentPolicy(ctx, documentID)
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, fmt.Errorf("%w: %s", ErrNoStoragePolicy, documentID)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
policyID, err := ident.FromBytes(policyBytes)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("%w: %v", ErrNoStoragePolicy, err)
|
||||
}
|
||||
if _, err := s.db.Queries.GetStoragePolicy(ctx, policyID); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, fmt.Errorf("%w: %s", ErrNoStoragePolicy, policyID)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
if _, err := s.db.Queries.GetStorageBackend(ctx, s.backendID); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, fmt.Errorf("%w: %s", ErrStorageBackendMissing, s.backendID)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
stagingID, err := ident.NewV7()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
staged, err := s.store.Stage(ctx, stagingID, params.Source)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
now := nowMillis()
|
||||
jobRef := sql.NullString{String: params.JobRef, Valid: params.JobRef != ""}
|
||||
|
||||
if err := s.db.WriteQueries.CreateStagingItem(ctx, database.CreateStagingItemParams{
|
||||
ID: stagingID,
|
||||
Origin: stagingOrigin(origin),
|
||||
JobRef: jobRef,
|
||||
Locator: staged.Locator,
|
||||
Size: sql.NullInt64{Int64: staged.Size, Valid: true},
|
||||
State: StagingStateStaged,
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
}); err != nil {
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
blob, err := s.db.Queries.GetBlob(ctx, staged.Root)
|
||||
newBlob := false
|
||||
newLocation := false
|
||||
blobLocator := ""
|
||||
|
||||
switch {
|
||||
case err == nil:
|
||||
if blob.State != BlobStatePresent {
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
|
||||
}
|
||||
if blob.Size != staged.Size {
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, fmt.Errorf("%w: taille incohérente", ErrBlobUnavailable)
|
||||
}
|
||||
|
||||
location, locationErr := s.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{
|
||||
Root: staged.Root,
|
||||
BackendID: s.backendID,
|
||||
})
|
||||
switch {
|
||||
case locationErr == nil:
|
||||
if location.State != BlobLocationPresent {
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
|
||||
}
|
||||
if err := s.store.Remove(ctx, staged.Locator); err != nil {
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, err
|
||||
}
|
||||
case errors.Is(locationErr, sql.ErrNoRows):
|
||||
blobLocator, err = s.store.Commit(ctx, staged)
|
||||
if err != nil {
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, err
|
||||
}
|
||||
newLocation = true
|
||||
default:
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, locationErr
|
||||
}
|
||||
case errors.Is(err, sql.ErrNoRows):
|
||||
blobLocator, err = s.store.Commit(ctx, staged)
|
||||
if err != nil {
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, err
|
||||
}
|
||||
newBlob = true
|
||||
newLocation = true
|
||||
default:
|
||||
_ = s.store.Remove(ctx, staged.Locator)
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var created database.DocumentVersion
|
||||
|
||||
err = s.withTx(ctx, func(q *database.Queries) error {
|
||||
if newBlob {
|
||||
if err := q.CreateBlob(ctx, database.CreateBlobParams{
|
||||
Root: staged.Root,
|
||||
Size: staged.Size,
|
||||
State: BlobStatePresent,
|
||||
Role: BlobRoleAuthoritative,
|
||||
UnitSize: blobUnitSize,
|
||||
TreeState: BlobTreeStateReady,
|
||||
Encryption: BlobEncryptionNone,
|
||||
CreatedAt: now,
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if newLocation {
|
||||
if err := q.CreateBlobLocation(ctx, database.CreateBlobLocationParams{
|
||||
Root: staged.Root,
|
||||
BackendID: s.backendID,
|
||||
Locator: blobLocator,
|
||||
State: BlobLocationPresent,
|
||||
CreatedAt: now,
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
seq, err := q.NextDocumentVersionSeq(ctx, documentID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
versionID, err := ident.NewV7()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
created, err = q.CreateDocumentVersion(ctx, database.CreateDocumentVersionParams{
|
||||
ID: versionID,
|
||||
DocumentID: documentID,
|
||||
Seq: seq,
|
||||
ContentRoot: staged.Root,
|
||||
Size: staged.Size,
|
||||
Mime: sql.NullString{String: params.Mime, Valid: params.Mime != ""},
|
||||
AuthorID: actorID,
|
||||
DeviceID: params.DeviceID,
|
||||
Origin: origin,
|
||||
Message: sql.NullString{String: params.Message, Valid: params.Message != ""},
|
||||
Pinned: boolToInt(params.Pinned),
|
||||
CreatedAt: now,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
rows, err := q.SetDocumentHeadVersion(ctx, database.SetDocumentHeadVersionParams{
|
||||
HeadVersionID: &versionID,
|
||||
UpdatedAt: now,
|
||||
ID: documentID,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if rows == 0 {
|
||||
return fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentID)
|
||||
}
|
||||
|
||||
return q.UpdateStagingItemState(ctx, database.UpdateStagingItemStateParams{
|
||||
State: StagingStateCommitted,
|
||||
UpdatedAt: now,
|
||||
ID: stagingID,
|
||||
})
|
||||
})
|
||||
if err != nil {
|
||||
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return versionFromDB(created), nil
|
||||
}
|
||||
|
||||
func (s *Service) OpenVersion(ctx context.Context, actorID, versionID ident.UUID) (io.ReadCloser, *Version, error) {
|
||||
if s.store == nil {
|
||||
return nil, nil, ErrStorageNotConfigured
|
||||
}
|
||||
|
||||
version, err := s.getVersion(ctx, versionID)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
documentRow, err := s.getDocument(ctx, version.DocumentID)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
if documentRow.DeletedAt.Valid {
|
||||
return nil, nil, fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentRow.ID)
|
||||
}
|
||||
if err := s.can(ctx, actorID, version.DocumentID, permission.Read); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
if version.ContentPurgedAt.Valid {
|
||||
return nil, nil, fmt.Errorf("%w: %s", ErrContentPurged, versionID)
|
||||
}
|
||||
|
||||
blob, err := s.db.Queries.GetBlob(ctx, version.ContentRoot)
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
|
||||
}
|
||||
return nil, nil, err
|
||||
}
|
||||
if blob.State != BlobStatePresent {
|
||||
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
|
||||
}
|
||||
|
||||
location, err := s.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{
|
||||
Root: version.ContentRoot,
|
||||
BackendID: s.backendID,
|
||||
})
|
||||
if err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
|
||||
}
|
||||
return nil, nil, err
|
||||
}
|
||||
if location.State != BlobLocationPresent {
|
||||
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
|
||||
}
|
||||
|
||||
reader, err := s.store.Open(ctx, location.Locator)
|
||||
if err != nil {
|
||||
if errors.Is(err, storage.ErrNotFound) {
|
||||
return nil, nil, fmt.Errorf("%w: %s", ErrContentUnavailable, versionID)
|
||||
}
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
return reader, versionFromDB(*version), nil
|
||||
}
|
||||
|
||||
func (s *Service) ListVersions(ctx context.Context, actorID, documentID ident.UUID) ([]Version, error) {
|
||||
documentRow, err := s.getDocument(ctx, documentID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if documentRow.DeletedAt.Valid {
|
||||
return nil, fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentID)
|
||||
}
|
||||
if err := s.can(ctx, actorID, documentID, permission.Read); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
rows, err := s.db.Queries.ListDocumentVersions(ctx, documentID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
versions := make([]Version, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
versions = append(versions, *versionFromDB(row))
|
||||
}
|
||||
|
||||
return versions, nil
|
||||
}
|
||||
|
||||
func boolToInt(value bool) int64 {
|
||||
if value {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
package content
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"mediarr/database"
|
||||
"mediarr/document"
|
||||
"mediarr/ident"
|
||||
"mediarr/permission"
|
||||
)
|
||||
|
||||
func TestCreateVersionStoresAndDeduplicates(t *testing.T) {
|
||||
env := newTestEnv(t, allowAll())
|
||||
ctx := context.Background()
|
||||
|
||||
payload := []byte("contenu de test")
|
||||
first, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader(payload),
|
||||
Mime: "video/mp4",
|
||||
Message: "première",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateVersion : %v", err)
|
||||
}
|
||||
if first.Seq != 1 || first.Size != int64(len(payload)) {
|
||||
t.Fatalf("version = seq %d taille %d", first.Seq, first.Size)
|
||||
}
|
||||
|
||||
second, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader(payload),
|
||||
Origin: OriginMerge,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateVersion(doublon) : %v", err)
|
||||
}
|
||||
if second.Seq != 2 {
|
||||
t.Fatalf("seq = %d, attendu 2", second.Seq)
|
||||
}
|
||||
if !bytes.Equal(second.ContentRoot, first.ContentRoot) {
|
||||
t.Fatalf("content_root = %x, attendu %x", second.ContentRoot, first.ContentRoot)
|
||||
}
|
||||
if second.Origin != OriginMerge {
|
||||
t.Fatalf("origin = %q, attendu %q", second.Origin, OriginMerge)
|
||||
}
|
||||
|
||||
reader, opened, err := env.service.OpenVersion(ctx, env.owner.ID, second.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("OpenVersion : %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)
|
||||
}
|
||||
if opened.ID != second.ID {
|
||||
t.Fatalf("version = %s, attendu %s", opened.ID, second.ID)
|
||||
}
|
||||
|
||||
versions, err := env.service.ListVersions(ctx, env.owner.ID, env.videoID)
|
||||
if err != nil {
|
||||
t.Fatalf("ListVersions : %v", err)
|
||||
}
|
||||
if len(versions) != 2 || versions[0].ID != second.ID || versions[1].ID != first.ID {
|
||||
t.Fatalf("versions = %+v", versions)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateVersionRejectsContainerKind(t *testing.T) {
|
||||
env := newTestEnv(t, allowAll())
|
||||
|
||||
_, err := env.service.CreateVersion(context.Background(), env.owner.ID, env.libraryID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
})
|
||||
if !errors.Is(err, ErrNoContentKind) {
|
||||
t.Fatalf("erreur = %v, attendu ErrNoContentKind", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateVersionRequiresWrite(t *testing.T) {
|
||||
env := newTestEnv(t, &testAuthorizer{allowed: permission.Read})
|
||||
|
||||
_, err := env.service.CreateVersion(context.Background(), env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
})
|
||||
if !errors.Is(err, document.ErrPermissionDenied) {
|
||||
t.Fatalf("erreur = %v, attendu ErrPermissionDenied", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenVersionRequiresRead(t *testing.T) {
|
||||
env := newTestEnv(t, &testAuthorizer{allowed: permission.Write})
|
||||
ctx := context.Background()
|
||||
|
||||
version, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateVersion : %v", err)
|
||||
}
|
||||
|
||||
if _, _, err := env.service.OpenVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, document.ErrPermissionDenied) {
|
||||
t.Fatalf("erreur = %v, attendu ErrPermissionDenied", err)
|
||||
}
|
||||
if _, err := env.service.ListVersions(ctx, env.owner.ID, env.videoID); !errors.Is(err, document.ErrPermissionDenied) {
|
||||
t.Fatalf("ListVersions : erreur = %v, attendu ErrPermissionDenied", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenVersionPurged(t *testing.T) {
|
||||
env := newTestEnv(t, allowAll())
|
||||
ctx := context.Background()
|
||||
|
||||
version, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateVersion : %v", err)
|
||||
}
|
||||
|
||||
if _, err := env.db.WriteDB.ExecContext(ctx,
|
||||
"UPDATE document_version SET content_purged_at = ? WHERE id = ?",
|
||||
time.Now().UnixMilli(), version.ID,
|
||||
); err != nil {
|
||||
t.Fatalf("UPDATE content_purged_at : %v", err)
|
||||
}
|
||||
|
||||
if _, _, err := env.service.OpenVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, ErrContentPurged) {
|
||||
t.Fatalf("erreur = %v, attendu ErrContentPurged", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenVersionMissingBlob(t *testing.T) {
|
||||
env := newTestEnv(t, allowAll())
|
||||
ctx := context.Background()
|
||||
|
||||
version, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("CreateVersion : %v", err)
|
||||
}
|
||||
|
||||
location, err := env.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{
|
||||
Root: version.ContentRoot,
|
||||
BackendID: testBackendID,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetBlobLocation : %v", err)
|
||||
}
|
||||
if err := env.store.Remove(ctx, location.Locator); err != nil {
|
||||
t.Fatalf("Remove : %v", err)
|
||||
}
|
||||
|
||||
if _, _, err := env.service.OpenVersion(ctx, env.owner.ID, version.ID); !errors.Is(err, ErrContentUnavailable) {
|
||||
t.Fatalf("erreur = %v, attendu ErrContentUnavailable", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateVersionConfigurationErrors(t *testing.T) {
|
||||
env := newTestEnv(t, allowAll())
|
||||
ctx := context.Background()
|
||||
|
||||
if _, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{}); !errors.Is(err, ErrInvalidSource) {
|
||||
t.Fatalf("sans source : erreur = %v, attendu ErrInvalidSource", err)
|
||||
}
|
||||
|
||||
if _, err := env.service.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
Origin: "inconnu",
|
||||
}); !errors.Is(err, ErrInvalidOrigin) {
|
||||
t.Fatalf("origine invalide : erreur = %v, attendu ErrInvalidOrigin", err)
|
||||
}
|
||||
|
||||
missingBackend := NewService(*env.db, env.store, ident.MustParse("00000000-0000-7000-8000-000000000202"), allowAll())
|
||||
if _, err := missingBackend.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
}); !errors.Is(err, ErrStorageBackendMissing) {
|
||||
t.Fatalf("backend manquant : erreur = %v, attendu ErrStorageBackendMissing", err)
|
||||
}
|
||||
|
||||
withoutStore := NewService(*env.db, nil, testBackendID, allowAll())
|
||||
if _, err := withoutStore.CreateVersion(ctx, env.owner.ID, env.videoID, CreateVersionParams{
|
||||
Source: bytes.NewReader([]byte("x")),
|
||||
}); !errors.Is(err, ErrStorageNotConfigured) {
|
||||
t.Fatalf("sans stockage : erreur = %v, attendu ErrStorageNotConfigured", err)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user