Merge f5b6ec3 into master-4.0

Author: realm-ci

CHANGELOG.md

@@ -59,6 +59,8 @@ and `SyncUser#retrieveInfoForUserAsync` which returns a `SyncUserInfo` with mode
 
 ### Bug Fixes
 
+* The `compactOnLaunch` callback is no longer invoked if the Realm at that path is already open on other threads.
+
 ### Internal
 
 * [ObjectServer] removed `ObjectServerUser` and its inner classes, in a step to reduce `SyncUser` complexity (#3741).

realm/realm-library/src/androidTest/java/io/realm/RealmTests.java

@@ -64,6 +64,8 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
+import javax.annotation.Nullable;
+
 import io.realm.entities.AllJavaTypes;
 import io.realm.entities.AllTypes;
 import io.realm.entities.AllTypesPrimaryKey;
@@ -1060,15 +1062,24 @@ public void compactRealm_onExternalStorage() {
         Realm.deleteRealm(config);
     }
 
+    private void populateTestRealmForCompact(Realm realm, int sizeInMB) {
+        byte[] oneMBData = new byte[1024 * 1024];
+        realm.beginTransaction();
+        for (int i = 0; i < sizeInMB; i++) {
+            realm.createObject(AllTypes.class).setColumnBinary(oneMBData);
+        }
+        realm.commitTransaction();
+    }
+
     private Pair<Long, Long> populateTestRealmAndCompactOnLaunch(CompactOnLaunchCallback compactOnLaunch) {
-        return populateTestRealmAndCompactOnLaunch(compactOnLaunch, 100);
+        return populateTestRealmAndCompactOnLaunch(compactOnLaunch, 1);
     }
 
-    private Pair<Long, Long> populateTestRealmAndCompactOnLaunch(CompactOnLaunchCallback compactOnLaunch, int objects) {
+    private Pair<Long, Long> populateTestRealmAndCompactOnLaunch(CompactOnLaunchCallback compactOnLaunch, int sizeInMB) {
         final String REALM_NAME = "test.realm";
         RealmConfiguration realmConfig = configFactory.createConfiguration(REALM_NAME);
         Realm realm = Realm.getInstance(realmConfig);
-        populateTestRealm(realm, objects);
+        populateTestRealmForCompact(realm, sizeInMB);
         realm.beginTransaction();
         realm.deleteAll();
         realm.commitTransaction();
@@ -1131,12 +1142,23 @@ public boolean shouldCompact(long totalBytes, long usedBytes) {
                 })
                 .build();
         Realm realm = Realm.getInstance(realmConfig);
+        realm.close();
+        // WARNING: We need to init the schema first and close the Realm to make sure the relevant logic works in Object
+        // Store. See https://github.com/realm/realm-object-store/blob/master/src/shared_realm.cpp#L58
+        // Called once.
+        assertEquals(1, compactOnLaunchCount.get());
+
+        realm = Realm.getInstance(realmConfig);
+        // Called 2 more times. The PK table migration logic (the old PK bug) needs to open/close the Realm once.
+        assertEquals(3, compactOnLaunchCount.get());
 
         Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 Realm bgRealm = Realm.getInstance(realmConfig);
                 bgRealm.close();
+                // compactOnLaunch should not be called anymore!
+                assertEquals(3, compactOnLaunchCount.get());
             }
         });
         thread.start();
@@ -1149,8 +1171,6 @@ public void run() {
 
         realm.close();
 
-        // FIXME: It should be 1. Current compactOnLaunch is called each time a Realm is opened on a new thread.
-        assertNotEquals(1, compactOnLaunchCount.get());
         assertEquals(3, compactOnLaunchCount.get());
     }
 
@@ -1162,7 +1182,7 @@ public boolean shouldCompact(long totalBytes, long usedBytes) {
                 final long thresholdSize = 50 * 1024 * 1024;
                 return (totalBytes > thresholdSize) && (((double) usedBytes / (double) totalBytes) < 0.5);
             }
-        }, 100);
+        }, 1);
         final long thresholdSize = 50 * 1024 * 1024;
         assertTrue(results.first < thresholdSize);
         assertEquals(results.first, results.second);
@@ -1195,7 +1215,7 @@ public boolean shouldCompact(long totalBytes, long usedBytes) {
 
     @Test
     public void defaultCompactOnLaunch() throws IOException {
-        Pair<Long, Long> results = populateTestRealmAndCompactOnLaunch(null, 30000);
+        Pair<Long, Long> results = populateTestRealmAndCompactOnLaunch(null, 50);
         final long thresholdSize = 50 * 1024 * 1024;
         assertTrue(results.first > thresholdSize);
         assertTrue(results.first > results.second);
@@ -1215,7 +1235,7 @@ public void defaultCompactOnLaunch_onlyCallback() {
 
     @Test
     public void defaultCompactOnLaunch_insufficientAmount() throws IOException {
-        Pair<Long, Long> results = populateTestRealmAndCompactOnLaunch(null, 100);
+        Pair<Long, Long> results = populateTestRealmAndCompactOnLaunch(null, 1);
         final long thresholdSize = 50 * 1024 * 1024;
         assertTrue(results.first < thresholdSize);
         assertEquals(results.first, results.second);

realm/realm-library/src/main/java/io/realm/DefaultCompactOnLaunchCallback.java

@@ -16,8 +16,6 @@
 
 package io.realm;
 
-import io.realm.log.RealmLog;
-
 /**
  * The default implementation for determining if a file should be compacted or not. This implementation will only
  * trigger if the file is above 50 MB and more than 50% can be reclaimed.

realm/realm-library/src/main/java/io/realm/RealmCache.java

@@ -292,35 +292,40 @@ private synchronized <E extends BaseRealm> E doCreateRealmOrGetFromCache(RealmCo
 
             SharedRealm sharedRealm = null;
             try {
-                sharedRealm = SharedRealm.getInstance(configuration);
-
-                // If waitForInitialRemoteData() was enabled, we need to make sure that all data is downloaded
-                // before proceeding. We need to open the Realm instance first to start any potential underlying
-                // SyncSession so this will work. TODO: This needs to be decoupled.
-                if (!fileExists) {
-                    try {
-                        ObjectServerFacade.getSyncFacadeIfPossible().downloadRemoteChanges(configuration);
-                    } catch (Throwable t) {
-                        // If an error happened while downloading initial data, we need to reset the file so we can
-                        // download it again on the next attempt.
-                        // Realm.deleteRealm() is under the same lock as this method and globalCount is still 0, so
-                        // this should be safe.
-                        sharedRealm.close();
-                        sharedRealm = null;
-                        Realm.deleteRealm(configuration);
-                        throw t;
+                if (configuration.isSyncConfiguration()) {
+                    // If waitForInitialRemoteData() was enabled, we need to make sure that all data is downloaded
+                    // before proceeding. We need to open the Realm instance first to start any potential underlying
+                    // SyncSession so this will work. TODO: This needs to be decoupled.
+                    if (!fileExists) {
+                        sharedRealm = SharedRealm.getInstance(configuration);
+                        try {
+                            ObjectServerFacade.getSyncFacadeIfPossible().downloadRemoteChanges(configuration);
+                        } catch (Throwable t) {
+                            // If an error happened while downloading initial data, we need to reset the file so we can
+                            // download it again on the next attempt.
+                            // Realm.deleteRealm() is under the same lock as this method and globalCount is still 0, so
+                            // this should be safe.
+                            sharedRealm.close();
+                            sharedRealm = null;
+                            Realm.deleteRealm(configuration);
+                            throw t;
+                        }
                     }
-                }
-
-                if (Table.primaryKeyTableNeedsMigration(sharedRealm)) {
-                    sharedRealm.beginTransaction();
-                    if (Table.migratePrimaryKeyTableIfNeeded(sharedRealm)) {
-                        sharedRealm.commitTransaction();
-                    } else {
-                        sharedRealm.cancelTransaction();
+                } else {
+                    if (fileExists) {
+                        // Primary key problem only exists before we release sync.
+                        sharedRealm = SharedRealm.getInstance(configuration);
+
+                        if (Table.primaryKeyTableNeedsMigration(sharedRealm)) {
+                            sharedRealm.beginTransaction();
+                            if (Table.migratePrimaryKeyTableIfNeeded(sharedRealm)) {
+                                sharedRealm.commitTransaction();
+                            } else {
+                                sharedRealm.cancelTransaction();
+                            }
+                        }
                     }
                 }
-
             } finally {
                 if (sharedRealm != null) {
                     sharedRealm.close();