commit 113f9d9ab4797de6ae17819c96ae866992214021
parent e0f9323b9aa98b55f3557086f7b0a17047943f39
Author: tsmethurst <tobi.smethurst@protonmail.com>
Date: Tue, 11 Jan 2022 17:49:14 +0100
pass a function into the manager, start work on emoji
Diffstat:
21 files changed, 1164 insertions(+), 527 deletions(-)
diff --git a/internal/api/client/admin/admin.go b/internal/api/client/admin/admin.go
@@ -58,7 +58,7 @@ func New(processor processing.Processor) api.ClientModule {
// Route attaches all routes from this module to the given router
func (m *Module) Route(r router.Router) error {
- r.AttachHandler(http.MethodPost, EmojiPath, m.emojiCreatePOSTHandler)
+ r.AttachHandler(http.MethodPost, EmojiPath, m.EmojiCreatePOSTHandler)
r.AttachHandler(http.MethodPost, DomainBlocksPath, m.DomainBlocksPOSTHandler)
r.AttachHandler(http.MethodGet, DomainBlocksPath, m.DomainBlocksGETHandler)
r.AttachHandler(http.MethodGet, DomainBlocksPathWithID, m.DomainBlockGETHandler)
diff --git a/internal/api/client/admin/admin_test.go b/internal/api/client/admin/admin_test.go
@@ -0,0 +1,123 @@
+/*
+ GoToSocial
+ Copyright (C) 2021-2022 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package admin_test
+
+import (
+ "bytes"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+
+ "codeberg.org/gruf/go-store/kv"
+ "github.com/gin-gonic/gin"
+ "github.com/spf13/viper"
+ "github.com/stretchr/testify/suite"
+ "github.com/superseriousbusiness/gotosocial/internal/api/client/admin"
+ "github.com/superseriousbusiness/gotosocial/internal/config"
+ "github.com/superseriousbusiness/gotosocial/internal/db"
+ "github.com/superseriousbusiness/gotosocial/internal/email"
+ "github.com/superseriousbusiness/gotosocial/internal/federation"
+ "github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+ "github.com/superseriousbusiness/gotosocial/internal/media"
+ "github.com/superseriousbusiness/gotosocial/internal/oauth"
+ "github.com/superseriousbusiness/gotosocial/internal/processing"
+ "github.com/superseriousbusiness/gotosocial/internal/typeutils"
+ "github.com/superseriousbusiness/gotosocial/testrig"
+)
+
+type AdminStandardTestSuite struct {
+ // standard suite interfaces
+ suite.Suite
+ db db.DB
+ tc typeutils.TypeConverter
+ storage *kv.KVStore
+ mediaManager media.Manager
+ federator federation.Federator
+ processor processing.Processor
+ emailSender email.Sender
+ sentEmails map[string]string
+
+ // standard suite models
+ testTokens map[string]*gtsmodel.Token
+ testClients map[string]*gtsmodel.Client
+ testApplications map[string]*gtsmodel.Application
+ testUsers map[string]*gtsmodel.User
+ testAccounts map[string]*gtsmodel.Account
+ testAttachments map[string]*gtsmodel.MediaAttachment
+ testStatuses map[string]*gtsmodel.Status
+
+ // module being tested
+ adminModule *admin.Module
+}
+
+func (suite *AdminStandardTestSuite) SetupSuite() {
+ suite.testTokens = testrig.NewTestTokens()
+ suite.testClients = testrig.NewTestClients()
+ suite.testApplications = testrig.NewTestApplications()
+ suite.testUsers = testrig.NewTestUsers()
+ suite.testAccounts = testrig.NewTestAccounts()
+ suite.testAttachments = testrig.NewTestAttachments()
+ suite.testStatuses = testrig.NewTestStatuses()
+}
+
+func (suite *AdminStandardTestSuite) SetupTest() {
+ testrig.InitTestConfig()
+ testrig.InitTestLog()
+
+ suite.db = testrig.NewTestDB()
+ suite.storage = testrig.NewTestStorage()
+ suite.mediaManager = testrig.NewTestMediaManager(suite.db, suite.storage)
+ suite.federator = testrig.NewTestFederator(suite.db, testrig.NewTestTransportController(testrig.NewMockHTTPClient(nil), suite.db), suite.storage, suite.mediaManager)
+ suite.sentEmails = make(map[string]string)
+ suite.emailSender = testrig.NewEmailSender("../../../../web/template/", suite.sentEmails)
+ suite.processor = testrig.NewTestProcessor(suite.db, suite.storage, suite.federator, suite.emailSender, suite.mediaManager)
+ suite.adminModule = admin.New(suite.processor).(*admin.Module)
+ testrig.StandardDBSetup(suite.db, nil)
+ testrig.StandardStorageSetup(suite.storage, "../../../../testrig/media")
+}
+
+func (suite *AdminStandardTestSuite) TearDownTest() {
+ testrig.StandardDBTeardown(suite.db)
+ testrig.StandardStorageTeardown(suite.storage)
+}
+
+func (suite *AdminStandardTestSuite) newContext(recorder *httptest.ResponseRecorder, requestMethod string, requestBody []byte, requestPath string, bodyContentType string) *gin.Context {
+ ctx, _ := gin.CreateTestContext(recorder)
+
+ ctx.Set(oauth.SessionAuthorizedAccount, suite.testAccounts["admin_account"])
+ ctx.Set(oauth.SessionAuthorizedToken, oauth.DBTokenToToken(suite.testTokens["admin_account"]))
+ ctx.Set(oauth.SessionAuthorizedApplication, suite.testApplications["admin_account"])
+ ctx.Set(oauth.SessionAuthorizedUser, suite.testUsers["admin_account"])
+
+ protocol := viper.GetString(config.Keys.Protocol)
+ host := viper.GetString(config.Keys.Host)
+
+ baseURI := fmt.Sprintf("%s://%s", protocol, host)
+ requestURI := fmt.Sprintf("%s/%s", baseURI, requestPath)
+
+ ctx.Request = httptest.NewRequest(http.MethodPatch, requestURI, bytes.NewReader(requestBody)) // the endpoint we're hitting
+
+ if bodyContentType != "" {
+ ctx.Request.Header.Set("Content-Type", bodyContentType)
+ }
+
+ ctx.Request.Header.Set("accept", "application/json")
+
+ return ctx
+}
diff --git a/internal/api/client/admin/emojicreate.go b/internal/api/client/admin/emojicreate.go
@@ -31,7 +31,7 @@ import (
"github.com/superseriousbusiness/gotosocial/internal/validate"
)
-// emojiCreateRequest swagger:operation POST /api/v1/admin/custom_emojis emojiCreate
+// EmojiCreatePOSTHandler swagger:operation POST /api/v1/admin/custom_emojis emojiCreate
//
// Upload and create a new instance emoji.
//
@@ -73,7 +73,7 @@ import (
// description: forbidden
// '400':
// description: bad request
-func (m *Module) emojiCreatePOSTHandler(c *gin.Context) {
+func (m *Module) EmojiCreatePOSTHandler(c *gin.Context) {
l := logrus.WithFields(logrus.Fields{
"func": "emojiCreatePOSTHandler",
"request_uri": c.Request.RequestURI,
diff --git a/internal/api/client/admin/emojicreate_test.go b/internal/api/client/admin/emojicreate_test.go
@@ -0,0 +1,50 @@
+package admin_test
+
+import (
+ "io/ioutil"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/stretchr/testify/suite"
+ "github.com/superseriousbusiness/gotosocial/internal/api/client/admin"
+ "github.com/superseriousbusiness/gotosocial/testrig"
+)
+
+type EmojiCreateTestSuite struct {
+ AdminStandardTestSuite
+}
+
+func (suite *EmojiCreateTestSuite) TestEmojiCreate() {
+ // set up the request
+ requestBody, w, err := testrig.CreateMultipartFormData(
+ "image", "../../../../testrig/media/rainbow-original.png",
+ map[string]string{
+ "shortcode": "rainbow",
+ })
+ if err != nil {
+ panic(err)
+ }
+ bodyBytes := requestBody.Bytes()
+ recorder := httptest.NewRecorder()
+ ctx := suite.newContext(recorder, http.MethodPost, bodyBytes, admin.EmojiPath, w.FormDataContentType())
+
+ // call the handler
+ suite.adminModule.EmojiCreatePOSTHandler(ctx)
+
+ // 1. we should have OK because our request was valid
+ suite.Equal(http.StatusOK, recorder.Code)
+
+ // 2. we should have no error message in the result body
+ result := recorder.Result()
+ defer result.Body.Close()
+
+ // check the response
+ b, err := ioutil.ReadAll(result.Body)
+ suite.NoError(err)
+ suite.NotEmpty(b)
+}
+
+func TestEmojiCreateTestSuite(t *testing.T) {
+ suite.Run(t, &EmojiCreateTestSuite{})
+}
diff --git a/internal/federation/dereferencing/account.go b/internal/federation/dereferencing/account.go
@@ -119,7 +119,6 @@ func (d *deref) GetRemoteAccount(ctx context.Context, username string, remoteAcc
} else {
// take the id we already have and do an update
gtsAccount.ID = maybeAccount.ID
-aaaaaaaaaaaaaaaaaa
if err := d.PopulateAccountFields(ctx, gtsAccount, username, refresh); err != nil {
return nil, new, fmt.Errorf("FullyDereferenceAccount: error populating further account fields: %s", err)
}
@@ -252,13 +251,12 @@ func (d *deref) fetchHeaderAndAviForAccount(ctx context.Context, targetAccount *
return err
}
- data, err := t.DereferenceMedia(ctx, avatarIRI)
- if err != nil {
- return err
+ data := func(innerCtx context.Context) ([]byte, error) {
+ return t.DereferenceMedia(innerCtx, avatarIRI)
}
avatar := true
- processingMedia, err := d.mediaManager.ProcessMedia(ctx, data, targetAccount.ID, &media.AdditionalInfo{
+ processingMedia, err := d.mediaManager.ProcessMedia(ctx, data, targetAccount.ID, &media.AdditionalMediaInfo{
RemoteURL: &targetAccount.AvatarRemoteURL,
Avatar: &avatar,
})
@@ -275,13 +273,12 @@ func (d *deref) fetchHeaderAndAviForAccount(ctx context.Context, targetAccount *
return err
}
- data, err := t.DereferenceMedia(ctx, headerIRI)
- if err != nil {
- return err
+ data := func(innerCtx context.Context) ([]byte, error) {
+ return t.DereferenceMedia(innerCtx, headerIRI)
}
header := true
- processingMedia, err := d.mediaManager.ProcessMedia(ctx, data, targetAccount.ID, &media.AdditionalInfo{
+ processingMedia, err := d.mediaManager.ProcessMedia(ctx, data, targetAccount.ID, &media.AdditionalMediaInfo{
RemoteURL: &targetAccount.HeaderRemoteURL,
Header: &header,
})
diff --git a/internal/federation/dereferencing/dereferencer.go b/internal/federation/dereferencing/dereferencer.go
@@ -41,7 +41,7 @@ type Dereferencer interface {
GetRemoteInstance(ctx context.Context, username string, remoteInstanceURI *url.URL) (*gtsmodel.Instance, error)
- GetRemoteMedia(ctx context.Context, requestingUsername string, accountID string, remoteURL string, ai *media.AdditionalInfo) (*media.Processing, error)
+ GetRemoteMedia(ctx context.Context, requestingUsername string, accountID string, remoteURL string, ai *media.AdditionalMediaInfo) (*media.ProcessingMedia, error)
DereferenceAnnounce(ctx context.Context, announce *gtsmodel.Status, requestingUsername string) error
DereferenceThread(ctx context.Context, username string, statusIRI *url.URL) error
diff --git a/internal/federation/dereferencing/media.go b/internal/federation/dereferencing/media.go
@@ -26,29 +26,28 @@ import (
"github.com/superseriousbusiness/gotosocial/internal/media"
)
-func (d *deref) GetRemoteMedia(ctx context.Context, requestingUsername string, accountID string, remoteURL string, ai *media.AdditionalInfo) (*media.Processing, error) {
+func (d *deref) GetRemoteMedia(ctx context.Context, requestingUsername string, accountID string, remoteURL string, ai *media.AdditionalMediaInfo) (*media.ProcessingMedia, error) {
if accountID == "" {
- return nil, fmt.Errorf("RefreshAttachment: minAttachment account ID was empty")
+ return nil, fmt.Errorf("GetRemoteMedia: account ID was empty")
}
t, err := d.transportController.NewTransportForUsername(ctx, requestingUsername)
if err != nil {
- return nil, fmt.Errorf("RefreshAttachment: error creating transport: %s", err)
+ return nil, fmt.Errorf("GetRemoteMedia: error creating transport: %s", err)
}
derefURI, err := url.Parse(remoteURL)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf("GetRemoteMedia: error parsing url: %s", err)
}
- data, err := t.DereferenceMedia(ctx, derefURI)
- if err != nil {
- return nil, fmt.Errorf("RefreshAttachment: error dereferencing media: %s", err)
+ dataFunc := func(innerCtx context.Context) ([]byte, error) {
+ return t.DereferenceMedia(innerCtx, derefURI)
}
- processingMedia, err := d.mediaManager.ProcessMedia(ctx, data, accountID, ai)
+ processingMedia, err := d.mediaManager.ProcessMedia(ctx, dataFunc, accountID, ai)
if err != nil {
- return nil, fmt.Errorf("RefreshAttachment: error processing attachment: %s", err)
+ return nil, fmt.Errorf("GetRemoteMedia: error processing attachment: %s", err)
}
return processingMedia, nil
diff --git a/internal/federation/dereferencing/media_test.go b/internal/federation/dereferencing/media_test.go
@@ -20,6 +20,7 @@ package dereferencing_test
import (
"context"
+ "fmt"
"testing"
"time"
@@ -44,7 +45,7 @@ func (suite *AttachmentTestSuite) TestDereferenceAttachmentBlocking() {
attachmentDescription := "It's a cute plushie."
attachmentBlurhash := "LwP?p=aK_4%N%MRjWXt7%hozM_a}"
- media, err := suite.dereferencer.GetRemoteMedia(ctx, fetchingAccount.Username, attachmentOwner, attachmentURL, &media.AdditionalInfo{
+ media, err := suite.dereferencer.GetRemoteMedia(ctx, fetchingAccount.Username, attachmentOwner, attachmentURL, &media.AdditionalMediaInfo{
StatusID: &attachmentStatus,
RemoteURL: &attachmentURL,
Description: &attachmentDescription,
@@ -53,7 +54,7 @@ func (suite *AttachmentTestSuite) TestDereferenceAttachmentBlocking() {
suite.NoError(err)
// make a blocking call to load the attachment from the in-process media
- attachment, err := media.Load(ctx)
+ attachment, err := media.LoadAttachment(ctx)
suite.NoError(err)
suite.NotNil(attachment)
@@ -118,18 +119,21 @@ func (suite *AttachmentTestSuite) TestDereferenceAttachmentAsync() {
attachmentDescription := "It's a cute plushie."
attachmentBlurhash := "LwP?p=aK_4%N%MRjWXt7%hozM_a}"
- media, err := suite.dereferencer.GetRemoteMedia(ctx, fetchingAccount.Username, attachmentOwner, attachmentURL, &media.AdditionalInfo{
+ processingMedia, err := suite.dereferencer.GetRemoteMedia(ctx, fetchingAccount.Username, attachmentOwner, attachmentURL, &media.AdditionalMediaInfo{
StatusID: &attachmentStatus,
RemoteURL: &attachmentURL,
Description: &attachmentDescription,
Blurhash: &attachmentBlurhash,
})
suite.NoError(err)
- attachmentID := media.AttachmentID()
-
- // wait 5 seconds to let the image process in the background
- // it probably won't really take this long but hey let's be sure
- time.Sleep(5 * time.Second)
+ attachmentID := processingMedia.AttachmentID()
+
+ // wait for the media to finish processing
+ for finished := processingMedia.Finished(); !finished; finished = processingMedia.Finished() {
+ time.Sleep(10 * time.Millisecond)
+ fmt.Printf("\n\nnot finished yet...\n\n")
+ }
+ fmt.Printf("\n\nfinished!\n\n")
// now get the attachment from the database
attachment, err := suite.db.GetAttachmentByID(ctx, attachmentID)
diff --git a/internal/federation/dereferencing/status.go b/internal/federation/dereferencing/status.go
@@ -394,7 +394,7 @@ func (d *deref) populateStatusAttachments(ctx context.Context, status *gtsmodel.
a.AccountID = status.AccountID
a.StatusID = status.ID
- media, err := d.GetRemoteMedia(ctx, requestingUsername, a.AccountID, a.RemoteURL, &media.AdditionalInfo{
+ media, err := d.GetRemoteMedia(ctx, requestingUsername, a.AccountID, a.RemoteURL, &media.AdditionalMediaInfo{
CreatedAt: &a.CreatedAt,
StatusID: &a.StatusID,
RemoteURL: &a.RemoteURL,
@@ -406,7 +406,7 @@ func (d *deref) populateStatusAttachments(ctx context.Context, status *gtsmodel.
continue
}
- attachment, err := media.Load(ctx)
+ attachment, err := media.LoadAttachment(ctx)
if err != nil {
logrus.Errorf("populateStatusAttachments: couldn't load remote attachment %s: %s", a.RemoteURL, err)
continue
diff --git a/internal/media/image.go b/internal/media/image.go
@@ -27,7 +27,6 @@ import (
"image/gif"
"image/jpeg"
"image/png"
- "strings"
"time"
"github.com/buckket/go-blurhash"
@@ -52,113 +51,6 @@ type ImageMeta struct {
blurhash string
}
-func (m *manager) preProcessImage(ctx context.Context, data []byte, contentType string, accountID string, ai *AdditionalInfo) (*Processing, error) {
- if !supportedImage(contentType) {
- return nil, fmt.Errorf("image type %s not supported", contentType)
- }
-
- if len(data) == 0 {
- return nil, errors.New("image was of size 0")
- }
-
- id, err := id.NewRandomULID()
- if err != nil {
- return nil, err
- }
-
- extension := strings.Split(contentType, "/")[1]
-
- // populate initial fields on the media attachment -- some of these will be overwritten as we proceed
- attachment := >smodel.MediaAttachment{
- ID: id,
- CreatedAt: time.Now(),
- UpdatedAt: time.Now(),
- StatusID: "",
- URL: uris.GenerateURIForAttachment(accountID, string(TypeAttachment), string(SizeOriginal), id, extension),
- RemoteURL: "",
- Type: gtsmodel.FileTypeImage,
- FileMeta: gtsmodel.FileMeta{
- Focus: gtsmodel.Focus{
- X: 0,
- Y: 0,
- },
- },
- AccountID: accountID,
- Description: "",
- ScheduledStatusID: "",
- Blurhash: "",
- Processing: gtsmodel.ProcessingStatusReceived,
- File: gtsmodel.File{
- Path: fmt.Sprintf("%s/%s/%s/%s.%s", accountID, TypeAttachment, SizeOriginal, id, extension),
- ContentType: contentType,
- UpdatedAt: time.Now(),
- },
- Thumbnail: gtsmodel.Thumbnail{
- URL: uris.GenerateURIForAttachment(accountID, string(TypeAttachment), string(SizeSmall), id, mimeJpeg), // all thumbnails are encoded as jpeg,
- Path: fmt.Sprintf("%s/%s/%s/%s.%s", accountID, TypeAttachment, SizeSmall, id, mimeJpeg), // all thumbnails are encoded as jpeg,
- ContentType: mimeJpeg,
- UpdatedAt: time.Now(),
- },
- Avatar: false,
- Header: false,
- }
-
- // check if we have additional info to add to the attachment,
- // and overwrite some of the attachment fields if so
- if ai != nil {
- if ai.CreatedAt != nil {
- attachment.CreatedAt = *ai.CreatedAt
- }
-
- if ai.StatusID != nil {
- attachment.StatusID = *ai.StatusID
- }
-
- if ai.RemoteURL != nil {
- attachment.RemoteURL = *ai.RemoteURL
- }
-
- if ai.Description != nil {
- attachment.Description = *ai.Description
- }
-
- if ai.ScheduledStatusID != nil {
- attachment.ScheduledStatusID = *ai.ScheduledStatusID
- }
-
- if ai.Blurhash != nil {
- attachment.Blurhash = *ai.Blurhash
- }
-
- if ai.Avatar != nil {
- attachment.Avatar = *ai.Avatar
- }
-
- if ai.Header != nil {
- attachment.Header = *ai.Header
- }
-
- if ai.FocusX != nil {
- attachment.FileMeta.Focus.X = *ai.FocusX
- }
-
- if ai.FocusY != nil {
- attachment.FileMeta.Focus.Y = *ai.FocusY
- }
- }
-
- media := &Processing{
- attachment: attachment,
- rawData: data,
- thumbstate: received,
- fullSizeState: received,
- database: m.db,
- storage: m.storage,
- }
-
- return media, nil
-}
-
func decodeGif(b []byte) (*ImageMeta, error) {
gif, err := gif.DecodeAll(bytes.NewReader(b))
if err != nil {
diff --git a/internal/media/manager.go b/internal/media/manager.go
@@ -21,9 +21,7 @@ package media
import (
"context"
"errors"
- "fmt"
"runtime"
- "strings"
"codeberg.org/gruf/go-runners"
"codeberg.org/gruf/go-store/kv"
@@ -33,15 +31,17 @@ import (
// Manager provides an interface for managing media: parsing, storing, and retrieving media objects like photos, videos, and gifs.
type Manager interface {
- // ProcessMedia begins the process of decoding and storing the given data as a piece of media (aka an attachment).
+ // ProcessMedia begins the process of decoding and storing the given data as an attachment.
// It will return a pointer to a Media struct upon which further actions can be performed, such as getting
// the finished media, thumbnail, attachment, etc.
//
+ // data should be a function that the media manager can call to return raw bytes of a piece of media.
+ //
// accountID should be the account that the media belongs to.
//
// ai is optional and can be nil. Any additional information about the attachment provided will be put in the database.
- ProcessMedia(ctx context.Context, data []byte, accountID string, ai *AdditionalInfo) (*Processing, error)
- ProcessEmoji(ctx context.Context, data []byte, accountID string) (*Processing, error)
+ ProcessMedia(ctx context.Context, data DataFunc, accountID string, ai *AdditionalMediaInfo) (*ProcessingMedia, error)
+ ProcessEmoji(ctx context.Context, data DataFunc, shortcode string, ai *AdditionalEmojiInfo) (*ProcessingEmoji, error)
// NumWorkers returns the total number of workers available to this manager.
NumWorkers() int
// QueueSize returns the total capacity of the queue.
@@ -101,49 +101,52 @@ func NewManager(database db.DB, storage *kv.KVStore) (Manager, error) {
return m, nil
}
-func (m *manager) ProcessMedia(ctx context.Context, data []byte, accountID string, ai *AdditionalInfo) (*Processing, error) {
- contentType, err := parseContentType(data)
+func (m *manager) ProcessMedia(ctx context.Context, data DataFunc, accountID string, ai *AdditionalMediaInfo) (*ProcessingMedia, error) {
+ processingMedia, err := m.preProcessMedia(ctx, data, accountID, ai)
if err != nil {
return nil, err
}
- split := strings.Split(contentType, "/")
- if len(split) != 2 {
- return nil, fmt.Errorf("content type %s malformed", contentType)
- }
-
- mainType := split[0]
-
- switch mainType {
- case mimeImage:
- media, err := m.preProcessImage(ctx, data, contentType, accountID, ai)
- if err != nil {
- return nil, err
+ logrus.Tracef("ProcessMedia: about to enqueue media with attachmentID %s, queue length is %d", processingMedia.AttachmentID(), m.pool.Queue())
+ m.pool.Enqueue(func(innerCtx context.Context) {
+ select {
+ case <-innerCtx.Done():
+ // if the inner context is done that means the worker pool is closing, so we should just return
+ return
+ default:
+ // start loading the media already for the caller's convenience
+ if _, err := processingMedia.LoadAttachment(innerCtx); err != nil {
+ logrus.Errorf("ProcessMedia: error processing media with attachmentID %s: %s", processingMedia.AttachmentID(), err)
+ }
}
+ })
+ logrus.Tracef("ProcessMedia: succesfully queued media with attachmentID %s, queue length is %d", processingMedia.AttachmentID(), m.pool.Queue())
- logrus.Tracef("ProcessMedia: about to enqueue media with attachmentID %s, queue length is %d", media.AttachmentID(), m.pool.Queue())
- m.pool.Enqueue(func(innerCtx context.Context) {
- select {
- case <-innerCtx.Done():
- // if the inner context is done that means the worker pool is closing, so we should just return
- return
- default:
- // start loading the media already for the caller's convenience
- if _, err := media.Load(innerCtx); err != nil {
- logrus.Errorf("ProcessMedia: error processing media with attachmentID %s: %s", media.AttachmentID(), err)
- }
- }
- })
- logrus.Tracef("ProcessMedia: succesfully queued media with attachmentID %s, queue length is %d", media.AttachmentID(), m.pool.Queue())
+ return processingMedia, nil
+}
- return media, nil
- default:
- return nil, fmt.Errorf("content type %s not (yet) supported", contentType)
+func (m *manager) ProcessEmoji(ctx context.Context, data DataFunc, shortcode string, ai *AdditionalEmojiInfo) (*ProcessingEmoji, error) {
+ processingEmoji, err := m.preProcessEmoji(ctx, data, shortcode, ai)
+ if err != nil {
+ return nil, err
}
-}
-func (m *manager) ProcessEmoji(ctx context.Context, data []byte, accountID string) (*Processing, error) {
- return nil, nil
+ logrus.Tracef("ProcessEmoji: about to enqueue emoji with id %s, queue length is %d", processingEmoji.EmojiID(), m.pool.Queue())
+ m.pool.Enqueue(func(innerCtx context.Context) {
+ select {
+ case <-innerCtx.Done():
+ // if the inner context is done that means the worker pool is closing, so we should just return
+ return
+ default:
+ // start loading the emoji already for the caller's convenience
+ if _, err := processingEmoji.LoadEmoji(innerCtx); err != nil {
+ logrus.Errorf("ProcessEmoji: error processing emoji with id %s: %s", processingEmoji.EmojiID(), err)
+ }
+ }
+ })
+ logrus.Tracef("ProcessEmoji: succesfully queued emoji with id %s, queue length is %d", processingEmoji.EmojiID(), m.pool.Queue())
+
+ return processingEmoji, nil
}
func (m *manager) NumWorkers() int {
diff --git a/internal/media/manager_test.go b/internal/media/manager_test.go
@@ -37,21 +37,21 @@ type ManagerTestSuite struct {
func (suite *ManagerTestSuite) TestSimpleJpegProcessBlocking() {
ctx := context.Background()
- // load bytes from a test image
- testBytes, err := os.ReadFile("./test/test-jpeg.jpg")
- suite.NoError(err)
- suite.NotEmpty(testBytes)
+ data := func(_ context.Context) ([]byte, error) {
+ // load bytes from a test image
+ return os.ReadFile("./test/test-jpeg.jpg")
+ }
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
// process the media with no additional info provided
- processingMedia, err := suite.manager.ProcessMedia(ctx, testBytes, accountID, nil)
+ processingMedia, err := suite.manager.ProcessMedia(ctx, data, accountID, nil)
suite.NoError(err)
// fetch the attachment id from the processing media
attachmentID := processingMedia.AttachmentID()
// do a blocking call to fetch the attachment
- attachment, err := processingMedia.Load(ctx)
+ attachment, err := processingMedia.LoadAttachment(ctx)
suite.NoError(err)
suite.NotNil(attachment)
@@ -103,15 +103,15 @@ func (suite *ManagerTestSuite) TestSimpleJpegProcessBlocking() {
func (suite *ManagerTestSuite) TestSimpleJpegProcessAsync() {
ctx := context.Background()
- // load bytes from a test image
- testBytes, err := os.ReadFile("./test/test-jpeg.jpg")
- suite.NoError(err)
- suite.NotEmpty(testBytes)
+ data := func(_ context.Context) ([]byte, error) {
+ // load bytes from a test image
+ return os.ReadFile("./test/test-jpeg.jpg")
+ }
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
// process the media with no additional info provided
- processingMedia, err := suite.manager.ProcessMedia(ctx, testBytes, accountID, nil)
+ processingMedia, err := suite.manager.ProcessMedia(ctx, data, accountID, nil)
suite.NoError(err)
// fetch the attachment id from the processing media
attachmentID := processingMedia.AttachmentID()
@@ -183,13 +183,17 @@ func (suite *ManagerTestSuite) TestSimpleJpegQueueSpamming() {
suite.NoError(err)
suite.NotEmpty(testBytes)
+ data := func(_ context.Context) ([]byte, error) {
+ return testBytes, nil
+ }
+
accountID := "01FS1X72SK9ZPW0J1QQ68BD264"
spam := 50
- inProcess := []*media.Processing{}
+ inProcess := []*media.ProcessingMedia{}
for i := 0; i < spam; i++ {
// process the media with no additional info provided
- processingMedia, err := suite.manager.ProcessMedia(ctx, testBytes, accountID, nil)
+ processingMedia, err := suite.manager.ProcessMedia(ctx, data, accountID, nil)
suite.NoError(err)
inProcess = append(inProcess, processingMedia)
}
@@ -201,7 +205,7 @@ func (suite *ManagerTestSuite) TestSimpleJpegQueueSpamming() {
attachmentID := processingMedia.AttachmentID()
// do a blocking call to fetch the attachment
- attachment, err := processingMedia.Load(ctx)
+ attachment, err := processingMedia.LoadAttachment(ctx)
suite.NoError(err)
suite.NotNil(attachment)
diff --git a/internal/media/processing.go b/internal/media/processing.go
@@ -1,256 +0,0 @@
-/*
- GoToSocial
- Copyright (C) 2021-2022 GoToSocial Authors admin@gotosocial.org
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU Affero General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package media
-
-import (
- "context"
- "fmt"
- "sync"
- "time"
-
- "codeberg.org/gruf/go-store/kv"
- "github.com/superseriousbusiness/gotosocial/internal/db"
- "github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
-)
-
-type processState int
-
-const (
- received processState = iota // processing order has been received but not done yet
- complete // processing order has been completed successfully
- errored // processing order has been completed with an error
-)
-
-// Processing represents a piece of media that is currently being processed. It exposes
-// various functions for retrieving data from the process.
-type Processing struct {
- mu sync.Mutex
-
- /*
- below fields should be set on newly created media;
- attachment will be updated incrementally as media goes through processing
- */
-
- attachment *gtsmodel.MediaAttachment // will only be set if the media is an attachment
- emoji *gtsmodel.Emoji // will only be set if the media is an emoji
-
- rawData []byte
-
- /*
- below fields represent the processing state of the media thumbnail
- */
-
- thumbstate processState
- thumb *ImageMeta
-
- /*
- below fields represent the processing state of the full-sized media
- */
-
- fullSizeState processState
- fullSize *ImageMeta
-
- /*
- below pointers to database and storage are maintained so that
- the media can store and update itself during processing steps
- */
-
- database db.DB
- storage *kv.KVStore
-
- err error // error created during processing, if any
-}
-
-func (p *Processing) Thumb(ctx context.Context) (*ImageMeta, error) {
- p.mu.Lock()
- defer p.mu.Unlock()
-
- switch p.thumbstate {
- case received:
- // we haven't processed a thumbnail for this media yet so do it now
-
- // check if we need to create a blurhash or if there's already one set
- var createBlurhash bool
- if p.attachment.Blurhash == "" {
- // no blurhash created yet
- createBlurhash = true
- }
-
- thumb, err := deriveThumbnail(p.rawData, p.attachment.File.ContentType, createBlurhash)
- if err != nil {
- p.err = fmt.Errorf("error deriving thumbnail: %s", err)
- p.thumbstate = errored
- return nil, p.err
- }
-
- // put the thumbnail in storage
- if err := p.storage.Put(p.attachment.Thumbnail.Path, thumb.image); err != nil {
- p.err = fmt.Errorf("error storing thumbnail: %s", err)
- p.thumbstate = errored
- return nil, p.err
- }
-
- // set appropriate fields on the attachment based on the thumbnail we derived
- if createBlurhash {
- p.attachment.Blurhash = thumb.blurhash
- }
-
- p.attachment.FileMeta.Small = gtsmodel.Small{
- Width: thumb.width,
- Height: thumb.height,
- Size: thumb.size,
- Aspect: thumb.aspect,
- }
- p.attachment.Thumbnail.FileSize = thumb.size
-
- if err := putOrUpdateAttachment(ctx, p.database, p.attachment); err != nil {
- p.err = err
- p.thumbstate = errored
- return nil, err
- }
-
- // set the thumbnail of this media
- p.thumb = thumb
-
- // we're done processing the thumbnail!
- p.thumbstate = complete
- fallthrough
- case complete:
- return p.thumb, nil
- case errored:
- return nil, p.err
- }
-
- return nil, fmt.Errorf("thumbnail processing status %d unknown", p.thumbstate)
-}
-
-func (p *Processing) FullSize(ctx context.Context) (*ImageMeta, error) {
- p.mu.Lock()
- defer p.mu.Unlock()
-
- switch p.fullSizeState {
- case received:
- var clean []byte
- var err error
- var decoded *ImageMeta
-
- ct := p.attachment.File.ContentType
- switch ct {
- case mimeImageJpeg, mimeImagePng:
- // first 'clean' image by purging exif data from it
- var exifErr error
- if clean, exifErr = purgeExif(p.rawData); exifErr != nil {
- err = exifErr
- break
- }
- decoded, err = decodeImage(clean, ct)
- case mimeImageGif:
- // gifs are already clean - no exif data to remove
- clean = p.rawData
- decoded, err = decodeGif(clean)
- default:
- err = fmt.Errorf("content type %s not a processible image type", ct)
- }
-
- if err != nil {
- p.err = err
- p.fullSizeState = errored
- return nil, err
- }
-
- // put the full size in storage
- if err := p.storage.Put(p.attachment.File.Path, decoded.image); err != nil {
- p.err = fmt.Errorf("error storing full size image: %s", err)
- p.fullSizeState = errored
- return nil, p.err
- }
-
- // set appropriate fields on the attachment based on the image we derived
- p.attachment.FileMeta.Original = gtsmodel.Original{
- Width: decoded.width,
- Height: decoded.height,
- Size: decoded.size,
- Aspect: decoded.aspect,
- }
- p.attachment.File.FileSize = decoded.size
- p.attachment.File.UpdatedAt = time.Now()
- p.attachment.Processing = gtsmodel.ProcessingStatusProcessed
-
- if err := putOrUpdateAttachment(ctx, p.database, p.attachment); err != nil {
- p.err = err
- p.fullSizeState = errored
- return nil, err
- }
-
- // set the fullsize of this media
- p.fullSize = decoded
-
- // we're done processing the full-size image
- p.fullSizeState = complete
- fallthrough
- case complete:
- return p.fullSize, nil
- case errored:
- return nil, p.err
- }
-
- return nil, fmt.Errorf("full size processing status %d unknown", p.fullSizeState)
-}
-
-// AttachmentID returns the ID of the underlying media attachment without blocking processing.
-func (p *Processing) AttachmentID() string {
- return p.attachment.ID
-}
-
-// Load blocks until the thumbnail and fullsize content has been processed, and then
-// returns the completed attachment.
-func (p *Processing) Load(ctx context.Context) (*gtsmodel.MediaAttachment, error) {
- if _, err := p.Thumb(ctx); err != nil {
- return nil, err
- }
-
- if _, err := p.FullSize(ctx); err != nil {
- return nil, err
- }
-
- return p.attachment, nil
-}
-
-func (p *Processing) LoadEmoji(ctx context.Context) (*gtsmodel.Emoji, error) {
- return nil, nil
-}
-
-func (p *Processing) Finished() bool {
- return p.thumbstate == complete && p.fullSizeState == complete
-}
-
-// putOrUpdateAttachment is just a convenience function for first trying to PUT the attachment in the database,
-// and then if that doesn't work because the attachment already exists, updating it instead.
-func putOrUpdateAttachment(ctx context.Context, database db.DB, attachment *gtsmodel.MediaAttachment) error {
- if err := database.Put(ctx, attachment); err != nil {
- if err != db.ErrAlreadyExists {
- return fmt.Errorf("putOrUpdateAttachment: proper error while putting attachment: %s", err)
- }
- if err := database.UpdateByPrimaryKey(ctx, attachment); err != nil {
- return fmt.Errorf("putOrUpdateAttachment: error while updating attachment: %s", err)
- }
- }
-
- return nil
-}
diff --git a/internal/media/processingemoji.go b/internal/media/processingemoji.go
@@ -0,0 +1,382 @@
+/*
+ GoToSocial
+ Copyright (C) 2021-2022 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package media
+
+import (
+ "context"
+ "fmt"
+ "strings"
+ "sync"
+ "time"
+
+ "codeberg.org/gruf/go-store/kv"
+ "github.com/superseriousbusiness/gotosocial/internal/db"
+ "github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+ "github.com/superseriousbusiness/gotosocial/internal/id"
+ "github.com/superseriousbusiness/gotosocial/internal/uris"
+)
+
+// ProcessingEmoji represents an emoji currently processing. It exposes
+// various functions for retrieving data from the process.
+type ProcessingEmoji struct {
+ mu sync.Mutex
+
+ /*
+ below fields should be set on newly created media;
+ emoji will be updated incrementally as media goes through processing
+ */
+
+ emoji *gtsmodel.Emoji
+ data DataFunc
+
+ rawData []byte // will be set once the fetchRawData function has been called
+
+ /*
+ below fields represent the processing state of the static version of the emoji
+ */
+
+ staticState processState
+ static *ImageMeta
+
+ /*
+ below fields represent the processing state of the emoji image
+ */
+
+ fullSizeState processState
+ fullSize *ImageMeta
+
+ /*
+ below pointers to database and storage are maintained so that
+ the media can store and update itself during processing steps
+ */
+
+ database db.DB
+ storage *kv.KVStore
+
+ err error // error created during processing, if any
+}
+
+// EmojiID returns the ID of the underlying emoji without blocking processing.
+func (p *ProcessingEmoji) EmojiID() string {
+ return p.emoji.ID
+}
+
+// LoadEmoji blocks until the static and fullsize image
+// has been processed, and then returns the completed emoji.
+func (p *ProcessingEmoji) LoadEmoji(ctx context.Context) (*gtsmodel.Emoji, error) {
+ if err := p.fetchRawData(ctx); err != nil {
+ return nil, err
+ }
+
+ if _, err := p.loadStatic(ctx); err != nil {
+ return nil, err
+ }
+
+ if _, err := p.loadFullSize(ctx); err != nil {
+ return nil, err
+ }
+
+ return p.emoji, nil
+}
+
+// Finished returns true if processing has finished for both the thumbnail
+// and full fized version of this piece of media.
+func (p *ProcessingEmoji) Finished() bool {
+ return p.staticState == complete && p.fullSizeState == complete
+}
+
+func (p *ProcessingEmoji) loadStatic(ctx context.Context) (*ImageMeta, error) {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+
+ switch p.staticState {
+ case received:
+ // we haven't processed a static version of this emoji yet so do it now
+ static, err := deriveStaticEmoji(p.rawData, p.emoji.ImageContentType)
+ if err != nil {
+ p.err = fmt.Errorf("error deriving static: %s", err)
+ p.staticState = errored
+ return nil, p.err
+ }
+
+ // put the static in storage
+ if err := p.storage.Put(p.emoji.ImageStaticPath, static.image); err != nil {
+ p.err = fmt.Errorf("error storing static: %s", err)
+ p.staticState = errored
+ return nil, p.err
+ }
+
+ // set appropriate fields on the emoji based on the static version we derived
+ p.attachment.FileMeta.Small = gtsmodel.Small{
+ Width: static.width,
+ Height: static.height,
+ Size: static.size,
+ Aspect: static.aspect,
+ }
+ p.attachment.Thumbnail.FileSize = static.size
+
+ if err := putOrUpdateAttachment(ctx, p.database, p.attachment); err != nil {
+ p.err = err
+ p.thumbstate = errored
+ return nil, err
+ }
+
+ // set the thumbnail of this media
+ p.thumb = static
+
+ // we're done processing the thumbnail!
+ p.thumbstate = complete
+ fallthrough
+ case complete:
+ return p.thumb, nil
+ case errored:
+ return nil, p.err
+ }
+
+ return nil, fmt.Errorf("thumbnail processing status %d unknown", p.thumbstate)
+}
+
+func (p *ProcessingEmoji) loadFullSize(ctx context.Context) (*ImageMeta, error) {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+
+ switch p.fullSizeState {
+ case received:
+ var clean []byte
+ var err error
+ var decoded *ImageMeta
+
+ ct := p.attachment.File.ContentType
+ switch ct {
+ case mimeImageJpeg, mimeImagePng:
+ // first 'clean' image by purging exif data from it
+ var exifErr error
+ if clean, exifErr = purgeExif(p.rawData); exifErr != nil {
+ err = exifErr
+ break
+ }
+ decoded, err = decodeImage(clean, ct)
+ case mimeImageGif:
+ // gifs are already clean - no exif data to remove
+ clean = p.rawData
+ decoded, err = decodeGif(clean)
+ default:
+ err = fmt.Errorf("content type %s not a processible image type", ct)
+ }
+
+ if err != nil {
+ p.err = err
+ p.fullSizeState = errored
+ return nil, err
+ }
+
+ // put the full size in storage
+ if err := p.storage.Put(p.attachment.File.Path, decoded.image); err != nil {
+ p.err = fmt.Errorf("error storing full size image: %s", err)
+ p.fullSizeState = errored
+ return nil, p.err
+ }
+
+ // set appropriate fields on the attachment based on the image we derived
+ p.attachment.FileMeta.Original = gtsmodel.Original{
+ Width: decoded.width,
+ Height: decoded.height,
+ Size: decoded.size,
+ Aspect: decoded.aspect,
+ }
+ p.attachment.File.FileSize = decoded.size
+ p.attachment.File.UpdatedAt = time.Now()
+ p.attachment.Processing = gtsmodel.ProcessingStatusProcessed
+
+ if err := putOrUpdateAttachment(ctx, p.database, p.attachment); err != nil {
+ p.err = err
+ p.fullSizeState = errored
+ return nil, err
+ }
+
+ // set the fullsize of this media
+ p.fullSize = decoded
+
+ // we're done processing the full-size image
+ p.fullSizeState = complete
+ fallthrough
+ case complete:
+ return p.fullSize, nil
+ case errored:
+ return nil, p.err
+ }
+
+ return nil, fmt.Errorf("full size processing status %d unknown", p.fullSizeState)
+}
+
+// fetchRawData calls the data function attached to p if it hasn't been called yet,
+// and updates the underlying attachment fields as necessary.
+// It should only be called from within a function that already has a lock on p!
+func (p *ProcessingEmoji) fetchRawData(ctx context.Context) error {
+ // check if we've already done this and bail early if we have
+ if p.rawData != nil {
+ return nil
+ }
+
+ // execute the data function and pin the raw bytes for further processing
+ b, err := p.data(ctx)
+ if err != nil {
+ return fmt.Errorf("fetchRawData: error executing data function: %s", err)
+ }
+ p.rawData = b
+
+ // now we have the data we can work out the content type
+ contentType, err := parseContentType(p.rawData)
+ if err != nil {
+ return fmt.Errorf("fetchRawData: error parsing content type: %s", err)
+ }
+
+ if !supportedEmoji(contentType) {
+ return fmt.Errorf("fetchRawData: content type %s was not valid for an emoji", contentType)
+ }
+
+ split := strings.Split(contentType, "/")
+ mainType := split[0] // something like 'image'
+ extension := split[1] // something like 'gif'
+
+ // set some additional fields on the emoji now that
+ // we know more about what the underlying image actually is
+ p.emoji.ImageURL = uris.GenerateURIForAttachment(p.attachment.AccountID, string(TypeAttachment), string(SizeOriginal), p.attachment.ID, extension)
+ p.attachment.File.Path = fmt.Sprintf("%s/%s/%s/%s.%s", p.attachment.AccountID, TypeAttachment, SizeOriginal, p.attachment.ID, extension)
+ p.attachment.File.ContentType = contentType
+
+ switch mainType {
+ case mimeImage:
+ if extension == mimeGif {
+ p.attachment.Type = gtsmodel.FileTypeGif
+ } else {
+ p.attachment.Type = gtsmodel.FileTypeImage
+ }
+ default:
+ return fmt.Errorf("fetchRawData: cannot process mime type %s (yet)", mainType)
+ }
+
+ return nil
+}
+
+// putOrUpdateEmoji is just a convenience function for first trying to PUT the emoji in the database,
+// and then if that doesn't work because the emoji already exists, updating it instead.
+func putOrUpdateEmoji(ctx context.Context, database db.DB, emoji *gtsmodel.Emoji) error {
+ if err := database.Put(ctx, emoji); err != nil {
+ if err != db.ErrAlreadyExists {
+ return fmt.Errorf("putOrUpdateEmoji: proper error while putting emoji: %s", err)
+ }
+ if err := database.UpdateByPrimaryKey(ctx, emoji); err != nil {
+ return fmt.Errorf("putOrUpdateEmoji: error while updating emoji: %s", err)
+ }
+ }
+
+ return nil
+}
+
+func (m *manager) preProcessEmoji(ctx context.Context, data DataFunc, shortcode string, ai *AdditionalEmojiInfo) (*ProcessingEmoji, error) {
+ instanceAccount, err := m.db.GetInstanceAccount(ctx, "")
+ if err != nil {
+ return nil, fmt.Errorf("preProcessEmoji: error fetching this instance account from the db: %s", err)
+ }
+
+ id, err := id.NewRandomULID()
+ if err != nil {
+ return nil, err
+ }
+
+ // populate initial fields on the emoji -- some of these will be overwritten as we proceed
+ emoji := >smodel.Emoji{
+ ID: id,
+ CreatedAt: time.Now(),
+ UpdatedAt: time.Now(),
+ Shortcode: shortcode,
+ Domain: "", // assume our own domain unless told otherwise
+ ImageRemoteURL: "",
+ ImageStaticRemoteURL: "",
+ ImageURL: "", // we don't know yet
+ ImageStaticURL: uris.GenerateURIForAttachment(instanceAccount.ID, string(TypeEmoji), string(SizeStatic), id, mimePng), // all static emojis are encoded as png
+ ImagePath: "", // we don't know yet
+ ImageStaticPath: fmt.Sprintf("%s/%s/%s/%s.%s", instanceAccount.ID, TypeEmoji, SizeStatic, id, mimePng), // all static emojis are encoded as png
+ ImageContentType: "", // we don't know yet
+ ImageStaticContentType: mimeImagePng, // all static emojis are encoded as png
+ ImageFileSize: 0,
+ ImageStaticFileSize: 0,
+ ImageUpdatedAt: time.Now(),
+ Disabled: false,
+ URI: "", // we don't know yet
+ VisibleInPicker: true,
+ CategoryID: "",
+ }
+
+ // check if we have additional info to add to the emoji,
+ // and overwrite some of the emoji fields if so
+ if ai != nil {
+ if ai.CreatedAt != nil {
+ attachment.CreatedAt = *ai.CreatedAt
+ }
+
+ if ai.StatusID != nil {
+ attachment.StatusID = *ai.StatusID
+ }
+
+ if ai.RemoteURL != nil {
+ attachment.RemoteURL = *ai.RemoteURL
+ }
+
+ if ai.Description != nil {
+ attachment.Description = *ai.Description
+ }
+
+ if ai.ScheduledStatusID != nil {
+ attachment.ScheduledStatusID = *ai.ScheduledStatusID
+ }
+
+ if ai.Blurhash != nil {
+ attachment.Blurhash = *ai.Blurhash
+ }
+
+ if ai.Avatar != nil {
+ attachment.Avatar = *ai.Avatar
+ }
+
+ if ai.Header != nil {
+ attachment.Header = *ai.Header
+ }
+
+ if ai.FocusX != nil {
+ attachment.FileMeta.Focus.X = *ai.FocusX
+ }
+
+ if ai.FocusY != nil {
+ attachment.FileMeta.Focus.Y = *ai.FocusY
+ }
+ }
+
+ processingEmoji := &ProcessingEmoji{
+ emoji: emoji,
+ data: data,
+ staticState: received,
+ fullSizeState: received,
+ database: m.db,
+ storage: m.storage,
+ }
+
+ return processingEmoji, nil
+}
diff --git a/internal/media/processingmedia.go b/internal/media/processingmedia.go
@@ -0,0 +1,411 @@
+/*
+ GoToSocial
+ Copyright (C) 2021-2022 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package media
+
+import (
+ "context"
+ "fmt"
+ "strings"
+ "sync"
+ "time"
+
+ "codeberg.org/gruf/go-store/kv"
+ "github.com/superseriousbusiness/gotosocial/internal/db"
+ "github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+ "github.com/superseriousbusiness/gotosocial/internal/id"
+ "github.com/superseriousbusiness/gotosocial/internal/uris"
+)
+
+type processState int
+
+const (
+ received processState = iota // processing order has been received but not done yet
+ complete // processing order has been completed successfully
+ errored // processing order has been completed with an error
+)
+
+// ProcessingMedia represents a piece of media that is currently being processed. It exposes
+// various functions for retrieving data from the process.
+type ProcessingMedia struct {
+ mu sync.Mutex
+
+ /*
+ below fields should be set on newly created media;
+ attachment will be updated incrementally as media goes through processing
+ */
+
+ attachment *gtsmodel.MediaAttachment
+ data DataFunc
+
+ rawData []byte // will be set once the fetchRawData function has been called
+
+ /*
+ below fields represent the processing state of the media thumbnail
+ */
+
+ thumbstate processState
+ thumb *ImageMeta
+
+ /*
+ below fields represent the processing state of the full-sized media
+ */
+
+ fullSizeState processState
+ fullSize *ImageMeta
+
+ /*
+ below pointers to database and storage are maintained so that
+ the media can store and update itself during processing steps
+ */
+
+ database db.DB
+ storage *kv.KVStore
+
+ err error // error created during processing, if any
+}
+
+// AttachmentID returns the ID of the underlying media attachment without blocking processing.
+func (p *ProcessingMedia) AttachmentID() string {
+ return p.attachment.ID
+}
+
+// LoadAttachment blocks until the thumbnail and fullsize content
+// has been processed, and then returns the completed attachment.
+func (p *ProcessingMedia) LoadAttachment(ctx context.Context) (*gtsmodel.MediaAttachment, error) {
+ if err := p.fetchRawData(ctx); err != nil {
+ return nil, err
+ }
+
+ if _, err := p.loadThumb(ctx); err != nil {
+ return nil, err
+ }
+
+ if _, err := p.loadFullSize(ctx); err != nil {
+ return nil, err
+ }
+
+ return p.attachment, nil
+}
+
+func (p *ProcessingMedia) LoadEmoji(ctx context.Context) (*gtsmodel.Emoji, error) {
+ return nil, nil
+}
+
+// Finished returns true if processing has finished for both the thumbnail
+// and full fized version of this piece of media.
+func (p *ProcessingMedia) Finished() bool {
+ return p.thumbstate == complete && p.fullSizeState == complete
+}
+
+func (p *ProcessingMedia) loadThumb(ctx context.Context) (*ImageMeta, error) {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+
+ switch p.thumbstate {
+ case received:
+ // we haven't processed a thumbnail for this media yet so do it now
+
+ // check if we need to create a blurhash or if there's already one set
+ var createBlurhash bool
+ if p.attachment.Blurhash == "" {
+ // no blurhash created yet
+ createBlurhash = true
+ }
+
+ thumb, err := deriveThumbnail(p.rawData, p.attachment.File.ContentType, createBlurhash)
+ if err != nil {
+ p.err = fmt.Errorf("error deriving thumbnail: %s", err)
+ p.thumbstate = errored
+ return nil, p.err
+ }
+
+ // put the thumbnail in storage
+ if err := p.storage.Put(p.attachment.Thumbnail.Path, thumb.image); err != nil {
+ p.err = fmt.Errorf("error storing thumbnail: %s", err)
+ p.thumbstate = errored
+ return nil, p.err
+ }
+
+ // set appropriate fields on the attachment based on the thumbnail we derived
+ if createBlurhash {
+ p.attachment.Blurhash = thumb.blurhash
+ }
+
+ p.attachment.FileMeta.Small = gtsmodel.Small{
+ Width: thumb.width,
+ Height: thumb.height,
+ Size: thumb.size,
+ Aspect: thumb.aspect,
+ }
+ p.attachment.Thumbnail.FileSize = thumb.size
+
+ if err := putOrUpdateAttachment(ctx, p.database, p.attachment); err != nil {
+ p.err = err
+ p.thumbstate = errored
+ return nil, err
+ }
+
+ // set the thumbnail of this media
+ p.thumb = thumb
+
+ // we're done processing the thumbnail!
+ p.thumbstate = complete
+ fallthrough
+ case complete:
+ return p.thumb, nil
+ case errored:
+ return nil, p.err
+ }
+
+ return nil, fmt.Errorf("thumbnail processing status %d unknown", p.thumbstate)
+}
+
+func (p *ProcessingMedia) loadFullSize(ctx context.Context) (*ImageMeta, error) {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+
+ switch p.fullSizeState {
+ case received:
+ var clean []byte
+ var err error
+ var decoded *ImageMeta
+
+ ct := p.attachment.File.ContentType
+ switch ct {
+ case mimeImageJpeg, mimeImagePng:
+ // first 'clean' image by purging exif data from it
+ var exifErr error
+ if clean, exifErr = purgeExif(p.rawData); exifErr != nil {
+ err = exifErr
+ break
+ }
+ decoded, err = decodeImage(clean, ct)
+ case mimeImageGif:
+ // gifs are already clean - no exif data to remove
+ clean = p.rawData
+ decoded, err = decodeGif(clean)
+ default:
+ err = fmt.Errorf("content type %s not a processible image type", ct)
+ }
+
+ if err != nil {
+ p.err = err
+ p.fullSizeState = errored
+ return nil, err
+ }
+
+ // put the full size in storage
+ if err := p.storage.Put(p.attachment.File.Path, decoded.image); err != nil {
+ p.err = fmt.Errorf("error storing full size image: %s", err)
+ p.fullSizeState = errored
+ return nil, p.err
+ }
+
+ // set appropriate fields on the attachment based on the image we derived
+ p.attachment.FileMeta.Original = gtsmodel.Original{
+ Width: decoded.width,
+ Height: decoded.height,
+ Size: decoded.size,
+ Aspect: decoded.aspect,
+ }
+ p.attachment.File.FileSize = decoded.size
+ p.attachment.File.UpdatedAt = time.Now()
+ p.attachment.Processing = gtsmodel.ProcessingStatusProcessed
+
+ if err := putOrUpdateAttachment(ctx, p.database, p.attachment); err != nil {
+ p.err = err
+ p.fullSizeState = errored
+ return nil, err
+ }
+
+ // set the fullsize of this media
+ p.fullSize = decoded
+
+ // we're done processing the full-size image
+ p.fullSizeState = complete
+ fallthrough
+ case complete:
+ return p.fullSize, nil
+ case errored:
+ return nil, p.err
+ }
+
+ return nil, fmt.Errorf("full size processing status %d unknown", p.fullSizeState)
+}
+
+// fetchRawData calls the data function attached to p if it hasn't been called yet,
+// and updates the underlying attachment fields as necessary.
+// It should only be called from within a function that already has a lock on p!
+func (p *ProcessingMedia) fetchRawData(ctx context.Context) error {
+ // check if we've already done this and bail early if we have
+ if p.rawData != nil {
+ return nil
+ }
+
+ // execute the data function and pin the raw bytes for further processing
+ b, err := p.data(ctx)
+ if err != nil {
+ return fmt.Errorf("fetchRawData: error executing data function: %s", err)
+ }
+ p.rawData = b
+
+ // now we have the data we can work out the content type
+ contentType, err := parseContentType(p.rawData)
+ if err != nil {
+ return fmt.Errorf("fetchRawData: error parsing content type: %s", err)
+ }
+
+ split := strings.Split(contentType, "/")
+ if len(split) != 2 {
+ return fmt.Errorf("fetchRawData: content type %s was not valid", contentType)
+ }
+
+ mainType := split[0] // something like 'image'
+ extension := split[1] // something like 'jpeg'
+
+ // set some additional fields on the attachment now that
+ // we know more about what the underlying media actually is
+ p.attachment.URL = uris.GenerateURIForAttachment(p.attachment.AccountID, string(TypeAttachment), string(SizeOriginal), p.attachment.ID, extension)
+ p.attachment.File.Path = fmt.Sprintf("%s/%s/%s/%s.%s", p.attachment.AccountID, TypeAttachment, SizeOriginal, p.attachment.ID, extension)
+ p.attachment.File.ContentType = contentType
+
+ switch mainType {
+ case mimeImage:
+ if extension == mimeGif {
+ p.attachment.Type = gtsmodel.FileTypeGif
+ } else {
+ p.attachment.Type = gtsmodel.FileTypeImage
+ }
+ default:
+ return fmt.Errorf("fetchRawData: cannot process mime type %s (yet)", mainType)
+ }
+
+ return nil
+}
+
+// putOrUpdateAttachment is just a convenience function for first trying to PUT the attachment in the database,
+// and then if that doesn't work because the attachment already exists, updating it instead.
+func putOrUpdateAttachment(ctx context.Context, database db.DB, attachment *gtsmodel.MediaAttachment) error {
+ if err := database.Put(ctx, attachment); err != nil {
+ if err != db.ErrAlreadyExists {
+ return fmt.Errorf("putOrUpdateAttachment: proper error while putting attachment: %s", err)
+ }
+ if err := database.UpdateByPrimaryKey(ctx, attachment); err != nil {
+ return fmt.Errorf("putOrUpdateAttachment: error while updating attachment: %s", err)
+ }
+ }
+
+ return nil
+}
+
+func (m *manager) preProcessMedia(ctx context.Context, data DataFunc, accountID string, ai *AdditionalMediaInfo) (*ProcessingMedia, error) {
+ id, err := id.NewRandomULID()
+ if err != nil {
+ return nil, err
+ }
+
+ file := gtsmodel.File{
+ Path: "", // we don't know yet because it depends on the uncalled DataFunc
+ ContentType: "", // we don't know yet because it depends on the uncalled DataFunc
+ UpdatedAt: time.Now(),
+ }
+
+ thumbnail := gtsmodel.Thumbnail{
+ URL: uris.GenerateURIForAttachment(accountID, string(TypeAttachment), string(SizeSmall), id, mimeJpeg), // all thumbnails are encoded as jpeg,
+ Path: fmt.Sprintf("%s/%s/%s/%s.%s", accountID, TypeAttachment, SizeSmall, id, mimeJpeg), // all thumbnails are encoded as jpeg,
+ ContentType: mimeJpeg,
+ UpdatedAt: time.Now(),
+ }
+
+ // populate initial fields on the media attachment -- some of these will be overwritten as we proceed
+ attachment := >smodel.MediaAttachment{
+ ID: id,
+ CreatedAt: time.Now(),
+ UpdatedAt: time.Now(),
+ StatusID: "",
+ URL: "", // we don't know yet because it depends on the uncalled DataFunc
+ RemoteURL: "",
+ Type: gtsmodel.FileTypeUnknown, // we don't know yet because it depends on the uncalled DataFunc
+ FileMeta: gtsmodel.FileMeta{},
+ AccountID: accountID,
+ Description: "",
+ ScheduledStatusID: "",
+ Blurhash: "",
+ Processing: gtsmodel.ProcessingStatusReceived,
+ File: file,
+ Thumbnail: thumbnail,
+ Avatar: false,
+ Header: false,
+ }
+
+ // check if we have additional info to add to the attachment,
+ // and overwrite some of the attachment fields if so
+ if ai != nil {
+ if ai.CreatedAt != nil {
+ attachment.CreatedAt = *ai.CreatedAt
+ }
+
+ if ai.StatusID != nil {
+ attachment.StatusID = *ai.StatusID
+ }
+
+ if ai.RemoteURL != nil {
+ attachment.RemoteURL = *ai.RemoteURL
+ }
+
+ if ai.Description != nil {
+ attachment.Description = *ai.Description
+ }
+
+ if ai.ScheduledStatusID != nil {
+ attachment.ScheduledStatusID = *ai.ScheduledStatusID
+ }
+
+ if ai.Blurhash != nil {
+ attachment.Blurhash = *ai.Blurhash
+ }
+
+ if ai.Avatar != nil {
+ attachment.Avatar = *ai.Avatar
+ }
+
+ if ai.Header != nil {
+ attachment.Header = *ai.Header
+ }
+
+ if ai.FocusX != nil {
+ attachment.FileMeta.Focus.X = *ai.FocusX
+ }
+
+ if ai.FocusY != nil {
+ attachment.FileMeta.Focus.Y = *ai.FocusY
+ }
+ }
+
+ processingMedia := &ProcessingMedia{
+ attachment: attachment,
+ data: data,
+ thumbstate: received,
+ fullSizeState: received,
+ database: m.db,
+ storage: m.storage,
+ }
+
+ return processingMedia, nil
+}
diff --git a/internal/media/types.go b/internal/media/types.go
@@ -20,6 +20,7 @@ package media
import (
"bytes"
+ "context"
"errors"
"fmt"
"time"
@@ -68,9 +69,9 @@ const (
TypeEmoji Type = "emoji" // TypeEmoji is the key for emoji type requests
)
-// AdditionalInfo represents additional information that should be added to an attachment
+// AdditionalMediaInfo represents additional information that should be added to an attachment
// when processing a piece of media.
-type AdditionalInfo struct {
+type AdditionalMediaInfo struct {
// Time that this media was created; defaults to time.Now().
CreatedAt *time.Time
// ID of the status to which this media is attached; defaults to "".
@@ -93,6 +94,13 @@ type AdditionalInfo struct {
FocusY *float32
}
+type AdditionalEmojiInfo struct {
+
+}
+
+// DataFunc represents a function used to retrieve the raw bytes of a piece of media.
+type DataFunc func(ctx context.Context) ([]byte, error)
+
// parseContentType parses the MIME content type from a file, returning it as a string in the form (eg., "image/jpeg").
// Returns an error if the content type is not something we can process.
func parseContentType(content []byte) (string, error) {
diff --git a/internal/processing/account/update.go b/internal/processing/account/update.go
@@ -137,84 +137,87 @@ func (p *processor) Update(ctx context.Context, account *gtsmodel.Account, form
// parsing and checking the image, and doing the necessary updates in the database for this to become
// the account's new avatar image.
func (p *processor) UpdateAvatar(ctx context.Context, avatar *multipart.FileHeader, accountID string) (*gtsmodel.MediaAttachment, error) {
- var err error
maxImageSize := viper.GetInt(config.Keys.MediaImageMaxSize)
if int(avatar.Size) > maxImageSize {
- err = fmt.Errorf("UpdateAvatar: avatar with size %d exceeded max image size of %d bytes", avatar.Size, maxImageSize)
- return nil, err
- }
- f, err := avatar.Open()
- if err != nil {
- return nil, fmt.Errorf("UpdateAvatar: could not read provided avatar: %s", err)
+ return nil, fmt.Errorf("UpdateAvatar: avatar with size %d exceeded max image size of %d bytes", avatar.Size, maxImageSize)
}
- // extract the bytes
- buf := new(bytes.Buffer)
- size, err := io.Copy(buf, f)
- if err != nil {
- return nil, fmt.Errorf("UpdateAvatar: could not read provided avatar: %s", err)
- }
- if size == 0 {
- return nil, errors.New("UpdateAvatar: could not read provided avatar: size 0 bytes")
- }
+ dataFunc := func(ctx context.Context) ([]byte, error) {
+ // pop open the fileheader
+ f, err := avatar.Open()
+ if err != nil {
+ return nil, fmt.Errorf("UpdateAvatar: could not read provided avatar: %s", err)
+ }
- // we're done with the FileHeader now
- if err := f.Close(); err != nil {
- return nil, fmt.Errorf("UpdateAvatar: error closing multipart fileheader: %s", err)
+ // extract the bytes
+ buf := new(bytes.Buffer)
+ size, err := io.Copy(buf, f)
+ if err != nil {
+ return nil, fmt.Errorf("UpdateAvatar: could not read provided avatar: %s", err)
+ }
+ if size == 0 {
+ return nil, errors.New("UpdateAvatar: could not read provided avatar: size 0 bytes")
+ }
+
+ return buf.Bytes(), f.Close()
}
- // do the setting
isAvatar := true
- processingMedia, err := p.mediaManager.ProcessMedia(ctx, buf.Bytes(), accountID, &media.AdditionalInfo{
+ ai := &media.AdditionalMediaInfo{
Avatar: &isAvatar,
- })
+ }
+
+ processingMedia, err := p.mediaManager.ProcessMedia(ctx, dataFunc, accountID, ai)
if err != nil {
return nil, fmt.Errorf("UpdateAvatar: error processing avatar: %s", err)
}
- return processingMedia.Load(ctx)
+ return processingMedia.LoadAttachment(ctx)
}
// UpdateHeader does the dirty work of checking the header part of an account update form,
// parsing and checking the image, and doing the necessary updates in the database for this to become
// the account's new header image.
func (p *processor) UpdateHeader(ctx context.Context, header *multipart.FileHeader, accountID string) (*gtsmodel.MediaAttachment, error) {
- var err error
maxImageSize := viper.GetInt(config.Keys.MediaImageMaxSize)
if int(header.Size) > maxImageSize {
- err = fmt.Errorf("UpdateHeader: header with size %d exceeded max image size of %d bytes", header.Size, maxImageSize)
- return nil, err
- }
- f, err := header.Open()
- if err != nil {
- return nil, fmt.Errorf("UpdateHeader: could not read provided header: %s", err)
+ return nil, fmt.Errorf("UpdateHeader: header with size %d exceeded max image size of %d bytes", header.Size, maxImageSize)
}
- // extract the bytes
- buf := new(bytes.Buffer)
- size, err := io.Copy(buf, f)
- if err != nil {
- return nil, fmt.Errorf("UpdateHeader: could not read provided header: %s", err)
- }
- if size == 0 {
- return nil, errors.New("UpdateHeader: could not read provided header: size 0 bytes")
- }
+ dataFunc := func(ctx context.Context) ([]byte, error) {
+ // pop open the fileheader
+ f, err := header.Open()
+ if err != nil {
+ return nil, fmt.Errorf("UpdateHeader: could not read provided header: %s", err)
+ }
+
+ // extract the bytes
+ buf := new(bytes.Buffer)
+ size, err := io.Copy(buf, f)
+ if err != nil {
+ return nil, fmt.Errorf("UpdateHeader: could not read provided header: %s", err)
+ }
+ if size == 0 {
+ return nil, errors.New("UpdateHeader: could not read provided header: size 0 bytes")
+ }
- // we're done with the FileHeader now
- if err := f.Close(); err != nil {
- return nil, fmt.Errorf("UpdateHeader: error closing multipart fileheader: %s", err)
+ return buf.Bytes(), f.Close()
}
- // do the setting
isHeader := true
- processingMedia, err := p.mediaManager.ProcessMedia(ctx, buf.Bytes(), accountID, &media.AdditionalInfo{
+ ai := &media.AdditionalMediaInfo{
Header: &isHeader,
- })
+ }
+
+ processingMedia, err := p.mediaManager.ProcessMedia(ctx, dataFunc, accountID, ai)
+ if err != nil {
+ return nil, fmt.Errorf("UpdateHeader: error processing header: %s", err)
+ }
if err != nil {
return nil, fmt.Errorf("UpdateHeader: error processing header: %s", err)
}
- return processingMedia.Load(ctx)
+ return processingMedia.LoadAttachment(ctx)
}
func (p *processor) processNote(ctx context.Context, note string, accountID string) (string, error) {
diff --git a/internal/processing/admin/emoji.go b/internal/processing/admin/emoji.go
@@ -30,30 +30,34 @@ import (
)
func (p *processor) EmojiCreate(ctx context.Context, account *gtsmodel.Account, user *gtsmodel.User, form *apimodel.EmojiCreateRequest) (*apimodel.Emoji, error) {
- if user.Admin {
+ if !user.Admin {
return nil, fmt.Errorf("user %s not an admin", user.ID)
}
- // open the emoji and extract the bytes from it
- f, err := form.Image.Open()
- if err != nil {
- return nil, fmt.Errorf("error opening emoji: %s", err)
- }
- buf := new(bytes.Buffer)
- size, err := io.Copy(buf, f)
- if err != nil {
- return nil, fmt.Errorf("error reading emoji: %s", err)
- }
- if size == 0 {
- return nil, errors.New("could not read provided emoji: size 0 bytes")
+ data := func(innerCtx context.Context) ([]byte, error) {
+ // open the emoji and extract the bytes from it
+ f, err := form.Image.Open()
+ if err != nil {
+ return nil, fmt.Errorf("error opening emoji: %s", err)
+ }
+ buf := new(bytes.Buffer)
+ size, err := io.Copy(buf, f)
+ if err != nil {
+ return nil, fmt.Errorf("error reading emoji: %s", err)
+ }
+ if size == 0 {
+ return nil, errors.New("could not read provided emoji: size 0 bytes")
+ }
+
+ return buf.Bytes(), f.Close()
}
- media, err := p.mediaManager.ProcessEmoji(ctx, buf.Bytes(), account.ID)
+ processingEmoji, err := p.mediaManager.ProcessEmoji(ctx, data, form.Shortcode, nil)
if err != nil {
return nil, err
}
- emoji, err := media.LoadEmoji(ctx)
+ emoji, err := processingEmoji.LoadEmoji(ctx)
if err != nil {
return nil, err
}
diff --git a/internal/processing/media/create.go b/internal/processing/media/create.go
@@ -31,18 +31,21 @@ import (
)
func (p *processor) Create(ctx context.Context, account *gtsmodel.Account, form *apimodel.AttachmentRequest) (*apimodel.Attachment, error) {
- // open the attachment and extract the bytes from it
- f, err := form.File.Open()
- if err != nil {
- return nil, fmt.Errorf("error opening attachment: %s", err)
- }
- buf := new(bytes.Buffer)
- size, err := io.Copy(buf, f)
- if err != nil {
- return nil, fmt.Errorf("error reading attachment: %s", err)
- }
- if size == 0 {
- return nil, errors.New("could not read provided attachment: size 0 bytes")
+ data := func(innerCtx context.Context) ([]byte, error) {
+ // open the attachment and extract the bytes from it
+ f, err := form.File.Open()
+ if err != nil {
+ return nil, fmt.Errorf("error opening attachment: %s", err)
+ }
+ buf := new(bytes.Buffer)
+ size, err := io.Copy(buf, f)
+ if err != nil {
+ return nil, fmt.Errorf("error reading attachment: %s", err)
+ }
+ if size == 0 {
+ return nil, errors.New("could not read provided attachment: size 0 bytes")
+ }
+ return buf.Bytes(), f.Close()
}
focusX, focusY, err := parseFocus(form.Focus)
@@ -51,7 +54,7 @@ func (p *processor) Create(ctx context.Context, account *gtsmodel.Account, form
}
// process the media attachment and load it immediately
- media, err := p.mediaManager.ProcessMedia(ctx, buf.Bytes(), account.ID, &media.AdditionalInfo{
+ media, err := p.mediaManager.ProcessMedia(ctx, data, account.ID, &media.AdditionalMediaInfo{
Description: &form.Description,
FocusX: &focusX,
FocusY: &focusY,
@@ -60,7 +63,7 @@ func (p *processor) Create(ctx context.Context, account *gtsmodel.Account, form
return nil, err
}
- attachment, err := media.Load(ctx)
+ attachment, err := media.LoadAttachment(ctx)
if err != nil {
return nil, err
}
diff --git a/internal/transport/transport.go b/internal/transport/transport.go
@@ -33,7 +33,7 @@ import (
// functionality for fetching remote media.
type Transport interface {
pub.Transport
- // DereferenceMedia fetches the bytes of the given media attachment IRI, with the expectedContentType.
+ // DereferenceMedia fetches the bytes of the given media attachment IRI.
DereferenceMedia(ctx context.Context, iri *url.URL) ([]byte, error)
// DereferenceInstance dereferences remote instance information, first by checking /api/v1/instance, and then by checking /.well-known/nodeinfo.
DereferenceInstance(ctx context.Context, iri *url.URL) (*gtsmodel.Instance, error)
diff --git a/testrig/testmodels.go b/testrig/testmodels.go
@@ -66,6 +66,16 @@ func NewTestTokens() map[string]*gtsmodel.Token {
AccessCreateAt: time.Now(),
AccessExpiresAt: time.Now().Add(72 * time.Hour),
},
+ "admin_account": {
+ ID: "01FS4TP8ANA5VE92EAPA9E0M7Q",
+ ClientID: "01F8MGWSJCND9BWBD4WGJXBM93",
+ UserID: "01F8MGWYWKVKS3VS8DV1AMYPGE",
+ RedirectURI: "http://localhost:8080",
+ Scope: "read write follow push admin",
+ Access: "AININALKNENFNF98717NAMG4LWE4NJITMWUXM2M4MTRHZDEX",
+ AccessCreateAt: time.Now(),
+ AccessExpiresAt: time.Now().Add(72 * time.Hour),
+ },
}
return tokens
}
