@hot-updater/react-native 1.0.0-rc.1 → 1.0.0-rc.15

package/android/src/test/java/com/hotupdater/HotUpdaterImplTest.kt

@@ -216,11 +216,10 @@ class HotUpdaterImplTest {
 
         override suspend fun updateBundle(
             bundleId: String,
-            fileUrl: String?,
-            fileHash: String?,
-            manifestUrl: String?,
-            manifestFileHash: String?,
-            changedAssets: Map<String, ChangedAssetDescriptor>?,
+            manifestUrl: String,
+            manifestFileHash: String,
+            assets: Map<String, ChangedAssetDescriptor>,
+            archiveUrl: String?,
             progressCallback: (UpdateProgressPayload) -> Unit,
         ) = Unit
 

package/android/src/test/java/com/hotupdater/HotUpdaterRecoveryStateTest.kt

@@ -0,0 +1,97 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+class HotUpdaterRecoveryStateTest {
+    @Test
+    fun `content queued after a fatal error cannot verify the failed bundle`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+
+        val request = requireNotNull(state.requestRecovery())
+        assertNull(state.completeLaunch())
+        state.finishRecoveryRequest(request, true)
+
+        assertNull(state.completeLaunch())
+        assertEquals(HotUpdaterRecoveryState.Launch("crashed-bundle", true), state.snapshot())
+    }
+
+    @Test
+    fun `a fatal error after first content preserves the verified bundle`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("verified-bundle", true)
+
+        assertNotNull(state.completeLaunch())
+
+        assertNull(state.requestRecovery())
+        assertNull(state.completeLaunch())
+        assertEquals(HotUpdaterRecoveryState.Launch("verified-bundle", false), state.snapshot())
+    }
+
+    @Test
+    fun `concurrent fatal errors schedule only one restart while the request is in flight`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+        val begin = CountDownLatch(1)
+        val finished = CountDownLatch(2)
+        val restartRequests = AtomicInteger()
+        val handledErrors = AtomicInteger()
+        val workers =
+            List(2) {
+                Thread {
+                    begin.await()
+                    val request = state.requestRecovery()
+                    if (request != null) {
+                        handledErrors.incrementAndGet()
+                        if (request.shouldRestart) restartRequests.incrementAndGet()
+                    }
+                    finished.countDown()
+                }.apply { start() }
+            }
+        begin.countDown()
+        assertTrue(finished.await(5, TimeUnit.SECONDS))
+        workers.forEach { it.join() }
+
+        assertEquals(2, handledErrors.get())
+        assertEquals(1, restartRequests.get())
+        assertNull(state.completeLaunch())
+    }
+
+    @Test
+    fun `a failed restart keeps the crash unverified and permits another restart request`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+        val request = requireNotNull(state.requestRecovery())
+
+        state.finishRecoveryRequest(request, false)
+
+        assertNull(state.completeLaunch())
+        val retry = requireNotNull(state.requestRecovery())
+        assertTrue(retry.shouldRestart)
+        state.finishRecoveryRequest(retry, true)
+        assertFalse(requireNotNull(state.requestRecovery()).shouldRestart)
+    }
+
+    @Test
+    fun `a previous launch restart completion cannot change the next launch`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+        val request = requireNotNull(state.requestRecovery())
+        state.start("safe-bundle", false)
+
+        state.finishRecoveryRequest(request, true)
+
+        assertEquals("safe-bundle", state.completeLaunch()?.bundleId)
+        state.stop()
+        assertNull(state.snapshot())
+        assertNull(state.requestRecovery())
+    }
+}

package/android/src/test/java/com/hotupdater/PendingCrashRecoveryTest.kt

@@ -0,0 +1,44 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class PendingCrashRecoveryTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `a watchdog reader waits until the native crash marker is fully written`() {
+        val marker = temporaryFolder.newFile("crash-marker.json")
+        marker.writeText("{\"bundleId\":\"crashed-bundle\",\"shouldRollback\":")
+
+        assertNull(PendingCrashRecovery.loadFromFile(marker))
+
+        marker.appendText("true}\n")
+        assertEquals(
+            PendingCrashRecovery("crashed-bundle", true),
+            PendingCrashRecovery.loadFromFile(marker),
+        )
+    }
+
+    @Test
+    fun `missing or empty markers do not request a restart`() {
+        assertNull(PendingCrashRecovery.loadFromFile(File(temporaryFolder.root, "missing.json")))
+        assertNull(PendingCrashRecovery.loadFromFile(temporaryFolder.newFile("empty.json")))
+    }
+
+    @Test
+    fun `a crash after content appeared does not request rollback`() {
+        val marker = temporaryFolder.newFile("verified-crash.json")
+        marker.writeText("{\"bundleId\":\"verified-bundle\",\"shouldRollback\":false}")
+
+        val recovery = requireNotNull(PendingCrashRecovery.loadFromFile(marker))
+        assertFalse(recovery.shouldRollback)
+        assertEquals("verified-bundle", recovery.launchedBundleId)
+    }
+}

package/android/src/test/java/com/hotupdater/TarBrArchiveExtractorTest.kt

@@ -0,0 +1,206 @@
+package com.hotupdater
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.IOException
+import java.util.Base64
+
+class TarBrArchiveExtractorTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `extracts exact regular file set`() {
+        val destination = extract(VALID, 3072, mapOf("assets/image.png" to 5, "index.android.bundle" to 6))
+
+        assertArrayEquals("image".toByteArray(), File(destination, "assets/image.png").readBytes())
+        assertArrayEquals("bundle".toByteArray(), File(destination, "index.android.bundle").readBytes())
+    }
+
+    @Test
+    fun `supports a POSIX PAX long path`() {
+        val path = "assets/${"x".repeat(120)}.bin"
+        val destination = extract(PAX_LONG_PATH, 3072, mapOf(path to 4))
+
+        assertArrayEquals("long".toByteArray(), File(destination, path).readBytes())
+    }
+
+    @Test
+    fun `rejects duplicate unsafe linked and malformed archives`() {
+        val cases =
+            listOf(
+                Triple(DUPLICATE, 3072L, mapOf("index.android.bundle" to 6L)),
+                Triple(TRAVERSAL, 2048L, mapOf("../escape" to 3L)),
+                Triple(SYMLINK, 1536L, mapOf("index.android.bundle" to 0L)),
+                Triple(SINGLE_END_BLOCK, 1536L, mapOf("index.android.bundle" to 6L)),
+                Triple(TRAILING_NON_ZERO, 2560L, mapOf("index.android.bundle" to 6L)),
+            )
+
+        cases.forEachIndexed { index, (fixture, tarSize, files) ->
+            val archive = temporaryFolder.newFile("invalid-$index.tar.br").apply { writeBytes(decode(fixture)) }
+            val destination = File(temporaryFolder.root, "invalid-$index")
+
+            assertThrows(Exception::class.java) {
+                TarBrArchiveExtractor.extract(archive, destination, tarSize, files)
+            }
+            check(!destination.exists())
+        }
+    }
+
+    @Test
+    fun `rejects dangling consecutive duplicate and unsupported extension metadata`() {
+        val pathRecord = paxRecord("path", "index.android.bundle")
+        val malformedShortRecord = "3 \n".toByteArray()
+        val cases =
+            listOf(
+                tarArchive(tarEntry("PaxHeader", 'x', pathRecord)),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', pathRecord),
+                    tarEntry("PaxHeader", 'x', pathRecord),
+                ),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', pathRecord + paxRecord("path", "other")),
+                    regularEntry("ignored", "bundle"),
+                ),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', malformedShortRecord),
+                    regularEntry("ignored", "bundle"),
+                ),
+                tarArchive(
+                    tarEntry("PaxHeader", 'x', paxRecord("linkpath", "target")),
+                    regularEntry("index.android.bundle", "bundle"),
+                ),
+                tarArchive(tarEntry("LongLink", 'L', "name\u0000".toByteArray())),
+            )
+
+        cases.forEach { bytes ->
+            assertThrows(IOException::class.java) { consumeTar(bytes) }
+        }
+    }
+
+    @Test
+    fun `preserves exact header paths and applies PAX size`() {
+        val spacedPathArchive = tarArchive(regularEntry("index.android.bundle ", "bundle"))
+        TarArchiveInputStream(ByteArrayInputStream(spacedPathArchive)).use { input ->
+            assertEquals("index.android.bundle ", input.getNextEntry()?.name)
+        }
+
+        val payload = "data".toByteArray()
+        val paxSizeArchive =
+            tarArchive(
+                tarEntry("PaxHeader", 'x', paxRecord("size", payload.size.toString())),
+                tarEntry("index.android.bundle", '0', payload, declaredSize = 1),
+            )
+        TarArchiveInputStream(ByteArrayInputStream(paxSizeArchive)).use { input ->
+            val entry = input.getNextEntry()
+            assertEquals(payload.size.toLong(), entry?.size)
+            assertArrayEquals(payload, input.readBytes())
+            assertEquals(null, input.getNextEntry())
+        }
+    }
+
+    private fun extract(
+        fixture: String,
+        tarSize: Long,
+        files: Map<String, Long>,
+    ): File {
+        val archive = temporaryFolder.newFile("fixture-${System.nanoTime()}.tar.br").apply { writeBytes(decode(fixture)) }
+        val destination = File(temporaryFolder.root, "extracted-${System.nanoTime()}")
+        TarBrArchiveExtractor.extract(archive, destination, tarSize, files)
+        return destination
+    }
+
+    private fun decode(value: String): ByteArray = Base64.getDecoder().decode(value)
+
+    private fun consumeTar(bytes: ByteArray) {
+        TarArchiveInputStream(ByteArrayInputStream(bytes)).use { input ->
+            while (input.getNextEntry() != null) input.readBytes()
+        }
+    }
+
+    private fun paxRecord(
+        key: String,
+        value: String,
+    ): ByteArray {
+        var length = key.toByteArray().size + value.toByteArray().size + 3
+        while (true) {
+            val record = "$length $key=$value\n".toByteArray()
+            if (record.size == length) return record
+            length = record.size
+        }
+    }
+
+    private fun regularEntry(
+        name: String,
+        content: String,
+    ): ByteArray = tarEntry(name, '0', content.toByteArray())
+
+    private fun tarEntry(
+        name: String,
+        type: Char,
+        payload: ByteArray,
+        declaredSize: Int = payload.size,
+    ): ByteArray {
+        val header = ByteArray(512)
+        name.toByteArray().copyInto(header, endIndex = name.toByteArray().size.coerceAtMost(100))
+        writeOctal(header, 100, 8, 420)
+        writeOctal(header, 108, 8, 0)
+        writeOctal(header, 116, 8, 0)
+        writeOctal(header, 124, 12, declaredSize)
+        writeOctal(header, 136, 12, 0)
+        for (index in 148 until 156) header[index] = ' '.code.toByte()
+        header[156] = type.code.toByte()
+        "ustar".toByteArray().copyInto(header, 257)
+        writeOctal(header, 148, 8, header.sumOf { it.toInt() and 0xff })
+
+        return ByteArrayOutputStream()
+            .apply {
+                write(header)
+                write(payload)
+                write(ByteArray((512 - payload.size % 512) % 512))
+            }.toByteArray()
+    }
+
+    private fun tarArchive(vararg entries: ByteArray): ByteArray =
+        ByteArrayOutputStream()
+            .apply {
+                entries.forEach(::write)
+                write(ByteArray(1024))
+            }.toByteArray()
+
+    private fun writeOctal(
+        target: ByteArray,
+        offset: Int,
+        length: Int,
+        value: Int,
+    ) {
+        val digits = value.toString(8).padStart(length - 2, '0')
+        digits.toByteArray().copyInto(target, offset)
+        target[offset + length - 2] = 0
+        target[offset + length - 1] = ' '.code.toByte()
+    }
+
+    companion object {
+        const val VALID =
+            "G/8LYI7UVnlCO6lhAMTqIo5tMQLiY7NptuP57iYyogHNeF9BlHNiXHeDMLCAJL3h9im3UyYnSs3aLbJIIBsjml0YwV1+Hd11htDfIA8GgPKHFrFNtD7SOfZo/h9mbgDYuSAJIPmy9Z2b"
+        private const val DUPLICATE =
+            "G/8L4I/UVnlCO6lh6sQAIm5ssV7ksdnUyXHelkgImbdLFCl08DwgyVOGdSmhfs8LgniesZ82/bHw7qIYoXwdSTsMVSkOBkDMM0vqHj11Ew=="
+        private const val TRAVERSAL =
+            "G/8H+AfKbRfTdvBDW1YMVZ0c3w7fLhJCyAFHCIm3xTUACIRyzK7qNZRgrBkUGlOQ+PtOBlH/uDAUZ9s9Dw=="
+        private const val SYMLINK =
+            "G/8FoI7UYs0ZrwQiHgYxvWizaUNMJ8cnP4h9lyiDwKKELcCA8pSZdZEoyN91S9BvNObx0n8IcrtxYn2sUe6QrffCuHk8LCgA"
+        private const val SINGLE_END_BLOCK =
+            "G/8F4I/UVnlCO6lh6sQAIm5ssV7ksdnUyfH9WyIhZN4uUaQSeB6Q5DGGvrXYkguCOs/YT5v+GLy7ECOUryNph6EqxcEAinlmEw=="
+        private const val TRAILING_NON_ZERO =
+            "G/8J4Adqc2ds55CPYbC2qk6O87ZEQsi0tUsUKUXN80TyGEPfWmyJBUGcZ6y72vQfJjUzyChogu7Xu5ODMLcUB0MBYu7ZOLkF"
+        private const val PAX_LONG_PATH =
+            "G/8LYAbCtn2mBfjh0GTohqrNYvNuZjueb2Ij3vmAJjz8C6jLIEtYgqi7gAMNAII62ZkiZILxgnbd1QSM8usRpO6ZyCgYZiz8dTRcx0YB/gG5MBRqZPyVyrk8J47iYenP+zXoZcGa8QLgayISZoflgdi14Q=="
+    }
+}

package/ios/HotUpdater/Internal/BrotliFileDecompressor.swift

@@ -0,0 +1,167 @@
+import Compression
+import Foundation
+
+enum BrotliFileDecompressor {
+    private static let bufferSize = 64 * 1024
+
+    static func decompress(
+        from sourcePath: String,
+        to outputPath: String,
+        expectedOutputByteSize: Int64? = nil
+    ) throws {
+        if let expectedOutputByteSize, expectedOutputByteSize < 0 {
+            throw error(6, "Invalid expected Brotli output size")
+        }
+        let fileManager = FileManager.default
+        let parentDirectory = (outputPath as NSString).deletingLastPathComponent
+        try fileManager.createDirectory(
+            atPath: parentDirectory,
+            withIntermediateDirectories: true
+        )
+        if fileManager.fileExists(atPath: outputPath) {
+            try fileManager.removeItem(atPath: outputPath)
+        }
+        guard fileManager.createFile(atPath: outputPath, contents: nil) else {
+            throw error(1, "Failed to create Brotli output file")
+        }
+
+        let input = try FileHandle(forReadingFrom: URL(fileURLWithPath: sourcePath))
+        let output = try FileHandle(forWritingTo: URL(fileURLWithPath: outputPath))
+        defer {
+            try? input.close()
+            try? output.close()
+        }
+
+        var stream = compression_stream(
+            dst_ptr: UnsafeMutablePointer<UInt8>(bitPattern: 1)!,
+            dst_size: 0,
+            src_ptr: UnsafePointer<UInt8>(bitPattern: 1)!,
+            src_size: 0,
+            state: nil
+        )
+        guard compression_stream_init(
+            &stream,
+            COMPRESSION_STREAM_DECODE,
+            COMPRESSION_BROTLI
+        ) == COMPRESSION_STATUS_OK else {
+            throw error(2, "Failed to initialize Brotli decompression")
+        }
+        defer { compression_stream_destroy(&stream) }
+
+        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(
+            capacity: bufferSize
+        )
+        defer { outputBuffer.deallocate() }
+
+        var reachedEnd = false
+        var totalOutputByteSize: UInt64 = 0
+        let maximumOutputByteSize = expectedOutputByteSize.map(UInt64.init)
+        while !reachedEnd {
+            let chunk = try FileUtilities.readUpToCount(
+                from: input,
+                count: bufferSize
+            ) ?? Data()
+            let status: compression_status
+            if chunk.isEmpty {
+                stream.src_ptr = UnsafePointer<UInt8>(bitPattern: 1)!
+                stream.src_size = 0
+                status = try process(
+                    &stream,
+                    output: output,
+                    outputBuffer: outputBuffer,
+                    finalize: true,
+                    totalOutputByteSize: &totalOutputByteSize,
+                    maximumOutputByteSize: maximumOutputByteSize
+                )
+            } else {
+                status = try chunk.withUnsafeBytes { bytes in
+                    guard let source = bytes.baseAddress?
+                        .assumingMemoryBound(to: UInt8.self) else {
+                        return COMPRESSION_STATUS_OK
+                    }
+                    stream.src_ptr = source
+                    stream.src_size = chunk.count
+                    return try process(
+                        &stream,
+                        output: output,
+                        outputBuffer: outputBuffer,
+                        finalize: false,
+                        totalOutputByteSize: &totalOutputByteSize,
+                        maximumOutputByteSize: maximumOutputByteSize
+                    )
+                }
+            }
+
+            if status == COMPRESSION_STATUS_END {
+                guard stream.src_size == 0 else {
+                    throw error(7, "Brotli stream contains trailing compressed bytes")
+                }
+                let trailing = try FileUtilities.readUpToCount(from: input, count: 1)
+                guard trailing?.isEmpty != false else {
+                    throw error(7, "Brotli stream contains trailing compressed bytes")
+                }
+                reachedEnd = true
+            } else if chunk.isEmpty {
+                throw error(3, "Brotli input ended before the stream completed")
+            }
+        }
+
+        if let maximumOutputByteSize,
+           totalOutputByteSize != maximumOutputByteSize {
+            throw error(
+                8,
+                "Brotli output size mismatch: expected \(maximumOutputByteSize), got \(totalOutputByteSize)"
+            )
+        }
+    }
+
+    private static func process(
+        _ stream: inout compression_stream,
+        output: FileHandle,
+        outputBuffer: UnsafeMutablePointer<UInt8>,
+        finalize: Bool,
+        totalOutputByteSize: inout UInt64,
+        maximumOutputByteSize: UInt64?
+    ) throws -> compression_status {
+        let flags = finalize ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
+        var status = COMPRESSION_STATUS_OK
+        repeat {
+            let previousSourceSize = stream.src_size
+            stream.dst_ptr = outputBuffer
+            stream.dst_size = bufferSize
+            status = compression_stream_process(&stream, flags)
+
+            guard status == COMPRESSION_STATUS_OK ||
+                    status == COMPRESSION_STATUS_END else {
+                throw error(4, "Brotli decompression failed")
+            }
+            let produced = bufferSize - stream.dst_size
+            if produced > 0 {
+                let (nextOutputByteSize, overflowed) = totalOutputByteSize
+                    .addingReportingOverflow(UInt64(produced))
+                guard !overflowed,
+                      maximumOutputByteSize.map({ nextOutputByteSize <= $0 }) ?? true else {
+                    throw error(6, "Brotli output exceeds expected size")
+                }
+                output.write(Data(bytes: outputBuffer, count: produced))
+                totalOutputByteSize = nextOutputByteSize
+            }
+            if finalize,
+               status == COMPRESSION_STATUS_OK,
+               produced == 0,
+               previousSourceSize == stream.src_size {
+                throw error(5, "Brotli decompression stalled")
+            }
+        } while stream.src_size > 0 || stream.dst_size == 0 ||
+            (finalize && status == COMPRESSION_STATUS_OK)
+        return status
+    }
+
+    private static func error(_ code: Int, _ message: String) -> NSError {
+        NSError(
+            domain: "BrotliFileDecompressor",
+            code: code,
+            userInfo: [NSLocalizedDescriptionKey: message]
+        )
+    }
+}