signalapp/Signal-iOS
signalapp/Signal-iOS
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases 4 Wiki Activity
e70302ac8f
Signal-iOS/SignalServiceKit/src/Storage/Database/GRDBDatabaseStorageAdapter.swift

950 lines
35 KiB
Swift
Raw Blame History

//
// Copyright (c) 2021 Open Whisper Systems. All rights reserved.
//
import Foundation
import GRDB
@objc
public class GRDBDatabaseStorageAdapter: NSObject {
// 256 bit key + 128 bit salt
public static let kSQLCipherKeySpecLength: UInt = 48
@objc
public enum DirectoryMode: Int {
case primary
case hotswap
var folderName: String {
switch self {
case .primary: return "grdb"
case .hotswap: return "grdb-hotswap"
}
}
}
@objc
public static func databaseDirUrl(baseDir: URL, directoryMode: DirectoryMode = .primary) -> URL {
return baseDir.appendingPathComponent(directoryMode.folderName, isDirectory: true)
}
public static func databaseFileUrl(baseDir: URL, directoryMode: DirectoryMode = .primary) -> URL {
let databaseDir = databaseDirUrl(baseDir: baseDir, directoryMode: directoryMode)
OWSFileSystem.ensureDirectoryExists(databaseDir.path)
return databaseDir.appendingPathComponent("signal.sqlite", isDirectory: false)
}
public static func databaseWalUrl(baseDir: URL, directoryMode: DirectoryMode = .primary) -> URL {
let databaseDir = databaseDirUrl(baseDir: baseDir, directoryMode: directoryMode)
OWSFileSystem.ensureDirectoryExists(databaseDir.path)
return databaseDir.appendingPathComponent("signal.sqlite-wal", isDirectory: false)
}
private let databaseUrl: URL
private let storage: GRDBStorage
public var pool: DatabasePool {
return storage.pool
}
private let checkpointLock = UnfairLock()
// The number of writes we can perform until our next checkpoint attempt.
//
// checkpointBudget should only be accessed while checkpointLock is acquired.
private var checkpointBudget: Int = 0
// lastSuccessfulCheckpointDate should only be accessed while checkpointLock is acquired.
private var lastSuccessfulCheckpointDate: Date?
init(baseDir: URL, directoryMode: DirectoryMode = .primary) {
databaseUrl = GRDBDatabaseStorageAdapter.databaseFileUrl(baseDir: baseDir, directoryMode: directoryMode)
do {
// Crash if keychain is inaccessible.
try GRDBDatabaseStorageAdapter.ensureDatabaseKeySpecExists(baseDir: baseDir)
} catch {
owsFail("\(error.grdbErrorForLogging)")
}
do {
// Crash if storage can't be initialized.
storage = try GRDBStorage(dbURL: databaseUrl, keyspec: GRDBDatabaseStorageAdapter.keyspec)
} catch {
owsFail("\(error.grdbErrorForLogging)")
}
super.init()
AppReadiness.runNowOrWhenAppWillBecomeReady { [weak self] in
// This adapter may have been discarded after running
// schema migrations.
guard let self = self else { return }
BenchEventStart(title: "GRDB Setup", eventId: "GRDB Setup")
defer { BenchEventComplete(eventId: "GRDB Setup") }
do {
try self.setup()
} catch {
owsFail("unable to setup database: \(error)")
}
}
}
public func add(function: DatabaseFunction) {
pool.add(function: function)
}
static let tables: [SDSTableMetadata] = [
// Models
TSThread.table,
TSInteraction.table,
StickerPack.table,
InstalledSticker.table,
KnownStickerPack.table,
TSAttachment.table,
SSKJobRecord.table,
OWSMessageContentJob.table,
OWSRecipientIdentity.table,
ExperienceUpgrade.table,
OWSDisappearingMessagesConfiguration.table,
SignalRecipient.table,
SignalAccount.table,
OWSUserProfile.table,
OWSDevice.table,
TestModel.table,
OWSReaction.table,
IncomingGroupsV2MessageJob.table,
TSMention.table,
TSPaymentModel.table,
TSPaymentRequestModel.table,
TSGroupMember.table
// NOTE: We don't include OWSMessageDecryptJob,
// since we should never use it with GRDB.
]
static let swiftTables: [TableRecord.Type] = [
ThreadAssociatedData.self,
PendingReadReceiptRecord.self,
PendingViewedReceiptRecord.self,
MediaGalleryRecord.self,
MessageSendLog.Payload.self,
MessageSendLog.Recipient.self,
MessageSendLog.Message.self
]
// MARK: - DatabaseChangeObserver
@objc
public private(set) var databaseChangeObserver: DatabaseChangeObserver?
@objc
public func setupDatabaseChangeObserver() throws {
owsAssertDebug(self.databaseChangeObserver == nil)
// DatabaseChangeObserver is a general purpose observer, whose delegates
// are notified when things change, but are not given any specific details
// about the changes.
let databaseChangeObserver = DatabaseChangeObserver()
self.databaseChangeObserver = databaseChangeObserver
try pool.write { db in
db.add(transactionObserver: databaseChangeObserver, extent: Database.TransactionObservationExtent.observerLifetime)
}
}
// NOTE: This should only be used in exceptional circumstances,
// e.g. after reloading the database due to a device transfer.
func publishUpdatesImmediately() {
databaseChangeObserver?.publishUpdatesImmediately()
}
func testing_tearDownDatabaseChangeObserver() {
// DatabaseChangeObserver is a general purpose observer, whose delegates
// are notified when things change, but are not given any specific details
// about the changes.
self.databaseChangeObserver = nil
}
func setup() throws {
MediaGalleryManager.setup(storage: self)
try setupDatabaseChangeObserver()
}
// MARK: -
private static let keyServiceName: String = "GRDBKeyChainService"
private static let keyName: String = "GRDBDatabaseCipherKeySpec"
public static var keyspec: GRDBKeySpecSource {
return GRDBKeySpecSource(keyServiceName: keyServiceName, keyName: keyName)
}
@objc
public static var isKeyAccessible: Bool {
do {
return try keyspec.fetchString().count > 0
} catch {
owsFailDebug("Key not accessible: \(error)")
return false
}
}
/// Fetches the GRDB key data from the keychain.
/// - Note: Will fatally assert if not running in a debug or test build.
/// - Returns: The key data, if available.
@objc
public static var debugOnly_keyData: Data? {
owsAssert(OWSIsTestableBuild())
return try? keyspec.fetchData()
}
@objc
public static func ensureDatabaseKeySpecExists(baseDir: URL) throws {
do {
_ = try keyspec.fetchString()
// Key exists and is valid.
return
} catch {
Logger.warn("Key not accessible: \(error)")
}
// Because we use kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly,
// the keychain will be inaccessible after device restart until
// device is unlocked for the first time. If the app receives
// a push notification, we won't be able to access the keychain to
// process that notification, so we should just terminate by throwing
// an uncaught exception.
var errorDescription = "CipherKeySpec inaccessible. New install, migration or no unlock since device restart?"
if CurrentAppContext().isMainApp {
let applicationState = CurrentAppContext().reportedApplicationState
errorDescription += ", ApplicationState: \(NSStringForUIApplicationState(applicationState))"
}
Logger.error(errorDescription)
Logger.flush()
if CurrentAppContext().isMainApp {
if CurrentAppContext().isInBackground() {
// Rather than crash here, we should have already detected the situation earlier
// and exited gracefully (in the app delegate) using isDatabasePasswordAccessible.
// This is a last ditch effort to avoid blowing away the user's database.
throw OWSAssertionError(errorDescription)
}
} else {
throw OWSAssertionError("CipherKeySpec inaccessible; not main app.")
}
// At this point, either:
//
// * This is a new install so there's no existing password to retrieve.
// * The keychain has become corrupt.
let databaseUrl = GRDBDatabaseStorageAdapter.databaseFileUrl(baseDir: baseDir)
let doesDBExist = FileManager.default.fileExists(atPath: databaseUrl.path)
if doesDBExist {
owsFail("Could not load database metadata")
}
keyspec.generateAndStore()
}
@objc
public static func resetAllStorage(baseDir: URL) {
Logger.info("")
// This might be redundant but in the spirit of thoroughness...
GRDBDatabaseStorageAdapter.removeAllFiles(baseDir: baseDir)
deleteDBKeys()
if CurrentAppContext().isMainApp {
TSAttachmentStream.deleteAttachmentsFromDisk()
}
// TODO: Delete Profiles on Disk?
}
private static func deleteDBKeys() {
do {
try keyspec.clear()
} catch {
owsFailDebug("Could not clear keychain: \(error)")
}
}
static func prepareDatabase(db: Database, keyspec: GRDBKeySpecSource, name: String? = nil) throws {
let prefix: String
if let name = name, !name.isEmpty {
prefix = name + "."
} else {
prefix = ""
}
let keyspec = try keyspec.fetchString()
try db.execute(sql: "PRAGMA \(prefix)key = \"\(keyspec)\"")
try db.execute(sql: "PRAGMA \(prefix)cipher_plaintext_header_size = 32")
}
}
// MARK: -
extension GRDBDatabaseStorageAdapter: SDSDatabaseStorageAdapter {
#if TESTABLE_BUILD
// TODO: We could eventually eliminate all nested transactions.
private static let detectNestedTransactions = false
// In debug builds, we can detect transactions opened within transaction.
// These checks can also be used to detect unexpected "sneaky" transactions.
@ThreadBacked(key: "canOpenTransaction", defaultValue: true)
public static var canOpenTransaction: Bool
#endif
// TODO writeThrows flavors
public func readThrows(block: (GRDBReadTransaction) throws -> Void) throws {
#if TESTABLE_BUILD
owsAssertDebug(Self.canOpenTransaction)
// Check for nested tractions.
if Self.detectNestedTransactions {
// Check for nested tractions.
Self.canOpenTransaction = false
}
defer {
if Self.detectNestedTransactions {
Self.canOpenTransaction = true
}
}
#endif
return try pool.read { database in
try autoreleasepool {
try block(GRDBReadTransaction(database: database))
}
}
}
@discardableResult
public func read<T>(block: (GRDBReadTransaction) throws -> T) throws -> T {
#if TESTABLE_BUILD
owsAssertDebug(Self.canOpenTransaction)
// Check for nested tractions.
if Self.detectNestedTransactions {
// Check for nested tractions.
Self.canOpenTransaction = false
}
defer {
if Self.detectNestedTransactions {
Self.canOpenTransaction = true
}
}
#endif
return try pool.read { database in
try autoreleasepool {
try block(GRDBReadTransaction(database: database))
}
}
}
@discardableResult
public func write<T>(block: (GRDBWriteTransaction) throws -> T) throws -> T {
var value: T!
var thrown: Error?
try write { (transaction) in
do {
value = try block(transaction)
} catch {
thrown = error
}
}
if let error = thrown {
throw error.grdbErrorForLogging
}
return value
}
@objc
public func read(block: (GRDBReadTransaction) -> Void) throws {
#if TESTABLE_BUILD
owsAssertDebug(Self.canOpenTransaction)
if Self.detectNestedTransactions {
// Check for nested tractions.
Self.canOpenTransaction = false
}
defer {
if Self.detectNestedTransactions {
Self.canOpenTransaction = true
}
}
#endif
try pool.read { database in
autoreleasepool {
block(GRDBReadTransaction(database: database))
}
}
}
@objc
public func write(block: (GRDBWriteTransaction) -> Void) throws {
#if TESTABLE_BUILD
owsAssertDebug(Self.canOpenTransaction)
// Check for nested tractions.
if Self.detectNestedTransactions {
// Check for nested tractions.
Self.canOpenTransaction = false
}
defer {
if Self.detectNestedTransactions {
Self.canOpenTransaction = true
}
}
#endif
var syncCompletions: [GRDBWriteTransaction.CompletionBlock] = []
var asyncCompletions: [GRDBWriteTransaction.AsyncCompletion] = []
try pool.write { database in
autoreleasepool {
let transaction = GRDBWriteTransaction(database: database)
block(transaction)
transaction.finalizeTransaction()
syncCompletions = transaction.syncCompletions
asyncCompletions = transaction.asyncCompletions
}
}
checkpointLock.withLock {
checkpointIfNecessary()
}
// Perform all completions _after_ the write transaction completes.
for block in syncCompletions {
block()
}
for asyncCompletion in asyncCompletions {
asyncCompletion.queue.async(execute: asyncCompletion.block)
}
}
// This method should only be invoked with checkpointLock already acquired.
private func checkpointIfNecessary() {
// What Is Checkpointing?
//
// Checkpointing is the process of integrating the WAL into the main database file.
// Without it, the WAL will grow indefinitely. A large WAL affects read performance.
// Therefore we want to keep the WAL small.
//
// * The SQLite WAL consists of "frames", representing changes to the database.
// * Frames are appended to the tail of the WAL.
// * The WAL tracks how many of its frames have been integrated into the database.
// * Checkpointing entails some subset of the following tasks:
// * Integrating some or all of the frames of the WAL into the database.
// * "Restarting" the WAL so the next frame is written to the head of the WAL
// file, not the tail. WAL file size doesn't change, but since subsequent writes
// overwrite from the start of the WAL, WAL file size growth can be bounded.
// * "Truncating" the WAL so that that the WAL file is deleted or returned to
// an empty state.
//
// The more unintegrated frames there are in the WAL, the longer a checkpoint takes
// to complete. Long-running checkpoints can cause problems in the app, e.g.
// blocking the main thread (note: we currently do _NOT_ checkpoint on the main
// thread). Therefore we want to bound overall WAL file size _and_ the number of
// unintegrated frames.
//
// To bound WAL file size, it's important to periodically "restart" or (preferably)
// truncate the WAL file. We currently always truncate.
//
// To bound the number of unintegrated frames, we can use passive checkpoints.
// We don't explicitly initiate passive checkpoints, but leave this to SQLite
// auto-checkpointing.
//
//
// Checkpoint Types
//
// Checkpointing has several flavors: passive, full, restart, truncate.
//
// * Passive checkpoints abort immediately if there are any database
// readers or writers. This makes them "cheap" in the sense that
// they won't block for long.
// However they only integrate WAL contents, they don't "restart" or
// "truncate" so they don't inherently limit WAL growth.
// My understanding is that they can have partial success, e.g.
// integrating some but not all of the frames of the WAL. This is
// beneficial.
// * Full/Restart/Truncate checkpoints will block using the busy-handler.
// We use truncate checkpoints since they truncate the WAL file.
// See GRDBStorage.buildConfiguration for our busy-handler (aka busyMode
// callback). It aborts after ~50ms.
// These checkpoints are more expensive and will block while they do
// their work but will limit WAL growth.
//
// SQLite has auto-checkpointing enabled by default, meaning that it
// is continually trying to perform passive checkpoints in the background.
// This is beneficial.
//
//
// Exclusion
//
// Note that we are navigating multiple exclusion mechanisms.
//
// * SQLite (as we have configured it) excludes database writes using
// write locks (POSIX advisory locking on the database files).
// This locking protects the database from cross-process writes.
// * GRDB writers use a serial DispatchQueue to exclude writes from
// each other within a given DatabasePool / DatabaseQueue.
// AFAIK this does not protect any GRDB internal state; it allows
// GRDB to detect re-entrancy, etc.
//
// SQLite cannot checkpoint if there are any readers or writers.
// Therefore we cannot checkpoint within a SQLite write transaction.
// We checkpoint after write transactions using
// DatabasePool.writeWithoutTransaction(). This method uses the
// GRDB exclusion mechanism but not the SQL one.
//
//
// Our approach:
//
// * Always (not including auto-checkpointing) use truncate checkpoints
// to limit WAL size.
// * Only checkpoint immediately after writes.
// * It's expensive and unnecessary to do a checkpoint on every write,
// so we only checkpoint once every N writes. We always checkpoint after
// the first write. Large (in terms of file size) writes should be rare,
// so WAL file size should be bounded and quite small.
// * Use a "budget" to tracking the urgency of trying to perform a checkpoint after
// the next write. When the budget reaches zero, we should try after the next
// write. Successes bump up the budget considerably, failures bump it up a little.
// * Retry more often after failures, via the budget.
//
//
// What could go wrong:
//
// * Our busy-handler (aka busyMode callback) is untested. Previously it was
// irrelevant because we always performed checkpoints on a separate
// DatabaseQueue.
// It needs to work correctly to ensure that checkpoints timeout if there's
// heavy contention (reads or writes).
// * Checkpointing could be expensive in some cases, causing blocking.
// This shouldn't be an issue: we're more aggressive than ever about
// keeping the WAL small.
// * Cross-process activity could interfere with checkpointing.
// This shouldn't be an issue: We shouldn't have more than one of
// the apps (main app, SAE, NSE) active at the same time for long.
// * Checkpoints might frequently fail if we're constantly doing reads.
// This shouldn't be an issue: A checkpoint should eventually
// succeed when db activity settles. This checkpoint might take a while
// but that's unavoidable.
// The counter-argument is that we only try to checkpoint immediately after
// a write. We often do reads immediately after writes to update the UI
// to reflect the DB changes. Those reads _might_ frequently interfere
// with checkpointing.
// * We might not be checkpointing often enough, or we might be checkpointing
// too often. Either way, it's about balancing overall perf with the perf
// cost of the next successful checkpoint. We can tune this behavior
// using the "checkpoint budget".
//
// Reference
//
// * https://www.sqlite.org/c3ref/wal_checkpoint_v2.html
// * https://www.sqlite.org/wal.html
// * https://www.sqlite.org/howtocorrupt.html
//
guard !Thread.isMainThread else {
// To avoid blocking the main thread, we avoid doing "truncate" checkpoints
// on the main thread. We perhaps could do passive checkpoints on the main
// thread, which abort if there is any contention.
//
// We decrement the checkpoint budget anyway.
checkpointBudget -= 1
return
}
var shouldCheckpoint = checkpointBudget <= 0
// Limit checkpoint frequency by time so that heavy write activity
// won't bog down the main thread.
let maxCheckpointFrequency: TimeInterval = 0.25
if shouldCheckpoint,
let lastSuccessfulCheckpointDate = self.lastSuccessfulCheckpointDate,
abs(lastSuccessfulCheckpointDate.timeIntervalSinceNow) < maxCheckpointFrequency {
Logger.verbose("Skipping checkpoint due to frequency.")
shouldCheckpoint = false
}
guard shouldCheckpoint else {
// We decrement the checkpoint budget.
checkpointBudget -= 1
return
}
// Set isCheckpointing flag.
owsAssertDebug(!GRDBStorage.isCheckpointing)
GRDBStorage.isCheckpointing = true
owsAssertDebug(GRDBStorage.isCheckpointing)
defer {
// Clear isCheckpointing flag.
owsAssertDebug(GRDBStorage.isCheckpointing)
GRDBStorage.isCheckpointing = false
owsAssertDebug(!GRDBStorage.isCheckpointing)
}
pool.writeWithoutTransaction { database in
let kind: Database.CheckpointMode = .truncate
var walSizePages: Int32 = 0
var pagesCheckpointed: Int32 = 0
var code: Int32 = 0
Bench(title: "Checkpoint",
logIfLongerThan: TimeInterval(5) / TimeInterval(1000),
logInProduction: true) {
code = sqlite3_wal_checkpoint_v2(database.sqliteConnection,
nil,
kind.rawValue,
&walSizePages,
&pagesCheckpointed)
}
if code != SQLITE_OK {
// Extracting this error message can race.
let errorMessage = String(cString: sqlite3_errmsg(database.sqliteConnection))
if code == SQLITE_BUSY {
// It is expected that the busy-handler (aka busyMode callback)
// will abort checkpoints if there is contention.
Logger.warn("Error code: \(code), errorMessage: \(errorMessage).")
} else {
owsFailDebug("Error code: \(code), errorMessage: \(errorMessage).")
}
// If the checkpoint failed, try again soon.
checkpointBudget += 5
} else {
let pageSize: Int32 = 4 * 1024
let walFileSizeBytes = walSizePages * pageSize
let maxWalFileSizeBytes = 4 * 1024 * 1024
if walFileSizeBytes > maxWalFileSizeBytes {
Logger.info("walFileSizeBytes: \(walFileSizeBytes).")
Logger.info("walSizePages: \(walSizePages), pagesCheckpointed: \(pagesCheckpointed).")
} else {
Logger.verbose("walSizePages: \(walSizePages), pagesCheckpointed: \(pagesCheckpointed).")
}
// If the checkpoint succeeded, wait N writes before performing another checkpoint.
checkpointBudget += 32
lastSuccessfulCheckpointDate = Date()
}
}
}
}
// MARK: -
func filterForDBQueryLog(_ input: String) -> String {
var result = input
while let matchRange = result.range(of: "x'[0-9a-f\n]*'", options: .regularExpression) {
let charCount = result.distance(from: matchRange.lowerBound, to: matchRange.upperBound)
let byteCount = Int64(charCount) / 2
let formattedByteCount = ByteCountFormatter.string(fromByteCount: byteCount, countStyle: .memory)
result = result.replacingCharacters(in: matchRange, with: "x'<\(formattedByteCount)>'")
}
return result
}
private func dbQueryLog(_ value: String) {
guard SDSDatabaseStorage.shouldLogDBQueries else {
return
}
Logger.info(filterForDBQueryLog(value))
}
// MARK: -
private struct GRDBStorage {
let pool: DatabasePool
private let dbURL: URL
private let poolConfiguration: Configuration
fileprivate static let maxBusyTimeoutMs = 50
init(dbURL: URL, keyspec: GRDBKeySpecSource) throws {
self.dbURL = dbURL
self.poolConfiguration = Self.buildConfiguration(keyspec: keyspec)
self.pool = try Self.buildPool(dbURL: dbURL, poolConfiguration: poolConfiguration)
Logger.debug("dbURL: \(dbURL)")
OWSFileSystem.protectFileOrFolder(atPath: dbURL.path)
}
// See: https://github.com/groue/GRDB.swift/blob/master/Documentation/SharingADatabase.md
private static func buildPool(dbURL: URL, poolConfiguration: Configuration) throws -> DatabasePool {
let coordinator = NSFileCoordinator(filePresenter: nil)
var coordinatorError: NSError?
var newPool: DatabasePool?
var dbError: Error?
coordinator.coordinate(writingItemAt: dbURL,
options: .forMerging,
error: &coordinatorError,
byAccessor: { url in
do {
newPool = try DatabasePool(path: url.path, configuration: poolConfiguration)
} catch {
dbError = error
}
})
if let error = dbError ?? coordinatorError {
throw error
}
guard let pool = newPool else {
throw OWSAssertionError("Missing pool.")
}
return pool
}
// The isCheckpointing flag is backed by a thread local.
// We don't want to affect the behavior of the busy-handler (aka busyMode callback)
// in other threads while checkpointing.
fileprivate static let isCheckpointingKey = "GRDBStorage.isCheckpointingKey"
fileprivate static var isCheckpointing: Bool {
get {
Thread.current.threadDictionary[Self.isCheckpointingKey] as? Bool == true
}
set {
Thread.current.threadDictionary[Self.isCheckpointingKey] = newValue
}
}
private static func buildConfiguration(keyspec: GRDBKeySpecSource) -> Configuration {
var configuration = Configuration()
configuration.readonly = false
configuration.foreignKeysEnabled = true // Default is already true
configuration.trace = { logString in
dbQueryLog(logString)
}
// Useful when your app opens multiple databases
configuration.label = "GRDB Storage"
configuration.maximumReaderCount = 10 // The default is 5
configuration.busyMode = .callback({ (retryCount: Int) -> Bool in
// sleep N milliseconds
let millis = 25
usleep(useconds_t(millis * 1000))
Logger.verbose("retryCount: \(retryCount)")
let accumulatedWaitMs = millis * (retryCount + 1)
if accumulatedWaitMs > 0, (accumulatedWaitMs % 250) == 0 {
Logger.warn("Database busy for \(accumulatedWaitMs)ms")
}
// Only time out during checkpoints, not writes.
if isCheckpointing {
if accumulatedWaitMs > GRDBStorage.maxBusyTimeoutMs {
Logger.warn("Aborting busy retry.")
return false
}
return true
} else {
return true
}
})
configuration.prepareDatabase = { db in
try GRDBDatabaseStorageAdapter.prepareDatabase(db: db, keyspec: keyspec)
}
configuration.defaultTransactionKind = .immediate
configuration.allowsUnsafeTransactions = true
return configuration
}
}
// MARK: -
public struct GRDBKeySpecSource {
private var kSQLCipherKeySpecLength: UInt {
GRDBDatabaseStorageAdapter.kSQLCipherKeySpecLength
}
let keyServiceName: String
let keyName: String
func fetchString() throws -> String {
// Use a raw key spec, where the 96 hexadecimal digits are provided
// (i.e. 64 hex for the 256 bit key, followed by 32 hex for the 128 bit salt)
// using explicit BLOB syntax, e.g.:
//
// x'98483C6EB40B6C31A448C22A66DED3B5E5E8D5119CAC8327B655C8B5C483648101010101010101010101010101010101'
let data = try fetchData()
guard data.count == kSQLCipherKeySpecLength else {
owsFail("unexpected keyspec length")
}
let passphrase = "x'\(data.hexadecimalString)'"
return passphrase
}
public func fetchData() throws -> Data {
return try CurrentAppContext().keychainStorage().data(forService: keyServiceName, key: keyName)
}
func clear() throws {
Logger.info("")
try CurrentAppContext().keychainStorage().remove(service: keyServiceName, key: keyName)
}
func generateAndStore() {
Logger.info("")
do {
let keyData = Randomness.generateRandomBytes(Int32(kSQLCipherKeySpecLength))
try store(data: keyData)
} catch {
owsFail("Could not generate key for GRDB: \(error)")
}
}
public func store(data: Data) throws {
guard data.count == kSQLCipherKeySpecLength else {
owsFail("unexpected keyspec length")
}
try CurrentAppContext().keychainStorage().set(data: data, service: keyServiceName, key: keyName)
}
}
// MARK: -
extension GRDBDatabaseStorageAdapter {
public var databaseFilePath: String {
return databaseUrl.path
}
public var databaseWALFilePath: String {
return databaseUrl.path + "-wal"
}
public var databaseSHMFilePath: String {
return databaseUrl.path + "-shm"
}
static func removeAllFiles(baseDir: URL) {
let databaseUrl = GRDBDatabaseStorageAdapter.databaseFileUrl(baseDir: baseDir)
OWSFileSystem.deleteFileIfExists(databaseUrl.path)
OWSFileSystem.deleteFileIfExists(databaseUrl.path + "-wal")
OWSFileSystem.deleteFileIfExists(databaseUrl.path + "-shm")
}
}
// MARK: - Reporting
extension GRDBDatabaseStorageAdapter {
var databaseFileSize: UInt64 {
guard let fileSize = OWSFileSystem.fileSize(ofPath: databaseFilePath) else {
owsFailDebug("Could not determine file size.")
return 0
}
return fileSize.uint64Value
}
var databaseWALFileSize: UInt64 {
guard let fileSize = OWSFileSystem.fileSize(ofPath: databaseWALFilePath) else {
owsFailDebug("Could not determine file size.")
return 0
}
return fileSize.uint64Value
}
var databaseSHMFileSize: UInt64 {
guard let fileSize = OWSFileSystem.fileSize(ofPath: databaseSHMFilePath) else {
owsFailDebug("Could not determine file size.")
return 0
}
return fileSize.uint64Value
}
}
// MARK: - Checkpoints
public struct GrdbTruncationResult {
let walSizePages: Int32
let pagesCheckpointed: Int32
}
extension GRDBDatabaseStorageAdapter {
@objc
public func syncTruncatingCheckpoint() throws {
Logger.info("Running truncating checkpoint.")
SDSDatabaseStorage.shared.logFileSizes()
let result = try GRDBDatabaseStorageAdapter.checkpoint(pool: pool,
mode: .truncate)
Logger.info("walSizePages: \(result.walSizePages), pagesCheckpointed: \(result.pagesCheckpointed)")
SDSDatabaseStorage.shared.logFileSizes()
}
public static func checkpoint(pool: DatabasePool,
mode: Database.CheckpointMode) throws -> GrdbTruncationResult {
var walSizePages: Int32 = 0
var pagesCheckpointed: Int32 = 0
try Bench(title: "Slow checkpoint: \(mode)", logIfLongerThan: 0.01, logInProduction: true) {
#if TESTABLE_BUILD
let startTime = CACurrentMediaTime()
#endif
try pool.writeWithoutTransaction { db in
#if TESTABLE_BUILD
let startElapsedSeconds: TimeInterval = CACurrentMediaTime() - startTime
let slowStartSeconds: TimeInterval = TimeInterval(GRDBStorage.maxBusyTimeoutMs) / 1000
if startElapsedSeconds > slowStartSeconds * 2 {
// maxBusyTimeoutMs isn't a hard limit, but slow starts should be very rare.
let formattedTime = String(format: "%0.2fms", startElapsedSeconds * 1000)
owsFailDebug("Slow checkpoint start: \(formattedTime)")
}
#endif
let code = sqlite3_wal_checkpoint_v2(db.sqliteConnection, nil, mode.rawValue, &walSizePages, &pagesCheckpointed)
switch code {
case SQLITE_OK:
if mode != .passive {
Logger.info("Checkpoint succeeded: \(mode).")
}
break
case SQLITE_BUSY:
// Busy is not an error.
Logger.info("Checkpoint \(mode) failed due to busy.")
break
default:
throw OWSAssertionError("checkpoint sql error with code: \(code)")
}
}
}
return GrdbTruncationResult(walSizePages: walSizePages, pagesCheckpointed: pagesCheckpointed)
}
}
// MARK: -
public extension Error {
var grdbErrorForLogging: Error {
// If not a GRDB error, return unmodified.
guard let grdbError = self as? GRDB.DatabaseError else {
return self
}
// DatabaseError.description includes the arguments.
Logger.verbose("grdbError: \(grdbError))")
// DatabaseError.description does not include the extendedResultCode.
Logger.verbose("resultCode: \(grdbError.resultCode), extendedResultCode: \(grdbError.extendedResultCode), message: \(String(describing: grdbError.message)), sql: \(String(describing: grdbError.sql))")
let error = GRDB.DatabaseError(resultCode: grdbError.extendedResultCode,
message: grdbError.message,
sql: nil,
arguments: nil)
return error
}
}
Reference in New Issue View Git Blame Copy Permalink