def testSharerBlocksDelete(self):
self.sl.acquire(shared=1)
self._addThread(target=self._doItDelete)
self.assertRaises(Queue.Empty, self.done.get_nowait)
self.sl.release()
self._waitThreads()
self.failUnlessEqual(self.done.get_nowait(), "DEL")
self.sl = locking.SharedLock(self.sl.name)
def testExclusiveBlocksDelete(self):
self.sl.acquire()
self._addThread(target=self._doItDelete)
self.assertRaises(queue.Empty, self.done.get_nowait)
self.sl.release()
self._waitThreads()
self.assertEqual(self.done.get_nowait(), "DEL")
self.sl = locking.SharedLock(self.sl.name)
def testAcquireTimeoutWithSpuriousNotifications(self):
ready = threading.Event()
locked = threading.Event()
req = Queue.Queue(0)
epoch = 4000.0
timeout = 60.0
def check_end(now):
self.assertFalse(locked.isSet())
# If we waited long enough (in virtual time), tell main thread to release
# lock, otherwise tell it to notify once more
req.put(now < (epoch + (timeout * 0.8)))
time_fn = self._FakeTimeForSpuriousNotifications(epoch, check_end).time
sl = locking.SharedLock("test", _time_fn=time_fn)
# Acquire in exclusive mode
sl.acquire(shared=0)
def fn():
self.assertTrue(
sl.acquire(shared=0, timeout=timeout, test_notify=ready.set))
locked.set()
sl.release()
self.done.put("success")
# Start acquire with timeout and wait for it to be ready
self._addThread(target=fn)
ready.wait()
# The separate thread is now waiting to acquire the lock, so start sending
# spurious notifications.
# Wait for separate thread to ask for another notification
count = 0
while req.get():
# After sending the notification, the lock will take a short amount of
# time to notice and to retrieve the current time
sl._notify_topmost()
count += 1
self.assertTrue(count > 100, "Not enough notifications were sent")
self.assertFalse(locked.isSet())
# Some notifications have been sent, now actually release the lock
sl.release()
# Wait for lock to be acquired
locked.wait()
self._waitThreads()
self.assertEqual(self.done.get_nowait(), "success")
self.assertRaises(Queue.Empty, self.done.get_nowait)
def __init__(self, owner, pending_fn):
"""Initializes this class.
"""
self._owner = owner
self._pending_fn = pending_fn
# The lock monitor runs in another thread, hence locking is necessary
self._lock = locking.SharedLock("PendingHttpRequests")
self.acquire = self._lock.acquire
self.release = self._lock.release
def testDeletePendingSharersExclusiveDelete(self):
self.sl.acquire()
self._addThread(target=self._doItSharer)
self._addThread(target=self._doItSharer)
self._addThread(target=self._doItExclusive)
self._addThread(target=self._doItDelete)
self.sl.delete()
self._waitThreads()
# The threads who were pending return ERR
for _ in range(4):
self.assertEqual(self.done.get_nowait(), "ERR")
self.sl = locking.SharedLock(self.sl.name)
def main():
(opts, _) = ParseOptions()
lock = locking.SharedLock("TestLock")
state = State(opts.thread_count)
lock.acquire(shared=0)
try:
for i in range(opts.thread_count):
t = threading.Thread(target=_Counter, args=(lock, state, i))
t.setDaemon(True)
t.start()
start = time.clock()
finally:
lock.release()
while True:
if (time.clock() - start) > opts.duration:
break
time.sleep(0.1)
# Make sure we get a consistent view
lock.acquire(shared=0)
lock_cputime = time.clock() - start
res = resource.getrusage(resource.RUSAGE_SELF)
print "Total number of acquisitions: %s" % state.total_count
print "Per-thread acquisitions:"
for (i, count) in enumerate(state.counts):
print(" Thread %s: %d (%0.1f%%)" %
(i, count, (100.0 * count / state.total_count)))
print "Benchmark CPU time: %0.3fs" % lock_cputime
print("Average time per lock acquisition: %0.5fms" %
(1000.0 * lock_cputime / state.total_count))
print "Process:"
print " User time: %0.3fs" % res.ru_utime
print " System time: %0.3fs" % res.ru_stime
print " Total time: %0.3fs" % (res.ru_utime + res.ru_stime)
# Exit directly without attempting to clean up threads
os._exit(0) # pylint: disable=W0212
def setUp(self):
_ThreadedTestCase.setUp(self)
self.sl = locking.SharedLock("TestSharedLock")
self.assertTrue(repr(self.sl).startswith("<"))
self.assertTrue("name=TestSharedLock" in repr(self.sl))
def setUp(self):
_ThreadedTestCase.setUp(self)
self.sl = locking.SharedLock("TestSharedLockInCondition")
self.setCondition()
import gc
import itertools
from ganeti import constants
from ganeti import locking
from ganeti import errors
from ganeti import utils
from ganeti import compat
from ganeti import objects
from ganeti import query
import testutils
# This is used to test the ssynchronize decorator.
# Since it's passed as input to a decorator it must be declared as a global.
_decoratorlock = locking.SharedLock("decorator lock")
#: List for looping tests
ITERATIONS = range(8)
def _Repeat(fn):
"""Decorator for executing a function many times"""
def wrapper(*args, **kwargs):
for i in ITERATIONS:
fn(*args, **kwargs)
return wrapper
def SafeSleep(duration):
