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

package/ios/HotUpdater/Internal/StreamingTarArchiveExtractor.swift

@@ -1,370 +0,0 @@
-import Compression
-import Foundation
-import zlib
-
-enum CompressedTarAlgorithm {
-    case gzip
-    case brotli
-}
-
-enum StreamingTarArchiveExtractor {
-    private static let bufferSize = 64 * 1024
-    private static let decompressionProgressWeight = 0.45
-
-    static func extractCompressedTar(
-        file: String,
-        to destination: String,
-        algorithm: CompressedTarAlgorithm,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        try withTemporaryTarFile { temporaryTarURL in
-            switch algorithm {
-            case .gzip:
-                try decompressGzipArchive(
-                    from: file,
-                    to: temporaryTarURL.path,
-                    progressHandler: { progress in
-                        progressHandler(progress * decompressionProgressWeight)
-                    }
-                )
-            case .brotli:
-                try decompressBrotliArchive(
-                    from: file,
-                    to: temporaryTarURL.path,
-                    progressHandler: { progress in
-                        progressHandler(progress * decompressionProgressWeight)
-                    }
-                )
-            }
-
-            try extractTarArchive(
-                from: temporaryTarURL.path,
-                to: destination,
-                progressHandler: { progress in
-                    let extractionStart = decompressionProgressWeight
-                    let extractionWeight = 1.0 - decompressionProgressWeight
-                    progressHandler(extractionStart + (progress * extractionWeight))
-                }
-            )
-        }
-    }
-
-    static func decompressBrotliFile(
-        from sourcePath: String,
-        to outputPath: String
-    ) throws {
-        try decompressBrotliArchive(
-            from: sourcePath,
-            to: outputPath,
-            progressHandler: { _ in }
-        )
-    }
-
-    static func containsTarEntries(file: String, algorithm: CompressedTarAlgorithm) -> Bool {
-        do {
-            return try withTemporaryTarFile { temporaryTarURL in
-                switch algorithm {
-                case .gzip:
-                    try decompressGzipArchive(
-                        from: file,
-                        to: temporaryTarURL.path,
-                        progressHandler: { _ in }
-                    )
-                case .brotli:
-                    try decompressBrotliArchive(
-                        from: file,
-                        to: temporaryTarURL.path,
-                        progressHandler: { _ in }
-                    )
-                }
-
-                return try tarArchiveHasEntries(at: temporaryTarURL.path)
-            }
-        } catch {
-            NSLog("[TarStreamExtractor] Validation failed: \(error.localizedDescription)")
-            return false
-        }
-    }
-
-    private static func withTemporaryTarFile<T>(
-        perform: (URL) throws -> T
-    ) throws -> T {
-        let temporaryTarURL = FileManager.default.temporaryDirectory
-            .appendingPathComponent("hot-updater-\(UUID().uuidString)")
-            .appendingPathExtension("tar")
-
-        defer {
-            try? FileManager.default.removeItem(at: temporaryTarURL)
-        }
-
-        return try perform(temporaryTarURL)
-    }
-
-    private static func tarArchiveHasEntries(at tarPath: String) throws -> Bool {
-        try TarArchiveExtractor.containsEntries(at: tarPath)
-    }
-
-    private static func extractTarArchive(
-        from tarPath: String,
-        to destination: String,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        try TarArchiveExtractor.extract(
-            from: tarPath,
-            to: destination,
-            progressHandler: progressHandler
-        )
-    }
-
-    private static func decompressGzipArchive(
-        from sourcePath: String,
-        to outputPath: String,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        let totalSourceSize = try fileSize(atPath: sourcePath)
-        try prepareEmptyFile(at: outputPath)
-
-        let outputHandle = try FileHandle(forWritingTo: URL(fileURLWithPath: outputPath))
-
-        defer {
-            try? outputHandle.close()
-        }
-
-        guard let gzipFile = sourcePath.withCString({ pathPointer in
-            "rb".withCString { modePointer in
-                gzopen(pathPointer, modePointer)
-            }
-        }) else {
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: 5,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to open gzip archive"]
-            )
-        }
-
-        defer {
-            gzclose(gzipFile)
-        }
-
-        var buffer = [UInt8](repeating: 0, count: bufferSize)
-
-        while true {
-            let bytesRead = gzread(gzipFile, &buffer, UInt32(buffer.count))
-
-            if bytesRead > 0 {
-                outputHandle.write(Data(buffer[0..<Int(bytesRead)]))
-
-                if totalSourceSize > 0 {
-                    let compressedOffset = max(Int64(gzoffset(gzipFile)), 0)
-                    let progress = min(Double(compressedOffset) / Double(totalSourceSize), 1.0)
-                    progressHandler(progress)
-                }
-
-                continue
-            }
-
-            if bytesRead == 0 {
-                progressHandler(1.0)
-                return
-            }
-
-            var errorCode: Int32 = 0
-            let messagePointer = gzerror(gzipFile, &errorCode)
-            let message = messagePointer.map { String(cString: $0) } ?? "Unknown gzip error"
-
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: Int(errorCode),
-                userInfo: [NSLocalizedDescriptionKey: "GZIP decompression failed: \(message)"]
-            )
-        }
-    }
-
-    private static func decompressBrotliArchive(
-        from sourcePath: String,
-        to outputPath: String,
-        progressHandler: @escaping (Double) -> Void
-    ) throws {
-        let totalSourceSize = try fileSize(atPath: sourcePath)
-        try prepareEmptyFile(at: outputPath)
-
-        let inputHandle = try FileHandle(forReadingFrom: URL(fileURLWithPath: sourcePath))
-        let outputHandle = try FileHandle(forWritingTo: URL(fileURLWithPath: outputPath))
-
-        defer {
-            try? inputHandle.close()
-            try? outputHandle.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
-        )
-        let status = compression_stream_init(&stream, COMPRESSION_STREAM_DECODE, COMPRESSION_BROTLI)
-
-        guard status == COMPRESSION_STATUS_OK else {
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: 6,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to initialize Brotli decompression stream"]
-            )
-        }
-
-        defer {
-            compression_stream_destroy(&stream)
-        }
-
-        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
-
-        defer {
-            outputBuffer.deallocate()
-        }
-
-        var processedSourceBytes: UInt64 = 0
-        var reachedStreamEnd = false
-
-        while !reachedStreamEnd {
-            let chunk = try ArchiveExtractionUtilities.readUpToCount(
-                from: inputHandle,
-                count: bufferSize
-            ) ?? Data()
-            processedSourceBytes += UInt64(chunk.count)
-
-            let streamStatus: compression_status
-            if chunk.isEmpty {
-                stream.src_ptr = UnsafePointer<UInt8>(bitPattern: 1)!
-                stream.src_size = 0
-                streamStatus = try flushCompressionStream(
-                    &stream,
-                    into: outputHandle,
-                    outputBuffer: outputBuffer,
-                    finalize: true
-                )
-            } else {
-                streamStatus = try chunk.withUnsafeBytes { rawBuffer in
-                    guard let baseAddress = rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
-                        return COMPRESSION_STATUS_OK
-                    }
-
-                    stream.src_ptr = baseAddress
-                    stream.src_size = chunk.count
-
-                    return try flushCompressionStream(
-                        &stream,
-                        into: outputHandle,
-                        outputBuffer: outputBuffer,
-                        finalize: false
-                    )
-                }
-            }
-
-            if totalSourceSize > 0 {
-                let progress = min(Double(processedSourceBytes) / Double(totalSourceSize), 1.0)
-                progressHandler(progress)
-            }
-
-            if streamStatus == COMPRESSION_STATUS_END {
-                reachedStreamEnd = true
-            } else if chunk.isEmpty {
-                throw NSError(
-                    domain: "StreamingTarArchiveExtractor",
-                    code: 7,
-                    userInfo: [NSLocalizedDescriptionKey: "Brotli decompression ended before reaching the end of stream"]
-                )
-            }
-        }
-
-        progressHandler(1.0)
-    }
-
-    private static func flushCompressionStream(
-        _ stream: inout compression_stream,
-        into outputHandle: FileHandle,
-        outputBuffer: UnsafeMutablePointer<UInt8>,
-        finalize: Bool
-    ) throws -> compression_status {
-        let flags = finalize ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
-        var lastStatus = COMPRESSION_STATUS_OK
-
-        repeat {
-            let previousSourceSize = stream.src_size
-
-            stream.dst_ptr = outputBuffer
-            stream.dst_size = bufferSize
-
-            lastStatus = compression_stream_process(&stream, flags)
-
-            switch lastStatus {
-            case COMPRESSION_STATUS_OK, COMPRESSION_STATUS_END:
-                let producedBytes = bufferSize - stream.dst_size
-                if producedBytes > 0 {
-                    outputHandle.write(
-                        Data(bytes: outputBuffer, count: producedBytes)
-                    )
-                }
-
-                if finalize,
-                   lastStatus == COMPRESSION_STATUS_OK,
-                   producedBytes == 0,
-                   previousSourceSize == stream.src_size {
-                    throw NSError(
-                        domain: "StreamingTarArchiveExtractor",
-                        code: 8,
-                        userInfo: [NSLocalizedDescriptionKey: "Brotli decompression stalled before reaching the end of stream"]
-                    )
-                }
-
-            default:
-                throw NSError(
-                    domain: "StreamingTarArchiveExtractor",
-                    code: 9,
-                    userInfo: [NSLocalizedDescriptionKey: "Brotli decompression failed"]
-                )
-            }
-        } while stream.src_size > 0 || stream.dst_size == 0 || (finalize && lastStatus == COMPRESSION_STATUS_OK)
-
-        return lastStatus
-    }
-
-    private static func prepareEmptyFile(at path: String) throws {
-        let fileManager = FileManager.default
-        let parentDirectory = (path as NSString).deletingLastPathComponent
-
-        if !fileManager.fileExists(atPath: parentDirectory) {
-            try fileManager.createDirectory(
-                atPath: parentDirectory,
-                withIntermediateDirectories: true,
-                attributes: nil
-            )
-        }
-
-        if fileManager.fileExists(atPath: path) {
-            try fileManager.removeItem(atPath: path)
-        }
-
-        guard fileManager.createFile(atPath: path, contents: nil) else {
-            throw NSError(
-                domain: "StreamingTarArchiveExtractor",
-                code: 10,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to create temporary archive file"]
-            )
-        }
-    }
-
-    private static func fileSize(atPath path: String) throws -> UInt64 {
-        let attributes = try FileManager.default.attributesOfItem(atPath: path)
-        if let value = attributes[.size] as? NSNumber {
-            return value.uint64Value
-        }
-
-        if let value = attributes[.size] as? UInt64 {
-            return value
-        }
-
-        return 0
-    }
-
-}

package/ios/HotUpdater/Internal/TarBrDecompressionStrategy.swift

@@ -1,39 +0,0 @@
-import Foundation
-
-/**
- * Strategy for handling TAR+Brotli compressed files
- */
-class TarBrDecompressionStrategy: DecompressionStrategy {
-    private static let MIN_FILE_SIZE: UInt64 = 10
-
-    func isValid(file: String) -> Bool {
-        guard FileManager.default.fileExists(atPath: file) else {
-            NSLog("[TarBrStrategy] Invalid file: doesn't exist")
-            return false
-        }
-
-        do {
-            let attributes = try FileManager.default.attributesOfItem(atPath: file)
-            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_FILE_SIZE else {
-                NSLog("[TarBrStrategy] Invalid file: too small")
-                return false
-            }
-        } catch {
-            NSLog("[TarBrStrategy] Invalid file: cannot read attributes - \(error.localizedDescription)")
-            return false
-        }
-
-        return StreamingTarArchiveExtractor.containsTarEntries(file: file, algorithm: .brotli)
-    }
-
-    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
-        NSLog("[TarBrStrategy] Starting extraction of \(file) to \(destination)")
-        try StreamingTarArchiveExtractor.extractCompressedTar(
-            file: file,
-            to: destination,
-            algorithm: .brotli,
-            progressHandler: progressHandler
-        )
-        NSLog("[TarBrStrategy] Successfully extracted all entries")
-    }
-}

package/ios/HotUpdater/Internal/TarGzDecompressionStrategy.swift

@@ -1,59 +0,0 @@
-import Foundation
-
-/**
- * Strategy for handling TAR+GZIP compressed files
- */
-class TarGzDecompressionStrategy: DecompressionStrategy {
-    private static let MIN_FILE_SIZE: UInt64 = 10
-
-    func isValid(file: String) -> Bool {
-        guard FileManager.default.fileExists(atPath: file) else {
-            NSLog("[TarGzStrategy] Invalid file: doesn't exist")
-            return false
-        }
-
-        do {
-            let attributes = try FileManager.default.attributesOfItem(atPath: file)
-            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_FILE_SIZE else {
-                NSLog("[TarGzStrategy] Invalid file: too small")
-                return false
-            }
-        } catch {
-            NSLog("[TarGzStrategy] Invalid file: cannot read attributes - \(error.localizedDescription)")
-            return false
-        }
-
-        // Check GZIP magic bytes (0x1F 0x8B)
-        guard let fileHandle = FileHandle(forReadingAtPath: file) else {
-            NSLog("[TarGzStrategy] Invalid file: cannot open file")
-            return false
-        }
-
-        defer {
-            fileHandle.closeFile()
-        }
-
-        guard let header = try? ArchiveExtractionUtilities.readUpToCount(from: fileHandle, count: 2),
-              header.count == 2 else {
-            NSLog("[TarGzStrategy] Invalid file: cannot read header")
-            return false
-        }
-
-        let isGzip = header[0] == 0x1F && header[1] == 0x8B
-        if !isGzip {
-            NSLog("[TarGzStrategy] Invalid file: wrong magic bytes (expected 0x1F 0x8B, got 0x\(String(format: "%02X", header[0])) 0x\(String(format: "%02X", header[1])))")
-        }
-        return isGzip
-    }
-
-    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
-        NSLog("[TarGzStrategy] Starting extraction of \(file) to \(destination)")
-        try StreamingTarArchiveExtractor.extractCompressedTar(
-            file: file,
-            to: destination,
-            algorithm: .gzip,
-            progressHandler: progressHandler
-        )
-        NSLog("[TarGzStrategy] Successfully extracted all entries")
-    }
-}