@otakit/capacitor-updater 2.3.2 → 3.0.0

package/android/src/main/java/com/otakit/updater/UpdaterCoordinator.java

@@ -10,6 +10,16 @@ import java.util.concurrent.locks.ReentrantLock;
 
 final class UpdaterCoordinator {
 
+  static final class Trial {
+
+    final String bundleId;
+    final String activationId = java.util.UUID.randomUUID().toString();
+
+    Trial(String bundleId) {
+      this.bundleId = bundleId;
+    }
+  }
+
   interface BundlePredicate {
     boolean test(BundleInfo bundle);
   }
@@ -42,6 +52,8 @@ final class UpdaterCoordinator {
     final String channel;
     final String releaseId;
     final String detail;
+    final String attemptId;
+    final String phase;
 
     DeviceEventPayload(
       String action,
@@ -50,6 +62,19 @@ final class UpdaterCoordinator {
       String channel,
       String releaseId,
       String detail
+    ) {
+      this(action, bundleVersion, runtimeVersion, channel, releaseId, detail, null, null);
+    }
+
+    DeviceEventPayload(
+      String action,
+      String bundleVersion,
+      String runtimeVersion,
+      String channel,
+      String releaseId,
+      String detail,
+      String attemptId,
+      String phase
     ) {
       this.action = action;
       this.bundleVersion = bundleVersion;
@@ -57,6 +82,8 @@ final class UpdaterCoordinator {
       this.channel = channel;
       this.releaseId = releaseId;
       this.detail = detail;
+      this.attemptId = attemptId;
+      this.phase = phase;
     }
   }
 
@@ -86,18 +113,18 @@ final class UpdaterCoordinator {
   static final class StartupPreparation {
 
     final String activationPath;
-    final String trialBundleId;
+    final Trial trial;
     final List<String> cleanupBundleIds;
     final DeviceEventPayload eventPayload;
 
     StartupPreparation(
       String activationPath,
-      String trialBundleId,
+      Trial trial,
       List<String> cleanupBundleIds,
       DeviceEventPayload eventPayload
     ) {
       this.activationPath = activationPath;
-      this.trialBundleId = trialBundleId;
+      this.trial = trial;
       this.cleanupBundleIds = cleanupBundleIds;
       this.eventPayload = eventPayload;
     }
@@ -106,12 +133,12 @@ final class UpdaterCoordinator {
   static final class ApplyPreparation {
 
     final String activationPath;
-    final String trialBundleId;
+    final Trial trial;
     final List<String> cleanupBundleIds;
 
-    ApplyPreparation(String activationPath, String trialBundleId, List<String> cleanupBundleIds) {
+    ApplyPreparation(String activationPath, Trial trial, List<String> cleanupBundleIds) {
       this.activationPath = activationPath;
-      this.trialBundleId = trialBundleId;
+      this.trial = trial;
       this.cleanupBundleIds = cleanupBundleIds;
     }
 
@@ -176,6 +203,7 @@ final class UpdaterCoordinator {
   private final BundleStore store;
   private final AtomicBoolean operationInProgress = new AtomicBoolean(false);
   private final ReentrantLock stateLock = new ReentrantLock();
+  private Trial activeTrial;
 
   UpdaterCoordinator(BundleStore store) {
     this.store = store;
@@ -214,6 +242,7 @@ final class UpdaterCoordinator {
 
   List<String> pruneIncompatibleBundles(BundlePredicate isCompatibleRuntime) {
     return withStateLock(() -> {
+      store.protectedBundleIds();
       Set<String> cleanupBundleIds = new LinkedHashSet<>();
 
       for (BundleInfo bundle : store.listDownloadedBundleInfos()) {
@@ -234,6 +263,8 @@ final class UpdaterCoordinator {
 
   StartupPreparation normalizeStartupState(BundlePredicate isBundleUsable) {
     return withStateLock(() -> {
+      store.protectedBundleIds();
+      activeTrial = null;
       Set<String> cleanupBundleIds = new LinkedHashSet<>();
       clearStaleBundlePointersLocked();
       normalizeStagedPointerLocked(isBundleUsable, cleanupBundleIds);
@@ -251,20 +282,28 @@ final class UpdaterCoordinator {
       }
 
       BundleInfo normalizedCurrent = store.getCurrentBundle();
-      if (!normalizedCurrent.isBuiltin() && !isBundleUsable.test(normalizedCurrent)) {
+      if (
+        !normalizedCurrent.isBuiltin() &&
+        (normalizedCurrent.status == BundleStatus.ERROR || !isBundleUsable.test(normalizedCurrent))
+      ) {
         cleanupBundleIds.add(normalizedCurrent.id);
-        normalizedCurrent = restoreFallbackOrBuiltinLocked(isBundleUsable, cleanupBundleIds);
+        normalizedCurrent = restoreFallbackOrBuiltinLocked(
+          isBundleUsable,
+          cleanupBundleIds,
+          normalizedCurrent.id,
+          null
+        );
       }
 
-      String trialBundleId = null;
+      Trial trial = null;
       if (!normalizedCurrent.isBuiltin() && normalizedCurrent.status == BundleStatus.PENDING) {
         normalizedCurrent = updateStatusLocked(normalizedCurrent, BundleStatus.TRIAL);
-        trialBundleId = normalizedCurrent.id;
+        trial = beginTrialLocked(normalizedCurrent.id);
       }
 
       return new StartupPreparation(
         normalizedCurrent.isBuiltin() ? null : normalizedCurrent.path,
-        trialBundleId,
+        trial,
         new ArrayList<>(cleanupBundleIds),
         eventPayload
       );
@@ -318,6 +357,9 @@ final class UpdaterCoordinator {
 
   List<String> stageDownloadedBundle(BundleInfo bundle) throws Exception {
     return withStateLock(() -> {
+      if (bundle.isBuiltin() || store.protectedBundleIds().contains(bundle.id)) {
+        throw new IllegalStateException("Cannot overwrite a referenced bundle installation");
+      }
       Set<String> cleanupBundleIds = new LinkedHashSet<>();
       String previousStagedId = store.getStagedBundleId();
       store.saveBundle(bundle);
@@ -343,6 +385,11 @@ final class UpdaterCoordinator {
   ) {
     return withStateLock(() -> {
       Set<String> cleanupBundleIds = new LinkedHashSet<>();
+      BundleInfo previousCurrent = store.getCurrentBundle();
+      // A staged update must not replace the only running trial before it is acknowledged.
+      if (previousCurrent.status == BundleStatus.TRIAL) {
+        return new ApplyPreparation(null, null, new ArrayList<>());
+      }
       BundleInfo staged = stagedBundleLocked(
         true,
         isCompatibleRuntime,
@@ -353,38 +400,42 @@ final class UpdaterCoordinator {
         return new ApplyPreparation(null, null, new ArrayList<>(cleanupBundleIds));
       }
 
-      BundleInfo previousCurrent = store.getCurrentBundle();
-      if (previousCurrent.isBuiltin()) {
-        store.setFallbackBundleId(null);
-      } else {
-        store.setFallbackBundleId(previousCurrent.id);
-      }
-
-      store.setCurrentBundleId(staged.id);
-      store.setStagedBundleId(null);
-
-      String trialBundleId = null;
+      String fallbackId = previousCurrent.isBuiltin()
+        ? null
+        : (previousCurrent.status == BundleStatus.SUCCESS
+            ? previousCurrent.id
+            : store.getFallbackBundleId());
       if (staged.status == BundleStatus.PENDING) {
         staged = updateStatusLocked(staged, BundleStatus.TRIAL);
-        trialBundleId = staged.id;
-      } else if (staged.status == BundleStatus.TRIAL) {
-        trialBundleId = staged.id;
       }
+      store.setCoreState(staged.id, fallbackId, null, store.getLastFailedBundle());
+      Trial trial = staged.status == BundleStatus.TRIAL ? beginTrialLocked(staged.id) : null;
 
-      return new ApplyPreparation(staged.path, trialBundleId, new ArrayList<>(cleanupBundleIds));
+      return new ApplyPreparation(staged.path, trial, new ArrayList<>(cleanupBundleIds));
     });
   }
 
-  NotifyReadyPreparation prepareNotifyAppReady() {
+  NotifyReadyPreparation prepareNotifyAppReady(String activationId) {
     return withStateLock(() -> {
       BundleInfo current = store.getCurrentBundle();
-      if (current.isBuiltin() || current.status != BundleStatus.TRIAL) {
+      if (
+        current.isBuiltin() ||
+        activeTrial == null ||
+        !activeTrial.activationId.equals(activationId) ||
+        !activeTrial.bundleId.equals(current.id) ||
+        (current.status != BundleStatus.TRIAL &&
+          !(current.status == BundleStatus.SUCCESS &&
+            !current.id.equals(store.getFallbackBundleId())))
+      ) {
         return new NotifyReadyPreparation(null, new ArrayList<>());
       }
 
       String oldFallbackId = store.getFallbackBundleId();
-      updateStatusLocked(current, BundleStatus.SUCCESS);
+      if (current.status == BundleStatus.TRIAL) {
+        updateStatusLocked(current, BundleStatus.SUCCESS);
+      }
       store.setFallbackBundleId(current.id);
+      activeTrial = null;
 
       Set<String> cleanupBundleIds = new LinkedHashSet<>();
       if (oldFallbackId != null && !oldFallbackId.equals(current.id)) {
@@ -398,15 +449,31 @@ final class UpdaterCoordinator {
           current.runtimeVersion,
           current.channel,
           current.releaseId,
-          null
+          null,
+          current.attemptId(),
+          "readiness"
         ),
         new ArrayList<>(cleanupBundleIds)
       );
     });
   }
 
-  RollbackPreparation prepareRollback(String reason, BundlePredicate isBundleUsable) {
+  RollbackPreparation prepareRollback(
+    Trial expectedTrial,
+    String reason,
+    BundlePredicate isBundleUsable
+  ) {
     return withStateLock(() -> {
+      BundleInfo current = store.getCurrentBundle();
+      if (
+        activeTrial == null ||
+        expectedTrial == null ||
+        !activeTrial.activationId.equals(expectedTrial.activationId) ||
+        !current.id.equals(expectedTrial.bundleId) ||
+        current.status != BundleStatus.TRIAL
+      ) {
+        return new RollbackPreparation(false, null, null, new ArrayList<>());
+      }
       Set<String> cleanupBundleIds = new LinkedHashSet<>();
       LockedRollbackResult rollback = rollbackLocked(reason, isBundleUsable, cleanupBundleIds);
       return new RollbackPreparation(
@@ -418,11 +485,9 @@ final class UpdaterCoordinator {
     });
   }
 
-  boolean isCurrentTrialBundle(String bundleId) {
-    return withStateLock(() -> {
-      BundleInfo current = store.getCurrentBundle();
-      return current.id.equals(bundleId) && current.status == BundleStatus.TRIAL;
-    });
+  private Trial beginTrialLocked(String bundleId) {
+    activeTrial = new Trial(bundleId);
+    return activeTrial;
   }
 
   void cleanupBundles(List<String> bundleIds) {
@@ -433,9 +498,22 @@ final class UpdaterCoordinator {
       }
     }
 
-    for (String bundleId : uniqueIds) {
-      deleteRecursivelyQuietly(store.bundleDirectory(bundleId));
-    }
+    withStateLock(() -> {
+      Set<String> protectedIds;
+      try {
+        protectedIds = store.protectedBundleIds();
+      } catch (Exception error) {
+        // An unreadable state is not evidence that these files are unreferenced.
+        return null;
+      }
+      for (String bundleId : uniqueIds) {
+        // Cleanup can run after a newer transition has made this bundle live again.
+        if (!protectedIds.contains(bundleId)) {
+          deleteRecursivelyQuietly(store.bundleDirectory(bundleId));
+        }
+      }
+      return null;
+    });
   }
 
   private <T> T withStateLock(LockedSupplier<T> work) {
@@ -482,7 +560,7 @@ final class UpdaterCoordinator {
       return;
     }
 
-    if (!isBundleUsable.test(fallback)) {
+    if (fallback.status != BundleStatus.SUCCESS || !isBundleUsable.test(fallback)) {
       store.setFallbackBundleId(null);
       cleanupBundleIds.add(fallback.id);
     }
@@ -576,11 +654,14 @@ final class UpdaterCoordinator {
       return new LockedRollbackResult(false, null, null);
     }
 
-    BundleInfo failed = updateStatusLocked(current, BundleStatus.ERROR);
-    store.setLastFailedBundle(failed);
-    store.setStagedBundleId(null);
-
-    BundleInfo fallback = restoreFallbackOrBuiltinLocked(isBundleUsable, cleanupBundleIds);
+    BundleInfo failed = current.withStatus(BundleStatus.ERROR);
+    BundleInfo fallback = restoreFallbackOrBuiltinLocked(
+      isBundleUsable,
+      cleanupBundleIds,
+      current.id,
+      failed
+    );
+    activeTrial = null;
     cleanupBundleIds.add(current.id);
 
     return new LockedRollbackResult(
@@ -592,40 +673,54 @@ final class UpdaterCoordinator {
         current.runtimeVersion,
         current.channel,
         current.releaseId,
-        reason
+        reason,
+        current.attemptId(),
+        "rollback"
       )
     );
   }
 
   private BundleInfo restoreFallbackOrBuiltinLocked(
     BundlePredicate isBundleUsable,
-    Set<String> cleanupBundleIds
+    Set<String> cleanupBundleIds,
+    String excludedBundleId,
+    BundleInfo failedBundle
   ) {
+    BundleInfo restored = store.builtinBundle();
     String fallbackId = store.getFallbackBundleId();
     if (fallbackId != null) {
       BundleInfo fallback = store.getBundle(fallbackId);
-      if (fallback != null && !fallback.isBuiltin() && isBundleUsable.test(fallback)) {
-        store.setCurrentBundleId(fallback.id);
-        return fallback;
+      if (
+        fallback != null &&
+        !fallback.isBuiltin() &&
+        !fallback.id.equals(excludedBundleId) &&
+        fallback.status == BundleStatus.SUCCESS &&
+        isBundleUsable.test(fallback)
+      ) {
+        restored = fallback;
       }
     }
 
-    if (fallbackId != null) {
-      store.setFallbackBundleId(null);
-      if (!"builtin".equals(fallbackId)) {
-        cleanupBundleIds.add(fallbackId);
-      }
+    if (fallbackId != null && !"builtin".equals(fallbackId) && !fallbackId.equals(restored.id)) {
+      cleanupBundleIds.add(fallbackId);
     }
-
-    store.setCurrentBundleId(null);
-    return store.builtinBundle();
+    String restoredId = restored.isBuiltin() ? null : restored.id;
+    store.setCoreState(
+      restoredId,
+      restoredId,
+      failedBundle == null ? store.getStagedBundleId() : null,
+      failedBundle == null ? store.getLastFailedBundle() : failedBundle
+    );
+    return restored;
   }
 
   private BundleInfo updateStatusLocked(BundleInfo bundle, BundleStatus status) {
     BundleInfo updated = bundle.withStatus(status);
     try {
       store.saveBundle(updated);
-    } catch (Exception ignored) {}
+    } catch (Exception error) {
+      throw new IllegalStateException("Could not persist bundle status", error);
+    }
     return updated;
   }