Skip to content

armgit / ente

Public Imported from GitHub
0

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

Maintain file counts during file creation

Neeraj Gupta9ed1a2fdcccd
diff --git a/server/pkg/repo/file.go b/server/pkg/repo/file.go
index 4d7eee525c..b7c1ad9e37 100644
--- a/server/pkg/repo/file.go
+++ b/server/pkg/repo/file.go
@@ -105,7 +105,7 @@ func (repo *FileRepository) Create(
tx.Rollback()
return file, -1, stacktrace.Propagate(err, "")
}
- usage, err := repo.updateUsage(ctx, tx, file.OwnerID, usageDiff)
+ usage, err := repo.updateUsageForFileCreation(ctx, tx, file.OwnerID, usageDiff, app)
if err != nil {
tx.Rollback()
return file, -1, stacktrace.Propagate(err, "")
@@ -171,6 +171,11 @@ func (repo *FileRepository) CreateMetaFile(
tx.Rollback()
return nil, stacktrace.Propagate(err, "")
}
+ _, err = repo.updateUsageForFileCreation(ctx, tx, metaFile.OwnerID, 0, app)
+ if err != nil {
+ tx.Rollback()
+ return nil, stacktrace.Propagate(err, "")
+ }
err = tx.Commit()
if err != nil {
return nil, stacktrace.Propagate(err, "")
@@ -323,7 +328,7 @@ func (repo *FileRepository) Update(file ente.File, fileSize int64, thumbnailSize
tx.Rollback()
return stacktrace.Propagate(err, "")
}
- _, err = repo.updateUsage(ctx, tx, file.OwnerID, usageDiff)
+ _, err = repo.updateUsage(ctx, tx, file.OwnerID, usageDiff, 0, 0)
if err != nil {
tx.Rollback()
return stacktrace.Propagate(err, "")
@@ -480,7 +485,7 @@ func (repo *FileRepository) UpdateThumbnail(ctx context.Context, fileID int64, u
tx.Rollback()
return stacktrace.Propagate(err, "")
}
- _, err = repo.updateUsage(ctx, tx, userID, usageDiff)
+ _, err = repo.updateUsage(ctx, tx, userID, usageDiff, 0, 0)
if err != nil {
tx.Rollback()
return stacktrace.Propagate(err, "")
@@ -808,29 +813,39 @@ func (repo *FileRepository) scheduleDeletion(ctx context.Context, tx *sql.Tx, fi
totalObjectSize += object.FileSize
}
diff = diff - (totalObjectSize)
- _, err = repo.updateUsage(ctx, tx, userID, diff)
+ _, err = repo.updateUsage(ctx, tx, userID, diff, 0, 0)
return stacktrace.Propagate(err, "")
}
-func (repo *FileRepository) updateUsage(ctx context.Context, tx *sql.Tx, userID int64, diff int64) (int64, error) {
- row := tx.QueryRowContext(ctx, `SELECT storage_consumed FROM usage WHERE user_id = $1 FOR UPDATE`, userID)
- var usage int64
- err := row.Scan(&usage)
- if err != nil {
- if errors.Is(err, sql.ErrNoRows) {
- usage = 0
- } else {
- return -1, stacktrace.Propagate(err, "")
- }
+func (repo *FileRepository) updateUsageForFileCreation(ctx context.Context, tx *sql.Tx, userID, storageDiff int64, app ente.App) (int64, error) {
+ switch app {
+ case ente.Photos:
+ return repo.updateUsage(ctx, tx, userID, storageDiff, 1, 0)
+ case ente.Locker:
+ return repo.updateUsage(ctx, tx, userID, storageDiff, 0, 1)
+ default:
+ return -1, stacktrace.Propagate(ente.ErrInvalidApp, "")
+ }
+}
+
+func (repo *FileRepository) updateUsage(ctx context.Context, tx *sql.Tx, userID, storageDiff, photosFileCountDiff, lockerFileCountDiff int64) (int64, error) {
+ fileCountSourceVersionDiff := int64(0)
+ if photosFileCountDiff != 0 || lockerFileCountDiff != 0 {
+ fileCountSourceVersionDiff = 1
}
- newUsage := usage + diff
- _, err = tx.ExecContext(ctx, `INSERT INTO usage (user_id, storage_consumed)
- VALUES ($1, $2)
- ON CONFLICT (user_id) DO UPDATE
- SET storage_consumed = $2`,
- userID, newUsage)
+ var usage int64
+ err := tx.QueryRowContext(ctx, `INSERT INTO usage
+ (user_id, storage_consumed, file_count_source_version)
+ VALUES ($1, $2, $5)
+ ON CONFLICT (user_id) DO UPDATE SET
+ storage_consumed = usage.storage_consumed + EXCLUDED.storage_consumed,
+ photos_file_count = usage.photos_file_count + $3,
+ locker_file_count = usage.locker_file_count + $4,
+ file_count_source_version = usage.file_count_source_version + EXCLUDED.file_count_source_version
+ RETURNING storage_consumed`,
+ userID, storageDiff, photosFileCountDiff, lockerFileCountDiff, fileCountSourceVersionDiff).Scan(&usage)
if err != nil {
return -1, stacktrace.Propagate(err, "")
}
- return newUsage, nil
+ return usage, nil
}
diff --git a/server/pkg/repo/file_usage_test.go b/server/pkg/repo/file_usage_test.go
new file mode 100644
index 0000000000..0bb06f2352
--- /dev/null
+++ b/server/pkg/repo/file_usage_test.go
@@ -0,0 +1,129 @@
+package repo
+
+import (
+ "database/sql"
+ "testing"
+
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/internal/testutil"
+)
+
+func TestUpdateUsageForFileCreationMaintainsCounterState(t *testing.T) {
+ db := setupFileUsageTest(t)
+ repo := &FileRepository{DB: db}
+ tests := []struct {
+ name string
+ app ente.App
+ usageExists bool
+ ready bool
+ }{
+ {name: "ready_photos", app: ente.Photos, usageExists: true, ready: true},
+ {name: "legacy_photos", app: ente.Photos, usageExists: true},
+ {name: "missing_locker", app: ente.Locker},
+ }
+
+ for i, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ userID := testutil.InsertUser(t, db, testutil.UserFixture{
+ UserID: int64(i + 1),
+ Email: tt.name + "@example.com",
+ CreationTime: 1,
+ })
+ if tt.ready {
+ if _, err := db.Exec(`INSERT INTO usage
+ (user_id, storage_consumed, photos_file_count, locker_file_count, file_count_source_version)
+ VALUES ($1, 10, 2, 3, 7)`, userID); err != nil {
+ t.Fatal(err)
+ }
+ } else if tt.usageExists {
+ testutil.InsertUsage(t, db, userID, 10)
+ }
+
+ tx, err := db.BeginTx(t.Context(), nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ usage, err := repo.updateUsageForFileCreation(t.Context(), tx, userID, 5, tt.app)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := tx.Commit(); err != nil {
+ t.Fatal(err)
+ }
+
+ var storage, version int64
+ var photos, locker sql.NullInt64
+ if err := db.QueryRow(`SELECT storage_consumed, photos_file_count, locker_file_count, file_count_source_version
+ FROM usage WHERE user_id = $1`, userID).Scan(&storage, &photos, &locker, &version); err != nil {
+ t.Fatal(err)
+ }
+ wantStorage := int64(15)
+ if !tt.usageExists {
+ wantStorage = 5
+ }
+ if usage != wantStorage || storage != wantStorage {
+ t.Fatalf("storage = (%d, %d), want %d", usage, storage, wantStorage)
+ }
+ if tt.ready {
+ if !photos.Valid || photos.Int64 != 3 || !locker.Valid || locker.Int64 != 3 || version != 8 {
+ t.Fatalf("counter state = (%v, %v, %d), want (3, 3, 8)", photos, locker, version)
+ }
+ } else if photos.Valid || locker.Valid || version != 1 {
+ t.Fatalf("counter state = (%v, %v, %d), want (NULL, NULL, 1)", photos, locker, version)
+ }
+ })
+ }
+}
+
+func TestCreateMetaFileUpdatesReadyLockerCount(t *testing.T) {
+ db := setupFileUsageTest(t)
+ userID := testutil.InsertUser(t, db, testutil.UserFixture{
+ UserID: 1,
+ Email: "[email protected]",
+ CreationTime: 1,
+ })
+ if _, err := db.Exec(`INSERT INTO usage
+ (user_id, storage_consumed, photos_file_count, locker_file_count, file_count_source_version)
+ VALUES ($1, 10, 2, 3, 7)`, userID); err != nil {
+ t.Fatal(err)
+ }
+ var collectionID int64
+ if err := db.QueryRow(`INSERT INTO collections
+ (owner_id, encrypted_key, key_decryption_nonce, name, type, attributes, updation_time, app)
+ VALUES ($1, 'key', 'nonce', 'Locker', 'album', '{}', 1, $2)
+ RETURNING collection_id`, userID, ente.Locker).Scan(&collectionID); err != nil {
+ t.Fatal(err)
+ }
+
+ _, err := (&FileRepository{DB: db}).CreateMetaFile(ente.MetaFile{
+ OwnerID: userID,
+ CollectionID: collectionID,
+ EncryptedKey: "file-key",
+ KeyDecryptionNonce: "file-nonce",
+ Metadata: ente.FileAttributes{
+ EncryptedData: "metadata",
+ DecryptionHeader: "header",
+ },
+ UpdationTime: 1,
+ }, userID, ente.Locker)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var storage, photos, locker, version int64
+ if err := db.QueryRow(`SELECT storage_consumed, photos_file_count, locker_file_count, file_count_source_version
+ FROM usage WHERE user_id = $1`, userID).Scan(&storage, &photos, &locker, &version); err != nil {
+ t.Fatal(err)
+ }
+ if storage != 10 || photos != 2 || locker != 4 || version != 8 {
+ t.Fatalf("usage state = (%d, %d, %d, %d), want (10, 2, 4, 8)", storage, photos, locker, version)
+ }
+}
+
+func setupFileUsageTest(t *testing.T) *sql.DB {
+ t.Helper()
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ t.Cleanup(func() { testutil.ResetTables(t, db) })
+ return db
+}