Cleaned up the poller logic a bit

SessionMessagingKit/Sending & Receiving/Pollers/ClosedGroupPoller.swift

@@ -184,31 +184,21 @@ public final class ClosedGroupPoller {
                             guard isBackgroundPoll || poller?.isPolling.wrappedValue[groupPublicKey] == true else { return Promise.value(()) }
                             
                             var promises: [Promise<Void>] = []
-                            var messageCount: Int = 0
-                            let totalMessagesCount: Int = messageResults
-                                .map { result -> Int in
-                                    switch result {
-                                        case .fulfilled(let messages): return messages.count
-                                        default: return 0
+                            let allMessages: [SnodeReceivedMessage] = messageResults
+                                .reduce([]) { result, next in
+                                    switch next {
+                                        case .fulfilled(let messages): return result.appending(contentsOf: messages)
+                                        default: return result
                                     }
                                 }
-                                .reduce(0, +)
-                            
-                            messageResults.forEach { result in
-                                guard case .fulfilled(let messages) = result else { return }
-                                guard !messages.isEmpty else { return }
-                                
-                                var jobToRun: Job?
+                            var messageCount: Int = 0
+                            let totalMessagesCount: Int = allMessages.count
                             
                             Storage.shared.write { db in
-                                    var jobDetailMessages: [MessageReceiveJob.Details.MessageInfo] = []
-                                    
-                                    messages.forEach { message in
+                                let processedMessages: [ProcessedMessage] = allMessages
+                                    .compactMap { message -> ProcessedMessage? in
                                         do {
-                                            let processedMessage: ProcessedMessage? = try Message.processRawReceivedMessage(db, rawMessage: message)
-                                            
-                                            jobDetailMessages = jobDetailMessages
-                                                .appending(processedMessage?.messageInfo)
+                                            return try Message.processRawReceivedMessage(db, rawMessage: message)
                                         }
                                         catch {
                                             switch error {
@@ -222,16 +212,19 @@ public final class ClosedGroupPoller {
 
                                                 default: SNLog("Failed to deserialize envelope due to error: \(error).")
                                             }
+
+                                            return nil
                                         }
                                     }
                                 
-                                    messageCount += jobDetailMessages.count
-                                    jobToRun = Job(
+                                messageCount = processedMessages.count
+                                
+                                let jobToRun: Job? = Job(
                                     variant: .messageReceive,
                                     behaviour: .runOnce,
                                     threadId: groupPublicKey,
                                     details: MessageReceiveJob.Details(
-                                            messages: jobDetailMessages,
+                                        messages: processedMessages.map { $0.messageInfo },
                                         isBackgroundPoll: isBackgroundPoll
                                     )
                                 )
@@ -239,7 +232,6 @@ public final class ClosedGroupPoller {
                                 // If we are force-polling then add to the JobRunner so they are persistent and will retry on
                                 // the next app run if they fail but don't let them auto-start
                                 JobRunner.add(db, job: jobToRun, canStartJob: !isBackgroundPoll)
-                                }
 
                                 // We want to try to handle the receive jobs immediately in the background
                                 if isBackgroundPoll {

SessionMessagingKit/Sending & Receiving/Pollers/Poller.swift

@@ -136,15 +136,10 @@ public final class Poller {
                     var messageCount: Int = 0
                     
                     Storage.shared.write { db in
-                        var threadMessages: [String: [MessageReceiveJob.Details.MessageInfo]] = [:]
-                        
-                        messages.forEach { message in
+                        messages
+                            .compactMap { message -> ProcessedMessage? in
                                 do {
-                                let processedMessage: ProcessedMessage? = try Message.processRawReceivedMessage(db, rawMessage: message)
-                                let key: String = (processedMessage?.threadId ?? Message.nonThreadMessageId)
-                                
-                                threadMessages[key] = (threadMessages[key] ?? [])
-                                    .appending(processedMessage?.messageInfo)
+                                    return try Message.processRawReceivedMessage(db, rawMessage: message)
                                 }
                                 catch {
                                     switch error {
@@ -158,14 +153,14 @@ public final class Poller {
 
                                         default: SNLog("Failed to deserialize envelope due to error: \(error).")
                                     }
+                                    
+                                    return nil
                                 }
                             }
+                            .grouped { threadId, _, _ in (threadId ?? Message.nonThreadMessageId) }
+                            .forEach { threadId, threadMessages in
+                                messageCount += threadMessages.count
                                 
-                        messageCount = threadMessages
-                            .values
-                            .reduce(into: 0) { prev, next in prev += next.count }
-                        
-                        threadMessages.forEach { threadId, threadMessages in
                                 JobRunner.add(
                                     db,
                                     job: Job(
@@ -173,7 +168,7 @@ public final class Poller {
                                         behaviour: .runOnce,
                                         threadId: threadId,
                                         details: MessageReceiveJob.Details(
-                                        messages: threadMessages,
+                                            messages: threadMessages.map { $0.messageInfo },
                                             isBackgroundPoll: false
                                         )
                                     )

SessionUtilitiesKit/JobRunner/JobRunner.swift

@@ -688,9 +688,11 @@ private final class JobQueue {
     }
     
     private func scheduleNextSoonestJob() {
+        let jobIdsAlreadyRunning: Set<Int64> = jobsCurrentlyRunning.wrappedValue
         let nextJobTimestamp: TimeInterval? = Storage.shared.read { db in
             try Job.filterPendingJobs(variants: jobVariants, excludeFutureJobs: false)
                 .select(.nextRunTimestamp)
+                .filter(!jobIdsAlreadyRunning.contains(Job.Columns.id)) // Exclude jobs already running
                 .asRequest(of: TimeInterval.self)
                 .fetchOne(db)
         }