mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-12-04 00:30:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Merge with bsddb3 2002.11.23.10.42.36

Browse source
This commit is contained in:
Martin v. Löwis 2002-11-23 11:26:07 +00:00
parent a797d8150d
commit b2c7affbaa
6 changed files with 100 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

36
Lib/bsddb/dbutils.py
View file

@ -1,11 +1,5 @@
#------------------------------------------------------------------------
#
# In my performance tests, using this (as in dbtest.py test4) is
# slightly slower than simply compiling _db.c with MYDB_THREAD
# undefined to prevent multithreading support in the C module.
# Using NoDeadlockDb also prevent deadlocks from mutliple processes
# accessing the same database.
#
# Copyright (C) 2000 Autonomous Zone Industries
#
# License: This is free software. You may use this software for any
@ -18,7 +12,7 @@
# Author: Gregory P. Smith <greg@electricrain.com>
#
# Note: I don't know how useful this is in reality since when a
# DBDeadlockError happens the current transaction is supposed to be
# DBLockDeadlockError happens the current transaction is supposed to be
# aborted. If it doesn't then when the operation is attempted again
# the deadlock is still happening...
# --Robin
@ -34,35 +28,47 @@ from time import sleep
_sleep = sleep
del sleep
import _db
import _bsddb
_deadlock_MinSleepTime = 1.0/64 # always sleep at least N seconds between retrys
_deadlock_MaxSleepTime = 1.0 # never sleep more than N seconds between retrys
_deadlock_MinSleepTime = 1.0/64 # always sleep at least N seconds between retrys
_deadlock_MaxSleepTime = 3.14159 # never sleep more than N seconds between retrys
_deadlock_VerboseFile = None # Assign a file object to this for a "sleeping"
# message to be written to it each retry
def DeadlockWrap(function, *_args, **_kwargs):
"""DeadlockWrap(function, *_args, **_kwargs) - automatically retries
function in case of a database deadlock.
This is a DeadlockWrapper method which DB calls can be made using to
preform infinite retrys with sleeps in between when a DBLockDeadlockError
exception is raised in a database call:
This is a function intended to be used to wrap database calls such
that they perform retrys with exponentially backing off sleeps in
between when a DBLockDeadlockError exception is raised.
A 'max_retries' parameter may optionally be passed to prevent it
from retrying forever (in which case the exception will be reraised).
d = DB(...)
d.open(...)
DeadlockWrap(d.put, "foo", data="bar") # set key "foo" to "bar"
"""
sleeptime = _deadlock_MinSleepTime
while (1) :
max_retries = _kwargs.get('max_retries', -1)
if _kwargs.has_key('max_retries'):
del _kwargs['max_retries']
while 1:
try:
return apply(function, _args, _kwargs)
except _db.DBLockDeadlockError:
print 'DeadlockWrap sleeping ', sleeptime
if _deadlock_VerboseFile:
_deadlock_VerboseFile.write('dbutils.DeadlockWrap: sleeping %1.3f\n' % sleeptime)
_sleep(sleeptime)
# exponential backoff in the sleep time
sleeptime = sleeptime * 2
if sleeptime > _deadlock_MaxSleepTime :
sleeptime = _deadlock_MaxSleepTime
max_retries = max_retries - 1
if max_retries == -1:
raise
#------------------------------------------------------------------------