def test_semaphore_type_check():
eventlet.Semaphore(0)
eventlet.Semaphore(1)
eventlet.Semaphore(1e2)
with tests.assert_raises(TypeError):
eventlet.Semaphore('foo')
with tests.assert_raises(ValueError):
eventlet.Semaphore(-1)
def test_nested_acquire(self):
q = zmq._QueueLock()
self.assertFalse(q)
q.acquire()
q.acquire()
s = eventlet.Semaphore(0)
results = []
def lock(x):
with q:
results.append(x)
s.release()
eventlet.spawn(lock, 1)
eventlet.sleep()
self.assertEqual(results, [])
q.release()
eventlet.sleep()
self.assertEqual(results, [])
self.assertTrue(q)
q.release()
s.acquire()
self.assertEqual(results, [1])
def test_queue_lock_order(self):
q = zmq._QueueLock()
s = eventlet.Semaphore(0)
results = []
def lock(x):
with q:
results.append(x)
s.release()
q.acquire()
eventlet.spawn(lock, 1)
eventlet.sleep()
eventlet.spawn(lock, 2)
eventlet.sleep()
eventlet.spawn(lock, 3)
eventlet.sleep()
self.assertEqual(results, [])
q.release()
s.acquire()
s.acquire()
s.acquire()
self.assertEqual(results, [1, 2, 3])
def test_reinit(self):
# py39+ expects locks to have a _at_fork_reinit() method; since we
# patch in Semaphores in eventlet.green.thread, they need it, too
sem = eventlet.Semaphore()
sem.acquire()
sem._at_fork_reinit()
self.assertEqual(sem.acquire(blocking=False), True)
self.assertEqual(sem.acquire(blocking=False), False)
sem = eventlet.Semaphore(0)
sem.release()
sem._at_fork_reinit()
self.assertEqual(sem.acquire(blocking=False), False)
sem = eventlet.Semaphore(2)
sem.acquire()
sem._at_fork_reinit()
self.assertEqual(sem.acquire(blocking=False), True)
self.assertEqual(sem.acquire(blocking=False), True)
self.assertEqual(sem.acquire(blocking=False), False)
def __init__(self, size=1000):
try:
size = int(size)
except ValueError as e:
msg = 'GreenPool() expect size :: int, actual: {0} {1}'.format(type(size), str(e))
raise TypeError(msg)
if size < 0:
msg = 'GreenPool() expect size >= 0, actual: {0}'.format(repr(size))
raise ValueError(msg)
self.size = size
self.coroutines_running = set()
self.sem = eventlet.Semaphore(size)
self.no_coros_running = eventlet.Event()
def semaphore_factory(limit, concurrent_processes):
"""Get a semaphore to limit concurrent operations.
The semaphore depends on the limit we want to set and the concurrent
processes that need to be limited.
"""
# Limit of 0 is no limit, so we won't use a semaphore
if limit:
# If we only have 1 process we can use eventlet's Semaphore
if concurrent_processes == 1:
return eventlet.Semaphore(limit)
# Use our own Sempahore for interprocess because eventlet blocks with
# the standard one
return Semaphore(limit)
return contextlib.suppress()
def test_semaphore_contention():
g_mutex = eventlet.Semaphore()
counts = [0, 0]
def worker(no):
while min(counts) < 200:
with g_mutex:
counts[no - 1] += 1
eventlet.sleep(0.001)
t1 = eventlet.spawn(worker, no=1)
t2 = eventlet.spawn(worker, no=2)
eventlet.sleep(0.5)
t1.kill()
t2.kill()
assert abs(counts[0] - counts[1]) < int(min(counts) * 0.1), counts
def test_exceptionleaks(self):
# tests expected behaviour with all versions of greenlet
def test_gt(sem):
try:
raise KeyError()
except KeyError:
sem.release()
hubs.get_hub().switch()
# semaphores for controlling execution order
sem = eventlet.Semaphore()
sem.acquire()
g = eventlet.spawn(test_gt, sem)
try:
sem.acquire()
assert sys.exc_info()[0] is None
finally:
g.kill()
def test_timeout_non_blocking(self):
sem = eventlet.Semaphore()
self.assertRaises(ValueError, sem.acquire, blocking=False, timeout=1)
def test_timeout(self):
sem = eventlet.Semaphore(0)
start = time.time()
self.assertEqual(sem.acquire(timeout=0.1), False)
self.assertTrue(time.time() - start >= 0.1)
def test_non_blocking(self):
sem = eventlet.Semaphore(0)
self.assertEqual(sem.acquire(blocking=False), False)
