[FME-8288] - Pausing - Reparsing

Split/Localhost/LocalhostSplitsStorage.swift

@@ -76,4 +76,8 @@ class LocalhostSplitsStorage: SplitsStorage {
     func destroy() {
         inMemorySplits.removeAll()
     }
+
+    func forceParsing() {
+
+    }
 }

Split/Network/Sync/FeatureFlagsSynchronizer.swift

@@ -78,13 +78,26 @@ class DefaultFeatureFlagsSynchronizer: FeatureFlagsSynchronizer {
             return
         }
 
-        let splitsStorage = self.storageContainer.splitsStorage
+        let splitsStorage = storageContainer.splitsStorage
         let ruleBasedSegmentsStorage = storageContainer.ruleBasedSegmentsStorage
-        DispatchQueue.general.async {
+
+        DispatchQueue.general.async { [weak self] in
+            guard let self = self else { return }
+
             let start = Date.nowMillis()
             self.filterSplitsInCache()
+
+            // Part of /memberships hits optimization
+            if self.storageContainer.generalInfoStorage.getSegmentsInUse() == nil {
+                splitsStorage.forceParsing()
+                ruleBasedSegmentsStorage.forceParsing()
+            }
+
+            // Load local
             splitsStorage.loadLocal()
             ruleBasedSegmentsStorage.loadLocal()
+
+            // Events & Logs
             if splitsStorage.getAll().count > 0 {
                 self.splitEventsManager.notifyInternalEvent(.splitsLoadedFromCache)
             }

Split/Storage/GeneralInfo/GeneralInfoStorage.swift

@@ -19,7 +19,7 @@ protocol GeneralInfoStorage {
     func setLastProxyUpdateTimestamp(_ timestamp: Int64)
 
     // Segments in use (for /memberships optimization)
-    func getSegmentsInUse() -> Int64
+    func getSegmentsInUse() -> Int64?
     func setSegmentsInUse(_ count: Int64)
 }
 
@@ -83,8 +83,8 @@ class DefaultGeneralInfoStorage: GeneralInfoStorage {
         generalInfoDao.update(info: .lastProxyUpdateTimestamp, longValue: timestamp)
     }
 
-    func getSegmentsInUse() -> Int64 {
-        return generalInfoDao.longValue(info: .segmentsInUse) ?? 0
+    func getSegmentsInUse() -> Int64? {
+        generalInfoDao.longValue(info: .segmentsInUse)
     }
 
     func setSegmentsInUse(_ count: Int64) {

Split/Storage/MySegments/MyLargeSegmentsStorage.swift

@@ -97,6 +97,6 @@ class MyLargeSegmentsStorage: MySegmentsStorage {
 
     // MARK: For Network Traffic Optimization
     func isUsingSegments() -> Bool {
-        generalInfoStorage.getSegmentsInUse() > 0
+        (generalInfoStorage.getSegmentsInUse() ?? 0) > 0
     }
 }

Split/Storage/MySegments/MySegmentsStorage.swift

@@ -93,6 +93,6 @@ class DefaultMySegmentsStorage: MySegmentsStorage {
 
     // MARK: For Network Traffic Optimization
     func isUsingSegments() -> Bool {
-        generalInfoStorage.getSegmentsInUse() > 0
+        (generalInfoStorage.getSegmentsInUse() ?? 0) > 0
     }
 }

Split/Storage/RuleBasedSegments/PersistentRuleBasedSegmentsStorage.swift

@@ -14,7 +14,7 @@ protocol PersistentRuleBasedSegmentsStorage {
     func clear()
     func getChangeNumber() -> Int64
 
-    func getSegmentsInUse() -> Int64
+    func getSegmentsInUse() -> Int64?
     func setSegmentsInUse(_ segmentsInUse: Int64)
 }
 
@@ -59,7 +59,7 @@ class DefaultPersistentRuleBasedSegmentsStorage: PersistentRuleBasedSegmentsStor
         return generalInfoStorage.getRuleBasedSegmentsChangeNumber()
     }
 
-    func getSegmentsInUse() -> Int64 {
+    func getSegmentsInUse() -> Int64? {
         generalInfoStorage.getSegmentsInUse()
     }
 

Split/Storage/RuleBasedSegments/RuleBasedSegmentsStorage.swift

@@ -16,6 +16,7 @@ protocol RuleBasedSegmentsStorage: RolloutDefinitionsCache {
     func contains(segmentNames: Set<String>) -> Bool
     func update(toAdd: Set<RuleBasedSegment>, toRemove: Set<RuleBasedSegment>, changeNumber: Int64) -> Bool
     func loadLocal()
+    func forceParsing() // For Lazy Parsing optimization
 }
 
 class DefaultRuleBasedSegmentsStorage: RuleBasedSegmentsStorage {
@@ -33,45 +34,29 @@ class DefaultRuleBasedSegmentsStorage: RuleBasedSegmentsStorage {
     }
 
     func loadLocal() {
-        segmentsInUse = persistentStorage.getSegmentsInUse()
+        segmentsInUse = persistentStorage.getSegmentsInUse() ?? 0
         let snapshot = persistentStorage.getSnapshot()
         let active = snapshot.segments.filter { $0.status == .active }
         let archived = snapshot.segments.filter { $0.status == .archived }
 
-        // Process active segments
-        for segment in active {
-            if let segmentName = segment.name?.lowercased() {
-                inMemorySegments.setValue(segment, forKey: segmentName)
-
-                if StorageHelper.usesSegments(segment.conditions) {
-                    segmentsInUse += 1
-                }
-            }
-        }
-
-        // Process archived segments - remove them from memory if they exist
-        for segment in archived {
-            if let segmentName = segment.name?.lowercased() {
-                inMemorySegments.removeValue(forKey: segmentName)
-            }
-        }
+        _ = processToAdd(Set(active))
+        _ = processToRemove(Set(archived))
 
         changeNumber = snapshot.changeNumber
         persistentStorage.setSegmentsInUse(segmentsInUse)
     }
 
     func get(segmentName: String) -> RuleBasedSegment? {
-        guard let segment = inMemorySegments.value(forKey: segmentName.lowercased()) else {
-            return nil
-        }
+        guard let segment = inMemorySegments.value(forKey: segmentName.lowercased()) else { return nil }
 
-        if !segment.isParsed {
-            if let parsed = try? Json.decodeFrom(json: segment.json, to: RuleBasedSegment.self) {
-                inMemorySegments.setValue(parsed, forKey: segmentName.lowercased())
-                return parsed
+        if !segment.isParsed { // Parse if neccesaty (Lazy Parsing)
+            if let parsedSegment = parseSegment(segment) {
+                inMemorySegments.setValue(parsedSegment, forKey: segmentName.lowercased())
+                return parsedSegment
             }
             return nil
         }
+
         return segment
     }
 
@@ -83,49 +68,84 @@ class DefaultRuleBasedSegmentsStorage: RuleBasedSegmentsStorage {
 
     func update(toAdd: Set<RuleBasedSegment>, toRemove: Set<RuleBasedSegment>, changeNumber: Int64) -> Bool {
 
-        var updated = false
-        segmentsInUse = persistentStorage.getSegmentsInUse()
+        segmentsInUse = persistentStorage.getSegmentsInUse() ?? 0
+        self.changeNumber = changeNumber
 
-        // Keep count of Segments in use
-        for segment in toAdd.union(toRemove) {
-            if StorageHelper.usesSegments(segment.conditions) {
-                if let segmentName = segment.name?.lowercased(), segment.status == .active && inMemorySegments.value(forKey: segmentName) == nil {
-                    segmentsInUse += 1
-                } else if inMemorySegments.value(forKey: segment.name?.lowercased() ?? "") != nil && segment.status != .active {
-                    segmentsInUse -= 1
-                }
-            }
-        }
+        // Process
+        let addResult = processToAdd(toAdd)
+        let removeResult = processToRemove(toRemove)
+
+        // Update persistent storage
+        persistentStorage.update(toAdd: toAdd, toRemove: toRemove, changeNumber: changeNumber)
+        persistentStorage.setSegmentsInUse(segmentsInUse)
+
+        return addResult || removeResult
+    }
 
-        // Process segments to add
+    private func processToAdd(_ toAdd: Set<RuleBasedSegment>) -> Bool { // Process segments to add
+        var result = false
+
         for segment in toAdd {
             if let segmentName = segment.name?.lowercased() {
+                updateSegmentsCount(segment)
                 inMemorySegments.setValue(segment, forKey: segmentName)
-
-                updated = true
+                result = true
             }
         }
-
-        // Process segments to remove
+        return result
+    }
+
+    private func processToRemove(_ toRemove: Set<RuleBasedSegment>) -> Bool { // Process segments to remove
+        var result = false
+
         for segment in toRemove {
             if let segmentName = segment.name?.lowercased(), inMemorySegments.value(forKey: segmentName) != nil {
+                updateSegmentsCount(segment)
                 inMemorySegments.removeValue(forKey: segmentName)
-                updated = true
+                result = true
             }
         }
-
-        self.changeNumber = changeNumber
-
-        // Update persistent storage
-        persistentStorage.update(toAdd: toAdd, toRemove: toRemove, changeNumber: changeNumber)
-        persistentStorage.setSegmentsInUse(segmentsInUse)
-
-        return updated
+        return result
     }
 
     func clear() {
         inMemorySegments.removeAll()
         changeNumber = -1
         persistentStorage.clear()
     }
+
+    func forceParsing() {
+        segmentsInUse = persistentStorage.getSegmentsInUse() ?? 0
+        let activeSegments = persistentStorage.getSnapshot().segments.filter { $0.status == .active }
+
+        for i in 0..<activeSegments.count {
+            guard let segmentName = activeSegments[i].name else { continue }
+
+            if let parsedSegment = parseSegment(activeSegments[i]) { // Parse it
+                updateSegmentsCount(parsedSegment)
+                inMemorySegments.setValue(parsedSegment, forKey: segmentName)
+            }
+        }
+
+        persistentStorage.setSegmentsInUse(segmentsInUse)
+    }
+
+    fileprivate func parseSegment(_ segment: RuleBasedSegment) -> RuleBasedSegment? {
+        guard let parsedSegment = try? Json.decodeFrom(json: segment.json, to: RuleBasedSegment.self) else { return nil }
+        return parsedSegment
+    }
+
+    fileprivate func updateSegmentsCount(_ segment: RuleBasedSegment) {
+        if let segmentName = segment.name?.lowercased(), segment.status == .active, inMemorySegments.value(forKey: segmentName) == nil, StorageHelper.usesSegments(segment.conditions) {
+            segmentsInUse += 1
+        } else if inMemorySegments.value(forKey: segment.name?.lowercased() ?? "") != nil, segment.status != .active, StorageHelper.usesSegments(segment.conditions) {
+            segmentsInUse -= 1
+        }
+    }
+
+    #if DEBUG
+    func getInMemorySegments() -> ConcurrentDictionary<String, RuleBasedSegment>  {
+        inMemorySegments
+    }
+    #endif
 }