URLCache store and fetch methods implemented using NSKeyedArchiver and NSKeyedUnarchiver

Author: karthikkeyan

Foundation/URLCache.swift

@@ -7,8 +7,6 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
-import SQLite3
-
 /*!
     @enum URLCache.StoragePolicy
 
@@ -125,24 +123,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 +153,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 +194,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()
     }
 
@@ -272,7 +271,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,19 +283,10 @@ 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() }
-    
-    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)")
-        }
+    open var currentDiskUsage: Int {
+        return self.syncQ.sync { self.persistence?.cacheSizeInDesk ?? 0 }
     }
-    
+
 }
 
 extension URLCache {
@@ -303,112 +295,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
+    }
+
 }