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()
     }
 
@@ -272,7 +273,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 +285,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 +297,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
+    }
+
 }

TestFoundation/TestURLCache.swift

@@ -1,92 +1,41 @@
+// This source file is part of the Swift.org open source project
 //
-//  TestURLCache.swift
-//  TestFoundation
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
 //
-//  Created by Karthikkeyan Bala Sundaram on 3/8/19.
-//  Copyright © 2019 Apple. All rights reserved.
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
-import SQLite3
-
 class TestURLCache: XCTestCase {
 
     static var allTests: [(String, (TestURLCache) -> () throws -> Void)] {
         return [
             ("test_cacheFileAndDirectorySetup", test_cacheFileAndDirectorySetup),
-            ("test_cacheDatabaseTables", test_cacheDatabaseTables),
-            ("test_cacheDatabaseIndices", test_cacheDatabaseIndices),
         ]
     }
-    
+
     private var cacheDirectoryPath: String {
         if let path = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first?.path {
             return "\(path)/org.swift.TestFoundation"
         } else {
             return "\(NSHomeDirectory())/Library/Caches/org.swift.TestFoundation"
         }
     }
-    
-    private var cacheDatabasePath: String {
-        return "\(cacheDirectoryPath)/Cache.db"
-    }
-    
+
     func test_cacheFileAndDirectorySetup() {
+        // Test default directory
         let _ = URLCache.shared
-        
         XCTAssertTrue(FileManager.default.fileExists(atPath: cacheDirectoryPath))
-        XCTAssertTrue(FileManager.default.fileExists(atPath: cacheDatabasePath))
-    }
-    
-    func test_cacheDatabaseTables() {
-        let _ = URLCache.shared
-        
-        var db: OpaquePointer? = nil
-        let openDBResult = sqlite3_open_v2(cacheDatabasePath, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, nil)
-        XCTAssertTrue(openDBResult == SQLITE_OK, "Unable to open database")
-        
-        var statement: OpaquePointer? = nil
-        let prepareResult = sqlite3_prepare_v2(db!, "select tbl_name from sqlite_master where type='table'", -1, &statement, nil)
-        XCTAssertTrue(prepareResult == SQLITE_OK, "Unable to prepare list tables statement")
-        
-        var tables = ["cfurl_cache_response": false, "cfurl_cache_receiver_data": false, "cfurl_cache_blob_data": false, "cfurl_cache_schema_version": false]
-        while sqlite3_step(statement!) == SQLITE_ROW {
-            let tableName = String(cString: sqlite3_column_text(statement!, 0))
-            tables[tableName] = true
-        }
-        
-        let tablesNotExist = tables.filter({ !$0.value })
-        if tablesNotExist.count == tables.count {
-            XCTFail("No tables created for URLCache")
-        }
-        
-        XCTAssertTrue(tablesNotExist.count == 0, "Table(s) not created: \(tablesNotExist.map({ $0.key }).joined(separator: ", "))")
-        sqlite3_close_v2(db!)
-    }
-    
-    func test_cacheDatabaseIndices() {
-        let _ = URLCache.shared
-        
-        var db: OpaquePointer? = nil
-        let openDBResult = sqlite3_open_v2(cacheDatabasePath, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, nil)
-        XCTAssertTrue(openDBResult == SQLITE_OK, "Unable to open database")
-        
-        var statement: OpaquePointer? = nil
-        let prepareResult = sqlite3_prepare_v2(db!, "select name from sqlite_master where type='index'", -1, &statement, nil)
-        XCTAssertTrue(prepareResult == SQLITE_OK, "Unable to prepare list tables statement")
-        
-        var indices = ["proto_props_index": false, "receiver_data_index": false, "request_key_index": false, "time_stamp_index": false]
-        while sqlite3_step(statement!) == SQLITE_ROW {
-            let name = String(cString: sqlite3_column_text(statement!, 0))
-            indices[name] = true
-        }
-        
-        let indicesNotExist = indices.filter({ !$0.value })
-        if indicesNotExist.count == indices.count {
-            XCTFail("No index created for URLCache")
-        }
-        
-        XCTAssertTrue(indicesNotExist.count == 0, "Indices not created: \(indicesNotExist.map({ $0.key }).joined(separator: ", "))")
-        sqlite3_close_v2(db!)
+
+        let fourMegaByte = 4 * 1024 * 1024
+        let twentyMegaByte = 20 * 1024 * 1024
+
+        // Test with a custom directory
+        let newPath = cacheDirectoryPath + ".test_cacheFileAndDirectorySetup/"
+        URLCache.shared = URLCache(memoryCapacity: fourMegaByte, diskCapacity: twentyMegaByte, diskPath: newPath)
+        XCTAssertTrue(FileManager.default.fileExists(atPath: newPath))
+        XCTAssertFalse(FileManager.default.fileExists(atPath: cacheDirectoryPath))
     }
-    
+
 }