Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Support up to ten photos per Space post

Anand Baburajan5e04c7fa3484
diff --git a/server/pkg/middleware/rate_limit.go b/server/pkg/middleware/rate_limit.go
index 66d92ac013..efc9e8a426 100644
--- a/server/pkg/middleware/rate_limit.go
+++ b/server/pkg/middleware/rate_limit.go
@@ -218,7 +218,7 @@ func (r *RateLimitMiddleware) getLimiter(reqPath string, reqMethod string) *limi
return r.limit10ReqPerMin
}
if reqPath == "/spaces/:spaceID/uploads/presign" && reqMethod == http.MethodPost {
- return r.limit10ReqPerMin
+ return r.limit60ReqPerMin
}
if reqPath == "/spaces/:spaceID/assets/redirect" && reqMethod == http.MethodGet {
return r.limit500ReqPerMin
diff --git a/server/pkg/middleware/space_test.go b/server/pkg/middleware/space_test.go
new file mode 100644
index 0000000000..1a8dc974f9
--- /dev/null
+++ b/server/pkg/middleware/space_test.go
@@ -0,0 +1,42 @@
+package middleware
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/ente/museum/pkg/controller/discord"
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSpacePresignAllowsPhotoBatchesAfterProfileUploads(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ rateLimiter := NewRateLimitMiddleware(discord.NewDiscordController(nil, "test", "test"), 1000, time.Minute)
+ t.Cleanup(rateLimiter.Stop)
+ router := gin.New()
+ router.POST("/spaces/:spaceID/uploads/presign", rateLimiter.APIRateLimitForUserMiddleware(func(c *gin.Context) string {
+ return c.FullPath()
+ }), func(c *gin.Context) {
+ c.Status(http.StatusNoContent)
+ })
+ request := func() int {
+ req := httptest.NewRequest(http.MethodPost, "/spaces/test-space/uploads/presign", nil)
+ req.RemoteAddr = "192.0.2.1:1234"
+ req.Header.Set("X-Auth-User-ID", "1")
+ response := httptest.NewRecorder()
+ router.ServeHTTP(response, req)
+ return response.Code
+ }
+ for range 2 {
+ require.Equal(t, http.StatusNoContent, request())
+ }
+ for range 10 {
+ require.Equal(t, http.StatusNoContent, request())
+ }
+ for range 48 {
+ require.Equal(t, http.StatusNoContent, request())
+ }
+ require.Equal(t, http.StatusTooManyRequests, request())
+}
diff --git a/server/space/controller/posts_test.go b/server/space/controller/posts_test.go
index 823630bc27..f2f90f6701 100644
--- a/server/space/controller/posts_test.go
+++ b/server/space/controller/posts_test.go
@@ -3,11 +3,19 @@ package controller
import (
"crypto/sha256"
"database/sql"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "slices"
+ "strconv"
"testing"
+ "github.com/ente/museum/pkg/utils/config"
+ "github.com/ente/museum/pkg/utils/s3config"
timeutil "github.com/ente/museum/pkg/utils/time"
"github.com/ente/museum/space/models"
spacerepo "github.com/ente/museum/space/repo"
+ "github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
@@ -42,18 +50,126 @@ func TestCreatePostRequiresAssetMetadataCipher(t *testing.T) {
require.Contains(t, err.Error(), "metadataCipher is required")
}
-func TestCreatePostRejectsMultipleObjects(t *testing.T) {
- controller := &PostsController{}
+func TestCreatePostAcceptsUpToTenObjects(t *testing.T) {
+ for _, test := range []struct {
+ count int
+ abandoned int
+ }{
+ {count: 1},
+ {count: 2},
+ {count: 10},
+ {count: 10, abandoned: 1},
+ {count: 10, abandoned: 10},
+ } {
+ t.Run(fmt.Sprintf("%d_photos_after_%d_abandoned", test.count, test.abandoned), func(t *testing.T) {
+ controller, repos, ctx := setupPostsControllerTest(t)
+ storage := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodHead {
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ return
+ }
+ w.Header().Set("Content-Length", "123")
+ }))
+ t.Cleanup(storage.Close)
+ viper.Reset()
+ t.Cleanup(viper.Reset)
+ require.NoError(t, config.ConfigureViper("local"))
+ viper.Set("s3.b2-eu-cen.key", "test-key")
+ viper.Set("s3.b2-eu-cen.secret", "test-secret")
+ viper.Set("s3.b2-eu-cen.endpoint", storage.URL)
+ viper.Set("s3.b2-eu-cen.region", "us-east-1")
+ viper.Set("s3.b2-eu-cen.bucket", "test-bucket")
+ viper.Set("s3.b2-eu-cen.use_path_style_urls", true)
+ viper.Set(spaceAssetsPrimaryBucketConfigKey, "b2-eu-cen")
+ repos.Assets.S3Config = s3config.NewS3Config()
+ ownerID := insertSpaceControllerUser(t, repos, "[email protected]", "public")
+ space, err := testCreateSpace(ctx, repos, ownerID, "multi_photo", "space-key", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
- _, err := controller.Create(t.Context(), &spacerepo.SpaceRecord{}, models.CreatePostRequest{
- EncryptedPostKey: "post-key",
- Objects: []models.PostObjectPayload{
- {ObjectKey: "first"},
- {ObjectKey: "second"},
- },
- })
+ assets := &AssetsController{AssetsRepo: repos.Assets}
+ reserve := func() string {
+ response, err := assets.PresignUpload(ctx, space, models.PresignUploadRequest{
+ Size: 123,
+ ContentMD5: "XUFAKrxLKna5cZ2REBfFkg==",
+ }, "space-test")
+ require.NoError(t, err)
+ return response.ObjectKey
+ }
+ abandoned := make([]string, test.abandoned)
+ for i := range abandoned {
+ abandoned[i] = reserve()
+ }
+ objects := make([]models.PostObjectPayload, test.count)
+ for position := range test.count {
+ objects[position] = models.PostObjectPayload{
+ ObjectKey: reserve(),
+ Size: 123,
+ Position: position,
+ MetadataCipher: "bWV0YWRhdGE=",
+ }
+ }
+ requestObjects := slices.Clone(objects)
+ slices.Reverse(requestObjects)
+ caption := "Y2FwdGlvbg=="
+ created, err := controller.Create(ctx, space, models.CreatePostRequest{
+ EncryptedPostKey: "cG9zdC1rZXk=",
+ CaptionCipher: &caption,
+ KeyVersion: space.CurrentVersion,
+ Objects: requestObjects,
+ })
+ require.NoError(t, err)
+ feed, err := controller.ListFeed(ctx, space, models.ListFeedRequest{Limit: 10})
+ require.NoError(t, err)
+ require.Len(t, feed.Items, 1)
+ require.Equal(t, created.PostID, feed.Items[0].PostID)
+ require.Equal(t, caption, feed.Items[0].CaptionCipher)
+ require.Equal(t, objects, feed.Items[0].Objects)
+ for _, object := range objects {
+ _, err := repos.Assets.GetTempObject(ctx, object.ObjectKey, spacerepo.TempObjectPurposePost, &space.SpaceID)
+ require.ErrorIs(t, err, sql.ErrNoRows)
+ }
+ for _, objectKey := range abandoned {
+ staged, err := repos.Assets.GetTempObject(ctx, objectKey, spacerepo.TempObjectPurposePost, &space.SpaceID)
+ require.NoError(t, err)
+ require.Equal(t, staged.ExpiresAt, staged.CleanupAfter)
+ }
+ })
+ }
+}
+
+func TestCreatePostRejectsInvalidObjectCount(t *testing.T) {
+ for _, test := range []struct {
+ count int
+ message string
+ }{
+ {count: 0, message: "encryptedPostKey and objects are required"},
+ {count: 11, message: "too many post objects"},
+ } {
+ t.Run(strconv.Itoa(test.count), func(t *testing.T) {
+ _, err := (&PostsController{}).Create(t.Context(), &spacerepo.SpaceRecord{}, models.CreatePostRequest{
+ EncryptedPostKey: "cG9zdC1rZXk=",
+ KeyVersion: 1,
+ Objects: make([]models.PostObjectPayload, test.count),
+ })
+ require.ErrorContains(t, err, test.message)
+ })
+ }
+}
- require.ErrorContains(t, err, "too many post objects")
+func TestCreatePostRejectsInvalidObjectPosition(t *testing.T) {
+ for _, position := range []int{-1, 10} {
+ t.Run(strconv.Itoa(position), func(t *testing.T) {
+ _, err := (&PostsController{}).Create(t.Context(), &spacerepo.SpaceRecord{}, models.CreatePostRequest{
+ EncryptedPostKey: "cG9zdC1rZXk=",
+ KeyVersion: 1,
+ Objects: []models.PostObjectPayload{{
+ ObjectKey: "photo",
+ Position: position,
+ }},
+ })
+ require.ErrorContains(t, err, "invalid object position")
+ })
+ }
}
func TestListPostsHydratesPostAssets(t *testing.T) {
diff --git a/server/space/controller/validation.go b/server/space/controller/validation.go
index 6b04dc6f3b..6f73661d60 100644
--- a/server/space/controller/validation.go
+++ b/server/space/controller/validation.go
@@ -17,7 +17,7 @@ const (
maxSpaceCaptionCipherDecodedBytes = 12 * 1024
maxSpaceAssetMetadataEncodedBytes = 8 * 1024
maxSpaceAssetMetadataDecodedBytes = 6 * 1024
- maxSpacePostObjects = 1
+ maxSpacePostObjects = repo.MaxPostObjects
maxSpaceFriendSharesPerRefresh = 500
maxSpaceObjectKeyBytes = 512
maxSpaceLinkKDFSaltEncodedBytes = 128
diff --git a/server/space/repo/posts.go b/server/space/repo/posts.go
index f4bdeb84b9..5d8a543450 100644
--- a/server/space/repo/posts.go
+++ b/server/space/repo/posts.go
@@ -11,7 +11,10 @@ import (
"github.com/ente/stacktrace"
)
-const MaxPostsPerSpace = 250
+const (
+ MaxPostsPerSpace = 250
+ MaxPostObjects = 10
+)
var ErrSpacePostLimitReached = errors.New("space post limit reached")
diff --git a/server/space/repo/temp_objects.go b/server/space/repo/temp_objects.go
index 854e3ca97c..ed86be11ee 100644
--- a/server/space/repo/temp_objects.go
+++ b/server/space/repo/temp_objects.go
@@ -13,7 +13,7 @@ import (
const (
SpaceUploadURLExpiry = 15 * time.Minute
SpaceUploadCleanupDelay = 2 * SpaceUploadURLExpiry
- MaxActiveUploadCount = 10
+ MaxActiveUploadCount = 2 * MaxPostObjects
)
var ErrSpaceUploadLimitReached = errors.New("space upload limit reached")