@ -8,11 +8,14 @@ import SessionSnodeKit
import SessionUtilitiesKit
public class Poller {
private var timers: Atomic < [ String : Timer ] > = Atomic ( [ : ] )
private var cancellables: Atomic < [ String : AnyCancellable ] > = Atomic ( [ : ] )
internal var isPolling : Atomic < [ String : Bool ] > = Atomic ( [ : ] )
internal var pollCount : Atomic < [ String : Int ] > = Atomic ( [ : ] )
internal var failureCount : Atomic < [ String : Int ] > = Atomic ( [ : ] )
internal var targetSnode : Atomic < Snode ? > = Atomic ( nil )
private var usedSnodes : Atomic < Set < Snode > > = Atomic ( [ ] )
// MARK: - S e t t i n g s
// / T h e n a m e s p a c e s w h i c h t h i s p o l l e r q u e r i e s
@ -20,7 +23,7 @@ public class Poller {
preconditionFailure ( " abstract class - override in subclass " )
}
// / T h e n u m b e r o f t i m e s t h e p o l l e r c a n p o l l e f o r e s w a p p i n g t o a n e w s n o d e
// / T h e n u m b e r o f t i m e s t h e p o l l e r c a n p o l l a s i n g l e s n o d e be f o r e s w a p p i n g t o a n e w s n o d e
internal var maxNodePollCount : UInt {
preconditionFailure ( " abstract class - override in subclass " )
}
@ -39,7 +42,7 @@ public class Poller {
public func stopPolling ( for publicKey : String ) {
isPolling . mutate { $0 [ publicKey ] = false }
timer s. mutate { $0 [ publicKey ] ? . invalidate ( ) }
cancellable s. mutate { $0 [ publicKey ] ? . cancel ( ) }
}
// MARK: - A b s t r a c t M e t h o d s
@ -49,17 +52,13 @@ public class Poller {
preconditionFailure ( " abstract class - override in subclass " )
}
// / C a l c u l a t e t h e d e l a y w h i c h s h o u l d o c c u r b e f o r e t h e n e x t p o l l
internal func nextPollDelay ( for publicKey : String ) -> TimeInterval {
preconditionFailure ( " abstract class - override in subclass " )
}
internal func getSnodeForPolling (
for publicKey : String
) -> AnyPublisher < Snode , Error > {
preconditionFailure ( " abstract class - override in subclass " )
}
internal func handlePollError ( _ error : Error , for publicKey : String , using dependencies : SMKDependencies ) {
// / P e r f o r m a n d l o g i c w h i c h s h o u l d o c c u r w h e n t h e p o l l e r r o r s , w i l l s t o p p o l l i n g i f ` f a l s e ` i s r e t u r n e d
internal func handlePollError ( _ error : Error , for publicKey : String , using dependencies : SMKDependencies ) -> Bool {
preconditionFailure ( " abstract class - override in subclass " )
}
@ -75,48 +74,65 @@ public class Poller {
// a n d t h e t i m e r i s n o t c r e a t e d , i f w e m a r k t h e g r o u p a s i s p o l l i n g
// a f t e r s e t U p P o l l i n g . S o t h e p o l l e r m a y n o t w o r k , t h u s m i s s e s m e s s a g e s
self ? . isPolling . mutate { $0 [ publicKey ] = true }
self ? . setUpPolling ( for : publicKey )
self ? . pollRecursively ( for : publicKey )
}
}
// / W e w a n t t o i n i t i a l l y t r i g g e r a p o l l a g a i n s t t h e t a r g e t s e r v i c e n o d e a n d t h e n r u n t h e r e c u r s i v e p o l l i n g ,
// / i f a n e r r o r i s t h r o w n d u r i n g t h e p o l l t h e n t h i s s h o u l d a u t o m a t i c a l l y r e s t a r t t h e p o l l i n g
internal func setUpPolling (
internal func getSnodeForPolling (
for publicKey : String ,
using dependencies : SMKDependencies = SMKDependencies (
subscribeQueue : Threading . pollerQueue ,
receiveQueue : Threading . pollerQueue
)
) {
guard isPolling . wrappedValue [ publicKey ] = = true else { return }
using dependencies : SMKDependencies = SMKDependencies ( )
) -> AnyPublisher < Snode , Error > {
// I f w e d o n ' t w a n t t o p o l l a s n o d e m u l t i p l e t i m e s t h e n j u s t g r a b a r a n d o m o n e f r o m t h e s w a r m
guard maxNodePollCount > 0 else {
return SnodeAPI . getSwarm ( for : publicKey , using : dependencies )
. tryMap { swarm -> Snode in
try swarm . randomElement ( ) ? ? { throw OnionRequestAPIError . insufficientSnodes } ( )
}
. eraseToAnyPublisher ( )
}
let namespaces : [ SnodeAPI . Namespace ] = self . namespaces
// I f w e a l r e a d y h a v e a t a r g e t s n o d e t h e n u s e t h a t
if let targetSnode : Snode = self . targetSnode . wrappedValue {
return Just ( targetSnode )
. setFailureType ( to : Error . self )
. eraseToAnyPublisher ( )
}
getSnodeForPolling ( for : publicKey )
. flatMap { snode -> AnyPublisher < [ Message ] , Error > in
Poller . poll (
namespaces : namespaces ,
from : snode ,
for : publicKey ,
poller : self ,
using : dependencies
)
}
. subscribe ( on : dependencies . subscribeQueue )
. receive ( on : dependencies . receiveQueue )
. sinkUntilComplete (
receiveCompletion : { [ weak self ] result in
switch result {
case . finished : self ? . pollRecursively ( for : publicKey , using : dependencies )
case . failure ( let error ) :
guard self ? . isPolling . wrappedValue [ publicKey ] = = true else { return }
self ? . handlePollError ( error , for : publicKey , using : dependencies )
}
// S e l e c t t h e n e x t u n u s e d s n o d e f r o m t h e s w a r m ( i f w e ' v e u s e d t h e m a l l t h e n c l e a r t h e u s e d l i s t a n d
// s t a r t c y c l i n g t h r o u g h t h e m a g a i n )
return SnodeAPI . getSwarm ( for : publicKey , using : dependencies )
. tryMap { [ usedSnodes = self . usedSnodes , targetSnode = self . targetSnode ] swarm -> Snode in
let unusedSnodes : Set < Snode > = swarm . subtracting ( usedSnodes . wrappedValue )
// I f w e ' v e u s e d a l l o f t h e S N o d e s t h e n c l e a r o u t t h e u s e d l i s t
if unusedSnodes . isEmpty {
usedSnodes . mutate { $0 . removeAll ( ) }
}
)
// S e l e c t t h e n e x t S N o d e
let nextSnode : Snode = try swarm . randomElement ( ) ? ? { throw OnionRequestAPIError . insufficientSnodes } ( )
targetSnode . mutate { $0 = nextSnode }
usedSnodes . mutate { $0 . insert ( nextSnode ) }
return nextSnode
}
. eraseToAnyPublisher ( )
}
internal func incrementPollCount ( publicKey : String ) {
guard maxNodePollCount > 0 else { return }
let pollCount : Int = ( self . pollCount . wrappedValue [ publicKey ] ? ? 0 )
self . pollCount . mutate { $0 [ publicKey ] = ( pollCount + 1 ) }
// C h e c k i f w e ' v e p o l l e d t h e s e r i c e n o d e t o o m a n y t i m e s
guard pollCount > maxNodePollCount else { return }
// I f w e h a v e p o l l e d t h i s s e r v i c e n o d e m o r e t h a n t h e m a x i m u m a l l o w e d t h e n c l e a r o u t
// t h e ' t a r g e t S e r v i c e N o d e ' v a l u e
self . targetSnode . mutate { $0 = nil }
}
private func pollRecursively (
for publicKey : String ,
using dependencies : SMKDependencies = SMKDependencies ( )
@ -124,65 +140,60 @@ public class Poller {
guard isPolling . wrappedValue [ publicKey ] = = true else { return }
let namespaces : [ SnodeAPI . Namespace ] = self . namespaces
let nextPollInterval : TimeInterval = nextPollDelay ( for : publicKey )
let lastPollStart : TimeInterval = Date ( ) . timeIntervalSince1970
let lastPollInterval : TimeInterval = nextPollDelay ( for : publicKey )
let getSnodePublisher : AnyPublisher < Snode , Error > = getSnodeForPolling ( for : publicKey )
timers . mutate {
$0 [ publicKey ] = Timer . scheduledTimerOnMainThread (
withTimeInterval : nextPollInterval ,
repeats : false
) { [ weak self ] timer in
timer . invalidate ( )
self ? . getSnodeForPolling ( for : publicKey )
. flatMap { snode -> AnyPublisher < [ Message ] , Error > in
Poller . poll (
namespaces : namespaces ,
from : snode ,
for : publicKey ,
poller : self ,
using : dependencies
// S t o r e t h e p u b l i s h e r i n t p t h e c a n c e l l a b l e s d i c t i o n a r y
cancellables . mutate { [ weak self ] cancellables in
cancellables [ publicKey ] = getSnodePublisher
. flatMap { snode -> AnyPublisher < [ Message ] , Error > in
Poller . poll (
namespaces : namespaces ,
from : snode ,
for : publicKey ,
poller : self ,
using : dependencies
)
}
. subscribe ( on : dependencies . subscribeQueue )
. receive ( on : dependencies . receiveQueue )
. sink (
receiveCompletion : { result in
switch result {
case . failure ( let error ) :
// D e t e r m i n e i f t h e e r r o r s h o u l d s t o p u s f r o m p o l l i n g a n y m o r e
guard self ? . handlePollError ( error , for : publicKey , using : dependencies ) = = true else {
return
}
case . finished : break
}
// I n c r e m e n t t h e p o l l c o u n t
self ? . incrementPollCount ( publicKey : publicKey )
// C a l c u l a t e t h e r e m a i n i n g p o l l d e l a y
let currentTime : TimeInterval = Date ( ) . timeIntervalSince1970
let nextPollInterval : TimeInterval = (
self ? . nextPollDelay ( for : publicKey ) ? ?
lastPollInterval
)
}
. subscribe ( on : dependencies . subscribeQueue )
. receive ( on : dependencies . receiveQueue )
. sinkUntilComplete (
receiveCompletion : { result in
switch result {
case . failure ( let error ) : self ? . handlePollError ( error , for : publicKey , using : dependencies )
case . finished :
let maxNodePollCount : UInt = ( self ? . maxNodePollCount ? ? 0 )
// I f w e h a v e p o l l e d t h i s s e r v i c e n o d e m o r e t h a n t h e
// m a x i m u m a l l o w e d t h e n t h r o w a n e r r o r s o t h e p a r e n t
// l o o p c a n r e s t a r t t h e p o l l i n g
if maxNodePollCount > 0 {
let pollCount : Int = ( self ? . pollCount . wrappedValue [ publicKey ] ? ? 0 )
self ? . pollCount . mutate { $0 [ publicKey ] = ( pollCount + 1 ) }
guard pollCount < maxNodePollCount else {
let newSnodeNextPollInterval : TimeInterval = ( self ? . nextPollDelay ( for : publicKey ) ? ? nextPollInterval )
self ? . timers . mutate {
$0 [ publicKey ] = Timer . scheduledTimerOnMainThread (
withTimeInterval : newSnodeNextPollInterval ,
repeats : false
) { [ weak self ] timer in
timer . invalidate ( )
self ? . pollCount . mutate { $0 [ publicKey ] = 0 }
self ? . setUpPolling ( for : publicKey , using : dependencies )
}
}
return
}
}
// O t h e r w i s e j u s t l o o p
self ? . pollRecursively ( for : publicKey , using : dependencies )
let remainingInterval : TimeInterval = max ( 0 , nextPollInterval - ( currentTime - lastPollStart ) )
// S c h e d u l e t h e n e x t p o l l
guard remainingInterval > 0 else {
return dependencies . subscribeQueue . async {
self ? . pollRecursively ( for : publicKey , using : dependencies )
}
}
)
}
dependencies . subscribeQueue . asyncAfter ( deadline : . now ( ) + . milliseconds ( Int ( remainingInterval * 1000 ) ) , qos : . default ) {
self ? . pollRecursively ( for : publicKey , using : dependencies )
}
} ,
receiveValue : { _ in }
)
}
}
@ -199,6 +210,7 @@ public class Poller {
isBackgroundPollValid : @ escaping ( ( ) -> Bool ) = { true } ,
poller : Poller ? = nil ,
using dependencies : SMKDependencies = SMKDependencies (
subscribeQueue : Threading . pollerQueue ,
receiveQueue : Threading . pollerQueue
)
) -> AnyPublisher < [ Message ] , Error > {
Morgan Pretty
2 years ago