Check for entitlement in DBP agent

DuckDuckGo/DBP/DataBrokerProtectionSubscriptionEventHandler.swift

@@ -31,11 +31,16 @@
 
     func registerForSubscriptionAccountManagerEvents() {
         NotificationCenter.default.addObserver(self, selector: #selector(handleAccountDidSignOut), name: .accountDidSignOut, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(entitlementsDidChange), name: .entitlementsDidChange, object: nil)
     }
 
     @objc private func handleAccountDidSignOut() {
         featureDisabler.disableAndDelete()
     }
+
+    @objc private func entitlementsDidChange() {
+        #warning("Validate if valid and delete if necessary after sending pixels")
+    }
 }
 
 #endif

LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Authentication/DataBrokerProtectionEntitlementMonitoring.swift

@@ -0,0 +1,56 @@
+//
+//  DataBrokerProtectionEntitlementMonitoring.swift
+//
+//  Copyright © 2024 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+protocol DataBrokerProtectionEntitlementMonitoring {
+    func start(checkEntitlementFunction: @escaping () async throws -> Bool, intervalInMinutes: Int, callback: @escaping (DataBrokerProtectionEntitlementMonitorResult) -> Void)
+    func stop()
+}
+
+public enum DataBrokerProtectionEntitlementMonitorResult {
+    case enabled
+    case disabled
+    case error
+}
+
+final class DataBrokerProtectionEntitlementMonitor: DataBrokerProtectionEntitlementMonitoring {
+    private var timer: Timer?
+
+    func start(checkEntitlementFunction: @escaping () async throws -> Bool, intervalInMinutes: Int, callback: @escaping (DataBrokerProtectionEntitlementMonitorResult) -> Void) {
+        timer = Timer.scheduledTimer(withTimeInterval: TimeInterval(intervalInMinutes * 60), repeats: true) { _ in
+            Task {
+                do {
+                    switch try await checkEntitlementFunction() {
+                    case true:
+                        callback(.enabled)
+                    case false:
+                        callback(.disabled)
+                    }
+                } catch {
+                    callback(.error)
+                }
+            }
+        }
+    }
+
+    func stop() {
+        timer?.invalidate()
+        timer = nil
+    }
+}

LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Scheduler/DataBrokerProtectionAgentManager.swift

@@ -71,7 +71,12 @@
                                                          contentScopeProperties: contentScopeProperties,
                                                          emailService: emailService,
                                                          captchaService: captchaService)
-         let operationDependencies = DefaultDataBrokerOperationDependencies(
+
+        let agentstopper = DefaultDataBrokerProtectionAgentStopper(dataManager: dataManager,
+                                                                   entitlementMonitor: DataBrokerProtectionEntitlementMonitor(),
+                                                                   authenticationManager: authenticationManager)
+
+        let operationDependencies = DefaultDataBrokerOperationDependencies(
             database: dataManager.database,
             config: executionConfig,
             runnerProvider: runnerProvider,
@@ -86,7 +91,8 @@
             queueManager: queueManager,
             dataManager: dataManager,
             operationDependencies: operationDependencies,
-            pixelHandler: pixelHandler)
+            pixelHandler: pixelHandler,
+            agentStopper: agentstopper)
     }
 }
 
@@ -99,6 +105,7 @@
     private let dataManager: DataBrokerProtectionDataManaging
     private let operationDependencies: DataBrokerOperationDependencies
     private let pixelHandler: EventMapping<DataBrokerProtectionPixels>
+    private let agentStopper: DataBrokerProtectionAgentStopper
 
     // Used for debug functions only, so not injected
     private lazy var browserWindowManager = BrowserWindowManager()
@@ -111,14 +118,17 @@
          queueManager: DataBrokerProtectionQueueManager,
          dataManager: DataBrokerProtectionDataManaging,
          operationDependencies: DataBrokerOperationDependencies,
-         pixelHandler: EventMapping<DataBrokerProtectionPixels>) {
+         pixelHandler: EventMapping<DataBrokerProtectionPixels>,
+         agentStopper: DataBrokerProtectionAgentStopper
+    ) {
         self.userNotificationService = userNotificationService
         self.activityScheduler = activityScheduler
         self.ipcServer = ipcServer
         self.queueManager = queueManager
         self.dataManager = dataManager
         self.operationDependencies = operationDependencies
         self.pixelHandler = pixelHandler
+        self.agentStopper = agentStopper
 
         self.activityScheduler.delegate = self
         self.ipcServer.serverDelegate = self
@@ -127,20 +137,18 @@
 
     public func agentFinishedLaunching() {
 
-        do {
-            // If there's no saved profile we don't need to start the scheduler
-            // Theoretically this should never happen, if there's no data, the agent shouldn't be running
-            guard (try dataManager.fetchProfile()) != nil else {
-                return
-            }
-        } catch {
-            os_log("Error during AgentManager.agentFinishedLaunching when trying to fetchProfile, error: %{public}@", log: .dataBrokerProtection, error.localizedDescription)
-            return
-        }
+        Task { @MainActor in
+            // The browser shouldn't start the agent if these prerequisites aren't met.
+            // However, since the agent can auto-start after a reboot without the browser, we need to validate it again.
+            // If the agent needs to be stopped, this function will stop it, so the subsequent calls after it will not be made.
+            await agentStopper.validateRunPrerequisitesAndStopAgentIfNecessary()
+
+            activityScheduler.startScheduler()
+            didStartActivityScheduler = true
+            queueManager.startScheduledOperationsIfPermitted(showWebView: false, operationDependencies: operationDependencies, completion: nil)
 
-        activityScheduler.startScheduler()
-        didStartActivityScheduler = true
-        queueManager.startScheduledOperationsIfPermitted(showWebView: false, operationDependencies: operationDependencies, completion: nil)
+            agentStopper.monitorEntitlementAndStopAgentIfEntitlementIsInvalid()
+        }
     }
 }
 
@@ -283,3 +291,4 @@
 extension DataBrokerProtectionAgentManager: DataBrokerProtectionAppToAgentInterface {
 
 }
+

LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Utils/DataBrokerProtectionAgentStopper.swift

@@ -0,0 +1,82 @@
+//
+//  DataBrokerProtectionAgentStopper.swift
+//
+//  Copyright © 2023 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+import Common
+
+protocol DataBrokerProtectionAgentStopper {
+    /// Validates if the user has profile data, is authenticated, and has valid entitlement. If any of these conditions are not met, the agent will be stopped.
+    func validateRunPrerequisitesAndStopAgentIfNecessary() async
+
+    /// Monitors the entitlement package. If the entitlement check returns false, the agent will be stopped.
+    /// This function ensures that the agent is stopped if the user's subscription has expired, even if the browser is not active. Regularly checking for entitlement is required since notifications are not posted to agents.
+    func monitorEntitlementAndStopAgentIfEntitlementIsInvalid()
+
+    /// Stops the agent
+    func stopAgent()
+}
+
+struct DefaultDataBrokerProtectionAgentStopper: DataBrokerProtectionAgentStopper {
+    private let dataManager: DataBrokerProtectionDataManaging
+    private let entitlementMonitor: DataBrokerProtectionEntitlementMonitoring
+    private let authenticationManager: DataBrokerProtectionAuthenticationManaging
+
+    init(dataManager: DataBrokerProtectionDataManaging,
+         entitlementMonitor: DataBrokerProtectionEntitlementMonitoring,
+         authenticationManager: DataBrokerProtectionAuthenticationManaging) {
+        self.dataManager = dataManager
+        self.entitlementMonitor = entitlementMonitor
+        self.authenticationManager = authenticationManager
+    }
+
+    public func validateRunPrerequisitesAndStopAgentIfNecessary() async {
+        do {
+            guard try dataManager.fetchProfile() != nil,
+                  authenticationManager.isUserAuthenticated,
+                  try await authenticationManager.hasValidEntitlement() else {
+
+                os_log("Prerequisites are invalid", log: .dataBrokerProtection)
+                stopAgent()
+                return
+            }
+            os_log("Prerequisites are valid", log: .dataBrokerProtection)
+        } catch {
+            os_log("Error validating prerequisites, error: %{public}@", log: .dataBrokerProtection, error.localizedDescription)
+            stopAgent()
+        }
+    }
+
+    public func monitorEntitlementAndStopAgentIfEntitlementIsInvalid() {
+        entitlementMonitor.start(checkEntitlementFunction: authenticationManager.hasValidEntitlement, intervalInMinutes: 60) { result in
+            switch result {
+            case .enabled:
+#warning("Send pixel enabled")
+                stopAgent()
+            case .disabled:
+#warning("Send pixel disabled")
+            case .error:
+#warning("Send pixel error")
+            }
+        }
+    }
+
+    func stopAgent() {
+        os_log("Stopping DataBrokerProtection Agent", log: .dataBrokerProtection)
+        exit(EXIT_SUCCESS)
+    }
+}