[RKOTLIN-1096] Map is_fatal to UnrecoverableSyncException (#1768)

Author: clementetb

CHANGELOG.md

@@ -1,3 +1,30 @@
+## 2.0.1 (YYYY-MM-DD)
+
+### Breaking changes
+* None.
+
+### Enhancements
+* None.
+
+### Fixed
+* [Sync] Fatal sync exceptions are now thrown as `UnrecoverableSyncException`. (Issue [#1767](https://github.com/realm/realm-kotlin/issues/1767) [RKOTLIN-1096](https://jira.mongodb.org/browse/RKOTLIN-1096)).
+
+### Compatibility
+* File format: Generates Realms with file format v24 (reads and upgrades file format v10 or later).
+* Realm Studio 15.0.0 or above is required to open Realms created by this version.
+* This release is compatible with the following Kotlin releases:
+  * Kotlin 2.0.0 and above. Support for experimental K2-compilation with `kotlin.experimental.tryK2=true`.
+  * Ktor 2.1.2 and above.
+  * Coroutines 1.7.0 and above.
+  * AtomicFu 0.18.3 and above.
+  * The new memory model only. See https://github.com/realm/realm-kotlin#kotlin-memory-model-and-coroutine-compatibility
+* Minimum Kbson 0.4.0.
+* Minimum Gradle version: 7.2.
+* Minimum Android Gradle Plugin version: 7.1.3.
+* Minimum Android SDK: 16.
+* Minimum R8: 8.0.34.
+
+
 ## 2.0.0 (2024-06-03)
 
 > [!NOTE]

packages/library-sync/src/commonMain/kotlin/io/realm/kotlin/mongodb/internal/RealmSyncUtils.kt

@@ -78,26 +78,34 @@ internal fun <T, R> channelResultCallback(
 internal fun convertSyncError(syncError: SyncError): SyncException {
     val errorCode = syncError.errorCode
     val message = createMessageFromSyncError(errorCode)
-    return when (errorCode.errorCode) {
-        ErrorCode.RLM_ERR_WRONG_SYNC_TYPE -> WrongSyncTypeException(message)
+    return if (syncError.isFatal) {
+        // An unrecoverable exception happened
+        UnrecoverableSyncException(message)
+    } else {
+        when (errorCode.errorCode) {
+            ErrorCode.RLM_ERR_WRONG_SYNC_TYPE -> WrongSyncTypeException(message)
 
-        ErrorCode.RLM_ERR_INVALID_SUBSCRIPTION_QUERY -> {
-            // Flexible Sync Query was rejected by the server
-            BadFlexibleSyncQueryException(message)
-        }
-        ErrorCode.RLM_ERR_SYNC_COMPENSATING_WRITE -> CompensatingWriteException(message, syncError.compensatingWrites)
+            ErrorCode.RLM_ERR_INVALID_SUBSCRIPTION_QUERY -> {
+                // Flexible Sync Query was rejected by the server
+                BadFlexibleSyncQueryException(message)
+            }
 
-        ErrorCode.RLM_ERR_SYNC_PROTOCOL_INVARIANT_FAILED,
-        ErrorCode.RLM_ERR_SYNC_PROTOCOL_NEGOTIATION_FAILED,
-        ErrorCode.RLM_ERR_SYNC_PERMISSION_DENIED -> {
-            // Permission denied errors should be unrecoverable according to Core, i.e. the
-            // client will disconnect sync and transition to the "inactive" state
-            UnrecoverableSyncException(message)
-        }
-        else -> {
-            // An error happened we are not sure how to handle. Just report as a generic
-            // SyncException.
-            SyncException(message)
+            ErrorCode.RLM_ERR_SYNC_COMPENSATING_WRITE -> CompensatingWriteException(
+                message,
+                syncError.compensatingWrites
+            )
+            ErrorCode.RLM_ERR_SYNC_PROTOCOL_INVARIANT_FAILED,
+            ErrorCode.RLM_ERR_SYNC_PROTOCOL_NEGOTIATION_FAILED,
+            ErrorCode.RLM_ERR_SYNC_PERMISSION_DENIED -> {
+                // Permission denied errors should be unrecoverable according to Core, i.e. the
+                // client will disconnect sync and transition to the "inactive" state
+                UnrecoverableSyncException(message)
+            }
+            else -> {
+                // An error happened we are not sure how to handle. Just report as a generic
+                // SyncException.
+                SyncException(message)
+            }
         }
     }
 }

packages/test-sync/src/commonTest/kotlin/io/realm/kotlin/test/mongodb/common/SyncedRealmTests.kt

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-@file:Suppress("invisible_reference", "invisible_member")
+@file:Suppress("invisible_member", "invisible_reference")
 
 package io.realm.kotlin.test.mongodb.common
 
@@ -28,15 +28,19 @@ import io.realm.kotlin.entities.sync.flx.FlexChildObject
 import io.realm.kotlin.entities.sync.flx.FlexEmbeddedObject
 import io.realm.kotlin.entities.sync.flx.FlexParentObject
 import io.realm.kotlin.ext.query
+import io.realm.kotlin.internal.interop.ErrorCode
+import io.realm.kotlin.internal.interop.RealmInterop
 import io.realm.kotlin.internal.platform.fileExists
 import io.realm.kotlin.internal.platform.pathOf
 import io.realm.kotlin.internal.platform.runBlocking
 import io.realm.kotlin.log.RealmLog
 import io.realm.kotlin.mongodb.App
+import io.realm.kotlin.mongodb.Credentials
 import io.realm.kotlin.mongodb.User
 import io.realm.kotlin.mongodb.exceptions.DownloadingRealmTimeOutException
 import io.realm.kotlin.mongodb.exceptions.SyncException
 import io.realm.kotlin.mongodb.exceptions.UnrecoverableSyncException
+import io.realm.kotlin.mongodb.internal.SyncSessionImpl
 import io.realm.kotlin.mongodb.subscriptions
 import io.realm.kotlin.mongodb.sync.InitialSubscriptionsCallback
 import io.realm.kotlin.mongodb.sync.SubscriptionSetState
@@ -313,6 +317,56 @@ class SyncedRealmTests {
         realm3.close()
     }
 
+    @Test
+    fun errorHandlerProcessFatalSyncErrors() {
+        val channel = TestChannel<Throwable>()
+        val user = runBlocking {
+            app.login(Credentials.anonymous())
+        }
+
+        val config = SyncConfiguration.Builder(
+            schema = setOf(ParentPk::class, ChildPk::class),
+            user = user,
+            partitionValue = partitionValue
+        ).errorHandler { _, error ->
+            channel.trySendOrFail(error)
+        }.build()
+
+        runBlocking {
+            val deferred = async {
+                Realm.open(config).use { realm ->
+                    RealmInterop.realm_sync_session_handle_error_for_testing(
+                        syncSession = (realm.syncSession as SyncSessionImpl).nativePointer,
+                        error = ErrorCode.RLM_ERR_ACCOUNT_NAME_IN_USE,
+                        errorMessage = "Non fatal error",
+                        isFatal = true, // flipped https://jira.mongodb.org/browse/RCORE-2146
+                    )
+
+                    RealmInterop.realm_sync_session_handle_error_for_testing(
+                        syncSession = (realm.syncSession as SyncSessionImpl).nativePointer,
+                        error = ErrorCode.RLM_ERR_INTERNAL_SERVER_ERROR,
+                        errorMessage = "Fatal error",
+                        isFatal = false, // flipped https://jira.mongodb.org/browse/RCORE-2146
+                    )
+                }
+            }
+
+            // First error
+            channel.receiveOrFail().let { error ->
+                assertNotNull(error.message)
+                assertIs<SyncException>(error)
+            }
+
+            // Second
+            channel.receiveOrFail().let { error ->
+                assertNotNull(error.message)
+                assertIs<UnrecoverableSyncException>(error)
+            }
+
+            deferred.cancel()
+        }
+    }
+
     @Test
     fun errorHandlerReceivesPermissionDeniedSyncError() {
         val channel = TestChannel<Throwable>()
@@ -336,15 +390,15 @@ class SyncedRealmTests {
                 Realm.open(config).use {
                     // Make sure that the test eventually fail. Coroutines can cancel a delay
                     // so this doesn't always block the test for 10 seconds.
-                    delay(10 * 1000)
+                    delay(10_000)
                     channel.send(AssertionError("Realm was successfully opened"))
                 }
             }
 
             val error = channel.receiveOrFail()
-            assertTrue(error is UnrecoverableSyncException, "Was $error")
             val message = error.message
             assertNotNull(message)
+            assertTrue(error is UnrecoverableSyncException, "Was $error")
             assertTrue(
                 message.lowercase().contains("permission denied"),
                 "The error should be 'PermissionDenied' but it was: $message"