SQLTransaction.cpp [plain text]
#include "config.h"
#include "SQLTransaction.h"
#include "Database.h"
#include "DatabaseAuthorizer.h"
#include "DatabaseContext.h"
#include "DatabaseThread.h"
#include "DatabaseTracker.h"
#include "ExceptionCode.h"
#include "Logging.h"
#include "OriginLock.h"
#include "SQLError.h"
#include "SQLStatement.h"
#include "SQLStatementCallback.h"
#include "SQLStatementErrorCallback.h"
#include "SQLTransactionBackend.h"
#include "SQLTransactionCallback.h"
#include "SQLTransactionCoordinator.h"
#include "SQLTransactionErrorCallback.h"
#include "SQLiteTransaction.h"
#include "VoidCallback.h"
#include <wtf/StdLibExtras.h>
#include <wtf/Vector.h>
namespace WebCore {
Ref<SQLTransaction> SQLTransaction::create(Ref<Database>&& database, RefPtr<SQLTransactionCallback>&& callback, RefPtr<VoidCallback>&& successCallback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
{
return adoptRef(*new SQLTransaction(WTFMove(database), WTFMove(callback), WTFMove(successCallback), WTFMove(errorCallback), WTFMove(wrapper), readOnly));
}
SQLTransaction::SQLTransaction(Ref<Database>&& database, RefPtr<SQLTransactionCallback>&& callback, RefPtr<VoidCallback>&& successCallback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
: m_database(WTFMove(database))
, m_callbackWrapper(WTFMove(callback), &m_database->scriptExecutionContext())
, m_successCallbackWrapper(WTFMove(successCallback), &m_database->scriptExecutionContext())
, m_errorCallbackWrapper(WTFMove(errorCallback), &m_database->scriptExecutionContext())
, m_wrapper(WTFMove(wrapper))
, m_nextStep(&SQLTransaction::acquireLock)
, m_readOnly(readOnly)
, m_backend(*this)
{
}
SQLTransaction::~SQLTransaction()
{
}
ExceptionOr<void> SQLTransaction::executeSql(const String& sqlStatement, std::optional<Vector<SQLValue>>&& arguments, RefPtr<SQLStatementCallback>&& callback, RefPtr<SQLStatementErrorCallback>&& callbackError)
{
if (!m_executeSqlAllowed || !m_database->opened())
return Exception { INVALID_STATE_ERR };
int permissions = DatabaseAuthorizer::ReadWriteMask;
if (!m_database->databaseContext().allowDatabaseAccess())
permissions |= DatabaseAuthorizer::NoAccessMask;
else if (m_readOnly)
permissions |= DatabaseAuthorizer::ReadOnlyMask;
auto statement = std::make_unique<SQLStatement>(m_database, sqlStatement, arguments.value_or(Vector<SQLValue> { }), WTFMove(callback), WTFMove(callbackError), permissions);
if (m_database->deleted())
statement->setDatabaseDeletedError();
enqueueStatement(WTFMove(statement));
return { };
}
void SQLTransaction::lockAcquired()
{
m_lockAcquired = true;
m_backend.m_requestedState = SQLTransactionState::OpenTransactionAndPreflight;
m_database->scheduleTransactionStep(*this);
}
void SQLTransaction::performNextStep()
{
m_backend.computeNextStateAndCleanupIfNeeded();
m_backend.runStateMachine();
}
void SQLTransaction::performPendingCallback()
{
LOG(StorageAPI, "Callback %s\n", debugStepName(m_nextStep));
ASSERT(m_nextStep == &SQLTransaction::deliverTransactionCallback
|| m_nextStep == &SQLTransaction::deliverTransactionErrorCallback
|| m_nextStep == &SQLTransaction::deliverStatementCallback
|| m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback
|| m_nextStep == &SQLTransaction::deliverSuccessCallback);
checkAndHandleClosedDatabase();
if (m_nextStep)
(this->*m_nextStep)();
}
void SQLTransaction::notifyDatabaseThreadIsShuttingDown()
{
m_backend.notifyDatabaseThreadIsShuttingDown();
}
void SQLTransaction::enqueueStatement(std::unique_ptr<SQLStatement> statement)
{
LockHolder locker(m_statementMutex);
m_statementQueue.append(WTFMove(statement));
}
SQLTransaction::StateFunction SQLTransaction::stateFunctionFor(SQLTransactionState state)
{
static const StateFunction stateFunctions[] = {
&SQLTransaction::unreachableState, &SQLTransaction::unreachableState, &SQLTransaction::unreachableState, &SQLTransaction::unreachableState, &SQLTransaction::unreachableState, &SQLTransaction::unreachableState, &SQLTransaction::unreachableState, &SQLTransaction::unreachableState, &SQLTransaction::deliverTransactionCallback, &SQLTransaction::deliverTransactionErrorCallback, &SQLTransaction::deliverStatementCallback, &SQLTransaction::deliverQuotaIncreaseCallback, &SQLTransaction::deliverSuccessCallback };
ASSERT(WTF_ARRAY_LENGTH(stateFunctions) == static_cast<int>(SQLTransactionState::NumberOfStates));
ASSERT(state < SQLTransactionState::NumberOfStates);
return stateFunctions[static_cast<int>(state)];
}
void SQLTransaction::requestTransitToState(SQLTransactionState nextState)
{
LOG(StorageAPI, "Scheduling %s for transaction %p\n", nameForSQLTransactionState(nextState), this);
m_requestedState = nextState;
m_database->scheduleTransactionCallback(this);
}
void SQLTransaction::checkAndHandleClosedDatabase()
{
if (m_database->opened())
return;
LOG(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
LockHolder locker(m_statementMutex);
m_statementQueue.clear();
m_nextStep = nullptr;
m_callbackWrapper.clear();
m_successCallbackWrapper.clear();
m_errorCallbackWrapper.clear();
if (currentThread() != m_database->databaseThread().getThreadID())
return;
if (m_sqliteTransaction) {
m_sqliteTransaction->stop();
m_sqliteTransaction = nullptr;
}
if (m_lockAcquired)
m_database->transactionCoordinator()->releaseLock(*this);
}
void SQLTransaction::scheduleCallback(void (SQLTransaction::*step)())
{
m_nextStep = step;
LOG(StorageAPI, "Scheduling %s for transaction %p\n", debugStepName(step), this);
m_database->scheduleTransactionCallback(this);
}
void SQLTransaction::acquireLock()
{
m_database->transactionCoordinator()->acquireLock(*this);
}
void SQLTransaction::openTransactionAndPreflight()
{
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
ASSERT(m_lockAcquired);
LOG(StorageAPI, "Opening and preflighting transaction %p", this);
if (m_database->deleted()) {
m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unable to open a transaction, because the user deleted the database");
handleTransactionError();
return;
}
if (!m_readOnly) {
acquireOriginLock();
m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
}
ASSERT(!m_sqliteTransaction);
m_sqliteTransaction = std::make_unique<SQLiteTransaction>(m_database->sqliteDatabase(), m_readOnly);
m_database->resetDeletes();
m_database->disableAuthorizer();
m_sqliteTransaction->begin();
m_database->enableAuthorizer();
if (!m_sqliteTransaction->inProgress()) {
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to begin transaction", m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
m_sqliteTransaction = nullptr;
handleTransactionError();
return;
}
String actualVersion;
if (!m_database->getActualVersionForTransaction(actualVersion)) {
m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to read version", m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
m_database->disableAuthorizer();
m_sqliteTransaction = nullptr;
m_database->enableAuthorizer();
handleTransactionError();
return;
}
m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
if (m_wrapper && !m_wrapper->performPreflight(*this)) {
m_database->disableAuthorizer();
m_sqliteTransaction = nullptr;
m_database->enableAuthorizer();
m_transactionError = m_wrapper->sqlError();
if (!m_transactionError)
m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction preflight");
handleTransactionError();
return;
}
if (m_callbackWrapper.hasCallback()) {
scheduleCallback(&SQLTransaction::deliverTransactionCallback);
return;
}
runStatements();
}
void SQLTransaction::runStatements()
{
ASSERT(m_lockAcquired);
do {
if (m_shouldRetryCurrentStatement && !m_sqliteTransaction->wasRolledBackBySqlite()) {
m_shouldRetryCurrentStatement = false;
m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
} else {
if (m_currentStatement && m_currentStatement->lastExecutionFailedDueToQuota()) {
handleCurrentStatementError();
break;
}
getNextStatement();
}
} while (runCurrentStatement());
if (!m_currentStatement)
postflightAndCommit();
}
void SQLTransaction::cleanupAndTerminate()
{
ASSERT(m_lockAcquired);
LOG(StorageAPI, "Transaction %p is complete\n", this);
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
m_backend.doCleanup();
m_database->inProgressTransactionCompleted();
}
void SQLTransaction::cleanupAfterTransactionErrorCallback()
{
ASSERT(m_lockAcquired);
LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
m_database->disableAuthorizer();
if (m_sqliteTransaction) {
m_sqliteTransaction->rollback();
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
m_sqliteTransaction = nullptr;
}
m_database->enableAuthorizer();
releaseOriginLockIfNeeded();
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
cleanupAndTerminate();
}
void SQLTransaction::deliverTransactionCallback()
{
bool shouldDeliverErrorCallback = false;
RefPtr<SQLTransactionCallback> callback = m_callbackWrapper.unwrap();
if (callback) {
m_executeSqlAllowed = true;
auto result = callback->handleEvent(*this);
shouldDeliverErrorCallback = result.type() == CallbackResultType::ExceptionThrown;
m_executeSqlAllowed = false;
}
if (shouldDeliverErrorCallback) {
m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the SQLTransactionCallback was null or threw an exception");
return deliverTransactionErrorCallback();
}
m_backend.requestTransitToState(SQLTransactionState::RunStatements);
}
void SQLTransaction::deliverTransactionErrorCallback()
{
ASSERT(m_transactionError);
RefPtr<SQLTransactionErrorCallback> errorCallback = m_errorCallbackWrapper.unwrap();
if (errorCallback)
errorCallback->handleEvent(*m_transactionError);
clearCallbackWrappers();
m_backend.requestTransitToState(SQLTransactionState::CleanupAfterTransactionErrorCallback);
}
void SQLTransaction::deliverStatementCallback()
{
ASSERT(m_currentStatement);
m_executeSqlAllowed = true;
bool result = m_currentStatement->performCallback(*this);
m_executeSqlAllowed = false;
if (result) {
m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the statement callback raised an exception or statement error callback did not return false");
if (m_errorCallbackWrapper.hasCallback())
return deliverTransactionErrorCallback();
m_backend.requestTransitToState(SQLTransactionState::CleanupAfterTransactionErrorCallback);
return;
}
m_backend.requestTransitToState(SQLTransactionState::RunStatements);
}
void SQLTransaction::deliverQuotaIncreaseCallback()
{
ASSERT(m_currentStatement);
ASSERT(!m_shouldRetryCurrentStatement);
m_shouldRetryCurrentStatement = m_database->didExceedQuota();
m_backend.requestTransitToState(SQLTransactionState::RunStatements);
}
void SQLTransaction::deliverSuccessCallback()
{
RefPtr<VoidCallback> successCallback = m_successCallbackWrapper.unwrap();
if (successCallback)
successCallback->handleEvent();
clearCallbackWrappers();
m_backend.requestTransitToState(SQLTransactionState::CleanupAndTerminate);
}
void SQLTransaction::unreachableState()
{
ASSERT_NOT_REACHED();
}
void SQLTransaction::computeNextStateAndCleanupIfNeeded()
{
if (m_database->opened()) {
setStateToRequestedState();
ASSERT(m_nextState == SQLTransactionState::End
|| m_nextState == SQLTransactionState::DeliverTransactionCallback
|| m_nextState == SQLTransactionState::DeliverTransactionErrorCallback
|| m_nextState == SQLTransactionState::DeliverStatementCallback
|| m_nextState == SQLTransactionState::DeliverQuotaIncreaseCallback
|| m_nextState == SQLTransactionState::DeliverSuccessCallback);
LOG(StorageAPI, "Callback %s\n", nameForSQLTransactionState(m_nextState));
return;
}
clearCallbackWrappers();
m_backend.requestTransitToState(SQLTransactionState::CleanupAndTerminate);
}
void SQLTransaction::clearCallbackWrappers()
{
m_callbackWrapper.clear();
m_successCallbackWrapper.clear();
m_errorCallbackWrapper.clear();
}
void SQLTransaction::getNextStatement()
{
m_currentStatement = nullptr;
LockHolder locker(m_statementMutex);
if (!m_statementQueue.isEmpty())
m_currentStatement = m_statementQueue.takeFirst();
}
bool SQLTransaction::runCurrentStatement()
{
if (!m_currentStatement) {
return false;
}
m_database->resetAuthorizer();
if (m_hasVersionMismatch)
m_currentStatement->setVersionMismatchedError();
if (m_currentStatement->execute(m_database)) {
if (m_database->lastActionChangedDatabase()) {
m_modifiedDatabase = true;
}
if (m_currentStatement->hasStatementCallback()) {
scheduleCallback(&SQLTransaction::deliverStatementCallback);
return false;
}
return true;
}
if (m_currentStatement->lastExecutionFailedDueToQuota()) {
scheduleCallback(&SQLTransaction::deliverQuotaIncreaseCallback);
return false;
}
handleCurrentStatementError();
return false;
}
void SQLTransaction::handleCurrentStatementError()
{
if (m_currentStatement->hasStatementErrorCallback() && !m_sqliteTransaction->wasRolledBackBySqlite()) {
scheduleCallback(&SQLTransaction::deliverStatementCallback);
return;
}
m_transactionError = m_currentStatement->sqlError();
if (!m_transactionError)
m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "the statement failed to execute");
handleTransactionError();
}
void SQLTransaction::handleTransactionError()
{
ASSERT(m_transactionError);
if (m_errorCallbackWrapper.hasCallback()) {
scheduleCallback(&SQLTransaction::deliverTransactionErrorCallback);
return;
}
m_backend.cleanupAfterTransactionErrorCallback();
}
void SQLTransaction::postflightAndCommit()
{
ASSERT(m_lockAcquired);
if (m_wrapper && !m_wrapper->performPostflight(*this)) {
m_transactionError = m_wrapper->sqlError();
if (!m_transactionError)
m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction postflight");
handleTransactionError();
return;
}
ASSERT(m_sqliteTransaction);
m_database->disableAuthorizer();
m_sqliteTransaction->commit();
m_database->enableAuthorizer();
releaseOriginLockIfNeeded();
if (m_sqliteTransaction->inProgress()) {
if (m_wrapper)
m_wrapper->handleCommitFailedAfterPostflight(*this);
m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to commit transaction", m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
handleTransactionError();
return;
}
if (m_database->hadDeletes())
m_database->incrementalVacuumIfNeeded();
if (m_modifiedDatabase)
m_database->didCommitWriteTransaction();
scheduleCallback(&SQLTransaction::deliverSuccessCallback);
}
void SQLTransaction::acquireOriginLock()
{
ASSERT(!m_originLock);
m_originLock = DatabaseTracker::singleton().originLockFor(m_database->securityOrigin());
m_originLock->lock();
}
void SQLTransaction::releaseOriginLockIfNeeded()
{
if (m_originLock) {
m_originLock->unlock();
m_originLock = nullptr;
}
}
#if !LOG_DISABLED
const char* SQLTransaction::debugStepName(void (SQLTransaction::*step)())
{
if (step == &SQLTransaction::acquireLock)
return "acquireLock";
if (step == &SQLTransaction::openTransactionAndPreflight)
return "openTransactionAndPreflight";
if (step == &SQLTransaction::runStatements)
return "runStatements";
if (step == &SQLTransaction::postflightAndCommit)
return "postflightAndCommit";
if (step == &SQLTransaction::cleanupAfterTransactionErrorCallback)
return "cleanupAfterTransactionErrorCallback";
if (step == &SQLTransaction::deliverTransactionCallback)
return "deliverTransactionCallback";
if (step == &SQLTransaction::deliverTransactionErrorCallback)
return "deliverTransactionErrorCallback";
if (step == &SQLTransaction::deliverStatementCallback)
return "deliverStatementCallback";
if (step == &SQLTransaction::deliverQuotaIncreaseCallback)
return "deliverQuotaIncreaseCallback";
if (step == &SQLTransaction::deliverSuccessCallback)
return "deliverSuccessCallback";
ASSERT_NOT_REACHED();
return "UNKNOWN";
}
#endif
}