Propagate user-level exceptions during client reset

CHANGELOG.md

@@ -5,6 +5,7 @@
 
 ### Enhancements
 * [Sync] Added option to use managed WebSockets via OkHttp instead of Realm's built-in WebSocket client for Sync traffic (Only Android and JVM targets for now). Managed WebSockets offer improved support for proxies and firewalls that require authentication. This feature is currently opt-in and can be enabled by using `AppConfiguration.usePlatformNetworking()`. Managed WebSockets will become the default in a future version. (PR [#1528](https://github.com/realm/realm-kotlin/pull/1528)).
+* `AutoClientResetFailed` exception now reports as the throwable cause any user exceptions that might occur during a client reset. (Issue [#1580](https://github.com/realm/realm-kotlin/issues/1580))
 
 ### Fixed
 * Cache notification callback JNI references at startup to ensure that symbols can be resolved in core callbacks. (Issue [#1577](https://github.com/realm/realm-kotlin/issues/1577))
@@ -28,6 +29,7 @@
 ### Internal
 * Update to Ktor 2.3.4.
 * Updated to CMake 3.27.7
+* Updated to Realm Core 13.25.0, commit 71f94d75e25bfc8913fcd93ae8de550b57577a4a.
 
 
 ## 1.13.1-SNAPSHOT (YYYY-MM-DD)

dependencies.list

@@ -1,11 +1,11 @@
 # Version of MongoDB Realm used by integration tests
 # See https://github.com/realm/ci/packages/147854 for available versions
-MONGODB_REALM_SERVER=2023-11-07
+MONGODB_REALM_SERVER=2023-12-15
 
 # `BAAS` and `BAAS-UI` projects commit hashes matching MONGODB_REALM_SERVER image version
 # note that the MONGODB_REALM_SERVER image is a nightly build, find the matching commits
 # for that date within the following repositories:
 # https://github.com/10gen/baas/
 # https://github.com/10gen/baas-ui/
-REALM_BAAS_GIT_HASH=41fa6cdbca47826c20a64f756e21b2c184393e90
-REALM_BAAS_UI_GIT_HASH=b97a27ac858e0e8126aeb63f6ff9734d11029a91
+REALM_BAAS_GIT_HASH=47d9f6170ab1ac2aa64e7b5046e85247f3ac6d30
+REALM_BAAS_UI_GIT_HASH=49157ef4a6af1c1de4dfbad5d7d02543776b25eb

packages/cinterop/src/commonMain/kotlin/io/realm/kotlin/internal/interop/ErrorCode.kt

@@ -67,6 +67,7 @@ expect enum class ErrorCode : CodeDescription {
     RLM_ERR_TLS_HANDSHAKE_FAILED,
     RLM_ERR_WRONG_SYNC_TYPE,
     RLM_ERR_SYNC_WRITE_NOT_ALLOWED,
+    RLM_ERR_SYNC_LOCAL_CLOCK_BEFORE_EPOCH,
     RLM_ERR_SYSTEM_ERROR,
     RLM_ERR_LOGIC,
     RLM_ERR_NOT_SUPPORTED,

packages/cinterop/src/commonMain/kotlin/io/realm/kotlin/internal/interop/sync/SyncError.kt

@@ -29,21 +29,23 @@ data class SyncError constructor(
     val isFatal: Boolean,
     val isUnrecognizedByClient: Boolean,
     val isClientResetRequested: Boolean,
-    val compensatingWrites: Array<CoreCompensatingWriteInfo>
+    val compensatingWrites: Array<CoreCompensatingWriteInfo>,
+    val userError: Throwable?,
 ) {
     // Constructs an SyncError out from a simple code. There are some situations (SyncSessionTransferCompletionCallback)
     // where we receive an error code rather than a full SyncErrorCode, wrapping the code
     // simplifies the error handling logic.
     constructor(
-        error: CoreError
+        error: CoreError,
     ) : this(
         errorCode = error,
         originalFilePath = null,
         recoveryFilePath = null,
         isFatal = false,
         isUnrecognizedByClient = false,
         isClientResetRequested = false,
-        compensatingWrites = emptyArray()
+        compensatingWrites = emptyArray(),
+        userError = null,
     )
 
     // Constructor used by JNI so we avoid creating too many objects on the JNI side.
@@ -56,14 +58,16 @@ data class SyncError constructor(
         isFatal: Boolean,
         isUnrecognizedByClient: Boolean,
         isClientResetRequested: Boolean,
-        compensatingWrites: Array<CoreCompensatingWriteInfo>
+        compensatingWrites: Array<CoreCompensatingWriteInfo>,
+        userError: Throwable?,
     ) : this(
         CoreError(categoryFlags, value, message),
         originalFilePath,
         recoveryFilePath,
         isFatal,
         isUnrecognizedByClient,
         isClientResetRequested,
-        compensatingWrites
+        compensatingWrites,
+        userError,
     )
 }

packages/cinterop/src/jvm/kotlin/io/realm/kotlin/internal/interop/ErrorCode.kt

@@ -64,6 +64,7 @@ actual enum class ErrorCode(override val description: String, override val nativ
     RLM_ERR_TLS_HANDSHAKE_FAILED("TLSHandshakeFailed", realm_errno_e.RLM_ERR_TLS_HANDSHAKE_FAILED),
     RLM_ERR_WRONG_SYNC_TYPE("WrongSyncType", realm_errno_e.RLM_ERR_WRONG_SYNC_TYPE),
     RLM_ERR_SYNC_WRITE_NOT_ALLOWED("SyncWriteNotAllowed", realm_errno_e.RLM_ERR_SYNC_WRITE_NOT_ALLOWED),
+    RLM_ERR_SYNC_LOCAL_CLOCK_BEFORE_EPOCH("SyncLocalClockBeforeEpoch", realm_errno_e.RLM_ERR_SYNC_LOCAL_CLOCK_BEFORE_EPOCH),
     RLM_ERR_SYSTEM_ERROR("SystemError", realm_errno_e.RLM_ERR_SYSTEM_ERROR),
     RLM_ERR_LOGIC("Logic", realm_errno_e.RLM_ERR_LOGIC),
     RLM_ERR_NOT_SUPPORTED("NotSupported", realm_errno_e.RLM_ERR_NOT_SUPPORTED),

packages/cinterop/src/nativeDarwin/kotlin/io/realm/kotlin/internal/interop/ErrorCode.kt

@@ -68,6 +68,7 @@ actual enum class ErrorCode(
     RLM_ERR_TLS_HANDSHAKE_FAILED("TLSHandshakeFailed", realm_errno.RLM_ERR_TLS_HANDSHAKE_FAILED),
     RLM_ERR_WRONG_SYNC_TYPE("WrongSyncType", realm_errno.RLM_ERR_WRONG_SYNC_TYPE),
     RLM_ERR_SYNC_WRITE_NOT_ALLOWED("SyncWriteNotAllowed", realm_errno.RLM_ERR_SYNC_WRITE_NOT_ALLOWED),
+    RLM_ERR_SYNC_LOCAL_CLOCK_BEFORE_EPOCH("SyncLocalClockBeforeEpoch", realm_errno.RLM_ERR_SYNC_LOCAL_CLOCK_BEFORE_EPOCH),
     RLM_ERR_SYSTEM_ERROR("SystemError", realm_errno.RLM_ERR_SYSTEM_ERROR),
     RLM_ERR_LOGIC("Logic", realm_errno.RLM_ERR_LOGIC),
     RLM_ERR_NOT_SUPPORTED("NotSupported", realm_errno.RLM_ERR_NOT_SUPPORTED),

packages/cinterop/src/nativeDarwin/kotlin/io/realm/kotlin/internal/interop/RealmInterop.kt

@@ -158,9 +158,9 @@ private fun throwOnError() {
                 errorCodeNativeValue = error.error.value.toInt(),
                 messageNativeValue = error.message?.toKString(),
                 path = error.path?.toKString(),
-                userError = error.usercode_error?.asStableRef<Throwable>()?.get()
+                userError = error.user_code_error?.asStableRef<Throwable>()?.get()
             ).also {
-                error.usercode_error?.let { disposeUserData<Throwable>(it) }
+                error.user_code_error?.let { disposeUserData<Throwable>(it) }
                 realm_clear_last_error()
             }
         }
@@ -638,9 +638,9 @@ actual object RealmInterop {
                             errorCodeNativeValue = err.error.value.toInt(),
                             messageNativeValue = err.message?.toKString(),
                             path = err.path?.toKString(),
-                            userError = err.usercode_error?.asStableRef<Throwable>()?.get()
+                            userError = err.user_code_error?.asStableRef<Throwable>()?.get()
                         )
-                        err.usercode_error?.let { disposeUserData<Throwable>(it) }
+                        err.user_code_error?.let { disposeUserData<Throwable>(it) }
                     } else {
                         realm_release(realm)
                     }
@@ -2534,8 +2534,11 @@ actual object RealmInterop {
                         isFatal = is_fatal,
                         isUnrecognizedByClient = is_unrecognized_by_client,
                         isClientResetRequested = is_client_reset_requested,
-                        compensatingWrites = compensatingWrites
-                    )
+                        compensatingWrites = compensatingWrites,
+                        userError = user_code_error?.asStableRef<Throwable>()?.get()
+                    ).also {
+                        user_code_error?.let { disposeUserData<Throwable>(it) }
+                    }
                 }
                 val errorCallback = safeUserData<SyncErrorCallback>(userData)
                 val session = CPointerWrapper<RealmSyncSessionT>(realm_clone(syncSession))
@@ -2565,16 +2568,10 @@ actual object RealmInterop {
         realm_wrapper.realm_sync_config_set_before_client_reset_handler(
             syncConfig.cptr(),
             staticCFunction { userData, beforeRealm ->
-                val beforeCallback = safeUserData<SyncBeforeClientResetHandler>(userData)
-                val beforeDb = CPointerWrapper<FrozenRealmT>(beforeRealm, false)
-
-                // Check if exceptions have been thrown, return true if all went as it should
-                try {
-                    beforeCallback.onBeforeReset(beforeDb)
+                stableUserDataWithErrorPropagation<SyncBeforeClientResetHandler>(userData) {
+                    val beforeDb = CPointerWrapper<FrozenRealmT>(beforeRealm, false)
+                    onBeforeReset(beforeDb)
                     true
-                } catch (e: Throwable) {
-                    println(e.message)
-                    false
                 }
             },
             StableRef.create(beforeHandler).asCPointer(),
@@ -2591,22 +2588,19 @@ actual object RealmInterop {
         realm_wrapper.realm_sync_config_set_after_client_reset_handler(
             syncConfig.cptr(),
             staticCFunction { userData, beforeRealm, afterRealm, didRecover ->
-                val afterCallback = safeUserData<SyncAfterClientResetHandler>(userData)
-                val beforeDb = CPointerWrapper<FrozenRealmT>(beforeRealm, false)
+                stableUserDataWithErrorPropagation<SyncAfterClientResetHandler>(userData) {
+                    val beforeDb = CPointerWrapper<FrozenRealmT>(beforeRealm, false)
 
-                // afterRealm is wrapped inside a ThreadSafeReference so the pointer needs to be resolved
-                val afterRealmPtr = realm_wrapper.realm_from_thread_safe_reference(afterRealm, null)
-                val afterDb = CPointerWrapper<LiveRealmT>(afterRealmPtr, false)
+                    // afterRealm is wrapped inside a ThreadSafeReference so the pointer needs to be resolved
+                    val afterRealmPtr = realm_wrapper.realm_from_thread_safe_reference(afterRealm, null)
+                    val afterDb = CPointerWrapper<LiveRealmT>(afterRealmPtr, false)
 
-                // Check if exceptions have been thrown, return true if all went as it should
-                try {
-                    afterCallback.onAfterReset(beforeDb, afterDb, didRecover)
-                    true
-                } catch (e: Throwable) {
-                    println(e.message)
-                    false
-                } finally {
-                    realm_wrapper.realm_close(afterRealmPtr)
+                    try {
+                        onAfterReset(beforeDb, afterDb, didRecover)
+                        true
+                    } finally {
+                        realm_wrapper.realm_close(afterRealmPtr)
+                    }
                 }
             },
             StableRef.create(afterHandler).asCPointer(),

packages/jni-swig-stub/src/main/jni/realm_api_helpers.cpp

@@ -34,20 +34,26 @@ jobject wrap_pointer(JNIEnv* jenv, jlong pointer, jboolean managed = false) {
                            managed);
 }
 
-inline jboolean jni_check_exception(JNIEnv *jenv = get_env(), bool registrable_callback_error = false) {
+inline jboolean jni_check_exception(JNIEnv *jenv = get_env()) {
     // FIXME https://github.com/realm/realm-kotlin/issues/665 This function is catching and swallowing
     //  the exception. This behavior could leave the SDK in an illegal state.
     if (jenv->ExceptionCheck()) {
-        if (registrable_callback_error) {
-            // setting the user code error is only propagated on certain callbacks.
-            jthrowable exception = jenv->ExceptionOccurred();
-            jenv->ExceptionClear();
-            realm_register_user_code_callback_error(jenv->NewGlobalRef(exception));
-        } else {
-            // Print the exception stacktrace in stderr.
-            jenv->ExceptionDescribe();
-            jenv->ExceptionClear();
-        }
+        // Print the exception stacktrace in stderr.
+        jenv->ExceptionDescribe();
+        jenv->ExceptionClear();
+        return false;
+    }
+    return true;
+}
+
+inline jboolean jni_check_exception_for_callback(JNIEnv *jenv = get_env()) {
+    if (jenv->ExceptionCheck()) {
+        // setting the user code error is only propagated on certain callbacks.
+        jthrowable exception = jenv->ExceptionOccurred();
+        jenv->ExceptionClear();
+        // This global ref would be released once core has propagated the exception back
+        // see: create_java_exception and convert_to_jvm_sync_error
+        realm_register_user_code_callback_error(jenv->NewGlobalRef(exception));
         return false;
     }
     return true;
@@ -79,10 +85,10 @@ inline jobject create_java_exception(JNIEnv *jenv, realm_error_t error) {
             jint(error.error),
             error_message,
             error_path,
-            static_cast<jobject>(error.usercode_error)
+            static_cast<jobject>(error.user_code_error)
     );
-    if (error.usercode_error) {
-        (jenv)->DeleteGlobalRef(static_cast<jobject>(error.usercode_error));
+    if (error.user_code_error) {
+        (jenv)->DeleteGlobalRef(static_cast<jobject>(error.user_code_error));
     }
     jni_check_exception(jenv);
     return jenv->PopLocalFrame(exception);
@@ -111,15 +117,6 @@ inline std::string get_exception_message(JNIEnv *env) {
     return env->GetStringUTFChars(message, NULL);
 }
 
-inline void system_out_println(JNIEnv *env, std::string message) {
-    jclass system_class = env->FindClass("java/lang/System");
-    jfieldID field_id = env->GetStaticFieldID(system_class, "out", "Ljava/io/PrintStream;");
-    jobject system_out = env->GetStaticObjectField(system_class, field_id);
-    jclass print_stream_class = env->FindClass("java/io/PrintStream");
-    jmethodID method_id = env->GetMethodID(print_stream_class, "println", "(Ljava/lang/String;)V");
-    env->CallVoidMethod(system_out, method_id, to_jstring(env, message));
-}
-
 void
 realm_changed_callback(void* userdata) {
     auto env = get_env(true);
@@ -161,7 +158,7 @@ bool migration_callback(void *userdata, realm_t *old_realm, realm_t *new_realm,
                         wrap_pointer(env, reinterpret_cast<jlong>(new_realm), false),
                         wrap_pointer(env, reinterpret_cast<jlong>(schema))
     );
-    bool failed = jni_check_exception(env, true);
+    bool failed = jni_check_exception_for_callback(env);
     env->PopLocalFrame(NULL);
     return failed;
 }
@@ -559,7 +556,7 @@ bool realm_should_compact_callback(void* userdata, uint64_t total_bytes, uint64_
 
     jobject callback = static_cast<jobject>(userdata);
     jboolean result = env->CallBooleanMethod(callback, java_should_compact_method, jlong(total_bytes), jlong(used_bytes));
-    return jni_check_exception(env, true) && result;
+    return jni_check_exception_for_callback(env) && result;
 }
 
 bool realm_data_initialization_callback(void* userdata, realm_t*) {
@@ -569,7 +566,7 @@ bool realm_data_initialization_callback(void* userdata, realm_t*) {
 
     jobject callback = static_cast<jobject>(userdata);
     env->CallVoidMethod(callback, java_data_init_method);
-    return jni_check_exception(env, true);
+    return jni_check_exception_for_callback(env);
 }
 
 static void send_request_via_jvm_transport(JNIEnv *jenv, jobject network_transport, const realm_http_request_t request, jobject j_response_callback) {
@@ -1001,7 +998,7 @@ jobject convert_to_jvm_sync_error(JNIEnv* jenv, const realm_sync_error_t& error)
     static JavaMethod sync_error_constructor(jenv,
                                              JavaClassGlobalDef::sync_error(),
                                              "<init>",
-    "(IILjava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZZ[Lio/realm/kotlin/internal/interop/sync/CoreCompensatingWriteInfo;)V");
+    "(IILjava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZZ[Lio/realm/kotlin/internal/interop/sync/CoreCompensatingWriteInfo;Ljava/lang/Throwable;)V");
 
     jint category = static_cast<jint>(error.status.categories);
     jint value = static_cast<jint>(error.status.error);
@@ -1089,10 +1086,14 @@ jobject convert_to_jvm_sync_error(JNIEnv* jenv, const realm_sync_error_t& error)
             is_fatal,
             is_unrecognized_by_client,
             is_client_reset_requested,
-            j_compensating_write_info_array
+            j_compensating_write_info_array,
+            static_cast<jobject>(error.user_code_error)
     );
 
     jni_check_exception(jenv);
+    if(error.user_code_error) {
+        jenv->DeleteGlobalRef(static_cast<jobject>(error.user_code_error));
+    }
     return jenv->PopLocalFrame(result);
 }
 
@@ -1192,14 +1193,7 @@ before_client_reset(void* userdata, realm_t* before_realm) {
     env->PushLocalFrame(1);
     jobject before_pointer = wrap_pointer(env, reinterpret_cast<jlong>(before_realm), false);
     env->CallVoidMethod(static_cast<jobject>(userdata), java_before_callback_function, before_pointer);
-
-    bool result = true;
-    if (env->ExceptionCheck()) {
-        std::string exception_message = get_exception_message(env);
-        std::string message_template = "An error has occurred in the 'onBefore' callback: ";
-        system_out_println(env, message_template.append(exception_message));
-        result = false;
-    }
+    bool result = jni_check_exception_for_callback(env);
     env->PopLocalFrame(NULL);
     return result;
 }
@@ -1222,13 +1216,7 @@ after_client_reset(void* userdata, realm_t* before_realm,
     jobject after_pointer = wrap_pointer(env, reinterpret_cast<jlong>(after_realm_ptr), false);
     env->CallVoidMethod(static_cast<jobject>(userdata), java_after_callback_function, before_pointer, after_pointer, did_recover);
     realm_close(after_realm_ptr);
-    bool result = true;
-    if (env->ExceptionCheck()) {
-        std::string exception_message = get_exception_message(env);
-        std::string message_template = "An error has occurred in the 'onAfter' callback: ";
-        system_out_println(env, message_template.append(exception_message));
-        result = false;
-    }
+    bool result = jni_check_exception_for_callback(env);
     env->PopLocalFrame(NULL);
     return result;
 }

packages/library-sync/src/commonMain/kotlin/io/realm/kotlin/mongodb/exceptions/ClientResetRequiredException.kt

@@ -30,8 +30,11 @@ import io.realm.kotlin.mongodb.internal.createMessageFromSyncError
  */
 public class ClientResetRequiredException constructor(
     private val appPointer: RealmAppPointer,
-    error: SyncError
-) : Throwable(message = createMessageFromSyncError(error.errorCode)) {
+    error: SyncError,
+) : Throwable(
+    message = createMessageFromSyncError(error.errorCode),
+    cause = error.userError,
+) {
 
     /**
      * Path to the original (local) copy of the realm when the Client Reset event was triggered.

packages/test-sync/src/commonMain/kotlin/io/realm/kotlin/test/mongodb/util/AppAdmin.kt

@@ -96,6 +96,11 @@ interface AppAdmin {
      */
     suspend fun countDocuments(clazz: String): Int
 
+    /**
+     * Delete documents of a given type.
+     */
+    suspend fun deleteDocuments(database: String, clazz: String, query: String): JsonObject?
+
     fun closeClient()
 }
 
@@ -191,6 +196,11 @@ class AppAdminImpl(
             app.countDocuments(clazz)
         }
 
+    override suspend fun deleteDocuments(database: String, clazz: String, query: String): JsonObject? =
+        baasClient.run {
+            app.deleteDocument(database, clazz, query)
+        }
+
     override fun closeClient() {
         baasClient.closeClient()
     }