@otakit/capacitor-updater 2.3.2 → 3.0.0

package/ios/Sources/UpdaterPlugin/UpdaterCoordinator.swift

@@ -1,6 +1,11 @@
 import Foundation
 
 final class UpdaterCoordinator {
+  struct Trial: Equatable {
+    let bundleId: String
+    let activationId = UUID().uuidString
+  }
+
   struct StateSnapshot {
     let current: BundleInfo
     let fallback: BundleInfo
@@ -15,6 +20,8 @@ final class UpdaterCoordinator {
     let channel: String?
     let releaseId: String?
     let detail: String?
+    var attemptId: String? = nil
+    var phase: String? = nil
   }
 
   enum LatestManifestClassification {
@@ -25,14 +32,14 @@ final class UpdaterCoordinator {
 
   struct StartupPreparation {
     let activationPath: String?
-    let trialBundleId: String?
+    let trial: Trial?
     let cleanupBundleIds: [String]
     let eventPayload: DeviceEventPayload?
   }
 
   struct ApplyPreparation {
     let activationPath: String?
-    let trialBundleId: String?
+    let trial: Trial?
     let cleanupBundleIds: [String]
 
     var didApply: Bool {
@@ -56,6 +63,7 @@ final class UpdaterCoordinator {
   private let operationLock = NSLock()
   private let stateLock = NSLock()
   private var operationInProgress = false
+  private var activeTrial: Trial?
 
   init(store: BundleStore) {
     self.store = store
@@ -110,18 +118,19 @@ final class UpdaterCoordinator {
 
   func pruneIncompatibleBundles(
     isCompatibleRuntime: @escaping (BundleInfo) -> Bool
-  ) -> [String] {
-    withStateLock {
+  ) throws -> [String] {
+    try withStateLock {
+      _ = try store.protectedBundleIds()
       var cleanupBundleIds = Set<String>()
 
       for bundle in store.listDownloadedBundles() where !isCompatibleRuntime(bundle) {
-        detachBundleReferencesLocked(bundleId: bundle.id)
+        try detachBundleReferencesLocked(bundleId: bundle.id)
         cleanupBundleIds.insert(bundle.id)
       }
 
       if let failed = store.getLastFailedBundle(),
          !isCompatibleRuntime(failed) {
-        store.setLastFailedBundle(nil)
+        try store.setLastFailedBundle(nil)
       }
 
       return Array(cleanupBundleIds)
@@ -130,15 +139,17 @@ final class UpdaterCoordinator {
 
   func normalizeStartupState(
     isBundleUsable: @escaping (BundleInfo) -> Bool
-  ) -> StartupPreparation {
-    withStateLock {
+  ) throws -> StartupPreparation {
+    try withStateLock {
+      _ = try store.protectedBundleIds()
+      activeTrial = nil
       var cleanupBundleIds = Set<String>()
-      clearStaleBundlePointersLocked()
-      normalizeStagedPointerLocked(
+      try clearStaleBundlePointersLocked()
+      try normalizeStagedPointerLocked(
         isBundleUsable: isBundleUsable,
         cleanupBundleIds: &cleanupBundleIds
       )
-      normalizeFallbackPointerLocked(
+      try normalizeFallbackPointerLocked(
         isBundleUsable: isBundleUsable,
         cleanupBundleIds: &cleanupBundleIds
       )
@@ -147,7 +158,7 @@ final class UpdaterCoordinator {
       let current = store.getCurrentBundle()
       if !current.isBuiltin,
          current.status == .trial {
-        let rollback = rollbackLocked(
+        let rollback = try rollbackLocked(
           reason: "app_restarted_before_notify",
           isBundleUsable: isBundleUsable,
           cleanupBundleIds: &cleanupBundleIds
@@ -157,24 +168,25 @@ final class UpdaterCoordinator {
 
       var normalizedCurrent = store.getCurrentBundle()
       if !normalizedCurrent.isBuiltin,
-         !isBundleUsable(normalizedCurrent) {
+         normalizedCurrent.status == .error || !isBundleUsable(normalizedCurrent) {
         cleanupBundleIds.insert(normalizedCurrent.id)
-        normalizedCurrent = restoreFallbackOrBuiltinLocked(
+        normalizedCurrent = try restoreFallbackOrBuiltinLocked(
           isBundleUsable: isBundleUsable,
-          cleanupBundleIds: &cleanupBundleIds
+          cleanupBundleIds: &cleanupBundleIds,
+          excluding: normalizedCurrent.id
         )
       }
 
-      var trialBundleId: String?
+      var trial: Trial?
       if !normalizedCurrent.isBuiltin,
          normalizedCurrent.status == .pending {
-        normalizedCurrent = updateStatusLocked(normalizedCurrent, status: .trial)
-        trialBundleId = normalizedCurrent.id
+        normalizedCurrent = try updateStatusLocked(normalizedCurrent, status: .trial)
+        trial = beginTrialLocked(bundleId: normalizedCurrent.id)
       }
 
       return StartupPreparation(
         activationPath: normalizedCurrent.isBuiltin ? nil : normalizedCurrent.path,
-        trialBundleId: trialBundleId,
+        trial: trial,
         cleanupBundleIds: Array(cleanupBundleIds),
         eventPayload: eventPayload
       )
@@ -225,10 +237,15 @@ final class UpdaterCoordinator {
 
   func stageDownloadedBundle(_ bundle: BundleInfo) throws -> [String] {
     try withStateLock {
+      guard !bundle.isBuiltin, !(try store.protectedBundleIds()).contains(bundle.id) else {
+        throw NSError(domain: "OtaKit", code: 1, userInfo: [
+          NSLocalizedDescriptionKey: "Cannot overwrite a referenced bundle installation"
+        ])
+      }
       var cleanupBundleIds = Set<String>()
       let previousStagedId = store.getStagedBundleId()
       try store.saveBundle(bundle)
-      store.setStagedBundleId(bundle.id)
+      try store.setStagedBundleId(bundle.id)
 
       if let previousStagedId,
          previousStagedId != bundle.id,
@@ -245,10 +262,15 @@ final class UpdaterCoordinator {
   func prepareApplyStaged(
     isCompatibleRuntime: @escaping (BundleInfo) -> Bool,
     isBundleUsable: @escaping (BundleInfo) -> Bool
-  ) -> ApplyPreparation {
-    withStateLock {
+  ) throws -> ApplyPreparation {
+    try withStateLock {
       var cleanupBundleIds = Set<String>()
-      guard var staged = stagedBundleLocked(
+      let previousCurrent = store.getCurrentBundle()
+      // Keep the staged update until the running trial has a definite outcome.
+      guard previousCurrent.status != .trial else {
+        return ApplyPreparation(activationPath: nil, trial: nil, cleanupBundleIds: [])
+      }
+      guard var staged = try stagedBundleLocked(
         cleanInvalid: true,
         isCompatibleRuntime: isCompatibleRuntime,
         isUsable: isBundleUsable,
@@ -256,48 +278,48 @@ final class UpdaterCoordinator {
       ) else {
         return ApplyPreparation(
           activationPath: nil,
-          trialBundleId: nil,
+          trial: nil,
           cleanupBundleIds: Array(cleanupBundleIds)
         )
       }
 
-      let previousCurrent = store.getCurrentBundle()
-      if previousCurrent.isBuiltin {
-        store.setFallbackBundleId(nil)
-      } else {
-        store.setFallbackBundleId(previousCurrent.id)
-      }
-
-      store.setCurrentBundleId(staged.id)
-      store.setStagedBundleId(nil)
-
-      var trialBundleId: String?
+      let fallbackId = previousCurrent.isBuiltin ? nil :
+        (previousCurrent.status == .success ? previousCurrent.id : store.getFallbackBundleId())
       if staged.status == .pending {
-        staged = updateStatusLocked(staged, status: .trial)
-        trialBundleId = staged.id
-      } else if staged.status == .trial {
-        trialBundleId = staged.id
+        staged = try updateStatusLocked(staged, status: .trial)
       }
+      // Persist trial metadata before publishing the pointer; keep all pointers in one write.
+      try store.setCoreState(
+        currentId: staged.id, fallbackId: fallbackId, stagedId: nil,
+        lastFailed: store.getLastFailedBundle()
+      )
+      let trial = staged.status == .trial ? beginTrialLocked(bundleId: staged.id) : nil
 
       return ApplyPreparation(
         activationPath: staged.path,
-        trialBundleId: trialBundleId,
+        trial: trial,
         cleanupBundleIds: Array(cleanupBundleIds)
       )
     }
   }
 
-  func prepareNotifyAppReady() -> NotifyReadyPreparation {
-    withStateLock {
+  func prepareNotifyAppReady(activationId: String?) throws -> NotifyReadyPreparation {
+    try withStateLock {
       let current = store.getCurrentBundle()
       guard !current.isBuiltin,
-            current.status == .trial else {
+            activeTrial?.bundleId == current.id,
+            let activationId, activeTrial?.activationId == activationId,
+            current.status == .trial ||
+              (current.status == .success && store.getFallbackBundleId() != current.id) else {
         return NotifyReadyPreparation(eventPayload: nil, cleanupBundleIds: [])
       }
 
       let oldFallbackId = store.getFallbackBundleId()
-      _ = updateStatusLocked(current, status: .success)
-      store.setFallbackBundleId(current.id)
+      if current.status == .trial {
+        _ = try updateStatusLocked(current, status: .success)
+      }
+      try store.setFallbackBundleId(current.id)
+      activeTrial = nil
 
       var cleanupBundleIds = Set<String>()
       if let oldFallbackId,
@@ -312,7 +334,9 @@ final class UpdaterCoordinator {
           runtimeVersion: current.runtimeVersion,
           channel: current.channel,
           releaseId: current.releaseId,
-          detail: nil
+          detail: nil,
+          attemptId: current.attemptId,
+          phase: "readiness"
         ),
         cleanupBundleIds: Array(cleanupBundleIds)
       )
@@ -320,12 +344,21 @@ final class UpdaterCoordinator {
   }
 
   func prepareRollback(
+    expectedTrial: Trial,
     reason: String,
     isBundleUsable: @escaping (BundleInfo) -> Bool
-  ) -> RollbackPreparation {
-    withStateLock {
+  ) throws -> RollbackPreparation {
+    try withStateLock {
+      let current = store.getCurrentBundle()
+      guard activeTrial == expectedTrial,
+            current.id == expectedTrial.bundleId,
+            current.status == .trial else {
+        return RollbackPreparation(
+          didRollback: false, activationPath: nil, eventPayload: nil, cleanupBundleIds: []
+        )
+      }
       var cleanupBundleIds = Set<String>()
-      let rollback = rollbackLocked(
+      let rollback = try rollbackLocked(
         reason: reason,
         isBundleUsable: isBundleUsable,
         cleanupBundleIds: &cleanupBundleIds
@@ -339,17 +372,22 @@ final class UpdaterCoordinator {
     }
   }
 
-  func isCurrentTrialBundle(_ bundleId: String) -> Bool {
-    withStateLock {
-      let current = store.getCurrentBundle()
-      return current.id == bundleId && current.status == .trial
-    }
+  private func beginTrialLocked(bundleId: String) -> Trial {
+    let trial = Trial(bundleId: bundleId)
+    activeTrial = trial
+    return trial
   }
 
   func cleanupBundles(_ bundleIds: [String]) {
-    let uniqueIds = Set(bundleIds).filter { !$0.isEmpty && $0 != "builtin" }
-    for bundleId in uniqueIds {
-      try? FileManager.default.removeItem(at: store.bundleDirectory(for: bundleId))
+    withStateLock {
+      // An unreadable state is not evidence that these files are unreferenced.
+      guard let protectedIds = try? store.protectedBundleIds() else { return }
+      let uniqueIds = Set(bundleIds).filter { !$0.isEmpty && $0 != "builtin" }
+      for bundleId in uniqueIds {
+        // A later transition may have made an earlier cleanup candidate live again.
+        guard !protectedIds.contains(bundleId) else { continue }
+        try? FileManager.default.removeItem(at: store.bundleDirectory(for: bundleId))
+      }
     }
   }
 
@@ -365,27 +403,27 @@ final class UpdaterCoordinator {
     return try work()
   }
 
-  private func clearStaleBundlePointersLocked() {
+  private func clearStaleBundlePointersLocked() throws {
     if let currentId = store.getCurrentBundleId(),
        store.getBundle(id: currentId) == nil {
-      store.setCurrentBundleId(nil)
+      try store.setCurrentBundleId(nil)
     }
 
     if let fallbackId = store.getFallbackBundleId(),
        store.getBundle(id: fallbackId) == nil {
-      store.setFallbackBundleId(nil)
+      try store.setFallbackBundleId(nil)
     }
 
     if let stagedId = store.getStagedBundleId(),
        store.getBundle(id: stagedId) == nil {
-      store.setStagedBundleId(nil)
+      try store.setStagedBundleId(nil)
     }
   }
 
   private func normalizeFallbackPointerLocked(
     isBundleUsable: (BundleInfo) -> Bool,
     cleanupBundleIds: inout Set<String>
-  ) {
+  ) throws {
     guard let fallbackId = store.getFallbackBundleId(),
           let fallback = store.getBundle(id: fallbackId) else {
       return
@@ -395,8 +433,8 @@ final class UpdaterCoordinator {
       return
     }
 
-    if !isBundleUsable(fallback) {
-      store.setFallbackBundleId(nil)
+    if fallback.status != .success || !isBundleUsable(fallback) {
+      try store.setFallbackBundleId(nil)
       cleanupBundleIds.insert(fallback.id)
     }
   }
@@ -404,18 +442,18 @@ final class UpdaterCoordinator {
   private func normalizeStagedPointerLocked(
     isBundleUsable: (BundleInfo) -> Bool,
     cleanupBundleIds: inout Set<String>
-  ) {
+  ) throws {
     guard let stagedId = store.getStagedBundleId() else {
       return
     }
 
     guard let staged = store.getBundle(id: stagedId) else {
-      store.setStagedBundleId(nil)
+      try store.setStagedBundleId(nil)
       return
     }
 
     if !isBundleUsable(staged) {
-      store.setStagedBundleId(nil)
+      try store.setStagedBundleId(nil)
       cleanupBundleIds.insert(staged.id)
     }
   }
@@ -425,7 +463,7 @@ final class UpdaterCoordinator {
     isUsable: (BundleInfo) -> Bool
   ) -> BundleInfo? {
     var ignored = Set<String>()
-    return stagedBundleLocked(
+    return try? stagedBundleLocked(
       cleanInvalid: false,
       isCompatibleRuntime: isCompatibleRuntime,
       isUsable: isUsable,
@@ -438,14 +476,14 @@ final class UpdaterCoordinator {
     isCompatibleRuntime: ((BundleInfo) -> Bool)?,
     isUsable: (BundleInfo) -> Bool,
     cleanupBundleIds: inout Set<String>
-  ) -> BundleInfo? {
+  ) throws -> BundleInfo? {
     guard let stagedId = store.getStagedBundleId() else {
       return nil
     }
 
     guard let staged = store.getBundle(id: stagedId) else {
       if cleanInvalid {
-        store.setStagedBundleId(nil)
+        try store.setStagedBundleId(nil)
       }
       return nil
     }
@@ -453,7 +491,7 @@ final class UpdaterCoordinator {
     if let isCompatibleRuntime,
        !isCompatibleRuntime(staged) {
       if cleanInvalid {
-        store.setStagedBundleId(nil)
+        try store.setStagedBundleId(nil)
         cleanupBundleIds.insert(staged.id)
       }
       return nil
@@ -461,7 +499,7 @@ final class UpdaterCoordinator {
 
     if !isUsable(staged) {
       if cleanInvalid {
-        store.setStagedBundleId(nil)
+        try store.setStagedBundleId(nil)
         cleanupBundleIds.insert(staged.id)
       }
       return nil
@@ -470,15 +508,15 @@ final class UpdaterCoordinator {
     return staged
   }
 
-  private func detachBundleReferencesLocked(bundleId: String) {
+  private func detachBundleReferencesLocked(bundleId: String) throws {
     if store.getCurrentBundleId() == bundleId {
-      store.setCurrentBundleId(nil)
+      try store.setCurrentBundleId(nil)
     }
     if store.getFallbackBundleId() == bundleId {
-      store.setFallbackBundleId(nil)
+      try store.setFallbackBundleId(nil)
     }
     if store.getStagedBundleId() == bundleId {
-      store.setStagedBundleId(nil)
+      try store.setStagedBundleId(nil)
     }
   }
 
@@ -486,7 +524,7 @@ final class UpdaterCoordinator {
     reason: String,
     isBundleUsable: (BundleInfo) -> Bool,
     cleanupBundleIds: inout Set<String>
-  ) -> LockedRollbackResult {
+  ) throws -> LockedRollbackResult {
     let current = store.getCurrentBundle()
     guard !current.isBuiltin else {
       return LockedRollbackResult(
@@ -496,14 +534,14 @@ final class UpdaterCoordinator {
       )
     }
 
-    let failed = updateStatusLocked(current, status: .error)
-    store.setLastFailedBundle(failed)
-    store.setStagedBundleId(nil)
-
-    let fallback = restoreFallbackOrBuiltinLocked(
+    let failed = current.withStatus(.error)
+    let fallback = try restoreFallbackOrBuiltinLocked(
       isBundleUsable: isBundleUsable,
-      cleanupBundleIds: &cleanupBundleIds
+      cleanupBundleIds: &cleanupBundleIds,
+      excluding: current.id,
+      failedBundle: failed
     )
+    activeTrial = nil
     cleanupBundleIds.insert(current.id)
 
     return LockedRollbackResult(
@@ -515,50 +553,48 @@ final class UpdaterCoordinator {
         runtimeVersion: current.runtimeVersion,
         channel: current.channel,
         releaseId: current.releaseId,
-        detail: reason
+        detail: reason,
+        attemptId: current.attemptId,
+        phase: "rollback"
       )
     )
   }
 
   private func restoreFallbackOrBuiltinLocked(
     isBundleUsable: (BundleInfo) -> Bool,
-    cleanupBundleIds: inout Set<String>
-  ) -> BundleInfo {
+    cleanupBundleIds: inout Set<String>,
+    excluding excludedBundleId: String,
+    failedBundle: BundleInfo? = nil
+  ) throws -> BundleInfo {
+    var restored = store.builtinBundle()
     if let fallbackId = store.getFallbackBundleId(),
        let fallback = store.getBundle(id: fallbackId),
        !fallback.isBuiltin,
+       fallback.id != excludedBundleId,
+       fallback.status == .success,
        isBundleUsable(fallback) {
-      store.setCurrentBundleId(fallback.id)
-      return fallback
-    }
-
-    if let fallbackId = store.getFallbackBundleId() {
-      store.setFallbackBundleId(nil)
-      if fallbackId != "builtin" {
-        cleanupBundleIds.insert(fallbackId)
-      }
+      restored = fallback
     }
 
-    store.setCurrentBundleId(nil)
-    return store.builtinBundle()
+    if let fallbackId = store.getFallbackBundleId(),
+       fallbackId != "builtin", fallbackId != restored.id {
+      cleanupBundleIds.insert(fallbackId)
+    }
+    let restoredId = restored.isBuiltin ? nil : restored.id
+    try store.setCoreState(
+      currentId: restoredId, fallbackId: restoredId,
+      stagedId: failedBundle == nil ? store.getStagedBundleId() : nil,
+      lastFailed: failedBundle ?? store.getLastFailedBundle()
+    )
+    return restored
   }
 
   private func updateStatusLocked(
     _ bundle: BundleInfo,
     status: BundleStatus
-  ) -> BundleInfo {
-    let updated = BundleInfo(
-      id: bundle.id,
-      version: bundle.version,
-      runtimeVersion: bundle.runtimeVersion,
-      status: status,
-      downloadedAt: bundle.downloadedAt,
-      sha256: bundle.sha256,
-      path: bundle.path,
-      channel: bundle.channel,
-      releaseId: bundle.releaseId
-    )
-    try? store.saveBundle(updated)
+  ) throws -> BundleInfo {
+    let updated = bundle.withStatus(status)
+    try store.saveBundle(updated)
     return updated
   }