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))

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

@@ -79,10 +79,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 +111,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);
@@ -1001,7 +992,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 +1080,12 @@ 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);
+    jenv->DeleteGlobalRef(static_cast<jobject>(error.user_code_error));
     return jenv->PopLocalFrame(result);
 }
 
@@ -1192,15 +1185,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;
-    }
-    env->PopLocalFrame(NULL);
+    bool result = jni_check_exception(env, true);
     return result;
 }
 
@@ -1222,14 +1207,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;
-    }
-    env->PopLocalFrame(NULL);
+    bool result = jni_check_exception(env, true);
     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/commonTest/kotlin/io/realm/kotlin/test/mongodb/common/SyncClientResetIntegrationTests.kt

@@ -64,6 +64,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertIs
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 import kotlin.test.fail
@@ -742,6 +743,11 @@ class SyncClientResetIntegrationTests {
                     "[Sync][AutoClientResetFailed(1028)] A fatal error occurred during client reset: 'User-provided callback failed'.",
                     exception.message
                 )
+                assertIs<IllegalStateException>(exception.cause)
+                assertEquals(
+                    "User exception",
+                    exception.cause?.message
+                )
                 channel.trySendOrFail(ClientResetEvents.ON_MANUAL_RESET_FALLBACK)
             }
 
@@ -754,6 +760,11 @@ class SyncClientResetIntegrationTests {
                     "[Sync][AutoClientResetFailed(1028)] A fatal error occurred during client reset: 'User-provided callback failed'.",
                     exception.message
                 )
+                assertIs<IllegalStateException>(exception.cause)
+                assertEquals(
+                    "User exception",
+                    exception.cause?.message
+                )
                 channel.trySendOrFail(ClientResetEvents.ON_MANUAL_RESET_FALLBACK)
             }
         }).build()