Files
Mediarr/content/version.go
T
2026-11-16 11:03:48 +01:00

435 lines
12 KiB
Go

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
healBlob := false
blobLocator := ""
switch {
case err == nil:
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)
}
if blob.State != BlobStatePresent {
_, locationErr := s.db.Queries.GetBlobLocation(ctx, database.GetBlobLocationParams{
Root: staged.Root,
BackendID: s.backendID,
})
switch {
case locationErr == nil:
blobLocator, err = s.store.Replace(ctx, staged)
if err != nil {
_ = s.store.Remove(ctx, staged.Locator)
_ = s.setStagingState(ctx, stagingID, StagingStateDiscarded)
return nil, err
}
case errors.Is(locationErr, sql.ErrNoRows):
blobLocator, err = s.store.Replace(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
}
healBlob = true
break
}
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
}
}
if healBlob {
if err := q.UpdateBlobVerification(ctx, database.UpdateBlobVerificationParams{
State: BlobStatePresent,
LastVerifiedAt: sql.NullInt64{Int64: now, Valid: true},
VerifyError: sql.NullString{},
Root: staged.Root,
}); err != nil {
return err
}
if !newLocation {
if err := q.UpdateBlobLocationState(ctx, database.UpdateBlobLocationStateParams{
State: BlobLocationPresent,
Root: staged.Root,
BackendID: s.backendID,
}); err != nil {
return err
}
}
}
if !newBlob {
existing, err := q.GetBlob(ctx, staged.Root)
if err != nil {
return fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
}
if existing.State != BlobStatePresent || existing.Size != staged.Size {
return fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
}
}
if !newLocation {
existingLocation, err := q.GetBlobLocation(ctx, database.GetBlobLocationParams{
Root: staged.Root,
BackendID: s.backendID,
})
if err != nil {
return fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
}
if existingLocation.State != BlobLocationPresent {
return fmt.Errorf("%w: %x", ErrBlobUnavailable, staged.Root)
}
}
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 (s *Service) HeadVersion(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
}
if documentRow.HeadVersionID == nil {
return nil, nil
}
version, err := s.getVersion(ctx, *documentRow.HeadVersionID)
if err != nil {
return nil, err
}
if version.DocumentID != documentID {
return nil, fmt.Errorf("%w: %s", ErrVersionMismatch, version.ID)
}
return versionFromDB(*version), nil
}
func boolToInt(value bool) int64 {
if value {
return 1
}
return 0
}