@onekeyfe/react-native-range-downloader 3.0.81-alpha.0 → 3.0.81-alpha.10

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/ReactNativeRangeDownloader.kt

@@ -9,6 +9,9 @@ import java.io.File
 import java.security.MessageDigest
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.atomic.AtomicLong
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 
 // P1: Nitro adapter for the Android concurrent multi-range downloader.
 //
@@ -34,6 +37,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
 
   private val listeners = CopyOnWriteArrayList<Listener>()
   private val nextListenerId = AtomicLong(1)
+  private val firmwareArtifactScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
   // Active downloads keyed by "channel|taskId" so cancel/discardArtifacts can
   // flip the abort flag + stop the worker pool BEFORE deleting files, instead of
@@ -268,7 +272,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
 
   override fun getFirmwareArtifactCapabilities(): FirmwareArtifactCapabilities {
     return FirmwareArtifactCapabilities(
-      firmwareArtifactProtocolVersion = 1.0,
+      firmwareArtifactProtocolVersion = 3.0,
       supportedRouteTypes = arrayOf("domain", "pinnedIp"),
       supportsArchiveMaterialization = true,
       maxReadBytes = FirmwareArtifactStore.MAX_READ_BYTES.toDouble(),
@@ -278,7 +282,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun downloadFirmwareArtifact(
     params: FirmwareArtifactDownloadParams,
   ): Promise<FirmwareArtifactReceipt> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val artifact = FirmwareArtifactStore.download(params)
       FirmwareArtifactReceipt(
         artifactRef = artifact.artifactRef,
@@ -291,7 +295,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun cancelFirmwareArtifactDownloads(
     params: FirmwareArtifactCancelParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.cancelDownloads(params.transactionId)
     }
   }
@@ -299,7 +303,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun discardFirmwareArtifact(
     params: FirmwareArtifactRefParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.discard(params.artifactRef)
     }
   }
@@ -307,7 +311,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun openFirmwareArtifact(
     params: FirmwareArtifactRefParams,
   ): Promise<FirmwareArtifactReaderInfo> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val (readerId, size) = FirmwareArtifactStore.open(params.artifactRef)
       FirmwareArtifactReaderInfo(readerId = readerId, size = size.toDouble())
     }
@@ -316,7 +320,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun readFirmwareArtifact(
     params: FirmwareArtifactReaderReadParams,
   ): Promise<ArrayBuffer> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       require(
         params.offset.isFinite() &&
           params.offset >= 0 &&
@@ -340,7 +344,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun closeFirmwareArtifact(
     params: FirmwareArtifactReaderCloseParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.close(params.readerId)
     }
   }
@@ -348,7 +352,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun materializeFirmwareArchive(
     params: FirmwareArchiveMaterializeParams,
   ): Promise<FirmwareArchiveMaterializeResult> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val artifacts = FirmwareArtifactStore.materializeArchive(
         params.leaseRef,
         params.archiveArtifactRef,
@@ -372,7 +376,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun createFirmwareArtifactLease(
     params: FirmwareArtifactLeaseCreateParams,
   ): Promise<FirmwareArtifactLease> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactLease(
         leaseRef = FirmwareArtifactStore.createLease(params.transactionId),
       )
@@ -382,7 +386,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun retainFirmwareArtifact(
     params: FirmwareArtifactLeaseRetainParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.retain(params.leaseRef, params.artifactRef)
     }
   }
@@ -390,21 +394,13 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
   override fun releaseFirmwareArtifactLease(
     params: FirmwareArtifactLeaseReleaseParams,
   ): Promise<Unit> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       FirmwareArtifactStore.releaseLease(params.leaseRef, params.disposition)
     }
   }
 
-  override fun reconcileFirmwareArtifactLeases(
-    params: FirmwareArtifactLeaseReconcileParams,
-  ): Promise<Unit> {
-    return Promise.async {
-      FirmwareArtifactStore.reconcileLeases(params.activeLeaseRefs)
-    }
-  }
-
   override fun sweepFirmwareArtifactOrphans(): Promise<FirmwareArtifactSweepResult> {
-    return Promise.async {
+    return Promise.async(firmwareArtifactScope) {
       val (deletedFiles, deletedBytes) = FirmwareArtifactStore.sweepOrphans()
       FirmwareArtifactSweepResult(
         deletedFiles = deletedFiles.toDouble(),

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArchiveRulesTest.kt

@@ -1,10 +1,19 @@
 package com.margelo.nitro.reactnativerangedownloader
 
+import java.io.File
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertThrows
+import org.junit.Rule
 import org.junit.Test
+import org.junit.rules.TemporaryFolder
 
 class FirmwareArchiveRulesTest {
+  @get:Rule
+  val temporaryFolder = TemporaryFolder()
+
   private fun entry(
     artifactId: String = "resource-entry",
     entryName: String = "assets/icon.png",
@@ -72,4 +81,34 @@ class FirmwareArchiveRulesTest {
       )
     }
   }
+
+  @Test
+  fun acceptsPortableEntriesWithoutExpectedIntegrityMetadata() {
+    val archive = createArchive("assets/icon.png", byteArrayOf(1, 2, 3))
+
+    val entries = FirmwareArchiveRules.validateCentralDirectory(archive, null)
+
+    assertEquals(1, entries.size)
+    assertEquals("assets/icon.png", entries.single().name)
+    assertEquals(3, entries.single().uncompressedSize)
+  }
+
+  @Test
+  fun rejectsTraversalWithoutExpectedIntegrityMetadata() {
+    val archive = createArchive("../icon.png", byteArrayOf(1))
+
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateCentralDirectory(archive, null)
+    }
+  }
+
+  private fun createArchive(entryName: String, content: ByteArray): File {
+    val archive = temporaryFolder.newFile("firmware.zip")
+    ZipOutputStream(FileOutputStream(archive)).use { zip ->
+      zip.putNextEntry(ZipEntry(entryName))
+      zip.write(content)
+      zip.closeEntry()
+    }
+    return archive
+  }
 }

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArtifactDeadlineTest.kt

@@ -0,0 +1,26 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class FirmwareArtifactDeadlineTest {
+  @Test
+  fun defaultsToABoundedThreeMinuteDeadline() {
+    assertEquals(180.0, validateFirmwareDownloadDeadlineSeconds(null), 0.0)
+  }
+
+  @Test
+  fun preservesFractionalDeadlines() {
+    assertEquals(2.75, validateFirmwareDownloadDeadlineSeconds(2.75), 0.0)
+  }
+
+  @Test
+  fun rejectsUnboundedOrInvalidDeadlines() {
+    listOf(0.0, -1.0, Double.NaN, Double.POSITIVE_INFINITY, 86_400.1).forEach {
+      assertThrows(IllegalArgumentException::class.java) {
+        validateFirmwareDownloadDeadlineSeconds(it)
+      }
+    }
+  }
+}

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArtifactOrphanSweepTest.kt

@@ -0,0 +1,107 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class FirmwareArtifactOrphanSweepTest {
+  @get:Rule
+  val temporaryFolder = TemporaryFolder()
+
+  @Test
+  fun removesOnlyStaleRootScratchEntriesWithExactNamesAndTypes() {
+    val root = temporaryFolder.newFolder("firmware-artifact-sweep")
+    val nowMs = 2_000_000_000_000L
+    val staleAt = nowMs - FIRMWARE_ARTIFACT_SCRATCH_GRACE_MS - 1
+    val freshAt = nowMs - FIRMWARE_ARTIFACT_SCRATCH_GRACE_MS + 1
+    val staleArchive = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000001",
+    ).apply {
+      assertTrue(mkdirs())
+      File(this, "0.entry").writeText("archive")
+    }
+    val stalePromote = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000002",
+    ).apply { writeText("promote") }
+    val freshArchive = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000003",
+    ).apply { assertTrue(mkdirs()) }
+    val freshPromote = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000004",
+    ).apply { writeText("promote") }
+    val malformedArchive = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000005.extra",
+    ).apply { assertTrue(mkdirs()) }
+    val malformedPromote = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000006.tmp",
+    ).apply { writeText("promote") }
+    val archiveNamedFile = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000007",
+    ).apply { writeText("promote") }
+    val promoteNamedDirectory = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000008",
+    ).apply { assertTrue(mkdirs()) }
+    val nestedArchive = File(
+      File(root, "nested"),
+      "archive-00000000-0000-4000-8000-000000000009",
+    ).apply { assertTrue(mkdirs()) }
+
+    for (
+      entry in listOf(
+        staleArchive,
+        stalePromote,
+        malformedArchive,
+        malformedPromote,
+        archiveNamedFile,
+        promoteNamedDirectory,
+        nestedArchive,
+      )
+    ) {
+      assertTrue(entry.setLastModified(staleAt))
+    }
+    for (entry in listOf(freshArchive, freshPromote)) {
+      assertTrue(entry.setLastModified(freshAt))
+    }
+
+    val result = sweepFirmwareArtifactOrphansAtRoot(
+      root = root,
+      retainedSha256 = emptySet(),
+      activeSha256 = emptySet(),
+      openPaths = emptySet(),
+      nowMs = nowMs,
+    )
+
+    assertEquals(2, result.first)
+    assertEquals(14L, result.second)
+    assertFalse(staleArchive.exists())
+    assertFalse(stalePromote.exists())
+    for (
+      retainedEntry in listOf(
+        freshArchive,
+        freshPromote,
+        malformedArchive,
+        malformedPromote,
+        archiveNamedFile,
+        promoteNamedDirectory,
+        nestedArchive,
+      )
+    ) {
+      assertTrue(
+        "Unexpectedly removed ${retainedEntry.name}",
+        retainedEntry.exists(),
+      )
+    }
+  }
+}