URLCache store and fetch methods implemented using NSKeyedArchiver and NSKeyedUnarchiver

Author: karthikkeyan

Foundation/URLCache.swift

@@ -125,24 +125,10 @@ open class CachedURLResponse : NSObject, NSSecureCoding, NSCopying {
 open class URLCache : NSObject {
 
     private static let sharedSyncQ = DispatchQueue(label: "org.swift.URLCache.sharedSyncQ")
-    
-    private static var sharedCache: URLCache? {
-        willSet {
-            URLCache.sharedCache?.syncQ.sync {
-                URLCache.sharedCache?._databaseClient?.close()
-                URLCache.sharedCache?.flushDatabase()
-            }
-        }
-        didSet {
-            URLCache.sharedCache?.syncQ.sync {
-                URLCache.sharedCache?.setupCacheDatabaseIfNotExist()
-            }
-        }
-    }
+    private static var sharedCache: URLCache?
 
     private let syncQ = DispatchQueue(label: "org.swift.URLCache.syncQ")
-    private let _baseDiskPath: String?
-    private var _databaseClient: _CacheSQLiteClient?
+    private var persistence: CachePersistence?
 
     /*! 
         @method sharedURLCache
@@ -169,19 +155,31 @@ open class URLCache : NSObject {
                 } else {
                     let fourMegaByte = 4 * 1024 * 1024
                     let twentyMegaByte = 20 * 1024 * 1024
-                    let cacheDirectoryPath = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first?.path ?? "\(NSHomeDirectory())/Library/Caches/"
-                    let path = "\(cacheDirectoryPath)\(Bundle.main.bundleIdentifier ?? UUID().uuidString)"
-                    let cache = URLCache(memoryCapacity: fourMegaByte, diskCapacity: twentyMegaByte, diskPath: path)
+                    let bundleIdentifier = Bundle.main.bundleIdentifier ?? UUID().uuidString
+                    let cacheDirectoryPath = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first?.path ?? "\(NSHomeDirectory())/Library/Caches"
+                    let diskPath = cacheDirectoryPath + "/" + bundleIdentifier
+                    let cache = URLCache(memoryCapacity: fourMegaByte, diskCapacity: twentyMegaByte, diskPath: diskPath)
                     sharedCache = cache
+                    cache.persistence?.setupCacheDirectory()
                     return cache
                 }
             }
         }
         set {
-            sharedSyncQ.sync { sharedCache = newValue }
+            guard newValue !== sharedCache else { return }
+            
+            sharedSyncQ.sync {
+                // Remove previous data before resetting new URLCache instance
+                URLCache.sharedCache?.persistence?.deleteAllCaches()
+                sharedCache = newValue
+                newValue.persistence?.setupCacheDirectory()
+            }
         }
     }
 
+    private var allCaches: [String: CachedURLResponse] = [:]
+    private var cacheSizeInMemory: Int = 0
+
     /*! 
         @method initWithMemoryCapacity:diskCapacity:diskPath:
         @abstract Initializes an URLCache with the given capacity and
@@ -198,8 +196,11 @@ open class URLCache : NSObject {
     public init(memoryCapacity: Int, diskCapacity: Int, diskPath path: String?) {
         self.memoryCapacity = memoryCapacity
         self.diskCapacity = diskCapacity
-        self._baseDiskPath = path
-        
+
+        if let _path = path {
+            self.persistence = CachePersistence(path: _path)
+        }
+
         super.init()
     }
 
@@ -214,7 +215,27 @@ open class URLCache : NSObject {
         request, or nil if there is no NSCachedURLResponse stored with the
         given request.
     */
-    open func cachedResponse(for request: URLRequest) -> CachedURLResponse? { NSUnimplemented() }
+    open func cachedResponse(for request: URLRequest) -> CachedURLResponse? {
+        var cache: CachedURLResponse?
+        self.syncQ.sync {
+            let identifier = request.cacheFileIdentifier
+            if let inMemoryCache = self.allCaches[identifier] {
+                cache = inMemoryCache
+            } else if let _persistence = self.persistence {
+                guard let inDiskCache = _persistence.cachedResponse(for: request) else {
+                    cache = nil
+                    return
+                }
+
+                self.allCaches[identifier] = inDiskCache
+                self.cacheSizeInMemory += inDiskCache.data.count
+                cache = inDiskCache
+            } else {
+                cache = nil
+            }
+        }
+        return cache
+    }
 
     /*! 
         @method storeCachedResponse:forRequest:
@@ -223,7 +244,19 @@ open class URLCache : NSObject {
         @param cachedResponse The cached response to store.
         @param request the NSURLRequest to use as a key for the storage.
     */
-    open func storeCachedResponse(_ cachedResponse: CachedURLResponse, for request: URLRequest) { NSUnimplemented() }
+    open func storeCachedResponse(_ cachedResponse: CachedURLResponse, for request: URLRequest) {
+        self.syncQ.sync {
+            purgeOldMemoryForNewCacheIfNeeded(cachedResponse)
+            
+            let identifier = request.cacheFileIdentifier
+            self.allCaches[identifier] = cachedResponse
+            self.cacheSizeInMemory += cachedResponse.data.count
+
+            if self.persistence != nil {
+                self.persistence?.saveCachedResponse(cachedResponse, for: request)
+            }
+        }
+    }
 
     /*! 
         @method removeCachedResponseForRequest:
@@ -272,7 +305,9 @@ open class URLCache : NSObject {
         usage of the in-memory cache. 
         @result the current usage of the in-memory cache of the receiver.
     */
-    open var currentMemoryUsage: Int { NSUnimplemented() }
+    open var currentMemoryUsage: Int {
+        return self.syncQ.sync { self.cacheSizeInMemory }
+    }
 
     /*! 
         @method currentDiskUsage
@@ -282,17 +317,14 @@ open class URLCache : NSObject {
         usage of the on-disk cache. 
         @result the current usage of the on-disk cache of the receiver.
     */
-    open var currentDiskUsage: Int { NSUnimplemented() }
+    open var currentDiskUsage: Int {
+        return self.syncQ.sync { self.persistence?.cacheSizeInDesk ?? 0 }
+    }
 
-    private func flushDatabase() {
-        guard let path = _baseDiskPath else { return }
-        
-        do {
-            let dbPath = path.appending("/Cache.db")
-            try FileManager.default.removeItem(atPath: dbPath)
-        } catch {
-            fatalError("Unable to flush database for URLCache: \(error.localizedDescription)")
-        }
+    private func purgeOldMemoryForNewCacheIfNeeded(_ newCache: CachedURLResponse) {
+        // 1. Check the in-memory cache size and purge old if needed
+        // 2. Check the disk-memory cache size and purge old if needed
+        NSUnimplemented()
     }
 
 }
@@ -303,112 +335,79 @@ extension URLCache {
     public func removeCachedResponse(for dataTask: URLSessionDataTask) { NSUnimplemented() }
 }
 
-extension URLCache {
-    
-    private func setupCacheDatabaseIfNotExist() {
-        guard let path = _baseDiskPath else { return }
-        
-        if !FileManager.default.fileExists(atPath: path) {
-            do {
-                try FileManager.default.createDirectory(atPath: path, withIntermediateDirectories: true)
-            } catch {
-                fatalError("Unable to create directories for URLCache: \(error.localizedDescription)")
+fileprivate struct CachePersistence {
+
+    let path: String
+
+    var cacheSizeInDesk: Int {
+        do {
+            let subFiles = try FileManager.default.subpathsOfDirectory(atPath: path)
+            var total: Int = 0
+            for fileName in subFiles {
+                let attributes = try FileManager.default.attributesOfItem(atPath: path.appending(fileName))
+                total += (attributes[.size] as? Int) ?? 0
             }
-        }
-        
-        // Close the currently opened database connection(if any), before creating/replacing the db file
-        _databaseClient?.close()
-        
-        let dbPath = path.appending("/Cache.db")
-        if !FileManager.default.createFile(atPath: dbPath, contents: nil, attributes: nil) {
-            fatalError("Unable to setup database for URLCache")
-        }
-        
-        _databaseClient = _CacheSQLiteClient(databasePath: dbPath)
-        if _databaseClient == nil {
-            _databaseClient?.close()
-            flushDatabase()
-            fatalError("Unable to setup database for URLCache")
-        }
-        
-        if !createTables() {
-            _databaseClient?.close()
-            flushDatabase()
-            fatalError("Unable to setup database for URLCache: Tables not created")
-        }
-        
-        if !createIndicesForTables() {
-            _databaseClient?.close()
-            flushDatabase()
-            fatalError("Unable to setup database for URLCache: Indices not created for tables")
+            return total
+        } catch {
+            return 0
         }
     }
 
-    private func createTables() -> Bool {
-        guard _databaseClient != nil else {
-            fatalError("Cannot create table before database setup")
-        }
-        
-        let tableSQLs = [
-            "CREATE TABLE cfurl_cache_response(entry_ID INTEGER PRIMARY KEY, version INTEGER, hash_value VARCHAR, storage_policy INTEGER, request_key VARCHAR, time_stamp DATETIME, partition VARCHAR)",
-            "CREATE TABLE cfurl_cache_receiver_data(entry_ID INTEGER PRIMARY KEY, isDataOnFS INTEGER, receiver_data BLOB)",
-            "CREATE TABLE cfurl_cache_blob_data(entry_ID INTEGER PRIMARY KEY, response_object BLOB, request_object BLOB, proto_props BLOB, user_info BLOB)",
-            "CREATE TABLE cfurl_cache_schema_version(schema_version INTEGER)"
-        ]
-        
-        for sql in tableSQLs {
-            if let isSuccess = _databaseClient?.execute(sql: sql), !isSuccess {
-                return false
+    func setupCacheDirectory() {
+        do {
+            if FileManager.default.fileExists(atPath: path) {
+                try FileManager.default.removeItem(atPath: path)
             }
+            
+            try FileManager.default.createDirectory(atPath: path, withIntermediateDirectories: true)
+        } catch {
+            fatalError("Unable to create directories for URLCache: \(error.localizedDescription)")
         }
-        
-        return true
     }
-    
-    private func createIndicesForTables() -> Bool {
-        guard _databaseClient != nil else {
-            fatalError("Cannot create table before database setup")
-        }
-        
-        let indicesSQLs = [
-            "CREATE INDEX proto_props_index ON cfurl_cache_blob_data(entry_ID)",
-            "CREATE INDEX receiver_data_index ON cfurl_cache_receiver_data(entry_ID)",
-            "CREATE INDEX request_key_index ON cfurl_cache_response(request_key)",
-            "CREATE INDEX time_stamp_index ON cfurl_cache_response(time_stamp)"
-        ]
-        
-        for sql in indicesSQLs {
-            if let isSuccess = _databaseClient?.execute(sql: sql), !isSuccess {
-                return false
-            }
+
+    func saveCachedResponse(_ response: CachedURLResponse, for request: URLRequest) {
+        let archivedData = NSKeyedArchiver.archivedData(withRootObject: response)
+        do {
+            let cacheFileURL = urlForFileIdentifier(request.cacheFileIdentifier)
+            try archivedData.write(to: cacheFileURL)
+        } catch {
+            fatalError("Unable to save cache data: \(error.localizedDescription)")
         }
-        
-        return true
     }
-    
-}
 
-fileprivate struct _CacheSQLiteClient {
-    
-    private var database: OpaquePointer?
-    
-    init?(databasePath: String) {
-        if sqlite3_open_v2(databasePath, &database, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, nil) != SQLITE_OK {
+    func cachedResponse(for request: URLRequest) -> CachedURLResponse? {
+        let url = urlForFileIdentifier(request.cacheFileIdentifier)
+        guard let data = try? Data(contentsOf: url),
+            let response = NSKeyedUnarchiver.unarchiveObject(with: data) as? CachedURLResponse else {
             return nil
         }
+
+        return response
     }
-    
-    func execute(sql: String) -> Bool {
-        guard let db = database else { return false }
-        
-        return sqlite3_exec(db, sql, nil, nil, nil) == SQLITE_OK
+
+    func deleteAllCaches() {
+        do {
+            try FileManager.default.removeItem(atPath: path)
+        } catch {
+            fatalError("Unable to flush database for URLCache: \(error.localizedDescription)")
+        }
     }
-    
-    mutating func close() {
-        guard let db = database else { return }
-        
-        sqlite3_close_v2(db)
-        database = nil
+
+    private func urlForFileIdentifier(_ identifier: String) -> URL {
+        return URL(fileURLWithPath: path + "/" + identifier)
     }
-    
+
+}
+
+fileprivate extension URLRequest {
+
+    var cacheFileIdentifier: String {
+        guard let urlString = url?.absoluteString else {
+            fatalError("Unable to create cache identifier for request: \(self)")
+        }
+
+        let method = httpMethod ?? "GET"
+        return urlString + method
+    }
+
 }