@viettelpost/react-native-ota 0.1.0

package/ios/OTAUpdateCleanup.swift

@@ -0,0 +1,269 @@
+import Foundation
+
+struct OTADiskUsageBundle: Codable {
+  let version: String
+  let bytes: UInt64
+  let isActive: Bool
+  let isPending: Bool
+  let isFailed: Bool
+}
+
+struct OTADiskUsage: Codable {
+  let otaRootPath: String
+  let totalBytes: UInt64
+  let tmpBytes: UInt64
+  let bundlesBytes: UInt64
+  let bundles: [OTADiskUsageBundle]
+}
+
+@objc(OTAUpdateCleanup)
+final class OTAUpdateCleanup: NSObject {
+  @objc static let shared = OTAUpdateCleanup()
+
+  private let fileManager: FileManager
+  private let encoder: JSONEncoder
+  private let storage: OTAUpdateStorage
+
+  private let embeddedVersion = "embedded"
+  private let metadataFileName = "metadata.json"
+
+  override init() {
+    fileManager = .default
+    encoder = JSONEncoder()
+    storage = OTAUpdateStorage.shared
+    super.init()
+  }
+
+  func cleanupAfterSuccessfulActivation(activeVersion: String) throws -> Bool {
+    if isEmbeddedVersion(activeVersion) {
+      return try cleanupOrphanedBundles(keepVersions: [])
+    }
+    return try cleanupOrphanedBundles(keepVersions: [activeVersion])
+  }
+
+  func cleanupFailedPendingBundle(failedVersion: String?) throws -> Bool {
+    guard let failedVersion = failedVersion, !isEmbeddedVersion(failedVersion) else {
+      return true
+    }
+
+    let bundleDeleted = try safeDeleteUnderOTARoot(bundleDirectoryURL(version: failedVersion))
+    let tempDeleted = try cleanupTemp(version: failedVersion)
+    return bundleDeleted && tempDeleted
+  }
+
+  func cleanupTemp(version: String?) throws -> Bool {
+    guard let version = version, !version.isEmpty else {
+      return true
+    }
+    return try safeDeleteUnderOTARoot(tempDirectoryURL(version: version))
+  }
+
+  func cleanupAllTemp() throws -> Bool {
+    try safeDeleteChildrenUnderOTARoot(tmpRootURL())
+  }
+
+  func cleanupOrphanedBundles(keepVersions: Set<String>) throws -> Bool {
+    let normalizedKeepVersions = Set(keepVersions.filter { !isEmbeddedVersion($0) })
+    return try safeDeleteChildrenUnderOTARoot(bundleRootURL()) { childURL in
+      !normalizedKeepVersions.contains(childURL.lastPathComponent)
+    }
+  }
+
+  @objc func cleanupOTAStorage() throws -> NSNumber {
+    let metadata = try storage.readMetadata()
+    var keepVersions = Set<String>()
+    if !isEmbeddedVersion(metadata.activeBundleVersion) {
+      keepVersions.insert(metadata.activeBundleVersion)
+    }
+    if let pendingVersion = metadata.pendingBundleVersion, !isEmbeddedVersion(pendingVersion) {
+      keepVersions.insert(pendingVersion)
+    }
+
+    var didCleanup = try cleanupAllTemp()
+    if let failedVersion = metadata.failedBundleVersion,
+       !isEmbeddedVersion(failedVersion),
+       !keepVersions.contains(failedVersion) {
+      didCleanup = (try cleanupFailedPendingBundle(failedVersion: failedVersion)) && didCleanup
+    }
+    didCleanup = (try cleanupOrphanedBundles(keepVersions: keepVersions)) && didCleanup
+    return didCleanup as NSNumber
+  }
+
+  @objc func getOTADiskUsageJSONString() throws -> String {
+    let usage = try getOTADiskUsage()
+    let data = try encoder.encode(usage)
+    guard let json = String(data: data, encoding: .utf8) else {
+      throw OTAUpdateCleanupError.jsonEncodingFailed
+    }
+    return json
+  }
+
+  func deleteFinalBundleForFailedInstall(version: String?) throws -> Bool {
+    guard let version = version, !isEmbeddedVersion(version) else {
+      return true
+    }
+    return try safeDeleteUnderOTARoot(bundleDirectoryURL(version: version))
+  }
+
+  private func getOTADiskUsage() throws -> OTADiskUsage {
+    let metadata = try storage.readMetadata()
+    let otaRoot = try otaDirectoryURL()
+    let tmpRoot = try tmpRootURL()
+    let bundlesRoot = try bundleRootURL()
+    let bundleURLs = (try? fileManager.contentsOfDirectory(
+      at: bundlesRoot,
+      includingPropertiesForKeys: [.isDirectoryKey],
+      options: [.skipsHiddenFiles]
+    )) ?? []
+
+    let bundles = bundleURLs
+      .filter { isDirectory($0) }
+      .sorted { $0.lastPathComponent < $1.lastPathComponent }
+      .map { bundleURL in
+        OTADiskUsageBundle(
+          version: bundleURL.lastPathComponent,
+          bytes: directorySize(bundleURL),
+          isActive: bundleURL.lastPathComponent == metadata.activeBundleVersion,
+          isPending: bundleURL.lastPathComponent == metadata.pendingBundleVersion,
+          isFailed: bundleURL.lastPathComponent == metadata.failedBundleVersion
+        )
+      }
+
+    return OTADiskUsage(
+      otaRootPath: otaRoot.path,
+      totalBytes: directorySize(otaRoot),
+      tmpBytes: directorySize(tmpRoot),
+      bundlesBytes: directorySize(bundlesRoot),
+      bundles: bundles
+    )
+  }
+
+  private func safeDeleteChildrenUnderOTARoot(
+    _ directoryURL: URL,
+    shouldDelete: (URL) -> Bool = { _ in true }
+  ) throws -> Bool {
+    guard fileManager.fileExists(atPath: directoryURL.path) else {
+      return true
+    }
+
+    let children = (try? fileManager.contentsOfDirectory(
+      at: directoryURL,
+      includingPropertiesForKeys: nil,
+      options: []
+    )) ?? []
+
+    var didDeleteAll = true
+    for child in children where shouldDelete(child) {
+      didDeleteAll = (try safeDeleteUnderOTARoot(child)) && didDeleteAll
+    }
+    return didDeleteAll
+  }
+
+  private func safeDeleteUnderOTARoot(_ targetURL: URL) throws -> Bool {
+    guard fileManager.fileExists(atPath: targetURL.path) else {
+      return true
+    }
+
+    let rootURL = try otaDirectoryURL().standardizedFileURL.resolvingSymlinksInPath()
+    let targetURL = targetURL.standardizedFileURL.resolvingSymlinksInPath()
+    let rootPath = rootURL.path
+    let targetPath = targetURL.path
+
+    // Cleanup must never remove metadata, the OTA root, or any path outside OTA storage.
+    if targetURL.lastPathComponent == metadataFileName ||
+       targetPath == rootPath ||
+       !targetPath.hasPrefix(rootPath + "/") {
+      NSLog("OTAKit cleanup refused unsafe delete; path=%@", targetPath)
+      return false
+    }
+
+    do {
+      try fileManager.removeItem(at: targetURL)
+      NSLog("OTAKit cleanup deleted %@", targetPath)
+      return true
+    } catch {
+      NSLog("OTAKit cleanup failed for %@: %@", targetPath, error.localizedDescription)
+      return false
+    }
+  }
+
+  private func directorySize(_ url: URL) -> UInt64 {
+    var isDirectory: ObjCBool = false
+    guard fileManager.fileExists(atPath: url.path, isDirectory: &isDirectory) else {
+      return 0
+    }
+    if !isDirectory.boolValue {
+      return fileSize(url)
+    }
+
+    guard let enumerator = fileManager.enumerator(
+      at: url,
+      includingPropertiesForKeys: [.fileSizeKey, .isRegularFileKey],
+      options: [],
+      errorHandler: { _, _ in true }
+    ) else {
+      return 0
+    }
+
+    var totalSize: UInt64 = 0
+    for case let fileURL as URL in enumerator {
+      let values = try? fileURL.resourceValues(forKeys: [.fileSizeKey, .isRegularFileKey])
+      if values?.isRegularFile == true, let fileSize = values?.fileSize {
+        totalSize += UInt64(fileSize)
+      }
+    }
+    return totalSize
+  }
+
+  private func fileSize(_ url: URL) -> UInt64 {
+    guard let attributes = try? fileManager.attributesOfItem(atPath: url.path),
+          let size = attributes[.size] as? NSNumber else {
+      return 0
+    }
+    return size.uint64Value
+  }
+
+  private func isDirectory(_ url: URL) -> Bool {
+    var isDirectory: ObjCBool = false
+    return fileManager.fileExists(atPath: url.path, isDirectory: &isDirectory) && isDirectory.boolValue
+  }
+
+  private func bundleRootURL() throws -> URL {
+    try otaDirectoryURL().appendingPathComponent("bundles", isDirectory: true)
+  }
+
+  private func tmpRootURL() throws -> URL {
+    try otaDirectoryURL().appendingPathComponent("tmp", isDirectory: true)
+  }
+
+  private func bundleDirectoryURL(version: String) throws -> URL {
+    try bundleRootURL().appendingPathComponent(version, isDirectory: true)
+  }
+
+  private func tempDirectoryURL(version: String) throws -> URL {
+    try tmpRootURL().appendingPathComponent(version, isDirectory: true)
+  }
+
+  private func otaDirectoryURL() throws -> URL {
+    let supportURL = try fileManager.url(
+      for: .applicationSupportDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: true
+    )
+    let otaURL = supportURL.appendingPathComponent("OTA", isDirectory: true)
+    try fileManager.createDirectory(at: otaURL, withIntermediateDirectories: true, attributes: nil)
+    return otaURL
+  }
+
+  private func isEmbeddedVersion(_ version: String?) -> Bool {
+    guard let version = version, !version.isEmpty else {
+      return true
+    }
+    return version == embeddedVersion
+  }
+}
+
+enum OTAUpdateCleanupError: Error {
+  case jsonEncodingFailed
+}