Merge pull request #998 from session-foundation/release/1.21.0

Release/1.21.0

app/src/main/java/org/thoughtcrime/securesms/ApplicationContext.java

@@ -347,13 +347,9 @@ public class ApplicationContext extends Application implements DefaultLifecycleO
             return;
         }
 
-        ThreadUtils.queue(()->{
-            if (poller != null) {
-                poller.setCaughtUp(false);
-            }
-
         startPollingIfNeeded();
 
+        ThreadUtils.queue(()->{
             OpenGroupManager.INSTANCE.startPolling();
             return Unit.INSTANCE;
         });
@@ -469,8 +465,10 @@ public class ApplicationContext extends Application implements DefaultLifecycleO
     private void setUpPollingIfNeeded() {
         String userPublicKey = textSecurePreferences.getLocalNumber();
         if (userPublicKey == null) return;
+        if(poller == null) {
             poller = new Poller(configFactory, storage, lokiAPIDatabase);
         }
+    }
 
     public void startPollingIfNeeded() {
         setUpPollingIfNeeded();

app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationViewModel.kt

@@ -203,11 +203,11 @@ class ConversationViewModel(
         }
 
     val showOptionsMenu: Boolean
-        get() = !isMessageRequestThread && !isDeprecatedLegacyGroup && !isKickedGroupV2Thread
+        get() = !isMessageRequestThread && !isDeprecatedLegacyGroup && !isInactiveGroupV2Thread
 
-    private val isKickedGroupV2Thread: Boolean
+    private val isInactiveGroupV2Thread: Boolean
         get() = recipient?.isGroupV2Recipient == true &&
-                configFactory.getGroup(AccountId(recipient!!.address.toString()))?.kicked == true
+                configFactory.getGroup(AccountId(recipient!!.address.toString()))?.shouldPoll == false
 
     private val isDeprecatedLegacyGroup: Boolean
         get() = recipient?.isLegacyGroupRecipient == true && legacyGroupDeprecationManager.isDeprecated

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

@@ -13,8 +13,6 @@ import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.supervisorScope
-import org.session.libsession.database.StorageProtocol
-import org.session.libsession.messaging.groups.GroupManagerV2
 import org.session.libsession.messaging.jobs.BatchMessageReceiveJob
 import org.session.libsession.messaging.jobs.JobQueue
 import org.session.libsession.messaging.jobs.MessageReceiveParameters
@@ -22,6 +20,7 @@ import org.session.libsession.messaging.messages.Destination
 import org.session.libsession.snode.RawResponse
 import org.session.libsession.snode.SnodeAPI
 import org.session.libsession.snode.SnodeClock
+import org.session.libsession.snode.model.BatchResponse
 import org.session.libsession.snode.model.RetrieveMessageResponse
 import org.session.libsession.utilities.ConfigFactoryProtocol
 import org.session.libsession.utilities.ConfigMessage
@@ -33,6 +32,7 @@ import org.session.libsignal.utilities.Log
 import org.session.libsignal.utilities.Namespace
 import org.session.libsignal.utilities.Snode
 import org.thoughtcrime.securesms.util.AppVisibilityManager
+import org.thoughtcrime.securesms.util.getRootCause
 import java.time.Instant
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Duration.Companion.days
@@ -41,8 +41,6 @@ class GroupPoller(
     scope: CoroutineScope,
     private val groupId: AccountId,
     private val configFactoryProtocol: ConfigFactoryProtocol,
-    private val groupManagerV2: GroupManagerV2,
-    private val storage: StorageProtocol,
     private val lokiApiDatabase: LokiAPIDatabaseProtocol,
     private val clock: SnodeClock,
     private val appVisibilityManager: AppVisibilityManager,
@@ -50,6 +48,7 @@ class GroupPoller(
 ) {
     companion object {
         private const val POLL_INTERVAL = 3_000L
+        private const val SWARM_FETCH_INTERVAL = 1800_000L // Every 30 minutes
 
         private const val TAG = "GroupPoller"
     }
@@ -73,9 +72,16 @@ class GroupPoller(
     }
 
     private class InternalPollState(
-        var swarmNodes: MutableSet<Snode> = mutableSetOf(),
+        // The nodes for current swarm
-        var currentSnode: Snode? = null,
+        var swarmNodes: Set<Snode> = emptySet(),
-    )
+
+        // The pool of snodes that are currently being used for polling
+        val pollPool: MutableSet<Snode> = hashSetOf()
+    ) {
+        fun shouldFetchSwarmNodes(): Boolean {
+            return swarmNodes.isEmpty()
+        }
+    }
 
     // A channel to send tokens to trigger a poll
     private val pollOnceTokens = Channel<PollOnceToken>()
@@ -162,20 +168,34 @@ class GroupPoller(
         val pollStartedAt = Instant.now()
         var groupExpired: Boolean? = null
 
+        var currentSnode: Snode? = null
+
         val result = runCatching {
             supervisorScope {
-                // Grab current snode or pick (and remove) a random one from the pool
+                // Fetch snodes if we don't have any
-                val snode = pollState.currentSnode ?: run {
+                val swarmNodes = if (pollState.shouldFetchSwarmNodes()) {
-                    if (pollState.swarmNodes.isEmpty()) {
                     Log.d(TAG, "Fetching swarm nodes for $groupId")
-                        pollState.swarmNodes.addAll(SnodeAPI.fetchSwarmNodes(groupId.hexString))
+                    val fetched = SnodeAPI.fetchSwarmNodes(groupId.hexString).toSet()
+                    pollState.swarmNodes = fetched
+                    fetched
+                } else {
+                    pollState.swarmNodes
                 }
 
-                    check(pollState.swarmNodes.isNotEmpty()) { "No swarm nodes found" }
+                // Ensure we have at least one snode
-                    pollState.swarmNodes.random().also {
+                check(swarmNodes.isNotEmpty()) {
-                        pollState.currentSnode = it
+                    "No swarm nodes found for $groupId"
-                        pollState.swarmNodes.remove(it)
                 }
+
+                // Fill the pool if it's empty
+                if (pollState.pollPool.isEmpty()) {
+                    pollState.pollPool.addAll(swarmNodes)
+                }
+
+                // Take a random snode from the pool
+                val snode = pollState.pollPool.random().also {
+                    pollState.pollPool.remove(it)
+                    currentSnode = it
                 }
 
                 val groupAuth =
@@ -241,7 +261,7 @@ class GroupPoller(
                         Namespace.GROUP_MESSAGES()
                     ).orEmpty()
 
-                    Log.d(TAG, "Retrieving group message since lastHash = $lastHash")
+                    Log.v(TAG, "Retrieving group($groupId) message since lastHash = $lastHash, snode = ${snode.publicKeySet}")
 
                     SnodeAPI.sendBatchRequest(
                         snode = snode,
@@ -331,9 +351,18 @@ class GroupPoller(
             val error = result.exceptionOrNull()
             Log.e(TAG, "Error polling group", error)
 
-            if (error !is NonRetryableException && error !is CancellationException) {
+            // Find if any exception throws in the process has a root cause of a node returning bad response,
-                // If the error can be retried, reset the current snode so we use another one
+            // then we will remove this snode from our swarm nodes set
-                pollState.currentSnode = null
+            if (error != null && currentSnode != null) {
+                val badResponse = (sequenceOf(error) + error.suppressedExceptions.asSequence())
+                    .firstOrNull { err ->
+                        err.getRootCause<BatchResponse.Error>()?.item?.let { it.isServerError || it.isSnodeNoLongerPartOfSwarm } == true
+                    }
+
+                if (badResponse != null) {
+                    Log.e(TAG, "Group polling failed due to a server error", badResponse)
+                    pollState.swarmNodes -= currentSnode!!
+                }
             }
         }
 
@@ -344,8 +373,6 @@ class GroupPoller(
             groupExpired = groupExpired
         )
 
-        Log.d(TAG, "Polling group $groupId result = $pollResult")
-
         return pollResult
     }
 

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

@@ -54,8 +54,6 @@ import javax.inject.Singleton
 @Singleton
 class GroupPollerManager @Inject constructor(
     configFactory: ConfigFactory,
-    groupManagerV2: Lazy<GroupManagerV2>,
-    storage: StorageProtocol,
     lokiApiDatabase: LokiAPIDatabaseProtocol,
     clock: SnodeClock,
     preferences: TextSecurePreferences,
@@ -113,8 +111,6 @@ class GroupPollerManager @Inject constructor(
                                 scope = scope,
                                 groupId = groupId,
                                 configFactoryProtocol = configFactory,
-                                groupManagerV2 = groupManagerV2.get(),
-                                storage = storage,
                                 lokiApiDatabase = lokiApiDatabase,
                                 clock = clock,
                                 appVisibilityManager = appVisibilityManager,

app/src/main/java/org/thoughtcrime/securesms/notifications/OptimizedMessageNotifier.java

@@ -52,7 +52,7 @@ public class OptimizedMessageNotifier implements MessageNotifier {
     Poller poller = ApplicationContext.getInstance(context).poller;
     boolean isCaughtUp = true;
     if (poller != null) {
-      isCaughtUp = isCaughtUp && poller.isCaughtUp();
+      isCaughtUp = isCaughtUp && !poller.isPolling();
     }
 
     isCaughtUp = isCaughtUp && OpenGroupManager.INSTANCE.isAllCaughtUp();
@@ -69,7 +69,7 @@ public class OptimizedMessageNotifier implements MessageNotifier {
     Poller lokiPoller = ApplicationContext.getInstance(context).poller;
     boolean isCaughtUp = true;
     if (lokiPoller != null) {
-      isCaughtUp = isCaughtUp && lokiPoller.isCaughtUp();
+      isCaughtUp = isCaughtUp && !lokiPoller.isPolling();
     }
 
     isCaughtUp = isCaughtUp && OpenGroupManager.INSTANCE.isAllCaughtUp();
@@ -86,7 +86,7 @@ public class OptimizedMessageNotifier implements MessageNotifier {
     Poller lokiPoller = ApplicationContext.getInstance(context).poller;
     boolean isCaughtUp = true;
     if (lokiPoller != null) {
-      isCaughtUp = isCaughtUp && lokiPoller.isCaughtUp();
+      isCaughtUp = isCaughtUp && !lokiPoller.isPolling();
     }
 
     isCaughtUp = isCaughtUp && OpenGroupManager.INSTANCE.isAllCaughtUp();
@@ -103,7 +103,7 @@ public class OptimizedMessageNotifier implements MessageNotifier {
     Poller lokiPoller = ApplicationContext.getInstance(context).poller;
     boolean isCaughtUp = true;
     if (lokiPoller != null) {
-      isCaughtUp = isCaughtUp && lokiPoller.isCaughtUp();
+      isCaughtUp = isCaughtUp && !lokiPoller.isPolling();
     }
 
     isCaughtUp = isCaughtUp && OpenGroupManager.INSTANCE.isAllCaughtUp();

app/src/main/java/org/thoughtcrime/securesms/util/ThrowableUtil.kt

@@ -0,0 +1,21 @@
+package org.thoughtcrime.securesms.util
+
+/**
+ * Walk the cause chain of this throwable. This chain includes itself as the first element.
+ */
+fun Throwable.causes(): Sequence<Throwable> = sequence {
+    var current: Throwable? = this@causes
+    while (current != null) {
+        yield(current)
+        current = current.cause
+    }
+}
+
+/**
+ * Find out if this throwable as a root cause of the specified type, if so return it.
+ */
+inline fun <reified E: Throwable> Throwable.getRootCause(): E? {
+    return causes()
+        .filterIsInstance<E>()
+        .firstOrNull()
+}

app/src/main/res/layout/view_input_bar.xml

@@ -49,7 +49,7 @@
             android:hint="@string/message"
             android:textColorHint="?attr/input_bar_text_hint"
             android:textColor="?input_bar_text_user"
-            android:textSize="@dimen/small_font_size" />
+            android:textSize="@dimen/medium_font_size" />
 
         <RelativeLayout
             android:id="@+id/microphoneOrSendButtonContainer"

libsession-util/src/main/cpp/CMakeLists.txt

@@ -37,6 +37,7 @@ set(SOURCES
         group_keys.cpp
         group_info.cpp
         config_common.cpp
+        logging.cpp
 )
 
 add_library( # Sets the name of the library.
@@ -65,6 +66,7 @@ find_library( # Sets the name of the path variable.
 target_link_libraries( # Specifies the target library.
         session_util
         PUBLIC
+        libsession::util
         libsession::config
         libsession::crypto
         libsodium::sodium-internal

libsession-util/src/main/cpp/logging.cpp

@@ -0,0 +1,47 @@
+#include <jni.h>
+#include <android/log.h>
+#include <string_view>
+#include <functional>
+
+#include "session/logging.hpp"
+#include "session/log_level.h"
+
+#define LOG_TAG "LibSession"
+
+extern "C" JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_util_Logger_initLogger(JNIEnv* env, jclass clazz) {
+    session::add_logger([](std::string_view msg, std::string_view category, session::LogLevel level) {
+        android_LogPriority prio = ANDROID_LOG_VERBOSE;
+
+        switch (level.level) {
+            case LOG_LEVEL_TRACE:
+                prio = ANDROID_LOG_VERBOSE;
+                break;
+
+            case LOG_LEVEL_DEBUG:
+                prio = ANDROID_LOG_DEBUG;
+                break;
+
+            case LOG_LEVEL_INFO:
+                prio = ANDROID_LOG_INFO;
+                break;
+
+            case LOG_LEVEL_WARN:
+                prio = ANDROID_LOG_WARN;
+                break;
+
+            case LOG_LEVEL_ERROR:
+            case LOG_LEVEL_CRITICAL:
+                prio = ANDROID_LOG_ERROR;
+                break;
+
+            default:
+                prio = ANDROID_LOG_INFO;
+                break;
+        }
+
+        __android_log_print(prio, LOG_TAG, "%.*s [%.*s]",
+                    static_cast<int>(msg.size()), msg.data(),
+                    static_cast<int>(category.size()), category.data());
+});
+}

libsession-util/src/main/java/network/loki/messenger/libsession_util/util/Logger.kt

@@ -0,0 +1,11 @@
+package network.loki.messenger.libsession_util.util
+
+object Logger {
+
+    init {
+        System.loadLibrary("session_util")
+    }
+
+    @JvmStatic
+    external fun initLogger()
+}

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/pollers/Poller.kt

@@ -2,6 +2,7 @@ package org.session.libsession.messaging.sending_receiving.pollers
 
 import android.util.SparseArray
 import androidx.core.util.valueIterator
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import network.loki.messenger.libsession_util.ConfigBase
@@ -13,6 +14,11 @@ import java.util.Timer
 import java.util.TimerTask
 import kotlin.time.Duration.Companion.days
 import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
 import nl.komponents.kovenant.Deferred
 import nl.komponents.kovenant.Promise
 import nl.komponents.kovenant.deferred
@@ -26,8 +32,12 @@ import org.session.libsession.messaging.jobs.JobQueue
 import org.session.libsession.messaging.jobs.MessageReceiveParameters
 import org.session.libsession.snode.RawResponse
 import org.session.libsession.snode.SnodeAPI
+import org.session.libsession.snode.SnodeAPI.KEY_BODY
+import org.session.libsession.snode.SnodeAPI.KEY_CODE
+import org.session.libsession.snode.SnodeAPI.KEY_RESULTS
 import org.session.libsession.snode.SnodeModule
 import org.session.libsession.snode.utilities.asyncPromise
+import org.session.libsession.snode.utilities.await
 import org.session.libsession.utilities.ConfigFactoryProtocol
 import org.session.libsession.utilities.ConfigMessage
 import org.session.libsession.utilities.UserConfigType
@@ -40,8 +50,6 @@ import org.session.libsignal.utilities.Util.SECURE_RANDOM
 
 private const val TAG = "Poller"
 
-private class PromiseCanceledException : Exception("Promise canceled.")
-
 class Poller(
     private val configFactory: ConfigFactoryProtocol,
     private val storage: StorageProtocol,
@@ -50,9 +58,9 @@ class Poller(
     private val userPublicKey: String
         get() = storage.getUserPublicKey().orEmpty()
 
-    private var hasStarted: Boolean = false
+    var scope: CoroutineScope? = null
-    private val usedSnodes: MutableSet<Snode> = mutableSetOf()
+
-    var isCaughtUp = false
+    var isPolling: Boolean = false
 
     // region Settings
     companion object {
@@ -64,25 +72,26 @@ class Poller(
 
     // region Public API
     fun startIfNeeded() {
-        if (hasStarted) { return }
+        if (scope != null) { return }
+
         Log.d(TAG, "Started polling.")
-        hasStarted = true
+        scope = CoroutineScope(Dispatchers.Default)
-        setUpPolling(RETRY_INTERVAL_MS)
+        scope?.launch {
+            setUpPolling()
+        }
     }
 
     fun stopIfNeeded() {
         Log.d(TAG, "Stopped polling.")
-        hasStarted = false
+        scope?.cancel()
-        usedSnodes.clear()
+        scope = null
+        isPolling = false
     }
 
     fun retrieveUserProfile() {
         Log.d(TAG, "Retrieving user profile. for key = $userPublicKey")
-        SnodeAPI.getSwarm(userPublicKey).bind {
+        SnodeAPI.getSwarm(userPublicKey).success {
-            usedSnodes.clear()
+            pollUserProfile(it.random())
-            deferred<Unit, Exception>().also { exception ->
-                pollNextSnode(userProfileOnly = true, exception)
-            }.promise
         }.fail { exception ->
             Log.e(TAG, "Failed to retrieve user profile.", exception)
         }
@@ -90,51 +99,41 @@ class Poller(
     // endregion
 
     // region Private API
-    private fun setUpPolling(delay: Long) {
+    private suspend fun setUpPolling() {
-        if (!hasStarted) { return; }
+        val pollPool = hashSetOf<Snode>() // pollPool is the list of snodes we can use while rotating snodes from our swarm
-        val thread = Thread.currentThread()
+        var retryScalingFactor = 1.0f // We increment the retry interval by NEXT_RETRY_MULTIPLIER times this value, which we bump on each failure
-        SnodeAPI.getSwarm(userPublicKey).bind {
+
-            usedSnodes.clear()
+        while(true){
-            val deferred = deferred<Unit, Exception>()
+            Log.d(TAG, "Polling...")
-            pollNextSnode(deferred = deferred)
+
-            deferred.promise
+            isPolling = true
-        }.success {
+
-            val nextDelay = if (isCaughtUp) RETRY_INTERVAL_MS else 0
+            // check if the polling pool is empty
-            Timer().schedule(object : TimerTask() {
+            if(pollPool.isEmpty()){
-                override fun run() {
+                // if it is empty, fill it with the snodes from our swarm
-                    thread.run { setUpPolling(RETRY_INTERVAL_MS) }
+                pollPool.addAll(SnodeAPI.getSwarm(userPublicKey).await())
-                }
-            }, nextDelay)
-        }.fail {
-            val nextDelay = minOf(MAX_RETRY_INTERVAL_MS, (delay * NEXT_RETRY_MULTIPLIER).toLong())
-            Timer().schedule(object : TimerTask() {
-                override fun run() {
-                    thread.run { setUpPolling(nextDelay) }
-                }
-            }, nextDelay)
-        }
-    }
-
-    private fun pollNextSnode(userProfileOnly: Boolean = false, deferred: Deferred<Unit, Exception>) {
-        val swarm = SnodeModule.shared.storage.getSwarm(userPublicKey) ?: setOf()
-        val unusedSnodes = swarm.subtract(usedSnodes)
-        if (unusedSnodes.isNotEmpty()) {
-            val index = SECURE_RANDOM.nextInt(unusedSnodes.size)
-            val nextSnode = unusedSnodes.elementAt(index)
-            usedSnodes.add(nextSnode)
-            Log.d(TAG, "Polling $nextSnode.")
-            poll(userProfileOnly, nextSnode, deferred).fail { exception ->
-                if (exception is PromiseCanceledException) {
-                    Log.d(TAG, "Polling $nextSnode canceled.")
-                } else {
-                    Log.d(TAG, "Polling $nextSnode failed; dropping it and switching to next snode.")
-                    SnodeAPI.dropSnodeFromSwarmIfNeeded(nextSnode, userPublicKey)
-                    pollNextSnode(userProfileOnly, deferred)
             }
+
+            // randomly get a snode from the pool
+            val currentNode = pollPool.random()
+
+            // remove that snode from the pool
+            pollPool.remove(currentNode)
+
+            var pollDelay = RETRY_INTERVAL_MS
+            try {
+                poll(currentNode)
+                retryScalingFactor = 1f
+            } catch (e: Exception){
+                Log.e(TAG, "Error while polling:", e)
+                pollDelay = minOf(MAX_RETRY_INTERVAL_MS, (RETRY_INTERVAL_MS * (NEXT_RETRY_MULTIPLIER * retryScalingFactor)).toLong())
+                retryScalingFactor++
+            } finally {
+                isPolling = false
             }
-        } else {
+
-            isCaughtUp = true
+            // wait before polling again
-            deferred.resolve()
+            delay(pollDelay)
         }
     }
 
@@ -184,14 +183,8 @@ class Poller(
         }
     }
 
-    private fun poll(userProfileOnly: Boolean, snode: Snode, deferred: Deferred<Unit, Exception>): Promise<Unit, Exception> {
+    //todo we will need to modify this further to fit within the new coroutine setup (currently used by ApplicationContext which is a java class)
-        if (userProfileOnly) {
+    private fun pollUserProfile(snode: Snode) {
-            return pollUserProfile(snode, deferred)
-        }
-        return poll(snode, deferred)
-    }
-
-    private fun pollUserProfile(snode: Snode, deferred: Deferred<Unit, Exception>): Promise<Unit, Exception> = GlobalScope.asyncPromise {
         val requests = mutableListOf<SnodeAPI.SnodeBatchRequestInfo>()
         val hashesToExtend = mutableSetOf<String>()
         val userAuth = requireNotNull(MessagingModuleConfiguration.shared.storage.userAuth)
@@ -224,14 +217,13 @@ class Poller(
 
         if (requests.isNotEmpty()) {
             SnodeAPI.getRawBatchResponse(snode, userPublicKey, requests).bind { rawResponses ->
-                isCaughtUp = true
+
-                if (!deferred.promise.isDone()) {
+                val responseList = (rawResponses[KEY_RESULTS] as List<RawResponse>)
-                    val responseList = (rawResponses["results"] as List<RawResponse>)
                 responseList.getOrNull(0)?.let { rawResponse ->
-                        if (rawResponse["code"] as? Int != 200) {
+                    if (rawResponse[KEY_CODE] as? Int != 200) {
-                            Log.e(TAG, "Batch sub-request had non-200 response code, returned code ${(rawResponse["code"] as? Int) ?: "[unknown]"}")
+                        Log.e(TAG, "Batch sub-request had non-200 response code, returned code ${(rawResponse[KEY_CODE] as? Int) ?: "[unknown]"}")
                     } else {
-                            val body = rawResponse["body"] as? RawResponse
+                        val body = rawResponse[KEY_BODY] as? RawResponse
                         if (body == null) {
                             Log.e(TAG, "Batch sub-request didn't contain a body")
                         } else {
@@ -239,7 +231,7 @@ class Poller(
                         }
                     }
                 }
-                }
+
                 Promise.ofSuccess(Unit)
             }.fail {
                 Log.e(TAG, "Failed to get raw batch response", it)
@@ -247,10 +239,7 @@ class Poller(
         }
     }
 
-
+    private suspend fun poll(snode: Snode) {
-    private fun poll(snode: Snode, deferred: Deferred<Unit, Exception>): Promise<Unit, Exception> {
-        if (!hasStarted) { return Promise.ofFail(PromiseCanceledException()) }
-        return GlobalScope.asyncPromise {
         val userAuth = requireNotNull(MessagingModuleConfiguration.shared.storage.userAuth)
         val requestSparseArray = SparseArray<SnodeAPI.SnodeBatchRequestInfo>()
         // get messages
@@ -290,8 +279,7 @@ class Poller(
             requestSparseArray[namespace] = request
         }
 
-            val requests =
+        val requests = requestSparseArray.valueIterator().asSequence().toMutableList()
-                requestSparseArray.valueIterator().asSequence().toMutableList()
 
         if (hashesToExtend.isNotEmpty()) {
             SnodeAPI.buildAuthenticatedAlterTtlBatchRequest(
@@ -305,12 +293,8 @@ class Poller(
         }
 
         if (requests.isNotEmpty()) {
-                SnodeAPI.getRawBatchResponse(snode, userPublicKey, requests).bind { rawResponses ->
+            val rawResponses = SnodeAPI.getRawBatchResponse(snode, userPublicKey, requests).await()
-                    isCaughtUp = true
+            val responseList = (rawResponses[KEY_RESULTS] as List<RawResponse>)
-                    if (deferred.promise.isDone()) {
-                        return@bind Promise.ofSuccess(Unit)
-                    } else {
-                        val responseList = (rawResponses["results"] as List<RawResponse>)
             // in case we had null configs, the array won't be fully populated
             // index of the sparse array key iterator should be the request index, with the key being the namespace
             UserConfigType.entries
@@ -318,11 +302,11 @@ class Poller(
                 .filter { (_, i) -> i >= 0 }
                 .forEach { (configType, requestIndex) ->
                     responseList.getOrNull(requestIndex)?.let { rawResponse ->
-                                    if (rawResponse["code"] as? Int != 200) {
+                        if (rawResponse[KEY_CODE] as? Int != 200) {
-                                        Log.e(TAG, "Batch sub-request had non-200 response code, returned code ${(rawResponse["code"] as? Int) ?: "[unknown]"}")
+                            Log.e(TAG, "Batch sub-request had non-200 response code, returned code ${(rawResponse[KEY_CODE] as? Int) ?: "[unknown]"}")
                             return@forEach
                         }
-                                    val body = rawResponse["body"] as? RawResponse
+                        val body = rawResponse[KEY_BODY] as? RawResponse
                         if (body == null) {
                             Log.e(TAG, "Batch sub-request didn't contain a body")
                             return@forEach
@@ -336,31 +320,21 @@ class Poller(
             val personalResponseIndex = requestSparseArray.indexOfKey(Namespace.DEFAULT())
             if (personalResponseIndex >= 0) {
                 responseList.getOrNull(personalResponseIndex)?.let { rawResponse ->
-                                if (rawResponse["code"] as? Int != 200) {
+                    if (rawResponse[KEY_CODE] as? Int != 200) {
-                                    Log.e(TAG, "Batch sub-request for personal messages had non-200 response code, returned code ${(rawResponse["code"] as? Int) ?: "[unknown]"}")
+                        // If we got a non-success response then the snode might be bad
-                                    // If we got a non-success response then the snode might be bad so we should try rotate
+                        throw(RuntimeException("Batch sub-request for personal messages had non-200 response code, returned code ${(rawResponse[KEY_CODE] as? Int) ?: "[unknown]"}"))
-                                    // to a different one just in case
-                                    pollNextSnode(deferred = deferred)
-                                    return@bind Promise.ofSuccess(Unit)
                     } else {
-                                    val body = rawResponse["body"] as? RawResponse
+                        val body = rawResponse[KEY_BODY] as? RawResponse
                         if (body == null) {
-                                        Log.e(TAG, "Batch sub-request for personal messages didn't contain a body")
+                            throw(RuntimeException("Batch sub-request for personal messages didn't contain a body"))
                         } else {
                             processPersonalMessages(snode, body)
                         }
                     }
                 }
-                        }
+            } else {
-
+                throw(SnodeAPI.Error.Generic)
-                        poll(snode, deferred)
-                    }
-                }.fail {
-                    Log.e(TAG, "Failed to get raw batch response", it)
-                    poll(snode, deferred)
-                }
             }
         }
     }
-    // endregion
 }

libsession/src/main/java/org/session/libsession/snode/SnodeAPI.kt

@@ -4,6 +4,8 @@ package org.session.libsession.snode
 
 import android.os.SystemClock
 import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.node.NullNode
+import com.fasterxml.jackson.databind.node.TextNode
 import com.goterl.lazysodium.exceptions.SodiumException
 import com.goterl.lazysodium.interfaces.GenericHash
 import com.goterl.lazysodium.interfaces.PwHash
@@ -94,6 +96,9 @@ object SnodeAPI {
     private const val snodeFailureThreshold = 3
     private const val useOnionRequests = true
 
+    const val KEY_BODY = "body"
+    const val KEY_CODE = "code"
+    const val KEY_RESULTS = "results"
     private const val KEY_IP = "public_ip"
     private const val KEY_PORT = "storage_port"
     private const val KEY_X25519 = "pubkey_x25519"
@@ -575,14 +580,14 @@ object SnodeAPI {
             parameters,
             publicKey
         ).success { rawResponses ->
-            rawResponses["results"].let { it as List<RawResponse> }
+            rawResponses[KEY_RESULTS].let { it as List<RawResponse> }
                 .asSequence()
-                .filter { it["code"] as? Int != 200 }
+                .filter { it[KEY_CODE] as? Int != 200 }
                 .forEach { response ->
                     Log.w("Loki", "response code was not 200")
                     handleSnodeError(
-                        response["code"] as? Int ?: 0,
+                        response[KEY_CODE] as? Int ?: 0,
-                        response["body"] as? Map<*, *>,
+                        response[KEY_BODY] as? Map<*, *>,
                         snode,
                         publicKey
                     )
@@ -657,8 +662,8 @@ object SnodeAPI {
                         // back through the request's callback.
                         for ((req, resp) in batch.zip(responses.results)) {
                             val result = runCatching {
-                                check(resp.code == 200) {
+                                if (!resp.isSuccessful) {
-                                    "Error calling \"${req.request.method}\" with code = ${resp.code}, msg = ${resp.body}"
+                                    throw BatchResponse.Error(resp)
                                 }
 
                                 JsonUtil.fromJson(resp.body, req.responseType)
@@ -899,7 +904,7 @@ object SnodeAPI {
             val deletedMessages = swarms.mapValuesNotNull { (hexSnodePublicKey, rawJSON) ->
                 (rawJSON as? Map<String, Any>)?.let { json ->
                     val isFailed = json["failed"] as? Boolean ?: false
-                    val statusCode = json["code"] as? String
+                    val statusCode = json[KEY_CODE] as? String
                     val reason = json["reason"] as? String
 
                     if (isFailed) {
@@ -1070,7 +1075,7 @@ object SnodeAPI {
             val json = rawJSON as? Map<String, Any> ?: return@mapValuesNotNull null
             if (json["failed"] as? Boolean == true) {
                 val reason = json["reason"] as? String
-                val statusCode = json["code"] as? String
+                val statusCode = json[KEY_CODE] as? String
                 Log.e("Loki", "Failed to delete all messages from: $hexSnodePublicKey due to error: $reason ($statusCode).")
                 false
             } else {

libsession/src/main/java/org/session/libsession/snode/model/BatchResponse.kt

@@ -13,5 +13,20 @@ data class BatchResponse @JsonCreator constructor(
     ) {
         val isSuccessful: Boolean
             get() = code in 200..299
+
+        val isServerError: Boolean
+            get() = code in 500..599
+
+        val isSnodeNoLongerPartOfSwarm: Boolean
+            get() = code == 421
+    }
+
+    data class Error(val item: Item)
+        : RuntimeException("Batch request failed with code ${item.code}") {
+        init {
+            require(!item.isSuccessful) {
+                "This response item does not represent an error state"
+            }
+        }
     }
 }