def test_wait(self):
channel = queue.Channel()
events = []
def another_greenlet():
events.append('sending hello')
channel.put('hello')
events.append('sending world')
channel.put('world')
events.append('sent world')
g = gevent.spawn(another_greenlet)
events.append('waiting')
events.append(channel.get())
events.append(channel.get())
self.assertEqual(
['waiting', 'sending hello', 'hello', 'sending world', 'world'],
events)
gevent.sleep(0)
self.assertEqual([
'waiting', 'sending hello', 'hello', 'sending world', 'world',
'sent world'
], events)
g.get()
def test_zero_max_size(self):
q = queue.Channel()
def sender(evt, q):
q.put('hi')
evt.set('done')
def receiver(evt, q):
x = q.get()
evt.set(x)
e1 = AsyncResult()
e2 = AsyncResult()
p1 = gevent.spawn(sender, e1, q)
gevent.sleep(0.001)
self.assert_(not e1.ready())
p2 = gevent.spawn(receiver, e2, q)
self.assertEquals(e2.get(), 'hi')
self.assertEquals(e1.get(), 'done')
timeout = gevent.Timeout.start_new(0)
try:
gevent.joinall([p1, p2])
finally:
timeout.cancel()
def test_get_nowait_unlock_channel(self):
# get_nowait runs fine in the hub, and
# it switches to a waiting putter if needed.
result = []
q = queue.Channel()
p = gevent.spawn(q.put, 5)
def store_result(func, *args):
result.append(func(*args))
self.assertTrue(q.empty())
self.assertTrue(q.full())
gevent.sleep(0.001)
self.assertTrue(q.empty())
self.assertTrue(q.full())
get_hub().loop.run_callback(store_result, q.get_nowait)
gevent.sleep(0.001)
self.assertTrue(q.empty())
self.assertTrue(q.full())
self.assertEqual(result, [5])
self.assertTrue(p.ready())
self.assertTrue(p.dead)
self.assertTrue(q.empty())
def main(addrs):
# Channel holding (addr, task) pairs.
tq = queue.Channel()
# Queue holding response messages (as a list of raw zmq frames).
rq = queue.Queue()
setup_task_listeners(addrs, tq, rq)
setup_worker_listener(addrs, tq, rq)
# TODO: Will switch to a Nanny central wait loop
setup_responder(addrs, rq).join()
def __init__(self, task_addr, rsp_addr, ctx=None, start=True):
ctx = zmq.Context() if ctx is None else ctx
self.tsock = ctx.socket(zmq.REQ)
self.tsock.connect(task_addr)
self.cid = uuid.uuid1().hex
self.rsock = ctx.socket(zmq.DEALER)
self.rsock.setsockopt(zmq.IDENTITY, self.cid)
self.rsock.connect(rsp_addr)
self.tq = queue.Channel()
self.taskmap = weakref.WeakValueDictionary()
if start: self.start()
def test_get_nowait_unlock_channel(self):
result = []
q = queue.Channel()
p = gevent.spawn(q.put, 5)
def store_result(func, *args):
result.append(func(*args))
assert q.empty(), q
assert q.full(), q
gevent.sleep(0.001)
assert q.empty(), q
assert q.full(), q
get_hub().loop.run_callback(store_result, q.get_nowait)
gevent.sleep(0.001)
assert q.empty(), q
assert q.full(), q
assert result == [5], result
assert p.ready(), p
assert p.dead, p
assert q.empty(), q
def test_iterable(self):
channel = queue.Channel()
gevent.spawn(channel.put, StopIteration)
r = list(channel)
self.assertEqual(r, [])
def make_put_interrupt(queue):
class TestPutInterrupt(GenericGetTestCase):
Timeout = Full
def wait(self, timeout):
while not queue.full():
queue.put(1)
return queue.put(2, timeout=timeout)
TestPutInterrupt.__name__ += '_' + queue.__class__.__name__
return TestPutInterrupt
for obj in [
queue.Queue(1),
queue.JoinableQueue(1),
queue.LifoQueue(1),
queue.PriorityQueue(1),
queue.Channel()
]:
klass = make_put_interrupt(obj)
globals()[klass.__name__] = klass
del klass, obj
del GenericGetTestCase
if __name__ == '__main__':
main()
globals()[klass.__name__] = klass
del klass, queue_type
def make_put_interrupt(queue):
class TestPutInterrupt(GenericGetTestCase):
Timeout = Full
def wait(self, timeout):
while not queue.full():
queue.put(1)
return queue.put(2, timeout=timeout)
TestPutInterrupt.__name__ += '_' + queue.__class__.__name__
return TestPutInterrupt
for obj in [queue.Queue(1), queue.JoinableQueue(1), queue.LifoQueue(1), queue.PriorityQueue(1), queue.Channel()]:
klass = make_put_interrupt(obj)
globals()[klass.__name__] = klass
del klass, obj
del GenericGetTestCase
if __name__ == '__main__':
main()
