| 1 |
from unittest import TestCase, main |
| 2 |
|
| 3 |
import eventlet |
| 4 |
from eventlet import Queue |
| 5 |
from eventlet import hubs |
| 6 |
from eventlet import pools |
| 7 |
|
| 8 |
|
| 9 |
class IntPool(pools.Pool): |
| 10 |
def create(self): |
| 11 |
self.current_integer = getattr(self, 'current_integer', 0) + 1 |
| 12 |
return self.current_integer |
| 13 |
|
| 14 |
|
| 15 |
class TestIntPool(TestCase): |
| 16 |
def setUp(self): |
| 17 |
self.pool = IntPool(min_size=0, max_size=4) |
| 18 |
|
| 19 |
def test_integers(self): |
| 20 |
# Do not actually use this pattern in your code. The pool will be |
| 21 |
# exhausted, and unrestoreable. |
| 22 |
# If you do a get, you should ALWAYS do a put, probably like this: |
| 23 |
# try: |
| 24 |
# thing = self.pool.get() |
| 25 |
# do stuff |
| 26 |
# finally: |
| 27 |
# self.pool.put(thing) |
| 28 |
|
| 29 |
# with self.pool.some_api_name() as thing: |
| 30 |
# do stuff |
| 31 |
self.assertEqual(self.pool.get(), 1) |
| 32 |
self.assertEqual(self.pool.get(), 2) |
| 33 |
self.assertEqual(self.pool.get(), 3) |
| 34 |
self.assertEqual(self.pool.get(), 4) |
| 35 |
|
| 36 |
def test_free(self): |
| 37 |
self.assertEqual(self.pool.free(), 4) |
| 38 |
gotten = self.pool.get() |
| 39 |
self.assertEqual(self.pool.free(), 3) |
| 40 |
self.pool.put(gotten) |
| 41 |
self.assertEqual(self.pool.free(), 4) |
| 42 |
|
| 43 |
def test_exhaustion(self): |
| 44 |
waiter = Queue(0) |
| 45 |
|
| 46 |
def consumer(): |
| 47 |
gotten = None |
| 48 |
try: |
| 49 |
gotten = self.pool.get() |
| 50 |
finally: |
| 51 |
waiter.put(gotten) |
| 52 |
|
| 53 |
eventlet.spawn(consumer) |
| 54 |
|
| 55 |
one, two, three, four = ( |
| 56 |
self.pool.get(), self.pool.get(), self.pool.get(), self.pool.get()) |
| 57 |
self.assertEqual(self.pool.free(), 0) |
| 58 |
|
| 59 |
# Let consumer run; nothing will be in the pool, so he will wait |
| 60 |
eventlet.sleep(0) |
| 61 |
|
| 62 |
# Wake consumer |
| 63 |
self.pool.put(one) |
| 64 |
|
| 65 |
# wait for the consumer |
| 66 |
self.assertEqual(waiter.get(), one) |
| 67 |
|
| 68 |
def test_blocks_on_pool(self): |
| 69 |
waiter = Queue(0) |
| 70 |
|
| 71 |
def greedy(): |
| 72 |
self.pool.get() |
| 73 |
self.pool.get() |
| 74 |
self.pool.get() |
| 75 |
self.pool.get() |
| 76 |
# No one should be waiting yet. |
| 77 |
self.assertEqual(self.pool.waiting(), 0) |
| 78 |
# The call to the next get will unschedule this routine. |
| 79 |
self.pool.get() |
| 80 |
# So this put should never be called. |
| 81 |
waiter.put('Failed!') |
| 82 |
|
| 83 |
killable = eventlet.spawn(greedy) |
| 84 |
|
| 85 |
# no one should be waiting yet. |
| 86 |
self.assertEqual(self.pool.waiting(), 0) |
| 87 |
|
| 88 |
# Wait for greedy |
| 89 |
eventlet.sleep(0) |
| 90 |
|
| 91 |
# Greedy should be blocking on the last get |
| 92 |
self.assertEqual(self.pool.waiting(), 1) |
| 93 |
|
| 94 |
# Send will never be called, so balance should be 0. |
| 95 |
self.assertFalse(not waiter.full()) |
| 96 |
|
| 97 |
eventlet.kill(killable) |
| 98 |
|
| 99 |
def test_ordering(self): |
| 100 |
# normal case is that items come back out in the |
| 101 |
# same order they are put |
| 102 |
one, two = self.pool.get(), self.pool.get() |
| 103 |
self.pool.put(one) |
| 104 |
self.pool.put(two) |
| 105 |
self.assertEqual(self.pool.get(), one) |
| 106 |
self.assertEqual(self.pool.get(), two) |
| 107 |
|
| 108 |
def test_putting_to_queue(self): |
| 109 |
timer = eventlet.Timeout(0.1) |
| 110 |
try: |
| 111 |
size = 2 |
| 112 |
self.pool = IntPool(min_size=0, max_size=size) |
| 113 |
queue = Queue() |
| 114 |
results = [] |
| 115 |
|
| 116 |
def just_put(pool_item, index): |
| 117 |
self.pool.put(pool_item) |
| 118 |
queue.put(index) |
| 119 |
for index in range(size + 1): |
| 120 |
pool_item = self.pool.get() |
| 121 |
eventlet.spawn(just_put, pool_item, index) |
| 122 |
|
| 123 |
for _ in range(size + 1): |
| 124 |
x = queue.get() |
| 125 |
results.append(x) |
| 126 |
self.assertEqual(sorted(results), list(range(size + 1))) |
| 127 |
finally: |
| 128 |
timer.cancel() |
| 129 |
|
| 130 |
def test_resize(self): |
| 131 |
pool = IntPool(max_size=2) |
| 132 |
a = pool.get() |
| 133 |
b = pool.get() |
| 134 |
self.assertEqual(pool.free(), 0) |
| 135 |
|
| 136 |
# verify that the pool discards excess items put into it |
| 137 |
pool.resize(1) |
| 138 |
pool.put(a) |
| 139 |
pool.put(b) |
| 140 |
self.assertEqual(pool.free(), 1) |
| 141 |
|
| 142 |
# resize larger and assert that there are more free items |
| 143 |
pool.resize(2) |
| 144 |
self.assertEqual(pool.free(), 2) |
| 145 |
|
| 146 |
def test_create_contention(self): |
| 147 |
creates = [0] |
| 148 |
|
| 149 |
def sleep_create(): |
| 150 |
creates[0] += 1 |
| 151 |
eventlet.sleep() |
| 152 |
return "slept" |
| 153 |
|
| 154 |
p = pools.Pool(max_size=4, create=sleep_create) |
| 155 |
|
| 156 |
def do_get(): |
| 157 |
x = p.get() |
| 158 |
self.assertEqual(x, "slept") |
| 159 |
p.put(x) |
| 160 |
|
| 161 |
gp = eventlet.GreenPool() |
| 162 |
for i in range(100): |
| 163 |
gp.spawn_n(do_get) |
| 164 |
gp.waitall() |
| 165 |
self.assertEqual(creates[0], 4) |
| 166 |
|
| 167 |
def test_put_with_timed_out_getters(self): |
| 168 |
p = IntPool(max_size=2) |
| 169 |
hub = hubs.get_hub() |
| 170 |
# check out all the items |
| 171 |
p.get() |
| 172 |
p.get() |
| 173 |
|
| 174 |
# all getting greenthreads are blocked and have Timeouts that are |
| 175 |
# ready to fire, but have not fired yet |
| 176 |
getters = [eventlet.spawn(p.get) for _ in range(5)] |
| 177 |
eventlet.sleep() |
| 178 |
for getter in getters: |
| 179 |
hub.schedule_call_global(0, getter.throw, eventlet.Timeout(None)) |
| 180 |
|
| 181 |
# put one item back; this should not block since the pool is empty |
| 182 |
with eventlet.Timeout(10): # don't hang if unblocking fails |
| 183 |
p.put(0) |
| 184 |
self.assertEqual(len(p.free_items), 1) |
| 185 |
|
| 186 |
|
| 187 |
class TestAbstract(TestCase): |
| 188 |
mode = 'static' |
| 189 |
|
| 190 |
def test_abstract(self): |
| 191 |
# Going for 100% coverage here |
| 192 |
# A Pool cannot be used without overriding create() |
| 193 |
pool = pools.Pool() |
| 194 |
self.assertRaises(NotImplementedError, pool.get) |
| 195 |
|
| 196 |
|
| 197 |
class TestIntPool2(TestCase): |
| 198 |
mode = 'static' |
| 199 |
|
| 200 |
def setUp(self): |
| 201 |
self.pool = IntPool(min_size=3, max_size=3) |
| 202 |
|
| 203 |
def test_something(self): |
| 204 |
self.assertEqual(len(self.pool.free_items), 3) |
| 205 |
# Cover the clause in get where we get from the free list instead of creating |
| 206 |
# an item on get |
| 207 |
gotten = self.pool.get() |
| 208 |
self.assertEqual(gotten, 1) |
| 209 |
|
| 210 |
|
| 211 |
class TestOrderAsStack(TestCase): |
| 212 |
mode = 'static' |
| 213 |
|
| 214 |
def setUp(self): |
| 215 |
self.pool = IntPool(max_size=3, order_as_stack=True) |
| 216 |
|
| 217 |
def test_ordering(self): |
| 218 |
# items come out in the reverse order they are put |
| 219 |
one, two = self.pool.get(), self.pool.get() |
| 220 |
self.pool.put(one) |
| 221 |
self.pool.put(two) |
| 222 |
self.assertEqual(self.pool.get(), two) |
| 223 |
self.assertEqual(self.pool.get(), one) |
| 224 |
|
| 225 |
|
| 226 |
class RaisePool(pools.Pool): |
| 227 |
def create(self): |
| 228 |
raise RuntimeError() |
| 229 |
|
| 230 |
|
| 231 |
class TestCreateRaises(TestCase): |
| 232 |
mode = 'static' |
| 233 |
|
| 234 |
def setUp(self): |
| 235 |
self.pool = RaisePool(max_size=3) |
| 236 |
|
| 237 |
def test_it(self): |
| 238 |
self.assertEqual(self.pool.free(), 3) |
| 239 |
self.assertRaises(RuntimeError, self.pool.get) |
| 240 |
self.assertEqual(self.pool.free(), 3) |
| 241 |
|
| 242 |
|
| 243 |
ALWAYS = RuntimeError('I always fail') |
| 244 |
SOMETIMES = RuntimeError('I fail half the time') |
| 245 |
|
| 246 |
|
| 247 |
class TookTooLongToRunTest(Exception): |
| 248 |
pass |
| 249 |
|
| 250 |
|
| 251 |
if __name__ == '__main__': |
| 252 |
main() |