Making sure that all in-progress transactions are rolled back on
[WebKit-https.git] / WebCore / storage / SQLTransaction.cpp
1 /*
2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "SQLTransaction.h"
31
32 #if ENABLE(DATABASE)
33
34 #include "ChromeClient.h"
35 #include "Database.h"
36 #include "DatabaseAuthorizer.h"
37 #include "DatabaseDetails.h"
38 #include "DatabaseThread.h"
39 #include "ExceptionCode.h"
40 #include "Logging.h"
41 #include "Page.h"
42 #include "PlatformString.h"
43 #include "ScriptExecutionContext.h"
44 #include "Settings.h"
45 #include "SQLError.h"
46 #include "SQLiteTransaction.h"
47 #include "SQLResultSet.h"
48 #include "SQLStatement.h"
49 #include "SQLStatementCallback.h"
50 #include "SQLStatementErrorCallback.h"
51 #include "SQLTransactionClient.h"
52 #include "SQLTransactionCoordinator.h"
53 #include "SQLValue.h"
54
55 // There's no way of knowing exactly how much more space will be required when a statement hits the quota limit.
56 // For now, we'll arbitrarily choose currentQuota + 1mb.
57 // In the future we decide to track if a size increase wasn't enough, and ask for larger-and-larger increases until its enough.
58 static const int DefaultQuotaSizeIncrease = 1048576;
59
60 namespace WebCore {
61
62 PassRefPtr<SQLTransaction> SQLTransaction::create(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
63                                                   PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
64 {
65     return adoptRef(new SQLTransaction(db, callback, errorCallback, successCallback, wrapper, readOnly));
66 }
67
68 SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
69                                PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
70     : m_nextStep(&SQLTransaction::acquireLock)
71     , m_executeSqlAllowed(false)
72     , m_database(db)
73     , m_wrapper(wrapper)
74     , m_callback(callback)
75     , m_successCallback(successCallback)
76     , m_errorCallback(errorCallback)
77     , m_shouldRetryCurrentStatement(false)
78     , m_modifiedDatabase(false)
79     , m_lockAcquired(false)
80     , m_readOnly(readOnly)
81 {
82     ASSERT(m_database);
83 }
84
85 SQLTransaction::~SQLTransaction()
86 {
87     ASSERT(!m_sqliteTransaction);
88 }
89
90 void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
91 {
92     if (!m_executeSqlAllowed || m_database->stopped()) {
93         e = INVALID_STATE_ERR;
94         return;
95     }
96
97     bool readOnlyMode = m_readOnly;
98     if (!readOnlyMode) {
99         if (m_database->scriptExecutionContext()->isDatabaseReadOnly())
100             readOnlyMode = true;
101     }
102
103     RefPtr<SQLStatement> statement = SQLStatement::create(sqlStatement, arguments, callback, callbackError, readOnlyMode);
104
105     if (m_database->deleted())
106         statement->setDatabaseDeletedError();
107
108     if (!m_database->versionMatchesExpected())
109         statement->setVersionMismatchedError();
110
111     enqueueStatement(statement);
112 }
113
114 void SQLTransaction::enqueueStatement(PassRefPtr<SQLStatement> statement)
115 {
116     MutexLocker locker(m_statementMutex);
117     m_statementQueue.append(statement);
118 }
119
120 #ifndef NDEBUG
121 const char* SQLTransaction::debugStepName(SQLTransaction::TransactionStepMethod step)
122 {
123     if (step == &SQLTransaction::acquireLock)
124         return "acquireLock";
125     else if (step == &SQLTransaction::openTransactionAndPreflight)
126         return "openTransactionAndPreflight";
127     else if (step == &SQLTransaction::runStatements)
128         return "runStatements";
129     else if (step == &SQLTransaction::postflightAndCommit)
130         return "postflightAndCommit";
131     else if (step == &SQLTransaction::cleanupAfterTransactionErrorCallback)
132         return "cleanupAfterTransactionErrorCallback";
133     else if (step == &SQLTransaction::deliverTransactionCallback)
134         return "deliverTransactionCallback";
135     else if (step == &SQLTransaction::deliverTransactionErrorCallback)
136         return "deliverTransactionErrorCallback";
137     else if (step == &SQLTransaction::deliverStatementCallback)
138         return "deliverStatementCallback";
139     else if (step == &SQLTransaction::deliverQuotaIncreaseCallback)
140         return "deliverQuotaIncreaseCallback";
141     else if (step == &SQLTransaction::deliverSuccessCallback)
142         return "deliverSuccessCallback";
143     else if (step == &SQLTransaction::cleanupAfterSuccessCallback)
144         return "cleanupAfterSuccessCallback";
145     else
146         return "UNKNOWN";
147 }
148 #endif
149
150 void SQLTransaction::checkAndHandleClosedDatabase()
151 {
152     if (!m_database->stopped())
153         return;
154
155     // If the database was stopped, don't do anything and cancel queued work
156     LOG(StorageAPI, "Database was stopped - cancelling work for this transaction");
157     MutexLocker locker(m_statementMutex);
158     m_statementQueue.clear();
159     m_nextStep = 0;
160
161     // The current SQLite transaction should be stopped, as well
162     if (m_sqliteTransaction) {
163         m_sqliteTransaction->stop();
164         m_sqliteTransaction.clear();
165     }
166
167     if (m_lockAcquired)
168         m_database->transactionCoordinator()->releaseLock(this);
169 }
170
171
172 bool SQLTransaction::performNextStep()
173 {
174     LOG(StorageAPI, "Step %s\n", debugStepName(m_nextStep));
175
176     ASSERT(m_nextStep == &SQLTransaction::acquireLock ||
177            m_nextStep == &SQLTransaction::openTransactionAndPreflight ||
178            m_nextStep == &SQLTransaction::runStatements ||
179            m_nextStep == &SQLTransaction::postflightAndCommit ||
180            m_nextStep == &SQLTransaction::cleanupAfterSuccessCallback ||
181            m_nextStep == &SQLTransaction::cleanupAfterTransactionErrorCallback);
182
183     checkAndHandleClosedDatabase();
184
185     if (m_nextStep)
186         (this->*m_nextStep)();
187
188     // If there is no nextStep after performing the above step, the transaction is complete
189     return !m_nextStep;
190 }
191
192 void SQLTransaction::performPendingCallback()
193 {
194     LOG(StorageAPI, "Callback %s\n", debugStepName(m_nextStep));
195
196     ASSERT(m_nextStep == &SQLTransaction::deliverTransactionCallback ||
197            m_nextStep == &SQLTransaction::deliverTransactionErrorCallback ||
198            m_nextStep == &SQLTransaction::deliverStatementCallback ||
199            m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback ||
200            m_nextStep == &SQLTransaction::deliverSuccessCallback);
201
202     checkAndHandleClosedDatabase();
203
204     if (m_nextStep)
205         (this->*m_nextStep)();
206 }
207
208 void SQLTransaction::notifyDatabaseThreadIsShuttingDown()
209 {
210     ASSERT(currentThread() == database()->scriptExecutionContext()->databaseThread()->getThreadID());
211
212     // If the transaction is in progress, we should roll it back here, since this is our last
213     // oportunity to do something related to this transaction on the DB thread.
214     // Clearing m_sqliteTransaction invokes SQLiteTransaction's destructor which does just that.
215     m_sqliteTransaction.clear();
216 }
217
218 void SQLTransaction::acquireLock()
219 {
220     m_database->transactionCoordinator()->acquireLock(this);
221 }
222
223 void SQLTransaction::lockAcquired()
224 {
225     m_lockAcquired = true;
226     m_nextStep = &SQLTransaction::openTransactionAndPreflight;
227     LOG(StorageAPI, "Scheduling openTransactionAndPreflight immediately for transaction %p\n", this);
228     m_database->scheduleTransactionStep(this, true);
229 }
230
231 void SQLTransaction::openTransactionAndPreflight()
232 {
233     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
234     ASSERT(m_lockAcquired);
235
236     LOG(StorageAPI, "Opening and preflighting transaction %p", this);
237
238     // If the database was deleted, jump to the error callback
239     if (m_database->deleted()) {
240         m_transactionError = SQLError::create(0, "unable to open a transaction, because the user deleted the database");
241         handleTransactionError(false);
242         return;
243     }
244
245     // Set the maximum usage for this transaction if this transactions is not read-only
246     if (!m_readOnly)
247         m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
248
249     ASSERT(!m_sqliteTransaction);
250     m_sqliteTransaction.set(new SQLiteTransaction(m_database->m_sqliteDatabase, m_readOnly));
251
252     m_database->m_databaseAuthorizer->disable();
253     m_sqliteTransaction->begin();
254     m_database->m_databaseAuthorizer->enable();
255
256     // Transaction Steps 1+2 - Open a transaction to the database, jumping to the error callback if that fails
257     if (!m_sqliteTransaction->inProgress()) {
258         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
259         m_sqliteTransaction.clear();
260         m_transactionError = SQLError::create(0, "unable to open a transaction to the database");
261         handleTransactionError(false);
262         return;
263     }
264
265     // Transaction Steps 3 - Peform preflight steps, jumping to the error callback if they fail
266     if (m_wrapper && !m_wrapper->performPreflight(this)) {
267         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
268         m_sqliteTransaction.clear();
269         m_transactionError = m_wrapper->sqlError();
270         if (!m_transactionError)
271             m_transactionError = SQLError::create(0, "unknown error occured setting up transaction");
272
273         handleTransactionError(false);
274         return;
275     }
276
277     // Transaction Step 4 - Invoke the transaction callback with the new SQLTransaction object
278     m_nextStep = &SQLTransaction::deliverTransactionCallback;
279     LOG(StorageAPI, "Scheduling deliverTransactionCallback for transaction %p\n", this);
280     m_database->scheduleTransactionCallback(this);
281 }
282
283 void SQLTransaction::deliverTransactionCallback()
284 {
285     bool shouldDeliverErrorCallback = false;
286
287     if (m_callback) {
288         m_executeSqlAllowed = true;
289         m_callback->handleEvent(this, shouldDeliverErrorCallback);
290         m_executeSqlAllowed = false;
291     } else
292         shouldDeliverErrorCallback = true;
293
294     // Transaction Step 5 - If the transaction callback was null or raised an exception, jump to the error callback
295     if (shouldDeliverErrorCallback) {
296         m_transactionError = SQLError::create(0, "the SQLTransactionCallback was null or threw an exception");
297         deliverTransactionErrorCallback();
298     } else
299         scheduleToRunStatements();
300 }
301
302 void SQLTransaction::scheduleToRunStatements()
303 {
304     m_nextStep = &SQLTransaction::runStatements;
305     LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
306     m_database->scheduleTransactionStep(this);
307 }
308
309 void SQLTransaction::runStatements()
310 {
311     ASSERT(m_lockAcquired);
312
313     // If there is a series of statements queued up that are all successful and have no associated
314     // SQLStatementCallback objects, then we can burn through the queue
315     do {
316         if (m_shouldRetryCurrentStatement) {
317             m_shouldRetryCurrentStatement = false;
318             // FIXME - Another place that needs fixing up after <rdar://problem/5628468> is addressed.
319             // See ::openTransactionAndPreflight() for discussion
320
321             // Reset the maximum size here, as it was increased to allow us to retry this statement.
322             // m_shouldRetryCurrentStatement is set to true only when a statement exceeds
323             // the quota, which can happen only in a read-write transaction. Therefore, there
324             // is no need to check here if the transaction is read-write.
325             m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
326         } else {
327             // If the current statement has already been run, failed due to quota constraints, and we're not retrying it,
328             // that means it ended in an error.  Handle it now
329             if (m_currentStatement && m_currentStatement->lastExecutionFailedDueToQuota()) {
330                 handleCurrentStatementError();
331                 break;
332             }
333
334             // Otherwise, advance to the next statement
335             getNextStatement();
336         }
337     } while (runCurrentStatement());
338
339     // If runCurrentStatement() returned false, that means either there was no current statement to run,
340     // or the current statement requires a callback to complete.  In the later case, it also scheduled
341     // the callback or performed any other additional work so we can return
342     if (!m_currentStatement)
343         postflightAndCommit();
344 }
345
346 void SQLTransaction::getNextStatement()
347 {
348     m_currentStatement = 0;
349
350     MutexLocker locker(m_statementMutex);
351     if (!m_statementQueue.isEmpty()) {
352         m_currentStatement = m_statementQueue.first();
353         m_statementQueue.removeFirst();
354     }
355 }
356
357 bool SQLTransaction::runCurrentStatement()
358 {
359     if (!m_currentStatement)
360         return false;
361
362     m_database->m_databaseAuthorizer->reset();
363
364     if (m_currentStatement->execute(m_database.get())) {
365         if (m_database->m_databaseAuthorizer->lastActionChangedDatabase()) {
366             // Flag this transaction as having changed the database for later delegate notification
367             m_modifiedDatabase = true;
368             // Also dirty the size of this database file for calculating quota usage
369             m_database->transactionClient()->didExecuteStatement(this);
370         }
371
372         if (m_currentStatement->hasStatementCallback()) {
373             m_nextStep = &SQLTransaction::deliverStatementCallback;
374             LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
375             m_database->scheduleTransactionCallback(this);
376             return false;
377         }
378         return true;
379     }
380
381     if (m_currentStatement->lastExecutionFailedDueToQuota()) {
382         m_nextStep = &SQLTransaction::deliverQuotaIncreaseCallback;
383         LOG(StorageAPI, "Scheduling deliverQuotaIncreaseCallback for transaction %p\n", this);
384         m_database->scheduleTransactionCallback(this);
385         return false;
386     }
387
388     handleCurrentStatementError();
389
390     return false;
391 }
392
393 void SQLTransaction::handleCurrentStatementError()
394 {
395     // Transaction Steps 6.error - Call the statement's error callback, but if there was no error callback,
396     // jump to the transaction error callback
397     if (m_currentStatement->hasStatementErrorCallback()) {
398         m_nextStep = &SQLTransaction::deliverStatementCallback;
399         LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
400         m_database->scheduleTransactionCallback(this);
401     } else {
402         m_transactionError = m_currentStatement->sqlError();
403         if (!m_transactionError)
404             m_transactionError = SQLError::create(1, "the statement failed to execute");
405         handleTransactionError(false);
406     }
407 }
408
409 void SQLTransaction::deliverStatementCallback()
410 {
411     ASSERT(m_currentStatement);
412
413     // Transaction Step 6.6 and 6.3(error) - If the statement callback went wrong, jump to the transaction error callback
414     // Otherwise, continue to loop through the statement queue
415     m_executeSqlAllowed = true;
416     bool result = m_currentStatement->performCallback(this);
417     m_executeSqlAllowed = false;
418
419     if (result) {
420         m_transactionError = SQLError::create(0, "the statement callback raised an exception or statement error callback did not return false");
421         handleTransactionError(true);
422     } else
423         scheduleToRunStatements();
424 }
425
426 void SQLTransaction::deliverQuotaIncreaseCallback()
427 {
428     ASSERT(m_currentStatement);
429     ASSERT(!m_shouldRetryCurrentStatement);
430
431     m_shouldRetryCurrentStatement = m_database->transactionClient()->didExceedQuota(this);
432
433     m_nextStep = &SQLTransaction::runStatements;
434     LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
435     m_database->scheduleTransactionStep(this);
436 }
437
438 void SQLTransaction::postflightAndCommit()
439 {
440     ASSERT(m_lockAcquired);
441
442     // Transaction Step 7 - Peform postflight steps, jumping to the error callback if they fail
443     if (m_wrapper && !m_wrapper->performPostflight(this)) {
444         m_transactionError = m_wrapper->sqlError();
445         if (!m_transactionError)
446             m_transactionError = SQLError::create(0, "unknown error occured setting up transaction");
447         handleTransactionError(false);
448         return;
449     }
450
451     // Transacton Step 8+9 - Commit the transaction, jumping to the error callback if that fails
452     ASSERT(m_sqliteTransaction);
453
454     m_database->m_databaseAuthorizer->disable();
455     m_sqliteTransaction->commit();
456     m_database->m_databaseAuthorizer->enable();
457
458     // If the commit failed, the transaction will still be marked as "in progress"
459     if (m_sqliteTransaction->inProgress()) {
460         m_transactionError = SQLError::create(0, "failed to commit the transaction");
461         handleTransactionError(false);
462         return;
463     }
464
465     // The commit was successful, notify the delegates if the transaction modified this database
466     if (m_modifiedDatabase)
467         m_database->transactionClient()->didCommitTransaction(this);
468
469     // Now release our unneeded callbacks, to break reference cycles.
470     m_callback = 0;
471     m_errorCallback = 0;
472
473     // Transaction Step 10 - Deliver success callback, if there is one
474     if (m_successCallback) {
475         m_nextStep = &SQLTransaction::deliverSuccessCallback;
476         LOG(StorageAPI, "Scheduling deliverSuccessCallback for transaction %p\n", this);
477         m_database->scheduleTransactionCallback(this);
478     } else
479         cleanupAfterSuccessCallback();
480 }
481
482 void SQLTransaction::deliverSuccessCallback()
483 {
484     // Transaction Step 10 - Deliver success callback
485     ASSERT(m_successCallback);
486     m_successCallback->handleEvent();
487
488     // Release the last callback to break reference cycle
489     m_successCallback = 0;
490
491     // Schedule a "post-success callback" step to return control to the database thread in case there
492     // are further transactions queued up for this Database
493     m_nextStep = &SQLTransaction::cleanupAfterSuccessCallback;
494     LOG(StorageAPI, "Scheduling cleanupAfterSuccessCallback for transaction %p\n", this);
495     m_database->scheduleTransactionStep(this);
496 }
497
498 void SQLTransaction::cleanupAfterSuccessCallback()
499 {
500     ASSERT(m_lockAcquired);
501
502     // Transaction Step 11 - End transaction steps
503     // There is no next step
504     LOG(StorageAPI, "Transaction %p is complete\n", this);
505     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
506     m_sqliteTransaction.clear();
507     m_nextStep = 0;
508
509     // Release the lock on this database
510     m_database->transactionCoordinator()->releaseLock(this);
511 }
512
513 void SQLTransaction::handleTransactionError(bool inCallback)
514 {
515     if (m_errorCallback) {
516         if (inCallback)
517             deliverTransactionErrorCallback();
518         else {
519             m_nextStep = &SQLTransaction::deliverTransactionErrorCallback;
520             LOG(StorageAPI, "Scheduling deliverTransactionErrorCallback for transaction %p\n", this);
521             m_database->scheduleTransactionCallback(this);
522         }
523         return;
524     }
525
526     // No error callback, so fast-forward to:
527     // Transaction Step 12 - Rollback the transaction.
528     if (inCallback) {
529         m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
530         LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
531         m_database->scheduleTransactionStep(this);
532     } else {
533         cleanupAfterTransactionErrorCallback();
534     }
535 }
536
537 void SQLTransaction::deliverTransactionErrorCallback()
538 {
539     ASSERT(m_transactionError);
540
541     // Transaction Step 12 - If exists, invoke error callback with the last
542     // error to have occurred in this transaction.
543     if (m_errorCallback)
544         m_errorCallback->handleEvent(m_transactionError.get());
545
546     m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
547     LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
548     m_database->scheduleTransactionStep(this);
549 }
550
551 void SQLTransaction::cleanupAfterTransactionErrorCallback()
552 {
553     ASSERT(m_lockAcquired);
554
555     m_database->m_databaseAuthorizer->disable();
556     if (m_sqliteTransaction) {
557         // Transaction Step 12 - Rollback the transaction.
558         m_sqliteTransaction->rollback();
559
560         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
561         m_sqliteTransaction.clear();
562     }
563     m_database->m_databaseAuthorizer->enable();
564
565     // Transaction Step 12 - Any still-pending statements in the transaction are discarded.
566     {
567         MutexLocker locker(m_statementMutex);
568         m_statementQueue.clear();
569     }
570
571     // Transaction is complete!  There is no next step
572     LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
573     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
574     m_nextStep = 0;
575
576     // Now release our callbacks, to break reference cycles.
577     m_callback = 0;
578     m_errorCallback = 0;
579
580     // Now release the lock on this database
581     m_database->transactionCoordinator()->releaseLock(this);
582 }
583
584 } // namespace WebCore
585
586 #endif // ENABLE(DATABASE)