Improve concurrency for background filter list update

Author: classicsc

MaruWeb/Filters/WebFilterListDownloader.swift

@@ -78,18 +78,24 @@ public actor WebFilterListDownloader {
     /// flight at once. Returns a per-id outcome map.
     @discardableResult
     public func refreshAll(force: Bool = false) async -> [UUID: WebFilterListRefreshOutcome] {
+        guard !Task.isCancelled else { return [:] }
         let entries = await MainActor.run { storage.entries.filter(\.isEnabled) }
         var outcomes: [UUID: WebFilterListRefreshOutcome] = [:]
         var iterator = entries.makeIterator()
         await withTaskGroup(of: (UUID, WebFilterListRefreshOutcome).self) { group in
             for _ in 0 ..< min(maxConcurrentRefreshes, entries.count) {
+                guard !Task.isCancelled else { break }
                 guard let entry = iterator.next() else { break }
                 group.addTask { [self] in
                     await (entry.id, refresh(entry: entry, force: force))
                 }
             }
             while let result = await group.next() {
                 outcomes[result.0] = result.1
+                guard !Task.isCancelled else {
+                    group.cancelAll()
+                    break
+                }
                 if let entry = iterator.next() {
                     group.addTask { [self] in
                         await (entry.id, refresh(entry: entry, force: force))
@@ -102,6 +108,7 @@ public actor WebFilterListDownloader {
 
     /// Refreshes a single filter list. `force` ignores etag/last-modified headers.
     public func refresh(entry: WebFilterListEntry, force: Bool = false) async -> WebFilterListRefreshOutcome {
+        guard !Task.isCancelled else { return .failed(message: "Cancelled") }
         let attemptedAt = Date()
         var request = URLRequest(url: entry.sourceURL)
         request.httpMethod = "GET"
@@ -116,6 +123,7 @@ public actor WebFilterListDownloader {
 
         do {
             let (data, response) = try await session.data(for: request)
+            guard !Task.isCancelled else { return .failed(message: "Cancelled") }
             guard let httpResponse = response as? HTTPURLResponse else {
                 let message = "Non-HTTP response"
                 await MainActor.run {
@@ -166,6 +174,8 @@ public actor WebFilterListDownloader {
                 }
                 return .failed(message: message)
             }
+        } catch where Task.isCancelled || error is CancellationError {
+            return .failed(message: "Cancelled")
         } catch {
             let message = (error as? URLError).map { "URLError(\($0.code.rawValue)): \($0.localizedDescription)" }
                 ?? error.localizedDescription
@@ -178,6 +188,7 @@ public actor WebFilterListDownloader {
     }
 
     private func updatePerListMetrics(entry: WebFilterListEntry, contents: String) async {
+        guard !Task.isCancelled else { return }
         let source = WebFilterListSource(
             identifier: entry.id.uuidString,
             contents: contents,
@@ -186,6 +197,7 @@ public actor WebFilterListDownloader {
         guard let result = try? WebFilterListConverter.convert([source]) else { return }
         let ruleCount = Int(result.ruleCount)
         let convertedCount = Int(result.convertedFilterCount)
+        guard !Task.isCancelled else { return }
         await MainActor.run {
             storage.applyCompileMetrics(
                 id: entry.id,

MaruWeb/Filters/WebFilterListUpdateScheduler.swift

@@ -31,25 +31,38 @@ public final class WebFilterListUpdateScheduler {
     private let log = Logger(subsystem: "MaruWeb", category: "filter-list-scheduler")
     private let downloader: WebFilterListDownloader
     private let storage: WebFilterListStorage
+    private let submitRequest: (BGTaskRequest) throws -> Void
     private var didRegister = false
     private var inFlight: Task<Void, Never>?
 
-    public init(
+    public convenience init(
         downloader: WebFilterListDownloader = .shared,
         storage: WebFilterListStorage = .shared
+    ) {
+        self.init(
+            downloader: downloader,
+            storage: storage,
+            submitRequest: { try BGTaskScheduler.shared.submit($0) }
+        )
+    }
+
+    init(
+        downloader: WebFilterListDownloader,
+        storage: WebFilterListStorage,
+        submitRequest: @escaping (BGTaskRequest) throws -> Void
     ) {
         self.downloader = downloader
         self.storage = storage
+        self.submitRequest = submitRequest
     }
 
     /// Registers the BGAppRefreshTask handler. Must be called from the host app's `init`
     /// (or before scene activation), exactly once per process.
     public func registerBackgroundTask() {
         guard !didRegister else { return }
-        didRegister = true
-        BGTaskScheduler.shared.register(
+        didRegister = BGTaskScheduler.shared.register(
             forTaskWithIdentifier: WebContentBlocker.backgroundRefreshTaskIdentifier,
-            using: nil
+            using: DispatchQueue.main
         ) { [weak self] task in
             guard let task = task as? BGAppRefreshTask else {
                 task.setTaskCompleted(success: false)
@@ -59,6 +72,9 @@ public final class WebFilterListUpdateScheduler {
                 await self?.handle(backgroundTask: task)
             }
         }
+        if !didRegister {
+            log.error("Failed to register background refresh task")
+        }
     }
 
     /// Triggers a refresh if the most recent successful fetch across enabled lists is
@@ -70,15 +86,22 @@ public final class WebFilterListUpdateScheduler {
 
     /// Manually triggers a refresh. UI calls this from the "Update Now" button.
     public func refreshNow() {
-        if inFlight != nil {
-            return
+        _ = startRefresh()
+    }
+
+    @discardableResult
+    func startRefresh() -> Task<Void, Never> {
+        if let inFlight {
+            return inFlight
         }
-        inFlight = Task { @MainActor [weak self] in
+        let task = Task { @MainActor [weak self] in
             guard let self else { return }
+            defer { self.inFlight = nil }
             await self.downloader.refreshAll(force: false)
             self.scheduleNextRefresh()
-            self.inFlight = nil
         }
+        inFlight = task
+        return task
     }
 
     /// Submits the next BGAppRefreshTask request. Safe to call repeatedly.
@@ -88,7 +111,7 @@ public final class WebFilterListUpdateScheduler {
         )
         request.earliestBeginDate = nextEligibleDate(now: now)
         do {
-            try BGTaskScheduler.shared.submit(request)
+            try submitRequest(request)
         } catch {
             log.error("Failed to schedule background refresh: \(String(describing: error), privacy: .public)")
         }
@@ -99,10 +122,10 @@ public final class WebFilterListUpdateScheduler {
     private func handle(backgroundTask: BGAppRefreshTask) async {
         // Always reschedule first so we keep ticking even if this run is curtailed.
         scheduleNextRefresh()
+        storage.start()
+        storage.seedDefaultsIfNeeded()
 
-        let task = Task { @MainActor [weak self] in
-            _ = await self?.downloader.refreshAll(force: false)
-        }
+        let task = startRefresh()
         backgroundTask.expirationHandler = {
             task.cancel()
         }