Make remote config accessible to background agents

DuckDuckGo.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -32,8 +32,7 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/duckduckgo/BrowserServicesKit",
       "state" : {
-        "branch" : "194.0.0",
-        "revision" : "026acbd36fb80c95e0bfc6a9080e369dd85db66f"
+        "revision" : "657a961c94c9c45f04ecd7c0937caf84cbedc731"
       }
     },
     {

DuckDuckGo/Application/AppDelegate.swift

@@ -98,6 +98,9 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
     public let vpnSettings = VPNSettings(defaults: .netP)
 
+    var configurationStore = ConfigurationStore()
+    var configurationManager: ConfigurationManager
+
     // MARK: - VPN
 
     private var networkProtectionSubscriptionEventHandler: NetworkProtectionSubscriptionEventHandler?
@@ -174,6 +177,8 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         let internalUserDeciderStore = InternalUserDeciderStore(fileStore: fileStore)
         internalUserDecider = DefaultInternalUserDecider(store: internalUserDeciderStore)
 
+        configurationManager = ConfigurationManager(store: configurationStore)
+
         if NSApplication.runType.requiresEnvironment {
             Self.configurePixelKit()
 
@@ -221,10 +226,10 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 #if DEBUG
         AppPrivacyFeatures.shared = NSApplication.runType.requiresEnvironment
         // runtime mock-replacement for Unit Tests, to be redone when we‘ll be doing Dependency Injection
-        ? AppPrivacyFeatures(contentBlocking: AppContentBlocking(internalUserDecider: internalUserDecider), database: Database.shared)
+        ? AppPrivacyFeatures(contentBlocking: AppContentBlocking(internalUserDecider: internalUserDecider, configurationStore: configurationStore), database: Database.shared)
         : AppPrivacyFeatures(contentBlocking: ContentBlockingMock(), httpsUpgradeStore: HTTPSUpgradeStoreMock())
 #else
-        AppPrivacyFeatures.shared = AppPrivacyFeatures(contentBlocking: AppContentBlocking(internalUserDecider: internalUserDecider), database: Database.shared)
+        AppPrivacyFeatures.shared = AppPrivacyFeatures(contentBlocking: AppContentBlocking(internalUserDecider: internalUserDecider, configurationStore: configurationStore), database: Database.shared)
 #endif
         if NSApplication.runType.requiresEnvironment {
             remoteMessagingClient = RemoteMessagingClient(
@@ -233,7 +238,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
                 appearancePreferences: .shared,
                 pinnedTabsManager: pinnedTabsManager,
                 internalUserDecider: internalUserDecider,
-                configurationStore: ConfigurationStore.shared,
+                configurationStore: configurationStore,
                 remoteMessagingAvailabilityProvider: PrivacyConfigurationRemoteMessagingAvailabilityProvider(
                     privacyConfigurationManager: ContentBlocking.shared.privacyConfigurationManager
                 )
@@ -310,7 +315,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         if case .normal = NSApp.runType {
             FaviconManager.shared.loadFavicons()
         }
-        ConfigurationManager.shared.start()
+        configurationManager.start()
         _ = DownloadListCoordinator.shared
         _ = RecentlyClosedCoordinator.shared
 

DuckDuckGo/Common/Utilities/UserDefaultsWrapper.swift

@@ -44,17 +44,6 @@ public struct UserDefaultsWrapper<T> {
         /// system setting defining window title double-click action
         case appleActionOnDoubleClick = "AppleActionOnDoubleClick"
 
-        case configLastUpdated = "config.last.updated"
-        case configStorageTrackerRadarEtag = "config.storage.trackerradar.etag"
-        case configStorageBloomFilterSpecEtag = "config.storage.bloomfilter.spec.etag"
-        case configStorageBloomFilterBinaryEtag = "config.storage.bloomfilter.binary.etag"
-        case configStorageBloomFilterExclusionsEtag = "config.storage.bloomfilter.exclusions.etag"
-        case configStorageSurrogatesEtag = "config.storage.surrogates.etag"
-        case configStoragePrivacyConfigurationEtag = "config.storage.privacyconfiguration.etag"
-        case configStorageRemoteMessagingConfigEtag = "config.storage.remotemessagingconfig.etag"
-
-        case configLastInstalled = "config.last.installed"
-
         case fireproofDomains = "com.duckduckgo.fireproofing.allowedDomains"
         case areDomainsMigratedToETLDPlus1 = "com.duckduckgo.are-domains-migrated-to-etldplus1"
         case unprotectedDomains = "com.duckduckgo.contentblocker.unprotectedDomains"

DuckDuckGo/Configuration/ConfigurationManager.swift

@@ -17,60 +17,32 @@
 //
 
 import Foundation
+import os.log
 import Combine
 import BrowserServicesKit
+import Persistence
 import Configuration
 import Common
 import Networking
 import PixelKit
-import os.log
-
-final class ConfigurationManager {
 
-    enum Error: Swift.Error {
-
-        case timeout
-        case bloomFilterSpecNotFound
-        case bloomFilterBinaryNotFound
-        case bloomFilterPersistenceFailed
-        case bloomFilterExclusionsNotFound
-        case bloomFilterExclusionsPersistenceFailed
-
-        func withUnderlyingError(_ underlyingError: Swift.Error) -> Swift.Error {
-            let nsError = self as NSError
-            return NSError(domain: nsError.domain, code: nsError.code, userInfo: [NSUnderlyingErrorKey: underlyingError])
-        }
+final class ConfigurationManager: DefaultConfigurationManager {
 
+    private enum Constants {
+        static let lastConfigurationInstallDateKey = "config.last.installed"
     }
 
-    enum Constants {
-
-        static let downloadTimeoutSeconds = 60.0 * 5
-#if DEBUG
-        static let refreshPeriodSeconds = 60.0 * 2 // 2 minutes
-#else
-        static let refreshPeriodSeconds = 60.0 * 30 // 30 minutes
-#endif
-        static let retryDelaySeconds = 60.0 * 60 * 1 // 1 hour delay before checking again if something went wrong last time
-        static let refreshCheckIntervalSeconds = 60.0 // check if we need a refresh every minute
+    private var defaults: KeyValueStoring
 
+    private(set) var lastConfigurationInstallDate: Date? {
+        get {
+            defaults.object(forKey: Constants.lastConfigurationInstallDateKey) as? Date
+        }
+        set {
+            defaults.set(newValue, forKey: Constants.lastConfigurationInstallDateKey)
+        }
     }
 
-    static let shared = ConfigurationManager()
-    static let queue: DispatchQueue = DispatchQueue(label: "Configuration Manager")
-
-    @UserDefaultsWrapper(key: .configLastUpdated, defaultValue: .distantPast)
-    private(set) var lastUpdateTime: Date
-
-    @UserDefaultsWrapper(key: .configLastInstalled, defaultValue: nil)
-    private(set) var lastConfigurationInstallDate: Date?
-
-    private var timerCancellable: AnyCancellable?
-    private var lastRefreshCheckTime: Date = Date()
-
-    private lazy var fetcher = ConfigurationFetcher(store: ConfigurationStore.shared,
-                                                    eventMapping: Self.configurationDebugEvents)
-
     static let configurationDebugEvents = EventMapping<ConfigurationDebugEvents> { event, error, _, _ in
         let domainEvent: GeneralPixel
         switch event {
@@ -81,21 +53,19 @@ final class ConfigurationManager {
         PixelKit.fire(DebugEvent(domainEvent, error: error))
     }
 
-    func start() {
-        Logger.config.debug("Starting configuration refresh timer")
-        timerCancellable = Timer.publish(every: Constants.refreshCheckIntervalSeconds, on: .main, in: .default)
-            .autoconnect()
-            .receive(on: Self.queue)
-            .sink(receiveValue: { _ in
-                self.lastRefreshCheckTime = Date()
-                self.refreshIfNeeded()
-            })
-        Task {
-            await refreshNow()
-        }
+    override init(fetcher: ConfigurationFetching = ConfigurationFetcher(store: ConfigurationStore(), eventMapping: configurationDebugEvents),
+                  store: ConfigurationStoring = ConfigurationStore(),
+                  defaults: KeyValueStoring = UserDefaults.appConfiguration) {
+        self.defaults = defaults
+        super.init(fetcher: fetcher, store: store, defaults: defaults)
+    }
+
+    func log() {
+        Logger.config.log("last update \(String(describing: self.lastUpdateTime), privacy: .public)")
+        Logger.config.log("last refresh check \(String(describing: self.lastRefreshCheckTime), privacy: .public)")
     }
 
-    private func refreshNow(isDebug: Bool = false) async {
+    override public func refreshNow(isDebug: Bool = false) async {
         let updateTrackerBlockingDependenciesTask = Task {
             let didFetchAnyTrackerBlockingDependencies = await fetchTrackerBlockingDependencies(isDebug: isDebug)
             if didFetchAnyTrackerBlockingDependencies {
@@ -116,7 +86,7 @@ final class ConfigurationManager {
 
         let updateBloomFilterExclusionsTask = Task {
             do {
-                try await fetcher.fetch(.bloomFilterExcludedDomains)
+                try await fetcher.fetch(.bloomFilterExcludedDomains, isDebug: isDebug)
                 try await updateBloomFilterExclusions()
                 tryAgainLater()
             } catch {
@@ -128,7 +98,7 @@ final class ConfigurationManager {
         await updateBloomFilterTask.value
         await updateBloomFilterExclusionsTask.value
 
-        ConfigurationStore.shared.log()
+        (store as? ConfigurationStore)?.log()
 
         Logger.config.info("last update \(String(describing: self.lastUpdateTime), privacy: .public)")
         Logger.config.info("last refresh check \(String(describing: self.lastRefreshCheckTime), privacy: .public)")
@@ -138,16 +108,18 @@ final class ConfigurationManager {
         var didFetchAnyTrackerBlockingDependencies = false
 
         var tasks = [Configuration: Task<(), Swift.Error>]()
-        tasks[.trackerDataSet] = Task { try await fetcher.fetch(.trackerDataSet) }
-        tasks[.surrogates] = Task { try await fetcher.fetch(.surrogates) }
+        tasks[.trackerDataSet] = Task { try await fetcher.fetch(.trackerDataSet, isDebug: isDebug) }
+        tasks[.surrogates] = Task { try await fetcher.fetch(.surrogates, isDebug: isDebug) }
         tasks[.privacyConfiguration] = Task { try await fetcher.fetch(.privacyConfiguration, isDebug: isDebug) }
 
         for (configuration, task) in tasks {
             do {
                 try await task.value
                 didFetchAnyTrackerBlockingDependencies = true
             } catch {
-                Logger.config.error("Failed to complete configuration update to \(configuration.rawValue): \(error.localizedDescription, privacy: .public)")
+                Logger.config.error(
+                    "Failed to complete configuration update to \(configuration.rawValue, privacy: .public): \(error.localizedDescription, privacy: .public)"
+                )
                 tryAgainSoon()
             }
         }
@@ -167,48 +139,20 @@ final class ConfigurationManager {
         tryAgainSoon()
     }
 
-    @discardableResult
-    public func refreshIfNeeded() -> Task<Void, Never>? {
-        guard isReadyToRefresh else {
-            Logger.config.debug("Configuration refresh is not needed at this time")
-            return nil
-        }
-        return Task {
-            await refreshNow()
-        }
-    }
-
-    private var isReadyToRefresh: Bool { Date().timeIntervalSince(lastUpdateTime) > Constants.refreshPeriodSeconds }
-
-    public func forceRefresh(isDebug: Bool = false) {
-        Task {
-            await refreshNow(isDebug: isDebug)
-        }
-    }
-
-    private func tryAgainLater() {
-        lastUpdateTime = Date()
-    }
-
-    private func tryAgainSoon() {
-        // Set the last update time to in the past so it triggers again sooner
-        lastUpdateTime = Date(timeIntervalSinceNow: Constants.refreshPeriodSeconds - Constants.retryDelaySeconds)
-    }
-
     private func updateTrackerBlockingDependencies() {
         lastConfigurationInstallDate = Date()
-        ContentBlocking.shared.trackerDataManager.reload(etag: ConfigurationStore.shared.loadEtag(for: .trackerDataSet),
-                                                         data: ConfigurationStore.shared.loadData(for: .trackerDataSet))
-        ContentBlocking.shared.privacyConfigurationManager.reload(etag: ConfigurationStore.shared.loadEtag(for: .privacyConfiguration),
-                                                                  data: ConfigurationStore.shared.loadData(for: .privacyConfiguration))
+        ContentBlocking.shared.trackerDataManager.reload(etag: store.loadEtag(for: .trackerDataSet),
+                                                         data: store.loadData(for: .trackerDataSet))
+        ContentBlocking.shared.privacyConfigurationManager.reload(etag: store.loadEtag(for: .privacyConfiguration),
+                                                                  data: store.loadData(for: .privacyConfiguration))
         ContentBlocking.shared.contentBlockingManager.scheduleCompilation()
     }
 
     private func updateBloomFilter() async throws {
-        guard let specData = ConfigurationStore.shared.loadData(for: .bloomFilterSpec) else {
+        guard let specData = store.loadData(for: .bloomFilterSpec) else {
             throw Error.bloomFilterSpecNotFound
         }
-        guard let bloomFilterData = ConfigurationStore.shared.loadData(for: .bloomFilterBinary) else {
+        guard let bloomFilterData = store.loadData(for: .bloomFilterBinary) else {
             throw Error.bloomFilterBinaryNotFound
         }
         try await Task.detached {
@@ -224,7 +168,7 @@ final class ConfigurationManager {
     }
 
     private func updateBloomFilterExclusions() async throws {
-        guard let bloomFilterExclusions = ConfigurationStore.shared.loadData(for: .bloomFilterExcludedDomains) else {
+        guard let bloomFilterExclusions = store.loadData(for: .bloomFilterExcludedDomains) else {
             throw Error.bloomFilterExclusionsNotFound
         }
         try await Task.detached {
@@ -239,3 +183,19 @@ final class ConfigurationManager {
     }
 
 }
+
+extension ConfigurationManager {
+    override var presentedItemURL: URL? {
+        store.fileUrl(for: .privacyConfiguration).deletingLastPathComponent()
+    }
+
+    override func presentedSubitemDidAppear(at url: URL) {
+        guard url == store.fileUrl(for: .privacyConfiguration) else { return }
+        updateTrackerBlockingDependencies()
+    }
+
+    override func presentedSubitemDidChange(at url: URL) {
+        guard url == store.fileUrl(for: .privacyConfiguration) else { return }
+        updateTrackerBlockingDependencies()
+    }
+}