@onekeyfe/react-native-range-downloader 6.7.0-alpha.311 → 6.7.0-alpha.314

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

@@ -100,7 +100,10 @@ class ConcurrentRangeDownloader(
      * segment files, so no in-flight worker resurrects a deleted file.
      */
     class CancelHandle {
+        // Only an explicit caller cancellation sets aborted. Worker failures use
+        // workerStop to stop sibling segments without changing that intent.
         val aborted = AtomicBoolean(false)
+        internal val workerStop = AtomicBoolean(false)
 
         @Volatile
         private var pool: java.util.concurrent.ExecutorService? = null
@@ -108,7 +111,7 @@ class ConcurrentRangeDownloader(
         internal fun attach(pool: java.util.concurrent.ExecutorService) {
             this.pool = pool
             // If cancel() already raced in before the pool was attached, honor it.
-            if (aborted.get()) pool.shutdownNow()
+            if (workerStop.get()) pool.shutdownNow()
         }
 
         /**
@@ -121,6 +124,7 @@ class ConcurrentRangeDownloader(
          */
         fun cancel() {
             aborted.set(true)
+            workerStop.set(true)
             pool?.let { p ->
                 p.shutdownNow()
                 try {
@@ -221,9 +225,9 @@ class ConcurrentRangeDownloader(
         )
         onProgress(transferred.get(), total)
 
-        // Share the abort flag with the cancel handle so an external cancel() is
-        // observed by the per-segment loops; default to a private flag otherwise.
-        val aborted = cancelHandle?.aborted ?: AtomicBoolean(false)
+        // External cancel also stops workers; internal fallback/failure must not
+        // mark the caller's explicit-cancellation flag.
+        val aborted = cancelHandle?.workerStop ?: AtomicBoolean(false)
         val fallback = AtomicBoolean(false)
         val firstError = AtomicReference<Exception?>(null)
 
@@ -243,11 +247,11 @@ class ConcurrentRangeDownloader(
                             }
                         } catch (e: FallbackException) {
                             fallback.set(true)
-                            aborted.set(true)
                             firstError.compareAndSet(null, e)
-                        } catch (e: Exception) {
                             aborted.set(true)
+                        } catch (e: Exception) {
                             firstError.compareAndSet(null, e)
+                            aborted.set(true)
                         }
                     }
                 }
@@ -274,7 +278,7 @@ class ConcurrentRangeDownloader(
             .firstOrNull { segFile(it.index).length() != it.length }
         if (incomplete != null) {
             // Keep the segment files for the next attempt to resume.
-            throw java.io.IOException("Concurrent download incomplete (segment ${incomplete.index})")
+            throw ProtocolException("Concurrent download incomplete (segment ${incomplete.index})")
         }
 
         // All segments complete → assemble the `.partial`.

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

@@ -293,6 +293,67 @@ class ConcurrentRangeDownloaderOcdsTest {
     assertNoArtifactsLeft(partial)
   }
 
+  @Test
+  fun internalFallbackDoesNotMarkCallerCancelled() {
+    val target = parts[2]
+    startServer(RangeFaultServer(content).arm(
+      RangeFaultServer.FaultMode.STATUS_200, target.start, target.end, times = Int.MAX_VALUE,
+    ))
+    val handle = ConcurrentRangeDownloader.CancelHandle()
+
+    val outcome = newDownloader().download(url(), partialPath(), handle) { _, _ -> }
+
+    assertEquals(ConcurrentRangeDownloader.Outcome.FALLBACK, outcome)
+    assertFalse(handle.aborted.get())
+    assertNoArtifactsLeft(partialPath())
+  }
+
+  @Test
+  fun segment403PreservesHttpStatusWithoutMarkingCallerCancelled() {
+    val target = parts[2]
+    val normal = RangeFaultServer(content)
+    server = MockWebServer()
+    server.dispatcher = object : Dispatcher() {
+      override fun dispatch(request: RecordedRequest): MockResponse =
+        if (request.getHeader("Range") == "bytes=${target.start}-${target.end}") {
+          MockResponse().setResponseCode(403)
+        } else {
+          normal.dispatcher.dispatch(request)
+        }
+    }
+    server.start()
+    val handle = ConcurrentRangeDownloader.CancelHandle()
+
+    val failure = runCatching {
+      newDownloader().download(url(), partialPath(), handle) { _, _ -> }
+    }.exceptionOrNull()
+
+    assertTrue(failure is ConcurrentRangeDownloader.PermanentHttpException)
+    assertEquals(403, (failure as ConcurrentRangeDownloader.PermanentHttpException).code)
+    assertFalse(handle.aborted.get())
+  }
+
+  @Test
+  fun exhaustedSocketTimeoutDoesNotMarkCallerCancelled() {
+    val target = parts[2]
+    startServer(RangeFaultServer(content).arm(
+      RangeFaultServer.FaultMode.STALL, target.start, target.end, times = Int.MAX_VALUE,
+    ))
+    val handle = ConcurrentRangeDownloader.CancelHandle()
+    val client = OkHttpClient.Builder().readTimeout(200, TimeUnit.MILLISECONDS).build()
+    val downloader = ConcurrentRangeDownloader(client, maxPartRetry = 0)
+
+    val failure = runCatching {
+      downloader.download(url(), partialPath(), handle) { _, _ -> }
+    }.exceptionOrNull()
+
+    assertTrue(
+      "expected a socket timeout, got ${failure?.javaClass?.name}: ${failure?.message}",
+      failure is java.net.SocketTimeoutException,
+    )
+    assertFalse(handle.aborted.get())
+  }
+
   // ------------------------------------------------------------------------
   // OCDS-T4: 429 (+Retry-After: 0) once on a segment → transient retry succeeds.
   //   SHA correct; the affected segment requested twice; no from-0 restart.
@@ -436,17 +497,17 @@ class ConcurrentRangeDownloaderOcdsTest {
     val partial = partialPath()
     // First invocation: the short body leaves segment 6 one byte short, so this
     // call throws "incomplete" and keeps the `.segN` for resume.
-    var firstThrew = false
-    try {
+    val handle = ConcurrentRangeDownloader.CancelHandle()
+    val firstFailure = runCatching {
       newDownloader().download(
         url = url(),
         partialFilePath = partial,
+        cancelHandle = handle,
         onProgress = { _, _ -> },
       )
-    } catch (e: Exception) {
-      firstThrew = true
-    }
-    assertTrue("short body must leave the first invocation incomplete", firstThrew)
+    }.exceptionOrNull()
+    assertTrue("short body must preserve a typed network failure", firstFailure is java.net.ProtocolException)
+    assertFalse("internal short body must not mark explicit cancellation", handle.aborted.get())
     // The short segment is kept on disk, one byte under its planned length.
     val seg = segFile(partial, target.index)
     assertTrue("short `.segN` must be kept for resume", seg.exists())
@@ -532,6 +593,7 @@ class ConcurrentRangeDownloaderOcdsTest {
     worker.shutdownNow()
 
     assertTrue("cancel must abort promptly (took ${elapsed}ms)", elapsed < 12_000)
+    assertTrue("explicit cancellation must mark caller intent", handle.aborted.get())
 
     // cancel-then-delete: now that workers are terminated, deleting the artifacts
     // must STICK — no straggler worker resurrects a `.segN`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-range-downloader",
-  "version": "6.7.0-alpha.311",
+  "version": "6.7.0-alpha.314",
   "description": "react-native-range-downloader",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",