220993bcc5
This is a no-op for most databases. Only necessary on PostgreSQL so that we can do things which will possibly intentionally raise an IntegrityError and not have to rollback the entire transaction. Not supported for PostgreSQL versions prior to 8.0, so should be used sparingly in internal Django code. git-svn-id: http://code.djangoproject.com/svn/django/trunk@8314 bcc190cf-cafb-0310-a4f2-bffc1f526a37
261 lines
8.3 KiB
Python
261 lines
8.3 KiB
Python
"""
|
|
This module implements a transaction manager that can be used to define
|
|
transaction handling in a request or view function. It is used by transaction
|
|
control middleware and decorators.
|
|
|
|
The transaction manager can be in managed or in auto state. Auto state means the
|
|
system is using a commit-on-save strategy (actually it's more like
|
|
commit-on-change). As soon as the .save() or .delete() (or related) methods are
|
|
called, a commit is made.
|
|
|
|
Managed transactions don't do those commits, but will need some kind of manual
|
|
or implicit commits or rollbacks.
|
|
"""
|
|
|
|
try:
|
|
import thread
|
|
except ImportError:
|
|
import dummy_thread as thread
|
|
try:
|
|
from functools import wraps
|
|
except ImportError:
|
|
from django.utils.functional import wraps # Python 2.3, 2.4 fallback.
|
|
from django.db import connection
|
|
from django.conf import settings
|
|
|
|
class TransactionManagementError(Exception):
|
|
"""
|
|
This exception is thrown when something bad happens with transaction
|
|
management.
|
|
"""
|
|
pass
|
|
|
|
# The states are dictionaries of lists. The key to the dict is the current
|
|
# thread and the list is handled as a stack of values.
|
|
state = {}
|
|
savepoint_state = {}
|
|
|
|
# The dirty flag is set by *_unless_managed functions to denote that the
|
|
# code under transaction management has changed things to require a
|
|
# database commit.
|
|
dirty = {}
|
|
|
|
def enter_transaction_management():
|
|
"""
|
|
Enters transaction management for a running thread. It must be balanced with
|
|
the appropriate leave_transaction_management call, since the actual state is
|
|
managed as a stack.
|
|
|
|
The state and dirty flag are carried over from the surrounding block or
|
|
from the settings, if there is no surrounding block (dirty is always false
|
|
when no current block is running).
|
|
"""
|
|
thread_ident = thread.get_ident()
|
|
if thread_ident in state and state[thread_ident]:
|
|
state[thread_ident].append(state[thread_ident][-1])
|
|
else:
|
|
state[thread_ident] = []
|
|
state[thread_ident].append(settings.TRANSACTIONS_MANAGED)
|
|
if thread_ident not in dirty:
|
|
dirty[thread_ident] = False
|
|
|
|
def leave_transaction_management():
|
|
"""
|
|
Leaves transaction management for a running thread. A dirty flag is carried
|
|
over to the surrounding block, as a commit will commit all changes, even
|
|
those from outside. (Commits are on connection level.)
|
|
"""
|
|
thread_ident = thread.get_ident()
|
|
if thread_ident in state and state[thread_ident]:
|
|
del state[thread_ident][-1]
|
|
else:
|
|
raise TransactionManagementError("This code isn't under transaction management")
|
|
if dirty.get(thread_ident, False):
|
|
rollback()
|
|
raise TransactionManagementError("Transaction managed block ended with pending COMMIT/ROLLBACK")
|
|
dirty[thread_ident] = False
|
|
|
|
def is_dirty():
|
|
"""
|
|
Returns True if the current transaction requires a commit for changes to
|
|
happen.
|
|
"""
|
|
return dirty.get(thread.get_ident(), False)
|
|
|
|
def set_dirty():
|
|
"""
|
|
Sets a dirty flag for the current thread and code streak. This can be used
|
|
to decide in a managed block of code to decide whether there are open
|
|
changes waiting for commit.
|
|
"""
|
|
thread_ident = thread.get_ident()
|
|
if thread_ident in dirty:
|
|
dirty[thread_ident] = True
|
|
else:
|
|
raise TransactionManagementError("This code isn't under transaction management")
|
|
|
|
def set_clean():
|
|
"""
|
|
Resets a dirty flag for the current thread and code streak. This can be used
|
|
to decide in a managed block of code to decide whether a commit or rollback
|
|
should happen.
|
|
"""
|
|
thread_ident = thread.get_ident()
|
|
if thread_ident in dirty:
|
|
dirty[thread_ident] = False
|
|
else:
|
|
raise TransactionManagementError("This code isn't under transaction management")
|
|
|
|
def is_managed():
|
|
"""
|
|
Checks whether the transaction manager is in manual or in auto state.
|
|
"""
|
|
thread_ident = thread.get_ident()
|
|
if thread_ident in state:
|
|
if state[thread_ident]:
|
|
return state[thread_ident][-1]
|
|
return settings.TRANSACTIONS_MANAGED
|
|
|
|
def managed(flag=True):
|
|
"""
|
|
Puts the transaction manager into a manual state: managed transactions have
|
|
to be committed explicitly by the user. If you switch off transaction
|
|
management and there is a pending commit/rollback, the data will be
|
|
commited.
|
|
"""
|
|
thread_ident = thread.get_ident()
|
|
top = state.get(thread_ident, None)
|
|
if top:
|
|
top[-1] = flag
|
|
if not flag and is_dirty():
|
|
connection._commit()
|
|
set_clean()
|
|
else:
|
|
raise TransactionManagementError("This code isn't under transaction management")
|
|
|
|
def commit_unless_managed():
|
|
"""
|
|
Commits changes if the system is not in managed transaction mode.
|
|
"""
|
|
if not is_managed():
|
|
connection._commit()
|
|
else:
|
|
set_dirty()
|
|
|
|
def rollback_unless_managed():
|
|
"""
|
|
Rolls back changes if the system is not in managed transaction mode.
|
|
"""
|
|
if not is_managed():
|
|
connection._rollback()
|
|
else:
|
|
set_dirty()
|
|
|
|
def commit():
|
|
"""
|
|
Does the commit itself and resets the dirty flag.
|
|
"""
|
|
connection._commit()
|
|
set_clean()
|
|
|
|
def rollback():
|
|
"""
|
|
This function does the rollback itself and resets the dirty flag.
|
|
"""
|
|
connection._rollback()
|
|
set_clean()
|
|
|
|
def savepoint():
|
|
"""
|
|
Creates a savepoint (if supported and required by the backend) inside the
|
|
current transaction. Returns an identifier for the savepoint that will be
|
|
used for the subsequent rollback or commit.
|
|
"""
|
|
thread_ident = thread.get_ident()
|
|
if thread_ident in savepoint_state:
|
|
savepoint_state[thread_ident].append(None)
|
|
else:
|
|
savepoint_state[thread_ident] = [None]
|
|
tid = str(thread_ident).replace('-', '')
|
|
sid = "s%s_x%d" % (tid, len(savepoint_state[thread_ident]))
|
|
connection._savepoint(sid)
|
|
return sid
|
|
|
|
def savepoint_rollback(sid):
|
|
"""
|
|
Rolls back the most recent savepoint (if one exists). Does nothing if
|
|
savepoints are not supported.
|
|
"""
|
|
connection._savepoint_rollback(sid)
|
|
|
|
def savepoint_commit(sid):
|
|
"""
|
|
Commits the most recent savepoint (if one exists). Does nothing if
|
|
savepoints are not supported.
|
|
"""
|
|
connection._savepoint_commit(sid)
|
|
|
|
##############
|
|
# DECORATORS #
|
|
##############
|
|
|
|
def autocommit(func):
|
|
"""
|
|
Decorator that activates commit on save. This is Django's default behavior;
|
|
this decorator is useful if you globally activated transaction management in
|
|
your settings file and want the default behavior in some view functions.
|
|
"""
|
|
def _autocommit(*args, **kw):
|
|
try:
|
|
enter_transaction_management()
|
|
managed(False)
|
|
return func(*args, **kw)
|
|
finally:
|
|
leave_transaction_management()
|
|
return wraps(func)(_autocommit)
|
|
|
|
def commit_on_success(func):
|
|
"""
|
|
This decorator activates commit on response. This way, if the view function
|
|
runs successfully, a commit is made; if the viewfunc produces an exception,
|
|
a rollback is made. This is one of the most common ways to do transaction
|
|
control in web apps.
|
|
"""
|
|
def _commit_on_success(*args, **kw):
|
|
try:
|
|
enter_transaction_management()
|
|
managed(True)
|
|
try:
|
|
res = func(*args, **kw)
|
|
except (Exception, KeyboardInterrupt, SystemExit):
|
|
# (We handle KeyboardInterrupt and SystemExit specially, since
|
|
# they don't inherit from Exception in Python 2.5, but we
|
|
# should treat them uniformly here.)
|
|
if is_dirty():
|
|
rollback()
|
|
raise
|
|
else:
|
|
if is_dirty():
|
|
commit()
|
|
return res
|
|
finally:
|
|
leave_transaction_management()
|
|
return wraps(func)(_commit_on_success)
|
|
|
|
def commit_manually(func):
|
|
"""
|
|
Decorator that activates manual transaction control. It just disables
|
|
automatic transaction control and doesn't do any commit/rollback of its
|
|
own -- it's up to the user to call the commit and rollback functions
|
|
themselves.
|
|
"""
|
|
def _commit_manually(*args, **kw):
|
|
try:
|
|
enter_transaction_management()
|
|
managed(True)
|
|
return func(*args, **kw)
|
|
finally:
|
|
leave_transaction_management()
|
|
|
|
return wraps(func)(_commit_manually)
|