| 1 |
import eventlet |
| 2 |
from eventlet import event, hubs, queue |
| 3 |
import tests |
| 4 |
|
| 5 |
|
| 6 |
def do_bail(q): |
| 7 |
eventlet.Timeout(0, RuntimeError()) |
| 8 |
try: |
| 9 |
result = q.get() |
| 10 |
return result |
| 11 |
except RuntimeError: |
| 12 |
return 'timed out' |
| 13 |
|
| 14 |
|
| 15 |
class TestQueue(tests.LimitedTestCase): |
| 16 |
def test_send_first(self): |
| 17 |
q = eventlet.Queue() |
| 18 |
q.put('hi') |
| 19 |
self.assertEqual(q.get(), 'hi') |
| 20 |
|
| 21 |
def test_send_last(self): |
| 22 |
q = eventlet.Queue() |
| 23 |
|
| 24 |
def waiter(q): |
| 25 |
self.assertEqual(q.get(), 'hi2') |
| 26 |
|
| 27 |
gt = eventlet.spawn(eventlet.with_timeout, 0.1, waiter, q) |
| 28 |
eventlet.sleep(0) |
| 29 |
eventlet.sleep(0) |
| 30 |
q.put('hi2') |
| 31 |
gt.wait() |
| 32 |
|
| 33 |
def test_max_size(self): |
| 34 |
q = eventlet.Queue(2) |
| 35 |
results = [] |
| 36 |
|
| 37 |
def putter(q): |
| 38 |
q.put('a') |
| 39 |
results.append('a') |
| 40 |
q.put('b') |
| 41 |
results.append('b') |
| 42 |
q.put('c') |
| 43 |
results.append('c') |
| 44 |
|
| 45 |
gt = eventlet.spawn(putter, q) |
| 46 |
eventlet.sleep(0) |
| 47 |
self.assertEqual(results, ['a', 'b']) |
| 48 |
self.assertEqual(q.get(), 'a') |
| 49 |
eventlet.sleep(0) |
| 50 |
self.assertEqual(results, ['a', 'b', 'c']) |
| 51 |
self.assertEqual(q.get(), 'b') |
| 52 |
self.assertEqual(q.get(), 'c') |
| 53 |
gt.wait() |
| 54 |
|
| 55 |
def test_zero_max_size(self): |
| 56 |
q = eventlet.Queue(0) |
| 57 |
|
| 58 |
def sender(evt, q): |
| 59 |
q.put('hi') |
| 60 |
evt.send('done') |
| 61 |
|
| 62 |
def receiver(q): |
| 63 |
x = q.get() |
| 64 |
return x |
| 65 |
|
| 66 |
evt = event.Event() |
| 67 |
gt = eventlet.spawn(sender, evt, q) |
| 68 |
eventlet.sleep(0) |
| 69 |
assert not evt.ready() |
| 70 |
gt2 = eventlet.spawn(receiver, q) |
| 71 |
self.assertEqual(gt2.wait(), 'hi') |
| 72 |
self.assertEqual(evt.wait(), 'done') |
| 73 |
gt.wait() |
| 74 |
|
| 75 |
def test_resize_up(self): |
| 76 |
q = eventlet.Queue(0) |
| 77 |
|
| 78 |
def sender(evt, q): |
| 79 |
q.put('hi') |
| 80 |
evt.send('done') |
| 81 |
|
| 82 |
evt = event.Event() |
| 83 |
gt = eventlet.spawn(sender, evt, q) |
| 84 |
eventlet.sleep(0) |
| 85 |
assert not evt.ready() |
| 86 |
q.resize(1) |
| 87 |
eventlet.sleep(0) |
| 88 |
assert evt.ready() |
| 89 |
gt.wait() |
| 90 |
|
| 91 |
def test_resize_down(self): |
| 92 |
q = eventlet.Queue(5) |
| 93 |
|
| 94 |
for i in range(5): |
| 95 |
q.put(i) |
| 96 |
|
| 97 |
self.assertEqual(list(q.queue), list(range(5))) |
| 98 |
q.resize(1) |
| 99 |
eventlet.sleep(0) |
| 100 |
self.assertEqual(list(q.queue), list(range(5))) |
| 101 |
|
| 102 |
def test_resize_to_Unlimited(self): |
| 103 |
q = eventlet.Queue(0) |
| 104 |
|
| 105 |
def sender(evt, q): |
| 106 |
q.put('hi') |
| 107 |
evt.send('done') |
| 108 |
|
| 109 |
evt = event.Event() |
| 110 |
gt = eventlet.spawn(sender, evt, q) |
| 111 |
eventlet.sleep() |
| 112 |
self.assertFalse(evt.ready()) |
| 113 |
q.resize(None) |
| 114 |
eventlet.sleep() |
| 115 |
self.assertTrue(evt.ready()) |
| 116 |
gt.wait() |
| 117 |
|
| 118 |
def test_multiple_waiters(self): |
| 119 |
# tests that multiple waiters get their results back |
| 120 |
q = eventlet.Queue() |
| 121 |
|
| 122 |
sendings = ['1', '2', '3', '4'] |
| 123 |
gts = [eventlet.spawn(q.get) for x in sendings] |
| 124 |
|
| 125 |
eventlet.sleep(0.01) # get 'em all waiting |
| 126 |
|
| 127 |
q.put(sendings[0]) |
| 128 |
q.put(sendings[1]) |
| 129 |
q.put(sendings[2]) |
| 130 |
q.put(sendings[3]) |
| 131 |
results = set() |
| 132 |
for i, gt in enumerate(gts): |
| 133 |
results.add(gt.wait()) |
| 134 |
self.assertEqual(results, set(sendings)) |
| 135 |
|
| 136 |
def test_waiters_that_cancel(self): |
| 137 |
q = eventlet.Queue() |
| 138 |
|
| 139 |
gt = eventlet.spawn(do_bail, q) |
| 140 |
self.assertEqual(gt.wait(), 'timed out') |
| 141 |
|
| 142 |
q.put('hi') |
| 143 |
self.assertEqual(q.get(), 'hi') |
| 144 |
|
| 145 |
def test_getting_before_sending(self): |
| 146 |
q = eventlet.Queue() |
| 147 |
gt = eventlet.spawn(q.put, 'sent') |
| 148 |
self.assertEqual(q.get(), 'sent') |
| 149 |
gt.wait() |
| 150 |
|
| 151 |
def test_two_waiters_one_dies(self): |
| 152 |
def waiter(q): |
| 153 |
return q.get() |
| 154 |
|
| 155 |
q = eventlet.Queue() |
| 156 |
dying = eventlet.spawn(do_bail, q) |
| 157 |
waiting = eventlet.spawn(waiter, q) |
| 158 |
eventlet.sleep(0) |
| 159 |
q.put('hi') |
| 160 |
self.assertEqual(dying.wait(), 'timed out') |
| 161 |
self.assertEqual(waiting.wait(), 'hi') |
| 162 |
|
| 163 |
def test_two_bogus_waiters(self): |
| 164 |
q = eventlet.Queue() |
| 165 |
gt1 = eventlet.spawn(do_bail, q) |
| 166 |
gt2 = eventlet.spawn(do_bail, q) |
| 167 |
eventlet.sleep(0) |
| 168 |
q.put('sent') |
| 169 |
self.assertEqual(gt1.wait(), 'timed out') |
| 170 |
self.assertEqual(gt2.wait(), 'timed out') |
| 171 |
self.assertEqual(q.get(), 'sent') |
| 172 |
|
| 173 |
def test_waiting(self): |
| 174 |
q = eventlet.Queue() |
| 175 |
gt1 = eventlet.spawn(q.get) |
| 176 |
eventlet.sleep(0) |
| 177 |
self.assertEqual(1, q.getting()) |
| 178 |
q.put('hi') |
| 179 |
eventlet.sleep(0) |
| 180 |
self.assertEqual(0, q.getting()) |
| 181 |
self.assertEqual('hi', gt1.wait()) |
| 182 |
self.assertEqual(0, q.getting()) |
| 183 |
|
| 184 |
def test_channel_send(self): |
| 185 |
channel = eventlet.Queue(0) |
| 186 |
events = [] |
| 187 |
|
| 188 |
def another_greenlet(): |
| 189 |
events.append(channel.get()) |
| 190 |
events.append(channel.get()) |
| 191 |
|
| 192 |
eventlet.spawn(another_greenlet) |
| 193 |
|
| 194 |
events.append('sending') |
| 195 |
channel.put('hello') |
| 196 |
events.append('sent hello') |
| 197 |
channel.put('world') |
| 198 |
events.append('sent world') |
| 199 |
|
| 200 |
self.assertEqual(['sending', 'hello', 'sent hello', 'world', 'sent world'], events) |
| 201 |
|
| 202 |
def test_channel_wait(self): |
| 203 |
channel = eventlet.Queue(0) |
| 204 |
events = [] |
| 205 |
|
| 206 |
def another_greenlet(): |
| 207 |
events.append('sending hello') |
| 208 |
channel.put('hello') |
| 209 |
events.append('sending world') |
| 210 |
channel.put('world') |
| 211 |
events.append('sent world') |
| 212 |
|
| 213 |
eventlet.spawn(another_greenlet) |
| 214 |
|
| 215 |
events.append('waiting') |
| 216 |
events.append(channel.get()) |
| 217 |
events.append(channel.get()) |
| 218 |
|
| 219 |
self.assertEqual(['waiting', 'sending hello', 'hello', 'sending world', 'world'], events) |
| 220 |
eventlet.sleep(0) |
| 221 |
self.assertEqual( |
| 222 |
['waiting', 'sending hello', 'hello', 'sending world', 'world', 'sent world'], events) |
| 223 |
|
| 224 |
def test_channel_waiters(self): |
| 225 |
c = eventlet.Queue(0) |
| 226 |
w1 = eventlet.spawn(c.get) |
| 227 |
w2 = eventlet.spawn(c.get) |
| 228 |
w3 = eventlet.spawn(c.get) |
| 229 |
eventlet.sleep(0) |
| 230 |
self.assertEqual(c.getting(), 3) |
| 231 |
s1 = eventlet.spawn(c.put, 1) |
| 232 |
s2 = eventlet.spawn(c.put, 2) |
| 233 |
s3 = eventlet.spawn(c.put, 3) |
| 234 |
|
| 235 |
s1.wait() |
| 236 |
s2.wait() |
| 237 |
s3.wait() |
| 238 |
self.assertEqual(c.getting(), 0) |
| 239 |
# NOTE: we don't guarantee that waiters are served in order |
| 240 |
results = sorted([w1.wait(), w2.wait(), w3.wait()]) |
| 241 |
self.assertEqual(results, [1, 2, 3]) |
| 242 |
|
| 243 |
def test_channel_sender_timing_out(self): |
| 244 |
c = eventlet.Queue(0) |
| 245 |
self.assertRaises(queue.Full, c.put, "hi", timeout=0.001) |
| 246 |
self.assertRaises(queue.Empty, c.get_nowait) |
| 247 |
|
| 248 |
def test_task_done(self): |
| 249 |
channel = eventlet.Queue(0) |
| 250 |
X = object() |
| 251 |
gt = eventlet.spawn(channel.put, X) |
| 252 |
result = channel.get() |
| 253 |
assert result is X, (result, X) |
| 254 |
assert channel.unfinished_tasks == 1, channel.unfinished_tasks |
| 255 |
channel.task_done() |
| 256 |
assert channel.unfinished_tasks == 0, channel.unfinished_tasks |
| 257 |
gt.wait() |
| 258 |
|
| 259 |
def test_join_doesnt_block_when_queue_is_already_empty(self): |
| 260 |
queue = eventlet.Queue() |
| 261 |
queue.join() |
| 262 |
|
| 263 |
def test_zero_length_queue_nonblocking_put(self): |
| 264 |
hub = hubs.get_hub() |
| 265 |
queue = eventlet.Queue(0) |
| 266 |
got = [] |
| 267 |
|
| 268 |
def fetch_item(): |
| 269 |
got.append(queue.get()) |
| 270 |
|
| 271 |
for _ in range(10): |
| 272 |
good_getter = eventlet.spawn(fetch_item) |
| 273 |
bad_getter = eventlet.spawn(fetch_item) |
| 274 |
hub.schedule_call_global(0, bad_getter.throw, Exception("kaboom")) |
| 275 |
eventlet.sleep(0) |
| 276 |
|
| 277 |
for i in range(10): |
| 278 |
queue.put(i) |
| 279 |
|
| 280 |
self.assertEqual(got, list(range(10))) |
| 281 |
|
| 282 |
|
| 283 |
def store_result(result, func, *args): |
| 284 |
try: |
| 285 |
result.append(func(*args)) |
| 286 |
except Exception as exc: |
| 287 |
result.append(exc) |
| 288 |
|
| 289 |
|
| 290 |
class TestNoWait(tests.LimitedTestCase): |
| 291 |
def test_put_nowait_simple(self): |
| 292 |
hub = hubs.get_hub() |
| 293 |
result = [] |
| 294 |
q = eventlet.Queue(1) |
| 295 |
hub.schedule_call_global(0, store_result, result, q.put_nowait, 2) |
| 296 |
hub.schedule_call_global(0, store_result, result, q.put_nowait, 3) |
| 297 |
eventlet.sleep(0) |
| 298 |
eventlet.sleep(0) |
| 299 |
assert len(result) == 2, result |
| 300 |
assert result[0] is None, result |
| 301 |
assert isinstance(result[1], queue.Full), result |
| 302 |
|
| 303 |
def test_get_nowait_simple(self): |
| 304 |
hub = hubs.get_hub() |
| 305 |
result = [] |
| 306 |
q = eventlet.Queue(1) |
| 307 |
q.put(4) |
| 308 |
hub.schedule_call_global(0, store_result, result, q.get_nowait) |
| 309 |
hub.schedule_call_global(0, store_result, result, q.get_nowait) |
| 310 |
eventlet.sleep(0) |
| 311 |
assert len(result) == 2, result |
| 312 |
assert result[0] == 4, result |
| 313 |
assert isinstance(result[1], queue.Empty), result |
| 314 |
|
| 315 |
# get_nowait must work from the mainloop |
| 316 |
def test_get_nowait_unlock(self): |
| 317 |
hub = hubs.get_hub() |
| 318 |
result = [] |
| 319 |
q = eventlet.Queue(0) |
| 320 |
p = eventlet.spawn(q.put, 5) |
| 321 |
assert q.empty(), q |
| 322 |
assert q.full(), q |
| 323 |
eventlet.sleep(0) |
| 324 |
assert q.empty(), q |
| 325 |
assert q.full(), q |
| 326 |
hub.schedule_call_global(0, store_result, result, q.get_nowait) |
| 327 |
eventlet.sleep(0) |
| 328 |
assert q.empty(), q |
| 329 |
assert q.full(), q |
| 330 |
assert result == [5], result |
| 331 |
# TODO add ready to greenthread |
| 332 |
# assert p.ready(), p |
| 333 |
assert p.dead, p |
| 334 |
assert q.empty(), q |
| 335 |
|
| 336 |
# put_nowait must work from the mainloop |
| 337 |
def test_put_nowait_unlock(self): |
| 338 |
hub = hubs.get_hub() |
| 339 |
result = [] |
| 340 |
q = eventlet.Queue(0) |
| 341 |
eventlet.spawn(q.get) |
| 342 |
assert q.empty(), q |
| 343 |
assert q.full(), q |
| 344 |
eventlet.sleep(0) |
| 345 |
assert q.empty(), q |
| 346 |
assert q.full(), q |
| 347 |
hub.schedule_call_global(0, store_result, result, q.put_nowait, 10) |
| 348 |
# TODO ready method on greenthread |
| 349 |
# assert not p.ready(), p |
| 350 |
eventlet.sleep(0) |
| 351 |
assert result == [None], result |
| 352 |
# TODO ready method |
| 353 |
# assert p.ready(), p |
| 354 |
assert q.full(), q |
| 355 |
assert q.empty(), q |
| 356 |
|
| 357 |
def test_wait_except(self): |
| 358 |
# https://github.com/eventlet/eventlet/issues/407 |
| 359 |
q = eventlet.Queue() |
| 360 |
|
| 361 |
def get(): |
| 362 |
q.get() |
| 363 |
raise KeyboardInterrupt |
| 364 |
|
| 365 |
eventlet.spawn(get) |
| 366 |
eventlet.sleep() |
| 367 |
|
| 368 |
with tests.assert_raises(KeyboardInterrupt): |
| 369 |
q.put(None) |
| 370 |
eventlet.sleep() |