From 1a140650af6b08a8eb8a94084c741f7d3940ded6 Mon Sep 17 00:00:00 2001 From: karol Date: Sun, 18 Oct 2026 00:44:23 +0200 Subject: [PATCH] Retry failed Matrix backfill messages and persist import progress --- README.md | 15 +++ .../com/moez/QKSMS/common/QKApplication.kt | 11 +- .../remotrix/background/CommandService.kt | 62 +++++---- .../ch/skew/remotrix/bridge/BackfillRunner.kt | 50 +++++++ .../ch/skew/remotrix/bridge/MatrixBridge.kt | 2 +- .../java/ch/skew/remotrix/data/RemotrixDB.kt | 13 +- .../data/backfillDB/BackfillProgress.kt | 20 +++ .../remotrix/bridge/BackfillRunnerTest.kt | 124 ++++++++++++++++++ 8 files changed, 268 insertions(+), 29 deletions(-) create mode 100644 remotrix-sync/src/main/java/ch/skew/remotrix/bridge/BackfillRunner.kt create mode 100644 remotrix-sync/src/main/java/ch/skew/remotrix/data/backfillDB/BackfillProgress.kt create mode 100644 remotrix-sync/src/test/java/ch/skew/remotrix/bridge/BackfillRunnerTest.kt diff --git a/README.md b/README.md index 8bfc6d2b..a6e840e4 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,21 @@ The reset removes local Matrix accounts, room mappings, encryption stores and br SMS messages, Quik settings, the Manager ID and the backfill limit are preserved. New rooms use contact names from Android, and SMS history is copied again up to the configured limit. +## History import + +History import retries a failed message before advancing, with retry delays up to one minute. +Synapse room-creation limits still apply. There is no fixed delay after each successful message. +Progress is stored by native message type and ID, so identical SMS texts remain separate messages +and saved progress is skipped when an unfinished import resumes. Reset Matrix clears this progress. +The completion flag means all selected messages were handed to the persistent Matrix outbox +(or intentionally excluded by forwarding settings); outbox delivery remains managed by Trixnity. +Logcat reports progress and retry positions without logging SMS bodies or phone numbers. + +Upgrading preserves an existing completed-import flag. It does not automatically replay old history: +older versions did not retain per-message progress, so replaying that history could create duplicates. +Checkpoint storage and the Matrix outbox use separate databases; an abrupt process/device failure +between enqueueing a message and saving its checkpoint can still replay that last message. + ## Persistent release signing Release APKs require the permanent signing key. Missing signing configuration fails the build; diff --git a/presentation/src/main/java/com/moez/QKSMS/common/QKApplication.kt b/presentation/src/main/java/com/moez/QKSMS/common/QKApplication.kt index f8284d41..00220588 100644 --- a/presentation/src/main/java/com/moez/QKSMS/common/QKApplication.kt +++ b/presentation/src/main/java/com/moez/QKSMS/common/QKApplication.kt @@ -102,8 +102,8 @@ class QKApplication : Application(), HasActivityInjector, HasBroadcastReceiverIn fromMatrix = fromMatrix ) } - override suspend fun getBackfillMessages(limit: Int): List> { - val messagesToSend = mutableListOf>() + override suspend fun getBackfillMessages(limit: Int): List { + val messagesToSend = mutableListOf() Realm.getDefaultInstance().use { realm -> val threads = realm.where(dev.octoshrimpy.quik.model.Conversation::class.java).findAll() for (thread in threads) { @@ -118,7 +118,12 @@ class QKApplication : Application(), HasActivityInjector, HasBroadcastReceiverIn val msgAddress = msg.address.takeIf { it.isNotBlank() } ?: threadAddress val msgBody = msg.getText(withSubject = false) if (msgAddress.isNotBlank() && msgBody.isNotBlank()) { - messagesToSend.add(Triple(msgAddress, msgBody, msg.isMe())) + messagesToSend.add(ch.skew.remotrix.bridge.BackfillMessage( + id = "${msg.type}:${msg.contentId}", + address = msgAddress, + body = msgBody, + outgoing = msg.isMe() + )) } } } diff --git a/remotrix-sync/src/main/java/ch/skew/remotrix/background/CommandService.kt b/remotrix-sync/src/main/java/ch/skew/remotrix/background/CommandService.kt index f2edf6e0..3af92d9c 100644 --- a/remotrix-sync/src/main/java/ch/skew/remotrix/background/CommandService.kt +++ b/remotrix-sync/src/main/java/ch/skew/remotrix/background/CommandService.kt @@ -20,6 +20,9 @@ import ch.skew.remotrix.data.RemotrixDB import ch.skew.remotrix.data.RemotrixSettings import ch.skew.remotrix.data.forwardRuleDB.ForwardRule import ch.skew.remotrix.data.roomIdDB.RoomIdData +import ch.skew.remotrix.bridge.BackfillRunner +import ch.skew.remotrix.data.backfillDB.BackfillProgress +import kotlinx.coroutines.CancellationException import ch.skew.remotrix.bridge.closeMatrixClient import ch.skew.remotrix.bridge.resetBridge import ch.skew.remotrix.bridge.RoomResolver @@ -405,7 +408,7 @@ class CommandService: Service() { return null } - private suspend fun sendMsg(sender: String, payload: String, log: Boolean, outgoing: Boolean = false) { + private suspend fun sendMsg(sender: String, payload: String, log: Boolean, outgoing: Boolean = false): Result { if(currentStatus.get() != StatusType.Running) { load() } @@ -421,7 +424,7 @@ class CommandService: Service() { MsgStatus.MESSAGE_DROPPED, null ) - return + return Result.success(Unit) // Intentionally excluded by forwarding settings. } // If match is not found, default account is chosen. val sendAs = if (match !== null) match else defaultAccount @@ -433,7 +436,7 @@ class CommandService: Service() { null, null ) - return + return Result.failure(IllegalStateException("No suitable Matrix forwarder")) } val client = pair.first while (client.syncState.first() != net.folivo.trixnity.clientserverapi.client.SyncState.RUNNING) { @@ -449,7 +452,7 @@ class CommandService: Service() { null, null ) - return + return Result.failure(it) } val roomId = RoomId(resolved.roomId) if (resolved.created) { @@ -469,11 +472,17 @@ class CommandService: Service() { } } // Message is sent successfully, mark the pre-recorded message as successfully sent - if(currentLog != -1L) db.getLogDao().setSuccess( - currentLog, - MsgStatus.MESSAGE_SENT, - sendAs - ) + // A logging failure must not cause an already queued SMS to be queued twice. + if (currentLog != -1L) { + try { + db.getLogDao().setSuccess(currentLog, MsgStatus.MESSAGE_SENT, sendAs) + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + Log.w("CommandService", "Could not record forwarding success", e) + } + } + return Result.success(Unit) } private fun stopAll() { @@ -586,8 +595,9 @@ class CommandService: Service() { // Backfill already routes each message to its selected account in sendMsg. // Running it for every client duplicates the entire history. if (clients.isNotEmpty() && !settings.getBackfillDone.first()) { - performBackfill(settings.getBackfillLimit.first()) - settings.saveBackfillDone(true) + if (performBackfill(settings.getBackfillLimit.first())) { + settings.saveBackfillDone(true) + } } } if(clients.isNotEmpty()){ @@ -697,19 +707,25 @@ class CommandService: Service() { } } - private suspend fun performBackfill(limit: Int) { - val bridge = ch.skew.remotrix.bridge.MatrixBridgeProvider.bridge ?: return - val messagesToSend = bridge.getBackfillMessages(limit) - Log.d("CommandService", "Starting backfill with ${messagesToSend.size} messages") - - for ((address, body, isOutgoing) in messagesToSend) { - try { - sendMsg(address, body, false, isOutgoing) - } catch (e: Exception) { - Log.e("CommandService", "Error backfilling message for $address", e) + private suspend fun performBackfill(limit: Int): Boolean { + val bridge = ch.skew.remotrix.bridge.MatrixBridgeProvider.bridge ?: return false + val messages = bridge.getBackfillMessages(limit) + val progress = db.getBackfillProgressDao() + Log.i("CommandService", "Starting backfill with ${messages.size} messages") + BackfillRunner( + isHandled = { progress.isHandled(it) }, + markHandled = { progress.insert(BackfillProgress(it)) }, + send = { sendMsg(it.address, it.body, false, it.outgoing) }, + onRetry = { index, error, delay -> + // Do not log SMS contents, addresses, or server error bodies. + Log.w("CommandService", "Backfill $index/${messages.size} failed (${error.javaClass.simpleName}); retry in ${delay}ms") + }, + onProgress = { completed, total -> + Log.i("CommandService", "Backfill queued or previously handled: $completed/$total") } - kotlinx.coroutines.delay(500) // Small delay to prevent rate limits - } + ).run(messages) + Log.i("CommandService", "Backfill completed: ${messages.size} messages handled") + return true } private suspend fun sendSMS(sender: Int, roomId: RoomId, payload: String): Boolean { diff --git a/remotrix-sync/src/main/java/ch/skew/remotrix/bridge/BackfillRunner.kt b/remotrix-sync/src/main/java/ch/skew/remotrix/bridge/BackfillRunner.kt new file mode 100644 index 00000000..40b3e10a --- /dev/null +++ b/remotrix-sync/src/main/java/ch/skew/remotrix/bridge/BackfillRunner.kt @@ -0,0 +1,50 @@ +package ch.skew.remotrix.bridge + +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.NonCancellable +import kotlinx.coroutines.delay +import kotlinx.coroutines.withContext + +data class BackfillMessage( + val id: String, + val address: String, + val body: String, + val outgoing: Boolean +) + +/** Stops at a failed message: later messages must never hide an incomplete import. */ +class BackfillRunner( + private val isHandled: suspend (String) -> Boolean, + private val markHandled: suspend (String) -> Unit, + private val send: suspend (BackfillMessage) -> Result, + private val waitBeforeRetry: suspend (Long) -> Unit = { delay(it) }, + private val onRetry: (Int, Throwable, Long) -> Unit = { _, _, _ -> }, + private val onProgress: (Int, Int) -> Unit = { _, _ -> } +) { + suspend fun run(messages: List) { + for ((index, message) in messages.withIndex()) { + if (!isHandled(message.id)) { + var retryDelay = 1_000L + while (true) { + val result = try { + send(message) + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + Result.failure(e) + } + val error = result.exceptionOrNull() + if (error == null) break + generateSequence(error) { it.cause } + .filterIsInstance().firstOrNull()?.let { throw it } + onRetry(index + 1, error, retryDelay) + waitBeforeRetry(retryDelay) + retryDelay = (retryDelay * 2).coerceAtMost(60_000L) + } + // Once queued, preserve progress even if the service is being stopped. + withContext(NonCancellable) { markHandled(message.id) } + } + onProgress(index + 1, messages.size) + } + } +} diff --git a/remotrix-sync/src/main/java/ch/skew/remotrix/bridge/MatrixBridge.kt b/remotrix-sync/src/main/java/ch/skew/remotrix/bridge/MatrixBridge.kt index 9be418ec..fb6ba91b 100644 --- a/remotrix-sync/src/main/java/ch/skew/remotrix/bridge/MatrixBridge.kt +++ b/remotrix-sync/src/main/java/ch/skew/remotrix/bridge/MatrixBridge.kt @@ -2,7 +2,7 @@ package ch.skew.remotrix.bridge interface MatrixBridge { suspend fun sendNewMessages(toAddress: String, body: String, fromMatrix: Boolean) - suspend fun getBackfillMessages(limit: Int): List> // sender, payload, isOutgoing + suspend fun getBackfillMessages(limit: Int): List } object MatrixBridgeProvider { diff --git a/remotrix-sync/src/main/java/ch/skew/remotrix/data/RemotrixDB.kt b/remotrix-sync/src/main/java/ch/skew/remotrix/data/RemotrixDB.kt index c1df4877..07e3de09 100644 --- a/remotrix-sync/src/main/java/ch/skew/remotrix/data/RemotrixDB.kt +++ b/remotrix-sync/src/main/java/ch/skew/remotrix/data/RemotrixDB.kt @@ -1,5 +1,7 @@ package ch.skew.remotrix.data +import ch.skew.remotrix.data.backfillDB.BackfillProgress +import ch.skew.remotrix.data.backfillDB.BackfillProgressDao import android.content.ContentValues import android.content.Context import android.database.sqlite.SQLiteDatabase @@ -24,12 +26,14 @@ import ch.skew.remotrix.data.roomIdDB.RoomIdData ForwardRule::class, RoomIdData::class, LogData::class, - DebugLogData::class + DebugLogData::class, + BackfillProgress::class ], - version = 3 + version = 4 ) abstract class RemotrixDB: RoomDatabase(){ + abstract fun getBackfillProgressDao(): BackfillProgressDao abstract fun getAccountDao(): AccountDao abstract fun getForwardRuleDao(): ForwardRuleDao abstract fun getRoomIdDao(): RoomIdDao @@ -51,8 +55,13 @@ abstract class RemotrixDB: RoomDatabase(){ .setJournalMode(androidx.room.RoomDatabase.JournalMode.WRITE_AHEAD_LOGGING) .addMigrations(migration1To2) .addMigrations(migration2To3) + .addMigrations(migration3To4) .build() + private val migration3To4 = Migration(3, 4) { + it.execSQL("CREATE TABLE IF NOT EXISTS backfill_progress (messageId TEXT NOT NULL PRIMARY KEY)") + } + private val migration2To3 = Migration(2, 3) { it.execSQL( "CREATE TABLE IF NOT EXISTS debug_log (" + diff --git a/remotrix-sync/src/main/java/ch/skew/remotrix/data/backfillDB/BackfillProgress.kt b/remotrix-sync/src/main/java/ch/skew/remotrix/data/backfillDB/BackfillProgress.kt new file mode 100644 index 00000000..3ab5b4b2 --- /dev/null +++ b/remotrix-sync/src/main/java/ch/skew/remotrix/data/backfillDB/BackfillProgress.kt @@ -0,0 +1,20 @@ +package ch.skew.remotrix.data.backfillDB + +import androidx.room.Dao +import androidx.room.Entity +import androidx.room.Insert +import androidx.room.OnConflictStrategy +import androidx.room.PrimaryKey +import androidx.room.Query + +@Entity(tableName = "backfill_progress") +data class BackfillProgress(@PrimaryKey val messageId: String) + +@Dao +interface BackfillProgressDao { + @Query("SELECT EXISTS(SELECT 1 FROM backfill_progress WHERE messageId = :id)") + suspend fun isHandled(id: String): Boolean + + @Insert(onConflict = OnConflictStrategy.IGNORE) + suspend fun insert(progress: BackfillProgress) +} diff --git a/remotrix-sync/src/test/java/ch/skew/remotrix/bridge/BackfillRunnerTest.kt b/remotrix-sync/src/test/java/ch/skew/remotrix/bridge/BackfillRunnerTest.kt new file mode 100644 index 00000000..8585ed82 --- /dev/null +++ b/remotrix-sync/src/test/java/ch/skew/remotrix/bridge/BackfillRunnerTest.kt @@ -0,0 +1,124 @@ +package ch.skew.remotrix.bridge + +import ch.skew.remotrix.classes.RoomCreationError +import ch.skew.remotrix.classes.MsgStatus +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.runBlocking +import org.junit.Assert.* +import org.junit.Test + +class BackfillRunnerTest { + private fun message(id: String) = BackfillMessage(id, "123", "same body", false) + + @Test + fun failedRoomCreationRetriesSameMessageBeforeAdvancing() = runBlocking { + val handled = mutableSetOf() + val attempts = mutableListOf() + val delays = mutableListOf() + var failures = 2 + BackfillRunner( + isHandled = { it in handled }, + markHandled = { handled.add(it); Unit }, + send = { + attempts.add(it.id) + if (failures-- > 0) Result.failure(RoomCreationError(IllegalStateException("rate limited"), MsgStatus.CANNOT_CREATE_ROOM)) + else Result.success(Unit) + }, + waitBeforeRetry = { delays.add(it); Unit } + ).run(listOf(message("sms:1"), message("sms:2"))) + assertEquals(listOf("sms:1", "sms:1", "sms:1", "sms:2"), attempts) + assertEquals(listOf(1000L, 2000L), delays) + assertEquals(setOf("sms:1", "sms:2"), handled) + } + + @Test + fun restartSkipsPersistedMessagesAndRetainsIdenticalTextsWithDifferentIds() = runBlocking { + val handled = mutableSetOf() + val attempts = mutableListOf() + val messages = listOf(message("sms:1"), message("sms:2"), message("mms:1")) + fun runner(stop: Boolean) = BackfillRunner( + isHandled = { it in handled }, + markHandled = { handled.add(it); Unit }, + send = { + if (stop && it.id == "sms:2") throw CancellationException() + attempts.add(it.id) + Result.success(Unit) + } + ) + try { + runner(true).run(messages) + fail("Import should stop") + } catch (_: CancellationException) { } + assertEquals(setOf("sms:1"), handled) + runner(false).run(messages) + assertEquals(listOf("sms:1", "sms:2", "mms:1"), attempts) + } + + @Test + fun cancellationReturnedAsFailureIsNotRetriedOrMarkedHandled() = runBlocking { + var marked = false + BackfillRunner( + isHandled = { false }, markHandled = { marked = true }, + send = { Result.failure(CancellationException()) }, + waitBeforeRetry = { fail("Cancellation must not be retried") } + ).let { + try { it.run(listOf(message("sms:1"))); fail("Must propagate cancellation") } + catch (_: CancellationException) { } + } + assertFalse(marked) + } + + @Test + fun cancellationDuringRetryLeavesImportIncomplete() = runBlocking { + var finished = false + var marked = false + try { + BackfillRunner( + isHandled = { false }, markHandled = { marked = true }, + send = { Result.failure(IllegalStateException("room unavailable")) }, + waitBeforeRetry = { throw CancellationException() } + ).run(listOf(message("sms:1"))) + finished = true + } catch (_: CancellationException) { } + assertFalse(finished) + assertFalse(marked) + } + + @Test + fun thrownFailureIsRetriedWithCappedBackoffAndNoDelayAfterSuccess() = runBlocking { + var attempts = 0 + val delays = mutableListOf() + BackfillRunner( + isHandled = { false }, markHandled = { }, + send = { if (++attempts <= 9) throw IllegalStateException(); Result.success(Unit) }, + waitBeforeRetry = { delays.add(it); Unit } + ).run(listOf(message("sms:1"))) + assertEquals(listOf(1000L, 2000L, 4000L, 8000L, 16000L, 32000L, 60000L, 60000L, 60000L), delays) + } + + @Test + fun checkpointFailureStopsImportInsteadOfResendingQueuedMessage() = runBlocking { + var sends = 0 + try { + BackfillRunner( + isHandled = { false }, markHandled = { throw IllegalStateException("disk full") }, + send = { sends++; Result.success(Unit) }, + waitBeforeRetry = { fail("Must not resend after a checkpoint failure") } + ).run(listOf(message("sms:1"), message("sms:2"))) + fail("Import must remain incomplete") + } catch (_: IllegalStateException) { } + assertEquals(1, sends) + } + @Test + fun cancellationWrappedByRoomCreationIsPropagated() = runBlocking { + try { + BackfillRunner( + isHandled = { false }, markHandled = { fail("Must not mark cancelled message") }, + send = { Result.failure(RoomCreationError(CancellationException(), MsgStatus.CANNOT_CREATE_ROOM)) }, + waitBeforeRetry = { fail("Must not retry cancellation") } + ).run(listOf(message("sms:1"))) + fail("Must propagate cancellation") + } catch (_: CancellationException) { } + } + +}