Skip to content

armgit / ente

Public Imported from GitHub
0

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

[space][server] Add encrypted video post support

Anand Baburajan1445b7d0d68b
diff --git a/server/migrations/148_space_post_video.down.sql b/server/migrations/148_space_post_video.down.sql
new file mode 100644
index 0000000000..d782d35345
--- /dev/null
+++ b/server/migrations/148_space_post_video.down.sql
@@ -0,0 +1,10 @@
+DO $$ BEGIN
+ IF EXISTS (SELECT 1 FROM space_post_assets WHERE role = 'video') THEN
+ RAISE EXCEPTION 'Cannot roll back while video posts exist';
+ END IF;
+END $$;
+DROP INDEX uq_space_posts_client_request;
+ALTER TABLE space_posts DROP COLUMN client_request_id;
+DROP INDEX uq_space_post_assets_position;
+ALTER TABLE space_post_assets DROP COLUMN role;
+CREATE UNIQUE INDEX uq_space_post_assets_position ON space_post_assets (post_id, position);
diff --git a/server/migrations/148_space_post_video.up.sql b/server/migrations/148_space_post_video.up.sql
new file mode 100644
index 0000000000..71a3e383e3
--- /dev/null
+++ b/server/migrations/148_space_post_video.up.sql
@@ -0,0 +1,6 @@
+ALTER TABLE space_post_assets ADD COLUMN role TEXT NOT NULL DEFAULT 'preview';
+ALTER TABLE space_post_assets ADD CONSTRAINT chk_space_post_assets_role CHECK (role IN ('preview', 'video'));
+DROP INDEX uq_space_post_assets_position;
+CREATE UNIQUE INDEX uq_space_post_assets_position ON space_post_assets (post_id, position, role);
+ALTER TABLE space_posts ADD COLUMN client_request_id TEXT;
+CREATE UNIQUE INDEX uq_space_posts_client_request ON space_posts (space_id, client_request_id) WHERE client_request_id IS NOT NULL;
diff --git a/server/space/POST_MEDIA.md b/server/space/POST_MEDIA.md
new file mode 100644
index 0000000000..6cf2299d72
--- /dev/null
+++ b/server/space/POST_MEDIA.md
@@ -0,0 +1,72 @@
+# Post media API
+
+The server stores encrypted assets. Clients choose the codec, resolution, bitrate,
+trim range, cover frame, audio settings, and encrypted metadata format. The
+10-second video limit is enforced by clients because the server cannot inspect
+encrypted video contents.
+
+## Upload and create
+
+Use the existing post upload endpoint with purpose `post` for both covers and
+videos. The size limit is 15 MiB (15,728,640 bytes) per encrypted asset, including
+encryption overhead. Uploads use `application/octet-stream`. Each Space can have
+40 active staged uploads, allowing 20 assets for a ten-video post alongside 20
+uploads abandoned by an earlier attempt. Upload URLs last 15 minutes; staged
+uploads expire after 30 minutes.
+
+Create a post through the existing endpoint. `objects` contains 1–10 logical
+items, with unique positions from 0 through 9. Each item is a photo or a video
+cover, with an optional nested `video` asset:
+
+```json
+{
+ "clientRequestId": "a-stable-id-for-this-publication",
+ "encryptedPostKey": "base64-ciphertext",
+ "keyVersion": 1,
+ "objects": [
+ {
+ "objectKey": "cover-object-key",
+ "position": 0,
+ "metadataCipher": "base64-ciphertext",
+ "video": {
+ "objectKey": "video-object-key",
+ "metadataCipher": "base64-ciphertext"
+ }
+ }
+ ]
+}
+```
+
+The video inherits its parent's position. Nested videos cannot contain another
+video. Every asset must have a distinct key, nonempty encrypted metadata, and a
+valid staged upload owned by the posting Space. The server verifies uploaded
+sizes against the reservations and consumes all reservations atomically when
+creating the post. Metadata ciphertext remains opaque, with the existing 6 KiB
+decoded limit. Asset sizes in responses come from the verified upload records.
+
+`clientRequestId` is optional for existing clients and limited to 64 bytes.
+Clients should generate a fresh ID for each intended publication and retain it
+across retries. IDs are scoped to the posting Space. The first successful create
+wins; subsequent and overlapping retries return the same post ID without another
+post or notification. Reusing an ID does not update the original post. Deleting
+the post does not release its ID or allow a retry to recreate it.
+
+## Read and delete
+
+Feed, profile, and individual-post responses use the same nested shape. Photo-only
+responses retain their existing shape. Clients that ignore the optional `video`
+field can show the cover normally. Covers and videos use the existing authorized
+asset download endpoint. Post deletion queues both for cleanup.
+
+## Database and rollout
+
+Migration 148 adds a `role` to post assets, changes position uniqueness to
+`(post_id, position, role)`, and stores the optional publication request ID with a
+unique index per Space. Existing assets default to `preview`; their ciphertext and
+object keys stay unchanged.
+
+Apply the migration and deploy the server throughout the fleet before enabling
+video creation in clients. Once deployed, clients can iterate on video processing
+and presentation within this contract without further server changes. Rolling
+the schema back is blocked while video asset rows exist, since the previous schema
+cannot represent both assets at the same position.
diff --git a/server/space/controller/assets.go b/server/space/controller/assets.go
index 0220724949..9f5a5ab023 100644
--- a/server/space/controller/assets.go
+++ b/server/space/controller/assets.go
@@ -24,7 +24,7 @@ import (
)
const (
- maxPostUploadBytes int64 = 5 * 1024 * 1024
+ maxPostUploadBytes int64 = 15 * 1024 * 1024
maxAvatarUploadBytes int64 = 2 * 1024 * 1024
maxCoverUploadBytes int64 = 2 * 1024 * 1024
uploadURLExpiry = spacerepo.SpaceUploadURLExpiry
diff --git a/server/space/controller/assets_test.go b/server/space/controller/assets_test.go
index df74ba421a..256d50d9cd 100644
--- a/server/space/controller/assets_test.go
+++ b/server/space/controller/assets_test.go
@@ -32,12 +32,12 @@ func TestPresignUploadStoresMetadata(t *testing.T) {
require.NoError(t, err)
const client = "io.ente.space.web/1.0"
resp, err := module.Assets.PresignUpload(ctx, space, models.PresignUploadRequest{
- Size: 5, ContentMD5: "5d41402abc4b2a76b9719d911017c592",
+ Size: 10 * 1024 * 1024, ContentMD5: "5d41402abc4b2a76b9719d911017c592",
}, client)
require.NoError(t, err)
rec, err := repos.Assets.GetTempObject(ctx, resp.ObjectKey, spacerepo.TempObjectPurposePost, &space.SpaceID)
require.NoError(t, err)
- require.Equal(t, int64(5), rec.ExpectedSize)
+ require.Equal(t, int64(10*1024*1024), rec.ExpectedSize)
require.True(t, rec.ContentMD5.Valid)
require.Equal(t, resp.Headers["Content-MD5"], rec.ContentMD5.String)
require.True(t, rec.Client.Valid)
diff --git a/server/space/controller/helpers.go b/server/space/controller/helpers.go
index 40dc5c8136..cde848274b 100644
--- a/server/space/controller/helpers.go
+++ b/server/space/controller/helpers.go
@@ -114,8 +114,20 @@ func toPostResponse(post *spacerepo.SpacePostRecord, assets []spacerepo.SpacePos
}
if len(assets) > 0 {
resp.Objects = make([]models.PostObjectPayload, 0, len(assets))
+ videos := make(map[int]*models.PostObjectPayload)
for _, asset := range assets {
- resp.Objects = append(resp.Objects, toPostObjectPayload(asset))
+ if asset.Role == "video" {
+ video := toPostObjectPayload(asset)
+ videos[asset.Position] = &video
+ }
+ }
+ for _, asset := range assets {
+ if asset.Role == "video" {
+ continue
+ }
+ object := toPostObjectPayload(asset)
+ object.Video = videos[asset.Position]
+ resp.Objects = append(resp.Objects, object)
}
}
return resp
diff --git a/server/space/controller/posts.go b/server/space/controller/posts.go
index 4e12aade0a..450d9ba4d5 100644
--- a/server/space/controller/posts.go
+++ b/server/space/controller/posts.go
@@ -47,34 +47,73 @@ func (c *PostsController) Create(ctx context.Context, space *repo.SpaceRecord, r
if err != nil {
return nil, err
}
- assets := make([]repo.SpacePostAssetRecord, 0, len(req.Objects))
- for _, object := range req.Objects {
- if strings.TrimSpace(object.ObjectKey) == "" {
- return nil, ente.NewBadRequestWithMessage("objectKey is required for each object")
+ if len(req.ClientRequestID) > 64 {
+ return nil, ente.NewBadRequestWithMessage("invalid client request id")
+ }
+ if req.ClientRequestID != "" {
+ postID, err := c.PostsRepo.PostIDForRequest(ctx, space.SpaceID, req.ClientRequestID)
+ if err == nil {
+ return &models.CreatePostResponse{PostID: postID}, nil
}
- if err := validateSpaceTextFieldBytes("objectKey", object.ObjectKey, maxSpaceObjectKeyBytes); err != nil {
+ if !errors.Is(err, sql.ErrNoRows) {
return nil, err
}
- if object.Position < 0 || object.Position >= maxSpacePostObjects {
+ }
+ assets := make([]repo.SpacePostAssetRecord, 0, len(req.Objects)*2)
+ positions := make(map[int]bool)
+ keys := make(map[string]bool)
+ for _, object := range req.Objects {
+ if object.Position < 0 || object.Position >= maxSpacePostObjects || positions[object.Position] {
return nil, ente.NewBadRequestWithMessage("invalid object position")
}
- metadataCipher, err := decodeEncodedSpaceField("metadataCipher", object.MetadataCipher, maxSpaceAssetMetadataEncodedBytes, maxSpaceAssetMetadataDecodedBytes)
- if err != nil {
- return nil, err
+ positions[object.Position] = true
+ parts := []models.PostObjectPayload{object}
+ if object.Video != nil {
+ if object.Video.Video != nil {
+ return nil, ente.NewBadRequestWithMessage("invalid nested video")
+ }
+ parts = append(parts, *object.Video)
}
- staged, err := verifyStagedUpload(ctx, c.AssetsRepo, object.ObjectKey, repo.TempObjectPurposePost, &space.SpaceID)
- if err != nil {
- return nil, err
+ for index, part := range parts {
+ if strings.TrimSpace(part.ObjectKey) == "" || keys[part.ObjectKey] {
+ return nil, ente.NewBadRequestWithMessage("a unique objectKey is required for each asset")
+ }
+ keys[part.ObjectKey] = true
+ if err := validateSpaceTextFieldBytes("objectKey", part.ObjectKey, maxSpaceObjectKeyBytes); err != nil {
+ return nil, err
+ }
+ metadataCipher, err := decodeEncodedSpaceField("metadataCipher", part.MetadataCipher, maxSpaceAssetMetadataEncodedBytes, maxSpaceAssetMetadataDecodedBytes)
+ if err != nil {
+ return nil, err
+ }
+ staged, err := verifyStagedUpload(ctx, c.AssetsRepo, part.ObjectKey, repo.TempObjectPurposePost, &space.SpaceID)
+ if err != nil {
+ if req.ClientRequestID != "" {
+ postID, lookupErr := c.PostsRepo.PostIDForRequest(ctx, space.SpaceID, req.ClientRequestID)
+ if lookupErr == nil {
+ return &models.CreatePostResponse{PostID: postID}, nil
+ }
+ if !errors.Is(lookupErr, sql.ErrNoRows) {
+ return nil, lookupErr
+ }
+ }
+ return nil, err
+ }
+ role := "preview"
+ if index == 1 {
+ role = "video"
+ }
+ assets = append(assets, repo.SpacePostAssetRecord{
+ ObjectKey: staged.ObjectKey,
+ BucketID: staged.BucketID,
+ Size: sql.NullInt64{Int64: staged.ExpectedSize, Valid: staged.ExpectedSize > 0},
+ Position: object.Position,
+ MetadataCipher: metadataCipher,
+ Role: role,
+ })
}
- assets = append(assets, repo.SpacePostAssetRecord{
- ObjectKey: staged.ObjectKey,
- BucketID: staged.BucketID,
- Size: sql.NullInt64{Int64: staged.ExpectedSize, Valid: staged.ExpectedSize > 0},
- Position: object.Position,
- MetadataCipher: metadataCipher,
- })
}
- postID, postCount, err := c.PostsRepo.CreatePost(ctx, space.SpaceID, encryptedPostKey, captionCipher, req.KeyVersion, assets)
+ postID, postCount, err := c.PostsRepo.CreatePost(ctx, space.SpaceID, encryptedPostKey, captionCipher, req.KeyVersion, assets, req.ClientRequestID)
if err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")
@@ -90,7 +129,9 @@ func (c *PostsController) Create(ctx context.Context, space *repo.SpaceRecord, r
space.SpaceID, space.OwnerID, postCount, repo.MaxPostsPerSpace,
))
}
- c.notifyFriendsOfNewPost(spaceActivityActor(space), postID)
+ if postCount > 0 {
+ c.notifyFriendsOfNewPost(spaceActivityActor(space), postID)
+ }
return &models.CreatePostResponse{PostID: postID}, nil
}
diff --git a/server/space/controller/posts_test.go b/server/space/controller/posts_test.go
index f2f90f6701..169b105742 100644
--- a/server/space/controller/posts_test.go
+++ b/server/space/controller/posts_test.go
@@ -8,6 +8,7 @@ import (
"net/http/httptest"
"slices"
"strconv"
+ "sync/atomic"
"testing"
"github.com/ente/museum/pkg/utils/config"
@@ -52,22 +53,40 @@ func TestCreatePostRequiresAssetMetadataCipher(t *testing.T) {
func TestCreatePostAcceptsUpToTenObjects(t *testing.T) {
for _, test := range []struct {
- count int
- abandoned int
+ count int
+ videos int
+ abandoned int
+ concurrent bool
+ legacy bool
}{
{count: 1},
+ {count: 1, videos: 1},
+ {count: 1, legacy: true},
+ {count: 1, videos: 1, legacy: true},
{count: 2},
+ {count: 2, videos: 1, concurrent: true},
{count: 10},
{count: 10, abandoned: 1},
{count: 10, abandoned: 10},
+ {count: 10, videos: 5},
+ {count: 10, videos: 10, abandoned: 20},
} {
- t.Run(fmt.Sprintf("%d_photos_after_%d_abandoned", test.count, test.abandoned), func(t *testing.T) {
+ t.Run(fmt.Sprintf("%d_items_%d_videos_after_%d_abandoned_concurrent_%t_legacy_%t", test.count, test.videos, test.abandoned, test.concurrent, test.legacy), func(t *testing.T) {
controller, repos, ctx := setupPostsControllerTest(t)
+ notifier := newRecordingSpaceActivityNotifier()
+ controller.ActivityNotifier = notifier
+ firstHead := make(chan struct{})
+ releaseFirstHead := make(chan struct{})
+ var headCount atomic.Int32
storage := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodHead {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
+ if test.concurrent && headCount.Add(1) == 1 {
+ close(firstHead)
+ <-releaseFirstHead
+ }
w.Header().Set("Content-Length", "123")
}))
t.Cleanup(storage.Close)
@@ -107,17 +126,48 @@ func TestCreatePostAcceptsUpToTenObjects(t *testing.T) {
Position: position,
MetadataCipher: "bWV0YWRhdGE=",
}
+ if position < test.videos {
+ objects[position].Video = &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{
+ request := models.CreatePostRequest{
+ ClientRequestID: "retry-this-post",
EncryptedPostKey: "cG9zdC1rZXk=",
CaptionCipher: &caption,
KeyVersion: space.CurrentVersion,
Objects: requestObjects,
- })
+ }
+ if test.legacy {
+ request.ClientRequestID = ""
+ }
+ var concurrentResponse *models.CreatePostResponse
+ var concurrentError error
+ concurrentDone := make(chan struct{})
+ if test.concurrent {
+ go func() {
+ concurrentResponse, concurrentError = controller.Create(ctx, space, request)
+ close(concurrentDone)
+ }()
+ <-firstHead
+ }
+ created, err := controller.Create(ctx, space, request)
+ if test.concurrent {
+ close(releaseFirstHead)
+ <-concurrentDone
+ require.NoError(t, concurrentError)
+ require.Equal(t, created, concurrentResponse)
+ }
require.NoError(t, err)
+ if !test.legacy {
+ retried, err := controller.Create(ctx, space, request)
+ require.NoError(t, err)
+ require.Equal(t, created.PostID, retried.PostID)
+ }
+ require.Equal(t, created.PostID, requireSpaceActivity(t, notifier).postID)
+ requireNoSpaceActivity(t, notifier)
feed, err := controller.ListFeed(ctx, space, models.ListFeedRequest{Limit: 10})
require.NoError(t, err)
require.Len(t, feed.Items, 1)
@@ -125,9 +175,42 @@ func TestCreatePostAcceptsUpToTenObjects(t *testing.T) {
require.Equal(t, caption, feed.Items[0].CaptionCipher)
require.Equal(t, objects, feed.Items[0].Objects)
for _, object := range objects {
+ if object.Video != nil {
+ _, err := repos.Assets.GetTempObject(ctx, object.Video.ObjectKey, spacerepo.TempObjectPurposePost, &space.SpaceID)
+ require.ErrorIs(t, err, sql.ErrNoRows)
+ }
_, err := repos.Assets.GetTempObject(ctx, object.ObjectKey, spacerepo.TempObjectPurposePost, &space.SpaceID)
require.ErrorIs(t, err, sql.ErrNoRows)
}
+ for _, object := range objects {
+ parts := []models.PostObjectPayload{object}
+ if object.Video != nil {
+ parts = append(parts, *object.Video)
+ }
+ for _, part := range parts {
+ bucket, err := repos.Assets.GetAssetBucketID(ctx, space.SpaceID, part.ObjectKey)
+ require.NoError(t, err)
+ require.Equal(t, "b2-eu-cen", bucket)
+ }
+ }
+ require.NoError(t, controller.Delete(ctx, space, created.PostID))
+ for _, object := range objects {
+ parts := []models.PostObjectPayload{object}
+ if object.Video != nil {
+ parts = append(parts, *object.Video)
+ }
+ for _, part := range parts {
+ _, err := repos.Assets.GetAssetBucketID(ctx, space.SpaceID, part.ObjectKey)
+ require.ErrorIs(t, err, sql.ErrNoRows)
+ var queued bool
+ err = repos.Assets.DB.QueryRowContext(ctx, `SELECT EXISTS (
+ SELECT 1 FROM space_temp_objects WHERE object_key = $1 AND purpose = $2
+ AND expires_at <= now_utc_micro_seconds() AND cleanup_after > now_utc_micro_seconds()
+ )`, part.ObjectKey, spacerepo.TempObjectPurposePost).Scan(&queued)
+ require.NoError(t, err)
+ require.True(t, queued)
+ }
+ }
for _, objectKey := range abandoned {
staged, err := repos.Assets.GetTempObject(ctx, objectKey, spacerepo.TempObjectPurposePost, &space.SpaceID)
require.NoError(t, err)
@@ -172,6 +255,21 @@ func TestCreatePostRejectsInvalidObjectPosition(t *testing.T) {
}
}
+func TestCreatePostRejectsNestedVideo(t *testing.T) {
+ _, err := (&PostsController{}).Create(t.Context(), &spacerepo.SpaceRecord{}, models.CreatePostRequest{
+ EncryptedPostKey: "cG9zdC1rZXk=",
+ KeyVersion: 1,
+ Objects: []models.PostObjectPayload{{
+ ObjectKey: "preview",
+ Video: &models.PostObjectPayload{
+ ObjectKey: "video",
+ Video: &models.PostObjectPayload{ObjectKey: "nested"},
+ },
+ }},
+ })
+ require.ErrorContains(t, err, "invalid nested video")
+}
+
func TestListPostsHydratesPostAssets(t *testing.T) {
controller, repos, ctx := setupPostsControllerTest(t)
aliceID := insertSpaceControllerUser(t, repos, "[email protected]", "alice-public")
diff --git a/server/space/controller/test_helpers_test.go b/server/space/controller/test_helpers_test.go
index f914db48a1..41ace16bfe 100644
--- a/server/space/controller/test_helpers_test.go
+++ b/server/space/controller/test_helpers_test.go
@@ -67,7 +67,7 @@ func testCreatePost(ctx context.Context, module *spacerepo.Module, _ int64, spac
if captionCipher != nil {
caption = testSpaceBytes(*captionCipher)
}
- postID, _, err := module.Posts.CreatePost(ctx, spaceID, testSpaceBytes(encryptedPostKey), caption, keyVersion, objects)
+ postID, _, err := module.Posts.CreatePost(ctx, spaceID, testSpaceBytes(encryptedPostKey), caption, keyVersion, objects, "")
return postID, err
}
diff --git a/server/space/models/models.go b/server/space/models/models.go
index 32faf2ba59..b33da65dd1 100644
--- a/server/space/models/models.go
+++ b/server/space/models/models.go
@@ -291,6 +291,7 @@ type ShareUpdatePayload struct {
}
type CreatePostRequest struct {
+ ClientRequestID string `json:"clientRequestId,omitempty" binding:"max=64"`
EncryptedPostKey string `json:"encryptedPostKey" binding:"required"`
KeyVersion int `json:"keyVersion" binding:"required,gt=0"`
CaptionCipher *string `json:"captionCipher,omitempty"`
@@ -380,10 +381,11 @@ type ConversationsResponse struct {
}
type PostObjectPayload struct {
- ObjectKey string `json:"objectKey" binding:"required"`
- Size int64 `json:"size,omitempty" binding:"omitempty,gt=0"`
- Position int `json:"position,omitempty" binding:"gte=0"`
- MetadataCipher string `json:"metadataCipher" binding:"required"`
+ Video *PostObjectPayload `json:"video,omitempty" binding:"omitempty"`
+ ObjectKey string `json:"objectKey" binding:"required"`
+ Size int64 `json:"size,omitempty" binding:"omitempty,gt=0"`
+ Position int `json:"position,omitempty" binding:"gte=0"`
+ MetadataCipher string `json:"metadataCipher" binding:"required"`
}
type PostResponse struct {
diff --git a/server/space/repo/module.go b/server/space/repo/module.go
index 991a5d40d1..0bdb9f9a49 100644
--- a/server/space/repo/module.go
+++ b/server/space/repo/module.go
@@ -109,6 +109,7 @@ type SpacePostRecord struct {
}
type SpacePostAssetRecord struct {
+ Role string
AssetID int64
PostID int64
ObjectKey string
diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.go
index 3f6b08d20a..35d6bcf5ae 100644
--- a/server/space/repo/module_test.go
+++ b/server/space/repo/module_test.go
@@ -217,7 +217,7 @@ func testCreatePost(ctx context.Context, module *Module, _ int64, spaceID string
if captionCipher != nil {
caption = testSpaceBytes(*captionCipher)
}
- postID, _, err := module.Posts.CreatePost(ctx, spaceID, testSpaceBytes(encryptedPostKey), caption, keyVersion, objects)
+ postID, _, err := module.Posts.CreatePost(ctx, spaceID, testSpaceBytes(encryptedPostKey), caption, keyVersion, objects, "")
return postID, err
}
@@ -275,7 +275,7 @@ func TestCreatePostEnforcesSpacePostLimit(t *testing.T) {
`, space.SpaceID, space.CurrentVersion, MaxPostsPerSpace)
require.NoError(t, err)
- _, postCount, err := module.Posts.CreatePost(ctx, space.SpaceID, testSpaceBytes("post-key"), nil, space.CurrentVersion, nil)
+ _, postCount, err := module.Posts.CreatePost(ctx, space.SpaceID, testSpaceBytes("post-key"), nil, space.CurrentVersion, nil, "")
require.ErrorIs(t, err, ErrSpacePostLimitReached)
require.Equal(t, MaxPostsPerSpace, postCount)
@@ -290,7 +290,7 @@ func TestCreatePostEnforcesSpacePostLimit(t *testing.T) {
`, space.SpaceID)
require.NoError(t, err)
- postID, postCount, err := module.Posts.CreatePost(ctx, space.SpaceID, testSpaceBytes("post-key"), nil, space.CurrentVersion, nil)
+ postID, postCount, err := module.Posts.CreatePost(ctx, space.SpaceID, testSpaceBytes("post-key"), nil, space.CurrentVersion, nil, "")
require.NoError(t, err)
require.NotZero(t, postID)
require.Equal(t, MaxPostsPerSpace, postCount)
diff --git a/server/space/repo/post_media_migration_test.go b/server/space/repo/post_media_migration_test.go
new file mode 100644
index 0000000000..c7970a89af
--- /dev/null
+++ b/server/space/repo/post_media_migration_test.go
@@ -0,0 +1,53 @@
+package repo
+
+import (
+ "os"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestPostMediaMigrationPreservesPhotos(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ ownerID := insertSpaceUser(t, module, "[email protected]", "public")
+ space, err := testCreateSpace(ctx, module, ownerID, "media_migration", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ up, err := os.ReadFile("migrations/148_space_post_video.up.sql")
+ require.NoError(t, err)
+ down, err := os.ReadFile("migrations/148_space_post_video.down.sql")
+ require.NoError(t, err)
+ tx, err := module.Posts.DB.BeginTx(ctx, nil)
+ require.NoError(t, err)
+ defer tx.Rollback()
+ _, err = tx.ExecContext(ctx, string(down))
+ require.NoError(t, err)
+ var postID int64
+ err = tx.QueryRowContext(ctx, `
+ INSERT INTO space_posts (space_id, encrypted_post_key)
+ VALUES ($1, $2) RETURNING post_id
+ `, space.SpaceID, []byte("post-key")).Scan(&postID)
+ require.NoError(t, err)
+ _, err = tx.ExecContext(ctx, `
+ INSERT INTO space_post_assets (post_id, object_key, bucket_id, position, metadata_cipher)
+ VALUES ($1, 'legacy-photo', 'test-bucket', 0, $2)
+ `, postID, []byte("legacy-metadata"))
+ require.NoError(t, err)
+ _, err = tx.ExecContext(ctx, string(up))
+ require.NoError(t, err)
+ var role string
+ var metadata []byte
+ err = tx.QueryRowContext(ctx, `
+ SELECT role, metadata_cipher FROM space_post_assets WHERE object_key = 'legacy-photo'
+ `).Scan(&role, &metadata)
+ require.NoError(t, err)
+ require.Equal(t, "preview", role)
+ require.Equal(t, []byte("legacy-metadata"), metadata)
+ _, err = tx.ExecContext(ctx, `
+ INSERT INTO space_post_assets (post_id, object_key, bucket_id, position, metadata_cipher, role)
+ VALUES ($1, 'video', 'test-bucket', 0, $2, 'video')
+ `, postID, []byte("video-metadata"))
+ require.NoError(t, err)
+ _, err = tx.ExecContext(ctx, string(down))
+ require.ErrorContains(t, err, "Cannot roll back while video posts exist")
+}
diff --git a/server/space/repo/posts.go b/server/space/repo/posts.go
index 72c79be54b..cad1e25d80 100644
--- a/server/space/repo/posts.go
+++ b/server/space/repo/posts.go
@@ -66,7 +66,13 @@ func scanPostRecords(rows *sql.Rows) ([]SpacePostRecord, error) {
return out, nil
}
-func (r *PostsRepository) CreatePost(ctx context.Context, spaceID string, encryptedPostKey []byte, captionCipher []byte, keyVersion int, objects []SpacePostAssetRecord) (int64, int, error) {
+func (r *PostsRepository) PostIDForRequest(ctx context.Context, spaceID, requestID string) (int64, error) {
+ var postID int64
+ err := r.DB.QueryRowContext(ctx, "SELECT post_id FROM space_posts WHERE space_id = $1 AND client_request_id = $2", spaceID, requestID).Scan(&postID)
+ return postID, err
+}
+
+func (r *PostsRepository) CreatePost(ctx context.Context, spaceID string, encryptedPostKey []byte, captionCipher []byte, keyVersion int, objects []SpacePostAssetRecord, clientRequestID string) (int64, int, error) {
tx, err := r.DB.BeginTx(ctx, nil)
if err != nil {
return 0, 0, stacktrace.Propagate(err, "")
@@ -84,6 +90,16 @@ func (r *PostsRepository) CreatePost(ctx context.Context, spaceID string, encryp
if currentVersion != keyVersion {
return 0, 0, sql.ErrNoRows
}
+ if clientRequestID != "" {
+ var existingID int64
+ err := tx.QueryRowContext(ctx, "SELECT post_id FROM space_posts WHERE space_id = $1 AND client_request_id = $2", spaceID, clientRequestID).Scan(&existingID)
+ if err == nil {
+ return existingID, 0, nil
+ }
+ if err != sql.ErrNoRows {
+ return 0, 0, err
+ }
+ }
var postCount int
if err := tx.QueryRowContext(ctx, `
SELECT COUNT(*)
@@ -101,17 +117,21 @@ func (r *PostsRepository) CreatePost(ctx context.Context, spaceID string, encryp
}
var postID int64
if err := tx.QueryRowContext(ctx, `
- INSERT INTO space_posts (space_id, encrypted_post_key, caption_cipher, key_version)
- VALUES ($1, $2, $3, $4)
+ INSERT INTO space_posts (space_id, encrypted_post_key, caption_cipher, key_version, client_request_id)
+ VALUES ($1, $2, $3, $4, NULLIF($5, ''))
RETURNING post_id
- `, spaceID, encryptedPostKey, caption, keyVersion).Scan(&postID); err != nil {
+ `, spaceID, encryptedPostKey, caption, keyVersion, clientRequestID).Scan(&postID); err != nil {
return 0, 0, stacktrace.Propagate(err, "")
}
for _, obj := range objects {
+ role := obj.Role
+ if role == "" {
+ role = "preview"
+ }
if _, err := tx.ExecContext(ctx, `
- INSERT INTO space_post_assets (post_id, object_key, bucket_id, size, position, metadata_cipher)
- VALUES ($1, $2, $3, $4, $5, $6)
- `, postID, obj.ObjectKey, obj.BucketID, obj.Size, obj.Position, obj.MetadataCipher); err != nil {
+ INSERT INTO space_post_assets (post_id, object_key, bucket_id, size, position, metadata_cipher, role)
+ VALUES ($1, $2, $3, $4, $5, $6, $7)
+ `, postID, obj.ObjectKey, obj.BucketID, obj.Size, obj.Position, obj.MetadataCipher, role); err != nil {
return 0, 0, stacktrace.Propagate(err, "")
}
if err := ConsumeTempObjectTx(ctx, tx, obj.ObjectKey, TempObjectPurposePost, &spaceID); err != nil {
@@ -233,7 +253,7 @@ func (r *PostsRepository) ListAssetsByPostIDs(ctx context.Context, postIDs []int
if len(postIDs) == 0 {
return map[int64][]SpacePostAssetRecord{}, nil
}
- query, args := inClause("SELECT asset_id, post_id, object_key, bucket_id, size, position, metadata_cipher, created_at FROM space_post_assets WHERE post_id IN (%s) ORDER BY position ASC, asset_id ASC", postIDs, 0)
+ query, args := inClause("SELECT asset_id, post_id, object_key, bucket_id, size, position, metadata_cipher, created_at, role FROM space_post_assets WHERE post_id IN (%s) ORDER BY position ASC, asset_id ASC", postIDs, 0)
rows, err := r.DB.QueryContext(ctx, query, args...)
if err != nil {
return nil, stacktrace.Propagate(err, "")
@@ -242,7 +262,7 @@ func (r *PostsRepository) ListAssetsByPostIDs(ctx context.Context, postIDs []int
result := make(map[int64][]SpacePostAssetRecord, len(postIDs))
for rows.Next() {
var rec SpacePostAssetRecord
- if err := rows.Scan(&rec.AssetID, &rec.PostID, &rec.ObjectKey, &rec.BucketID, &rec.Size, &rec.Position, &rec.MetadataCipher, &rec.CreatedAt); err != nil {
+ if err := rows.Scan(&rec.AssetID, &rec.PostID, &rec.ObjectKey, &rec.BucketID, &rec.Size, &rec.Position, &rec.MetadataCipher, &rec.CreatedAt, &rec.Role); err != nil {
return nil, stacktrace.Propagate(err, "")
}
result[rec.PostID] = append(result[rec.PostID], rec)
diff --git a/server/space/repo/temp_objects.go b/server/space/repo/temp_objects.go
index ed86be11ee..6732d338ae 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 = 2 * MaxPostObjects
+ MaxActiveUploadCount = 4 * MaxPostObjects
)
var ErrSpaceUploadLimitReached = errors.New("space upload limit reached")