@onekeyfe/react-native-range-downloader 3.0.81-alpha.1 → 3.0.81-alpha.2

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

@@ -6,7 +6,6 @@ import com.sniconnect.SniPinnedTransport
 import java.io.BufferedInputStream
 import java.io.File
 import java.io.FileInputStream
-import java.io.FileOutputStream
 import java.io.IOException
 import java.io.RandomAccessFile
 import java.security.MessageDigest
@@ -14,14 +13,29 @@ import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
 import java.util.zip.ZipInputStream
+import javax.net.ssl.SSLException
+import kotlin.math.ceil
 import okhttp3.Call
 import okhttp3.OkHttpClient
 import okhttp3.Protocol
 import okhttp3.Request
 import okhttp3.Response
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
-import org.json.JSONArray
-import org.json.JSONObject
+
+private const val DEFAULT_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS = 180.0
+private const val MAX_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS = 24.0 * 60 * 60
+
+internal fun validateFirmwareDownloadDeadlineSeconds(value: Double?): Double {
+  val deadline = value ?: DEFAULT_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS
+  require(
+    deadline.isFinite() &&
+      deadline > 0 &&
+      deadline <= MAX_FIRMWARE_DOWNLOAD_DEADLINE_SECONDS
+  ) {
+    "Invalid firmware download deadline"
+  }
+  return deadline
+}
 
 internal data class StoredFirmwareArtifact(
   val artifactRef: String,
@@ -43,23 +57,26 @@ private data class StagedFirmwareArchiveEntry(
 )
 
 private data class FirmwareDownloadKey(
-  val transactionId: String,
   val expectedSha256: String,
 )
 
+private class FirmwareDownloadLock {
+  val monitor = Any()
+  var references = 0
+}
+
 internal object FirmwareArtifactStore {
   const val MAX_READ_BYTES = 256 * 1024
 
   private const val MAX_ARTIFACT_BYTES = 512L * 1024 * 1024
-  private const val MAX_LEASE_METADATA_BYTES = 1024L * 1024
-  private const val MAX_TOTAL_LEASE_REFS = 8192
   private const val FINAL_ARTIFACT_GRACE_MS = 24L * 60 * 60 * 1000
   private const val PARTIAL_ARTIFACT_GRACE_MS = 7L * 24 * 60 * 60 * 1000
   private val sha256Pattern = Regex("^[a-fA-F0-9]{64}$")
   private val artifactRefPattern = Regex("^fw:[a-f0-9]{64}$")
   private val leaseRefPattern = Regex("^fwlease:[a-f0-9-]{36}$")
   private val identifierPattern = Regex("^[A-Za-z0-9._:-]{1,160}$")
-  private val downloadLocks = ConcurrentHashMap<FirmwareDownloadKey, Any>()
+  private val downloadLocks =
+    ConcurrentHashMap<FirmwareDownloadKey, FirmwareDownloadLock>()
   private val activeCalls =
     ConcurrentHashMap<String, MutableSet<Call>>()
   private val cancelledTransactions =
@@ -69,6 +86,7 @@ internal object FirmwareArtifactStore {
   private val leaseLock = Any()
   private val readerLock = Any()
   private val readers = mutableMapOf<String, OpenReader>()
+  private val leases = mutableMapOf<String, LeaseState>()
 
   private data class LeaseState(
     val transactionId: String,
@@ -102,14 +120,15 @@ internal object FirmwareArtifactStore {
       transactionId = params.transactionId,
       artifactRef = "fw:${validated.expectedSha256}",
     )
-    val lockKey = FirmwareDownloadKey(
-      params.transactionId,
-      validated.expectedSha256,
-    )
-    val lock = downloadLocks.computeIfAbsent(lockKey) { Any() }
+    val lockKey = FirmwareDownloadKey(validated.expectedSha256)
+    val downloadLock = downloadLocks.compute(lockKey) { _, current ->
+      (current ?: FirmwareDownloadLock()).also {
+        it.references += 1
+      }
+    } ?: error("Firmware artifact lock is unavailable")
     markDownloadActive(validated.expectedSha256, 1)
     try {
-      return synchronized(lock) {
+      return synchronized(downloadLock.monitor) {
         check(!cancelledTransactions.contains(params.transactionId)) {
           "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
         }
@@ -117,6 +136,14 @@ internal object FirmwareArtifactStore {
       }
     } finally {
       markDownloadActive(validated.expectedSha256, -1)
+      downloadLocks.compute(lockKey) { _, current ->
+        if (current !== downloadLock) {
+          current
+        } else {
+          current.references -= 1
+          current.takeIf { it.references > 0 }
+        }
+      }
     }
   }
 
@@ -133,7 +160,7 @@ internal object FirmwareArtifactStore {
   fun discard(artifactRef: String) {
     val file = resolveArtifactFile(artifactRef)
     synchronized(leaseLock) {
-      require(loadLeasesLocked().values.none { artifactRef in it.artifactRefs }) {
+      require(leases.values.none { artifactRef in it.artifactRefs }) {
         "ARTIFACT_LEASED: firmware artifact is retained"
       }
     }
@@ -284,6 +311,7 @@ internal object FirmwareArtifactStore {
     val maxBytes: Long,
     val expectedSha256: String,
     val hostname: String,
+    val overallDeadlineSeconds: Double,
   )
 
   private fun validateDownloadParams(
@@ -324,6 +352,8 @@ internal object FirmwareArtifactStore {
     require(sha256Pattern.matches(params.expectedSha256)) {
       "Invalid firmware artifact SHA-256"
     }
+    val overallDeadlineSeconds =
+      validateFirmwareDownloadDeadlineSeconds(params.overallDeadlineSeconds)
     require(params.routeType == "domain" || params.routeType == "pinnedIp") {
       "Invalid firmware route type"
     }
@@ -341,6 +371,7 @@ internal object FirmwareArtifactStore {
       maxBytes = maxBytes,
       expectedSha256 = params.expectedSha256.lowercase(),
       hostname = url.host,
+      overallDeadlineSeconds = overallDeadlineSeconds,
     )
   }
 
@@ -400,12 +431,10 @@ internal object FirmwareArtifactStore {
         .build()
     }
     val call = client.newCall(requestBuilder.build())
-    params.overallDeadlineSeconds?.let { deadline ->
-      require(deadline.isFinite() && deadline > 0) {
-        "Invalid firmware download deadline"
-      }
-      call.timeout().timeout(deadline.toLong().coerceAtLeast(1), TimeUnit.SECONDS)
-    }
+    call.timeout().timeout(
+      ceil(validated.overallDeadlineSeconds * 1000).toLong(),
+      TimeUnit.MILLISECONDS,
+    )
 
     registerCall(params.transactionId, call)
     try {
@@ -428,6 +457,12 @@ internal object FirmwareArtifactStore {
           error,
         )
       }
+      if (generateSequence<Throwable>(error) { it.cause }.any { it is SSLException }) {
+        throw IllegalStateException(
+          "ARTIFACT_TLS_FAILED: firmware TLS validation failed",
+          error,
+        )
+      }
       throw IllegalStateException(
         "ARTIFACT_NETWORK_FAILED: firmware request failed",
         error,
@@ -563,13 +598,11 @@ internal object FirmwareArtifactStore {
       "Invalid firmware transactionId"
     }
     return synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
       require(leases.size < 32) {
         "Too many firmware artifact leases"
       }
       val leaseRef = "fwlease:${UUID.randomUUID()}"
       leases[leaseRef] = LeaseState(transactionId, mutableSetOf())
-      saveLeasesLocked(leases)
       leaseRef
     }
   }
@@ -592,41 +625,18 @@ internal object FirmwareArtifactStore {
       "Invalid firmware lease disposition"
     }
     val transactionId = synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
       val removed = leases.remove(validateLeaseRef(leaseRef))
       require(removed != null) {
         "Firmware artifact lease is unavailable"
       }
-      saveLeasesLocked(leases)
       removed.transactionId
     }
     cancelledTransactions.remove(transactionId)
-    downloadLocks.keys.removeIf { it.transactionId == transactionId }
-  }
-
-  fun reconcileLeases(activeLeaseRefs: Array<String>) {
-    require(activeLeaseRefs.size <= 32) {
-      "Too many active firmware artifact leases"
-    }
-    val active = activeLeaseRefs.mapTo(mutableSetOf()) {
-      validateLeaseRef(it)
-    }
-    require(active.size == activeLeaseRefs.size) {
-      "Duplicate active firmware artifact lease"
-    }
-    synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
-      require(active.all { leases.containsKey(it) }) {
-        "Firmware artifact lease reconciliation is incomplete"
-      }
-      leases.keys.retainAll(active)
-      saveLeasesLocked(leases)
-    }
   }
 
   fun sweepOrphans(): Pair<Int, Long> {
     val retainedSha256 = synchronized(leaseLock) {
-      loadLeasesLocked().values
+      leases.values
         .flatMap { it.artifactRefs }
         .mapTo(mutableSetOf()) { it.removePrefix("fw:") }
     }
@@ -640,7 +650,7 @@ internal object FirmwareArtifactStore {
     var deletedFiles = 0
     var deletedBytes = 0L
     root.listFiles()?.forEach { file ->
-      if (!file.isFile || file.name == "leases.json") return@forEach
+      if (!file.isFile) return@forEach
       val sha256 = file.name.take(64)
       if (
         !sha256Pattern.matches(sha256) ||
@@ -669,7 +679,7 @@ internal object FirmwareArtifactStore {
 
   private fun requireLease(leaseRef: String) {
     synchronized(leaseLock) {
-      require(loadLeasesLocked().containsKey(validateLeaseRef(leaseRef))) {
+      require(leases.containsKey(validateLeaseRef(leaseRef))) {
         "Firmware artifact lease is unavailable"
       }
     }
@@ -684,7 +694,6 @@ internal object FirmwareArtifactStore {
       "Invalid firmware artifactRef"
     }
     synchronized(leaseLock) {
-      val leases = loadLeasesLocked()
       val lease = leases[validateLeaseRef(leaseRef)]
         ?: error("Firmware artifact lease is unavailable")
       if (transactionId != null) {
@@ -692,9 +701,7 @@ internal object FirmwareArtifactStore {
           "Firmware artifact lease transaction mismatch"
         }
       }
-      if (lease.artifactRefs.add(artifactRef)) {
-        saveLeasesLocked(leases)
-      }
+      lease.artifactRefs.add(artifactRef)
     }
   }
 
@@ -705,81 +712,6 @@ internal object FirmwareArtifactStore {
     return leaseRef
   }
 
-  private fun loadLeasesLocked(): MutableMap<String, LeaseState> {
-    val file = File(root, "leases.json")
-    if (!file.exists()) return mutableMapOf()
-    require(file.length() in 1..MAX_LEASE_METADATA_BYTES) {
-      "Firmware lease metadata is too large"
-    }
-    val envelope = JSONObject(file.readText(Charsets.UTF_8))
-    require(envelope.optInt("schemaVersion") == 1) {
-      "Unsupported firmware lease schema"
-    }
-    val result = mutableMapOf<String, LeaseState>()
-    val jsonLeases = envelope.getJSONObject("leases")
-    val keys = jsonLeases.keys()
-    while (keys.hasNext()) {
-      val leaseRef = validateLeaseRef(keys.next())
-      val jsonLease = jsonLeases.getJSONObject(leaseRef)
-      val transactionId = jsonLease.getString("transactionId")
-      require(identifierPattern.matches(transactionId)) {
-        "Invalid persisted firmware transactionId"
-      }
-      val jsonRefs = jsonLease.getJSONArray("artifactRefs")
-      require(jsonRefs.length() <= 4096) {
-        "Too many persisted firmware artifact refs"
-      }
-      val refs = mutableSetOf<String>()
-      for (index in 0 until jsonRefs.length()) {
-        val artifactRef = jsonRefs.getString(index)
-        require(artifactRefPattern.matches(artifactRef) && refs.add(artifactRef)) {
-          "Invalid persisted firmware artifact ref"
-        }
-      }
-      result[leaseRef] = LeaseState(transactionId, refs)
-    }
-    require(result.size <= 32) {
-      "Too many persisted firmware artifact leases"
-    }
-    require(result.values.sumOf { it.artifactRefs.size } <= MAX_TOTAL_LEASE_REFS) {
-      "Too many persisted firmware artifact refs"
-    }
-    return result
-  }
-
-  private fun saveLeasesLocked(leases: Map<String, LeaseState>) {
-    require(
-      leases.size <= 32 &&
-        leases.values.sumOf { it.artifactRefs.size } <= MAX_TOTAL_LEASE_REFS
-    ) {
-      "Firmware lease metadata is too large"
-    }
-    val jsonLeases = JSONObject()
-    leases.toSortedMap().forEach { (leaseRef, lease) ->
-      jsonLeases.put(
-        leaseRef,
-        JSONObject()
-          .put("transactionId", lease.transactionId)
-          .put("artifactRefs", JSONArray(lease.artifactRefs.sorted())),
-      )
-    }
-    val bytes = JSONObject()
-      .put("schemaVersion", 1)
-      .put("leases", jsonLeases)
-      .toString()
-      .toByteArray(Charsets.UTF_8)
-    require(bytes.size.toLong() <= MAX_LEASE_METADATA_BYTES) {
-      "Firmware lease metadata is too large"
-    }
-    val destination = File(root, "leases.json")
-    val temporary = File(root, ".leases-${UUID.randomUUID()}.tmp")
-    FileOutputStream(temporary).use { output ->
-      output.write(bytes)
-      output.fd.sync()
-    }
-    Os.rename(temporary.absolutePath, destination.absolutePath)
-  }
-
   private fun markDownloadActive(sha256: String, delta: Int) {
     synchronized(activeDownloadLock) {
       val count = (activeDownloadCounts[sha256] ?: 0) + delta

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

@@ -268,7 +268,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
 
   override fun getFirmwareArtifactCapabilities(): FirmwareArtifactCapabilities {
     return FirmwareArtifactCapabilities(
-      firmwareArtifactProtocolVersion = 1.0,
+      firmwareArtifactProtocolVersion = 2.0,
       supportedRouteTypes = arrayOf("domain", "pinnedIp"),
       supportsArchiveMaterialization = true,
       maxReadBytes = FirmwareArtifactStore.MAX_READ_BYTES.toDouble(),
@@ -395,14 +395,6 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
     }
   }
 
-  override fun reconcileFirmwareArtifactLeases(
-    params: FirmwareArtifactLeaseReconcileParams,
-  ): Promise<Unit> {
-    return Promise.async {
-      FirmwareArtifactStore.reconcileLeases(params.activeLeaseRefs)
-    }
-  }
-
   override fun sweepFirmwareArtifactOrphans(): Promise<FirmwareArtifactSweepResult> {
     return Promise.async {
       val (deletedFiles, deletedBytes) = FirmwareArtifactStore.sweepOrphans()

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)
+      }
+    }
+  }
+}