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 }