342 lines
9.0 KiB
Go
342 lines
9.0 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
|
|
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
|
|
}
|