Fix a few crashes (#1933)

* Add stack to API exception and catches a few exceptions

* Try catch PathManager

* Cancellation handling

* Cancellation handling and comments

* Tidy up cancellation handling in fetchSnodePoolFromSeedWithFallback

Author: SessionHero01

app/src/main/java/org/session/libsession/messaging/open_groups/OfficialCommunityRepository.kt

@@ -100,6 +100,8 @@ class OfficialCommunityRepository @Inject constructor(
                                 )
                             }
                         }
+                    }.onFailure {
+                        if (it is CancellationException) throw it
                     })
                 }
             }

app/src/main/java/org/session/libsession/network/onion/PathManager.kt

@@ -93,7 +93,13 @@ open class PathManager @Inject constructor(
         scope.launch {
             _paths.drop(1).collectLatest { paths ->
                 if (paths.isEmpty()) storage.clearOnionRequestPaths()
-                else storage.setOnionRequestPaths(paths)
+                else {
+                    try {
+                        storage.setOnionRequestPaths(paths)
+                    } catch (e: Exception) {
+                        Log.e("Onion Request", "Failed to persist paths to storage, keeping in-memory only", e)
+                    }
+                }
             }
         }
     }

app/src/main/java/org/session/libsession/network/snode/SnodeDirectory.kt

@@ -2,6 +2,7 @@ package org.session.libsession.network.snode
 
 import android.content.Context
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
@@ -175,6 +176,8 @@ class SnodeDirectory @Inject constructor(
                     }
                     .result
             }.onFailure { e ->
+                if (e is CancellationException) throw e
+
                 lastError = e
                 Log.w("SnodeDirectory", "Seed node failed: $target", e)
             }
@@ -277,11 +280,17 @@ class SnodeDirectory @Inject constructor(
         if (now >= last && now - last < POOL_REFRESH_INTERVAL_MS) return
 
         scope.launch {
-            refreshPoolFromSnodes(
-                totalSnodeQueries = 3,
-                minAppearance = 2,
-                distinctQuerySubnetPrefix = 24,
-            )
+            try {
+                refreshPoolFromSnodes(
+                    totalSnodeQueries = 3,
+                    minAppearance = 2,
+                    distinctQuerySubnetPrefix = 24,
+                )
+            } catch (e: Throwable) {
+                if (e is CancellationException) throw e
+
+                Log.w("SnodeDirectory", "Error refreshing snode pool", e)
+            }
         }
     }
 

app/src/main/java/org/thoughtcrime/securesms/api/AutoRetryApiExecutor.kt

@@ -18,6 +18,8 @@ class AutoRetryApiExecutor<Req, Res>(
     private val actualExecutor: ApiExecutor<Req, Res>,
 ) : ApiExecutor<Req, Res> {
     override suspend fun send(ctx: ApiExecutorContext, req: Req): Res {
+        val initStack = Throwable().stackTrace
+
         var numRetried = 0
         while (true) {
             try {
@@ -32,7 +34,16 @@ class AutoRetryApiExecutor<Req, Res>(
                     Log.e(TAG, "Retrying $req $numRetried times due to error", e)
                     delay(numRetried * 2000L)
                 } else {
-                    throw e
+                    // If we know the error is ErrorWithFailureDecision, we can
+                    // safely modify its stacktrace as we know that exception contains
+                    // a cause where it can pinpoint to the direct trace of the error.
+                    // Otherwise, we'll create a new exception to modify the stacktrace, so to
+                    // preserve the original error's stacktrace which may contain important
+                    // information about the error.
+
+                    val errorToUpdateStack = e.takeIf { it is ErrorWithFailureDecision } ?: RuntimeException(e)
+                    errorToUpdateStack.stackTrace = initStack
+                    throw errorToUpdateStack
                 }
             }
         }

app/src/main/java/org/thoughtcrime/securesms/configs/ConfigToDatabaseSync.kt

@@ -2,6 +2,7 @@ package org.thoughtcrime.securesms.configs
 
 import android.content.Context
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -323,10 +324,19 @@ class ConfigToDatabaseSync @Inject constructor(
                             messageHashes = cleanedHashes,
                             swarmAuth = groupAdminAuth
                         )
-                        swarmApiExecutor.execute(SwarmApiRequest(
-                            swarmPubKeyHex = groupInfoConfig.id.hexString,
-                            api = deleteMessageApi
-                        ))
+
+                        try {
+                            swarmApiExecutor.execute(
+                                SwarmApiRequest(
+                                    swarmPubKeyHex = groupInfoConfig.id.hexString,
+                                    api = deleteMessageApi
+                                )
+                            )
+                        } catch (e: Exception) {
+                            if (e is CancellationException) throw e
+
+                            Log.e(TAG, "Failed to delete messages from swarm for group", e)
+                        }
                     }
                 }
             }

app/src/main/java/org/thoughtcrime/securesms/groups/GroupManagerV2Impl.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import com.google.protobuf.ByteString
 import com.squareup.phrase.Phrase
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.filter
@@ -1225,7 +1226,12 @@ class GroupManagerV2Impl @Inject constructor(
 
     override fun onBlocked(groupAccountId: AccountId) {
         scope.launch(groupAccountId, "On blocked") {
-            respondToInvitation(groupAccountId, false)
+            try {
+                respondToInvitation(groupAccountId, false)
+            } catch (e: Throwable) {
+                if (e is CancellationException) throw e
+                Log.e(TAG, "Failed to unapprove invitation for group", e)
+            }
 
             // Remove this group from config regardless
             configFactory.removeGroup(groupAccountId)

app/src/main/java/org/thoughtcrime/securesms/notifications/MarkReadProcessor.kt

@@ -2,6 +2,7 @@ package org.thoughtcrime.securesms.notifications
 
 import android.content.Context
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
@@ -107,17 +108,23 @@ class MarkReadProcessor @Inject constructor(
                     keySelector = { it.value.expirationInfo.expiresIn },
                     valueTransform = { it.key }
                 ).forEach { (expiresIn, hashes) ->
-                    swarmApiExecutor.execute(
-                        SwarmApiRequest(
-                            swarmPubKeyHex = userAuth.accountId.hexString,
-                            api = alterTtyFactory.create(
-                                messageHashes = hashes,
-                                auth = userAuth,
-                                alterType = AlterTtlApi.AlterType.Shorten,
-                                newExpiry = snodeClock.currentTimeMillis() + expiresIn
+                    try {
+                        swarmApiExecutor.execute(
+                            SwarmApiRequest(
+                                swarmPubKeyHex = userAuth.accountId.hexString,
+                                api = alterTtyFactory.create(
+                                    messageHashes = hashes,
+                                    auth = userAuth,
+                                    alterType = AlterTtlApi.AlterType.Shorten,
+                                    newExpiry = snodeClock.currentTimeMillis() + expiresIn
+                                )
                             )
                         )
-                    )
+                    } catch (e: Throwable) {
+                        if (e is CancellationException) throw e
+
+                        Log.e(TAG, "Failed to shorten expiry for messages with hashes $hashes", e)
+                    }
                 }
         }
     }