def run_select_for_update(self, status, nowait=False):
"""
Utility method that runs a SELECT FOR UPDATE against all
Person instances. After the select_for_update, it attempts
to update the name of the only record, save, and commit.
This function expects to run in a separate thread.
"""
status.append('started')
try:
# We need to enter transaction management again, as this is done on
# per-thread basis
transaction.enter_transaction_management()
people = list(
Person.objects.all().select_for_update(nowait=nowait)
)
people[0].name = 'Fred'
people[0].save()
transaction.commit()
except DatabaseError as e:
status.append(e)
finally:
# This method is run in a separate thread. It uses its own
# database connection. Close it without waiting for the GC.
transaction.abort()
connection.close()
def process(self, backend):
self.log.debug("Checking backend for items")
self.set_process_title("Waiting for items")
# Tell master process that we are not processing anything.
self.tell_master(None, False)
job = backend.dequeue(self.queue, 1)
if job is None:
return
# Update master what we are doing
self.tell_master(
job.timeout,
job.sigkill_on_stop,
)
self.log.debug("Running job %s", job)
self.set_process_title("Running job %s" % job)
if job.run() and self.touch_filename:
with open(self.touch_filename, 'a'):
os.utime(self.touch_filename, None)
# Emulate Django's request_finished signal and close all of our
# connections. Django assumes that making a DB connection is cheap, so
# it's probably safe to assume that too.
for x in connections:
try:
# Removed in recent versions
transaction.abort(x)
except AttributeError:
pass
connections[x].close()
def process(self, backend):
self.log.debug("Checking backend for items")
self.set_process_title("Waiting for items")
# Tell master process that we are not processing anything.
self.tell_master(None, False)
job = backend.dequeue(self.queue, 1)
if job is None:
return
# Update master what we are doing
self.tell_master(
job.timeout,
job.sigkill_on_stop,
)
self.log.debug("Running job %s", job)
self.set_process_title("Running job %s" % job)
if job.run() and self.touch_filename:
with open(self.touch_filename, 'a'):
os.utime(self.touch_filename, None)
# Emulate Django's request_finished signal and close all of our
# connections. Django assumes that making a DB connection is cheap, so
# it's probably safe to assume that too.
for x in connections:
try:
# Removed in recent versions
transaction.abort(x)
except AttributeError:
pass
connections[x].close()
def close_connection(**kwargs):
# Avoid circular imports
from django.db import transaction
for conn in connections:
# If an error happens here the connection will be left in broken
# state. Once a good db connection is again available, the
# connection state will be cleaned up.
transaction.abort(conn)
connections[conn].close()
def close_connection(**kwargs):
# Avoid circular imports
from django.db import transaction
for conn in connections:
# If an error happens here the connection will be left in broken
# state. Once a good db connection is again available, the
# connection state will be cleaned up.
transaction.abort(conn)
connections[conn].close()
def close_connection(**kwargs):
warnings.warn("close_connection is superseded by close_old_connections.", RemovedInDjango18Warning, stacklevel=2)
# Avoid circular imports
from django.db import transaction
for conn in connections:
# If an error happens here the connection will be left in broken
# state. Once a good db connection is again available, the
# connection state will be cleaned up.
transaction.abort(conn)
connections[conn].close()
def close_connection(**kwargs):
# Avoid circular imports
from django.db import transaction
for conn in connections:
try:
transaction.abort(conn)
connections[conn].close()
except Exception:
# The connection's state is unknown, so it has to be
# abandoned. This could happen for example if the network
# connection has a failure.
del connections[conn]
def close_connection(**kwargs):
warnings.warn(
"close_connection is superseded by close_old_connections.",
RemovedInDjango18Warning, stacklevel=2)
# Avoid circular imports
from django.db import transaction
for conn in connections:
# If an error happens here the connection will be left in broken
# state. Once a good db connection is again available, the
# connection state will be cleaned up.
transaction.abort(conn)
connections[conn].close()
def tearDown(self):
try:
# We don't really care if this fails - some of the tests will set
# this in the course of their run.
transaction.abort()
self.new_connection.abort()
except transaction.TransactionManagementError:
pass
self.new_connection.close()
try:
self.end_blocking_transaction()
except (DatabaseError, AttributeError):
pass
def tearDown(self):
try:
# We don't really care if this fails - some of the tests will set
# this in the course of their run.
transaction.abort()
self.new_connection.abort()
except transaction.TransactionManagementError:
pass
self.new_connection.close()
try:
self.end_blocking_transaction()
except (DatabaseError, AttributeError):
pass
def close_connection(self, connection):
"""
关闭数据库
"""
alias = connection.alias
connection_list = self.pooled_connections[alias]
# connection_list = []
max_conn = settings.ALIAS_2_MAX_CONNECT_NUM.get(alias, 10)
# 清空状态
from django.db import transaction
transaction.abort(connection)
# 关闭，或者归还到Pool中
connection.close()
connection.connection_handler = None
if len(connection_list) > max_conn:
pass
else:
connection_list.append(connection)
def close_connection(self, connection):
"""
关闭数据库
"""
alias = connection.alias
connection_list = self.pooled_connections[alias]
# connection_list = []
max_conn = settings.ALIAS_2_MAX_CONNECT_NUM.get(alias, 10)
# 清空状态
from django.db import transaction
transaction.abort(connection)
# 关闭，或者归还到Pool中
connection.close()
connection.connection_handler = None
if len(connection_list) > max_conn:
pass
else:
connection_list.append(connection)
def _get_content(self):
transaction.enter_transaction_management()
# transaction.managed(False)
# sid = transaction.savepoint()
self._assets = defaultdict(list)
try:
output = self.callable
while callable(output):
# collect css/js in an ordered fashion, de-duping on the way.
if hasattr(output, 'assets'):
for key, value in output.assets.items():
for thing in value:
if thing not in self._assets[key]:
self._assets[key].append(thing)
# it's probably a class instance, or a response generator
output = output(request=self.request)
finally:
transaction.abort()
# transaction.savepoint_rollback(sid)
# transaction.leave_transaction_management()
return "\n".join(x for x in output.splitlines() if x.strip())
def tearDown(self):
transaction.abort()
def tearDown(self):
transaction.abort()
super(TransactionMiddlewareTest, self).tearDown()
def tearDown(self):
transaction.abort()
super(TransactionMiddlewareTest, self).tearDown()
