Add multiple cache storages feature

Sources/ScipioKit/Producer/Cache/CacheSystem.swift

@@ -108,7 +108,6 @@ struct CacheSystem: Sendable {
     static let defaultParalellNumber = 8
     private let pinsStore: PinsStore
     private let outputDirectory: URL
-    private let storage: (any CacheStorage)?
     private let fileSystem: any FileSystem
 
     struct CacheTarget: Hashable, Sendable {
@@ -139,18 +138,23 @@ struct CacheSystem: Sendable {
     init(
         pinsStore: PinsStore,
         outputDirectory: URL,
-        storage: (any CacheStorage)?,
         fileSystem: any FileSystem = localFileSystem
     ) {
         self.pinsStore = pinsStore
         self.outputDirectory = outputDirectory
-        self.storage = storage
         self.fileSystem = fileSystem
     }
 
-    func cacheFrameworks(_ targets: Set<CacheTarget>) async {
-        let chunked = targets.chunks(ofCount: storage?.parallelNumber ?? CacheSystem.defaultParalellNumber)
+    func cacheFrameworks(_ targets: Set<CacheTarget>, to storages: [any CacheStorage]) async {
+        for storage in storages {
+            await cacheFrameworks(targets, to: storage)
+        }
+    }
 
+    private func cacheFrameworks(_ targets: Set<CacheTarget>, to storage: any CacheStorage) async {
+        let chunked = targets.chunks(ofCount: storage.parallelNumber ?? CacheSystem.defaultParalellNumber)
+
+        let storageName = storage.displayName
         for chunk in chunked {
             await withTaskGroup(of: Void.self) { group in
                 for target in chunk {
@@ -159,10 +163,10 @@ struct CacheSystem: Sendable {
                         let frameworkPath = outputDirectory.appendingPathComponent(frameworkName)
                         do {
                             logger.info(
-                                "🚀 Cache \(frameworkName) to cache storage",
+                                "🚀 Cache \(frameworkName) to cache storage: \(storageName)",
                                 metadata: .color(.green)
                             )
-                            try await cacheFramework(target, at: frameworkPath)
+                            try await cacheFramework(target, at: frameworkPath, to: storage)
                         } catch {
                             logger.warning("⚠️ Can't create caches for \(frameworkPath.path)")
                         }
@@ -173,10 +177,10 @@ struct CacheSystem: Sendable {
         }
     }
 
-    private func cacheFramework(_ target: CacheTarget, at frameworkPath: URL) async throws {
+    private func cacheFramework(_ target: CacheTarget, at frameworkPath: URL, to storage: any CacheStorage) async throws {
         let cacheKey = try await calculateCacheKey(of: target)
 
-        try await storage?.cacheFramework(frameworkPath, for: cacheKey)
+        try await storage.cacheFramework(frameworkPath, for: cacheKey)
     }
 
     func generateVersionFile(for target: CacheTarget) async throws {
@@ -210,8 +214,8 @@ struct CacheSystem: Sendable {
         case failed(LocalizedError?)
         case noCache
     }
-    func restoreCacheIfPossible(target: CacheTarget) async -> RestoreResult {
-        guard let storage = storage else { return .noCache }
+
+    func restoreCacheIfPossible(target: CacheTarget, storage: any CacheStorage) async -> RestoreResult {
         do {
             let cacheKey = try await calculateCacheKey(of: target)
             if try await storage.existsValidCache(for: cacheKey) {
@@ -225,12 +229,6 @@ struct CacheSystem: Sendable {
         }
     }
 
-    private func fetchArtifacts(target: CacheTarget, to destination: URL) async throws {
-        guard let storage = storage else { return }
-        let cacheKey = try await calculateCacheKey(of: target)
-        try await storage.fetchArtifacts(for: cacheKey, to: destination)
-    }
-
     func calculateCacheKey(of target: CacheTarget) async throws -> SwiftPMCacheKey {
         let targetName = target.buildProduct.target.name
         let pin = try retrievePin(package: target.buildProduct.package)
@@ -247,7 +245,10 @@ struct CacheSystem: Sendable {
             buildOptions: buildOptions,
             clangVersion: clangVersion,
             xcodeVersion: xcodeVersion,
-            scipioVersion: currentScipioVersion
+            // Making the cache key compatible with 0.24.0 temporarily for easier debugging.
+            //
+            // TODO: revert this before merging
+            scipioVersion: "578ce98d236e79dad3e473cb11153e867be07174"
         )
     }
 

Sources/ScipioKit/Producer/Cache/LocalCacheStorage.swift → Sources/ScipioKit/Producer/Cache/LocalDiskCacheStorage.swift

@@ -3,7 +3,7 @@ import ScipioStorage
 import PackageGraph
 import TSCBasic
 
-public struct LocalCacheStorage: CacheStorage {
+public struct LocalDiskCacheStorage: CacheStorage {
     private let fileSystem: any FileSystem
 
     public var parallelNumber: Int? { nil }

Sources/ScipioKit/Producer/Cache/ProjectCacheStorage.swift

@@ -0,0 +1,10 @@
+import Foundation
+import ScipioStorage
+
+/// The pseudo cache storage for "project cache policy", which treats built frameworks under the project's output directory (e.g. `XCFrameworks`)
+/// as valid caches but does not saving / restoring anything.
+public struct ProjectCacheStorage: CacheStorage {
+    public func existsValidCache(for cacheKey: some ScipioStorage.CacheKey) async throws -> Bool { false }
+    public func fetchArtifacts(for cacheKey: some ScipioStorage.CacheKey, to destinationDir: URL) async throws {}
+    public func cacheFramework(_ frameworkPath: URL, for cacheKey: some ScipioStorage.CacheKey) async throws {}
+}

Sources/ScipioKit/Producer/CacheStorage+DisplayName.swift

@@ -0,0 +1,9 @@
+import ScipioStorage
+
+extension CacheStorage {
+    /// The display name of the cache storage used for logging purpose
+    var displayName: String {
+        // TODO: Define the property as CacheStorage's requirement in scipio-cache-storage
+        "\(type(of: self))"
+    }
+}

Sources/ScipioKit/Producer/FrameworkProducer.swift

@@ -10,31 +10,15 @@ struct FrameworkProducer {
     private let descriptionPackage: DescriptionPackage
     private let baseBuildOptions: BuildOptions
     private let buildOptionsMatrix: [String: BuildOptions]
-    private let cacheMode: Runner.Options.CacheMode
+    private let cachePolicies: [Runner.Options.CachePolicy]
     private let overwrite: Bool
     private let outputDir: URL
     private let fileSystem: any FileSystem
     private let toolchainEnvironment: [String: String]?
 
-    private var cacheStorage: (any CacheStorage)? {
-        switch cacheMode {
-        case .disabled, .project: return nil
-        case .storage(let storage, _): return storage
-        }
-    }
-
-    private var isProducingCacheEnabled: Bool {
-        switch cacheMode {
-        case .disabled: return false
-        case .project: return true
-        case .storage(_, let actors):
-            return actors.contains(.producer)
-        }
-    }
-
     private var shouldGenerateVersionFile: Bool {
-        // cacheMode is not disabled
-        if case .disabled = cacheMode {
+        // cache is not disabled
+        guard !cachePolicies.isEmpty else {
             return false
         }
 
@@ -49,7 +33,7 @@ struct FrameworkProducer {
         descriptionPackage: DescriptionPackage,
         buildOptions: BuildOptions,
         buildOptionsMatrix: [String: BuildOptions],
-        cacheMode: Runner.Options.CacheMode,
+        cachePolicies: [Runner.Options.CachePolicy],
         overwrite: Bool,
         outputDir: URL,
         toolchainEnvironment: [String: String]? = nil,
@@ -58,7 +42,7 @@ struct FrameworkProducer {
         self.descriptionPackage = descriptionPackage
         self.baseBuildOptions = buildOptions
         self.buildOptionsMatrix = buildOptionsMatrix
-        self.cacheMode = cacheMode
+        self.cachePolicies = cachePolicies
         self.overwrite = overwrite
         self.outputDir = outputDir
         self.toolchainEnvironment = toolchainEnvironment
@@ -108,12 +92,14 @@ struct FrameworkProducer {
         let pinsStore = try descriptionPackage.workspace.pinsStore.load()
         let cacheSystem = CacheSystem(
             pinsStore: pinsStore,
-            outputDirectory: outputDir,
-            storage: cacheStorage
+            outputDirectory: outputDir
         )
 
         let targetsToBuild: OrderedSet<CacheSystem.CacheTarget>
-        if cacheMode.isConsumingCacheEnabled {
+        if cachePolicies.isEmpty {
+            // no-op because cache is disabled
+            targetsToBuild = allTargets
+        } else {
             let targets = Set(allTargets)
 
             // Validate the existing frameworks in `outputDir` before restoration
@@ -122,16 +108,20 @@ struct FrameworkProducer {
                 cacheSystem: cacheSystem
             )
 
-            let restored = await restoreAllAvailableCaches(
-                availableTargets: targets.subtracting(valid),
-                cacheSystem: cacheSystem
-            )
-
-            targetsToBuild = allTargets
-                .subtracting(valid)
-                .subtracting(restored)
-        } else {
-            targetsToBuild = allTargets
+            let storagesWithConsumer = cachePolicies.storages(for: .consumer)
+            if storagesWithConsumer.isEmpty {
+                // no-op
+                targetsToBuild = allTargets.subtracting(valid)
+            } else {
+                let restored = await restoreAllAvailableCachesIfNeeded(
+                    availableTargets: targets.subtracting(valid),
+                    to: storagesWithConsumer,
+                    cacheSystem: cacheSystem
+                )
+                targetsToBuild = allTargets
+                    .subtracting(valid)
+                    .subtracting(restored)
+            }
         }
 
         for target in targetsToBuild {
@@ -142,9 +132,7 @@ struct FrameworkProducer {
             )
         }
 
-        if isProducingCacheEnabled {
-            await cacheSystem.cacheFrameworks(Set(targetsToBuild))
-        }
+        await cacheFrameworksIfNeeded(Set(targetsToBuild), cacheSystem: cacheSystem)
 
         if shouldGenerateVersionFile {
             // Versionfiles should be generate for all targets
@@ -167,13 +155,20 @@ struct FrameworkProducer {
                     group.addTask { [outputDir, fileSystem] in
                         do {
                             let product = target.buildProduct
-                            let outputPath = outputDir.appendingPathComponent(product.frameworkName)
+                            let frameworkName = product.frameworkName
+                            let outputPath = outputDir.appendingPathComponent(frameworkName)
                             let exists = fileSystem.exists(outputPath.absolutePath)
                             guard exists else { return nil }
 
                             let expectedCacheKey = try await cacheSystem.calculateCacheKey(of: target)
                             let isValidCache = await cacheSystem.existsValidCache(cacheKey: expectedCacheKey)
-                            guard isValidCache else { return nil }
+                            guard isValidCache else {
+                                logger.warning("⚠️ Existing \(frameworkName) is outdated.", metadata: .color(.yellow))
+                                logger.info("🗑️ Delete \(frameworkName)", metadata: .color(.red))
+                                try fileSystem.removeFileTree(outputPath.absolutePath)
+
+                                return nil
+                            }
 
                             let expectedCacheKeyHash = try expectedCacheKey.calculateChecksum()
                             logger.info(
@@ -194,11 +189,58 @@ struct FrameworkProducer {
         return validFrameworks
     }
 
-    private func restoreAllAvailableCaches(
+    private func restoreAllAvailableCachesIfNeeded(
         availableTargets: Set<CacheSystem.CacheTarget>,
+        to storages: [any CacheStorage],
+        cacheSystem: CacheSystem
+    ) async -> Set<CacheSystem.CacheTarget> {
+        var remainingTargets = availableTargets
+        var restored: Set<CacheSystem.CacheTarget> = []
+
+        for index in storages.indices {
+            let storage = storages[index]
+
+            let logSuffix = "[\(index)] \(storage.displayName)"
+            if index == storages.startIndex {
+                logger.info(
+                    "▶️ Starting restoration with cache storage: \(logSuffix)",
+                    metadata: .color(.green)
+                )
+            } else {
+                logger.info(
+                    "⏭️ Falling back to next cache storage: \(logSuffix)",
+                    metadata: .color(.green)
+                )
+            }
+
+            let restoredPerStorage = await restoreCaches(
+                for: remainingTargets,
+                from: storage,
+                cacheSystem: cacheSystem
+            )
+            restored.formUnion(restoredPerStorage)
+
+            logger.info(
+                "⏸️ Restoration finished with cache storage: \(logSuffix)",
+                metadata: .color(.green)
+            )
+
+            remainingTargets.subtract(restoredPerStorage)
+            if remainingTargets.isEmpty {
+                break
+            }
+        }
+
+        logger.info("⏹️ Restoration finished", metadata: .color(.green))
+        return restored
+    }
+
+    private func restoreCaches(
+        for targets: Set<CacheSystem.CacheTarget>,
+        from cacheStorage: any CacheStorage,
         cacheSystem: CacheSystem
     ) async -> Set<CacheSystem.CacheTarget> {
-        let chunked = availableTargets.chunks(ofCount: cacheStorage?.parallelNumber ?? CacheSystem.defaultParalellNumber)
+        let chunked = targets.chunks(ofCount: cacheStorage.parallelNumber ?? CacheSystem.defaultParalellNumber)
 
         var restored: Set<CacheSystem.CacheTarget> = []
         for chunk in chunked {
@@ -209,7 +251,8 @@ struct FrameworkProducer {
                         do {
                             let restored = try await restorer.restore(
                                 target: target,
-                                cacheSystem: cacheSystem
+                                cacheSystem: cacheSystem,
+                                cacheStorage: cacheStorage
                             )
                             return restored ? target : nil
                         } catch {
@@ -233,23 +276,16 @@ struct FrameworkProducer {
         // Return true if pre-built artifact is available (already existing or restored from cache)
         func restore(
             target: CacheSystem.CacheTarget,
-            cacheSystem: CacheSystem
+            cacheSystem: CacheSystem,
+            cacheStorage: any CacheStorage
         ) async throws -> Bool {
             let product = target.buildProduct
             let frameworkName = product.frameworkName
-            let outputPath = outputDir.appendingPathComponent(frameworkName)
-            let exists = fileSystem.exists(outputPath.absolutePath)
 
             let expectedCacheKey = try await cacheSystem.calculateCacheKey(of: target)
             let expectedCacheKeyHash = try expectedCacheKey.calculateChecksum()
 
-            if exists {
-                logger.warning("⚠️ Existing \(frameworkName) is outdated.", metadata: .color(.yellow))
-                logger.info("🗑️ Delete \(frameworkName)", metadata: .color(.red))
-                try fileSystem.removeFileTree(outputPath.absolutePath)
-            }
-
-            let restoreResult = await cacheSystem.restoreCacheIfPossible(target: target)
+            let restoreResult = await cacheSystem.restoreCacheIfPossible(target: target, storage: cacheStorage)
             switch restoreResult {
             case .succeeded:
                 logger.info("✅ Restore \(frameworkName) (\(expectedCacheKeyHash)) from cache storage.", metadata: .color(.green))
@@ -303,6 +339,13 @@ struct FrameworkProducer {
         return []
     }
 
+    private func cacheFrameworksIfNeeded(_ targets: Set<CacheSystem.CacheTarget>, cacheSystem: CacheSystem) async {
+        let storagesWithProducer = cachePolicies.storages(for: .producer)
+        if !storagesWithProducer.isEmpty {
+            await cacheSystem.cacheFrameworks(targets, to: storagesWithProducer)
+        }
+    }
+
     private func generateVersionFile(for target: CacheSystem.CacheTarget, using cacheSystem: CacheSystem) async {
         do {
             try await cacheSystem.generateVersionFile(for: target)
@@ -312,13 +355,12 @@ struct FrameworkProducer {
     }
 }
 
-extension Runner.Options.CacheMode {
-    fileprivate var isConsumingCacheEnabled: Bool {
-        switch self {
-        case .disabled: return false
-        case .project: return true
-        case .storage(_, let actors):
-            return actors.contains(.consumer)
+extension [Runner.Options.CachePolicy] {
+    fileprivate func storages(for actor: Runner.Options.CachePolicy.CacheActorKind) -> [any CacheStorage] {
+        reduce(into: []) { result, cachePolicy in
+            if cachePolicy.actors.contains(actor) {
+                result.append(cachePolicy.storage)
+            }
         }
     }
 }