def test_waiters_get_woken(self):
# verify that when there's someone waiting on an empty pool
# and someone puts an immediately-closed connection back in
# the pool that the waiter gets woken
self.pool.put(self.connection)
self.pool.clear()
self.pool = self.create_pool(max_size=1, max_age=0)
self.connection = self.pool.get()
self.assertEquals(self.pool.free(), 0)
self.assertEquals(self.pool.waiting(), 0)
e = event.Event()
def retrieve(pool, ev):
c = pool.get()
ev.send(c)
evy.spawn(retrieve, self.pool, e)
sleep(0) # these two sleeps should advance the retrieve
sleep(0) # coroutine until it's waiting in get()
self.assertEquals(self.pool.free(), 0)
self.assertEquals(self.pool.waiting(), 1)
self.pool.put(self.connection)
timer = Timeout(1)
conn = e.wait()
timer.cancel()
self.assertEquals(self.pool.free(), 0)
self.assertEquals(self.pool.waiting(), 0)
self.pool.put(conn)
def test_waiters_get_woken (self):
# verify that when there's someone waiting on an empty pool
# and someone puts an immediately-closed connection back in
# the pool that the waiter gets woken
self.pool.put(self.connection)
self.pool.clear()
self.pool = self.create_pool(max_size = 1, max_age = 0)
self.connection = self.pool.get()
self.assertEquals(self.pool.free(), 0)
self.assertEquals(self.pool.waiting(), 0)
e = event.Event()
def retrieve (pool, ev):
c = pool.get()
ev.send(c)
evy.spawn(retrieve, self.pool, e)
sleep(0) # these two sleeps should advance the retrieve
sleep(0) # coroutine until it's waiting in get()
self.assertEquals(self.pool.free(), 0)
self.assertEquals(self.pool.waiting(), 1)
self.pool.put(self.connection)
timer = Timeout(1)
conn = e.wait()
timer.cancel()
self.assertEquals(self.pool.free(), 0)
self.assertEquals(self.pool.waiting(), 0)
self.pool.put(conn)
def test_hub_exceptions (self):
debug.hub_exceptions(True)
server = convenience.listen(('0.0.0.0', 0))
client = convenience.connect(('127.0.0.1', server.getsockname()[1]))
client_2, addr = server.accept()
def hurl (s):
s.recv(1)
{}[1] # keyerror
fake = StringIO()
orig = sys.stderr
sys.stderr = fake
try:
gt = evy.spawn(hurl, client_2)
sleep(0)
client.send(s2b(' '))
sleep(0)
# allow the "hurl" greenlet to trigger the KeyError
# not sure why the extra context switch is needed
sleep(0)
finally:
sys.stderr = orig
self.assertRaises(KeyError, gt.wait)
debug.hub_exceptions(False)
# look for the KeyError exception in the traceback
self.assert_('KeyError: 1' in fake.getvalue(),
"Traceback not in:\n" + fake.getvalue())
def test_returns_immediately(self):
self.pool = self.create_pool()
conn = self.pool.get()
self.set_up_dummy_table(conn)
self.fill_up_table(conn)
curs = conn.cursor()
results = []
SHORT_QUERY = "select * from test_table"
evt = event.Event()
def a_query():
self.assert_cursor_works(curs)
curs.execute(SHORT_QUERY)
results.append(2)
evt.send()
evy.spawn(a_query)
results.append(1)
self.assertEqual([1], results)
evt.wait()
self.assertEqual([1, 2], results)
self.pool.put(conn)
def test_returns_immediately (self):
self.pool = self.create_pool()
conn = self.pool.get()
self.set_up_dummy_table(conn)
self.fill_up_table(conn)
curs = conn.cursor()
results = []
SHORT_QUERY = "select * from test_table"
evt = event.Event()
def a_query ():
self.assert_cursor_works(curs)
curs.execute(SHORT_QUERY)
results.append(2)
evt.send()
evy.spawn(a_query)
results.append(1)
self.assertEqual([1], results)
evt.wait()
self.assertEqual([1, 2], results)
self.pool.put(conn)
def test_two_simultaneous_connections (self):
# timing-sensitive test, disabled until we come up with a better
# way to do this
self.pool = self.create_pool(2)
conn = self.pool.get()
self.set_up_dummy_table(conn)
self.fill_up_table(conn)
curs = conn.cursor()
conn2 = self.pool.get()
self.set_up_dummy_table(conn2)
self.fill_up_table(conn2)
curs2 = conn2.cursor()
results = []
LONG_QUERY = "select * from test_table"
SHORT_QUERY = "select * from test_table where row_id <= 20"
evt = event.Event()
def long_running_query ():
self.assert_cursor_works(curs)
curs.execute(LONG_QUERY)
results.append(1)
evt.send()
evt2 = event.Event()
def short_running_query ():
self.assert_cursor_works(curs2)
curs2.execute(SHORT_QUERY)
results.append(2)
evt2.send()
evy.spawn(long_running_query)
evy.spawn(short_running_query)
evt.wait()
evt2.wait()
results.sort()
self.assertEqual([1, 2], results)
def test_two_simultaneous_connections(self):
# timing-sensitive test, disabled until we come up with a better
# way to do this
self.pool = self.create_pool(2)
conn = self.pool.get()
self.set_up_dummy_table(conn)
self.fill_up_table(conn)
curs = conn.cursor()
conn2 = self.pool.get()
self.set_up_dummy_table(conn2)
self.fill_up_table(conn2)
curs2 = conn2.cursor()
results = []
LONG_QUERY = "select * from test_table"
SHORT_QUERY = "select * from test_table where row_id <= 20"
evt = event.Event()
def long_running_query():
self.assert_cursor_works(curs)
curs.execute(LONG_QUERY)
results.append(1)
evt.send()
evt2 = event.Event()
def short_running_query():
self.assert_cursor_works(curs2)
curs2.execute(SHORT_QUERY)
results.append(2)
evt2.send()
evy.spawn(long_running_query)
evy.spawn(short_running_query)
evt.wait()
evt2.wait()
results.sort()
self.assertEqual([1, 2], results)
def test_duplex_response (self):
def serve (listener):
sock, addr = listener.accept()
stuff = sock.read(8192)
sock.write('response')
sock = listen_ssl_socket()
server_coro = evy.spawn(serve, sock)
client = util.wrap_ssl(connect(('127.0.0.1', sock.getsockname()[1])))
client.write('line 1\r\nline 2\r\n\r\n')
self.assertEquals(client.read(8192), 'response')
server_coro.wait()
def test_ssl_connect (self):
def serve (listener):
sock, addr = listener.accept()
stuff = sock.read(8192)
sock = listen_ssl_socket()
server_coro = evy.spawn(serve, sock)
raw_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_client = util.wrap_ssl(raw_client)
ssl_client.connect(('127.0.0.1', sock.getsockname()[1]))
ssl_client.write('abc')
shutdown_safe(ssl_client)
ssl_client.close()
server_coro.wait()
def test_ssl_close (self):
def serve (listener):
sock, addr = listener.accept()
stuff = sock.read(8192)
try:
self.assertEquals("", sock.read(8192))
except SSL.ZeroReturnError:
pass
sock = listen_ssl_socket()
server_coro = evy.spawn(serve, sock)
raw_client = connect(('127.0.0.1', sock.getsockname()[1]))
client = util.wrap_ssl(raw_client)
client.write('X')
shutdown_safe(client)
client.close()
server_coro.wait()
def test_greensslobject (self):
import warnings
# disabling socket.ssl warnings because we're testing it here
warnings.filterwarnings(action = 'ignore',
message = '.*socket.ssl.*',
category = DeprecationWarning)
def serve (listener):
sock, addr = listener.accept()
sock.write('content')
shutdown_safe(sock)
sock.close()
listener = listen_ssl_socket(('', 0))
killer = evy.spawn(serve, listener)
from evy.patched.socket import ssl
client = ssl(connect(('localhost', listener.getsockname()[1])))
self.assertEquals(client.read(1024), 'content')
self.assertEquals(client.read(1024), '')
def test_ssl_unwrap (self):
def serve ():
sock, addr = listener.accept()
self.assertEquals(sock.recv(6), 'before')
sock_ssl = util.wrap_ssl(sock, certificate_file, private_key_file,
server_side = True)
sock_ssl.do_handshake()
self.assertEquals(sock_ssl.read(6), 'during')
sock2 = sock_ssl.unwrap()
self.assertEquals(sock2.recv(5), 'after')
sock2.close()
listener = listen(('127.0.0.1', 0))
server_coro = evy.spawn(serve)
client = connect((listener.getsockname()))
client.send('before')
client_ssl = util.wrap_ssl(client)
client_ssl.do_handshake()
client_ssl.write('during')
client2 = client_ssl.unwrap()
client2.send('after')
server_coro.wait()
def test_server (self):
listener = socket.socket()
listener.bind(('localhost', 0))
listener.listen(50)
serv = evy.spawn(backdoor.backdoor_server, listener)
client = socket.socket()
client.connect(('localhost', listener.getsockname()[1]))
f = client.makefile('rw')
self.assert_('Python' in f.readline())
f.readline() # build info
f.readline() # help info
self.assert_('InteractiveConsole' in f.readline())
self.assertEquals('>>> ', f.read(4))
f.write('print("hi")\n')
f.flush()
self.assertEquals('hi\n', f.readline())
self.assertEquals('>>> ', f.read(4))
f.close()
client.close()
serv.kill()
# wait for the console to discover that it's dead
sleep(0.1)
def test_server(self):
listener = socket.socket()
listener.bind(('localhost', 0))
listener.listen(50)
serv = evy.spawn(backdoor.backdoor_server, listener)
client = socket.socket()
client.connect(('localhost', listener.getsockname()[1]))
f = client.makefile('rw')
self.assert_('Python' in f.readline())
f.readline() # build info
f.readline() # help info
self.assert_('InteractiveConsole' in f.readline())
self.assertEquals('>>> ', f.read(4))
f.write('print("hi")\n')
f.flush()
self.assertEquals('hi\n', f.readline())
self.assertEquals('>>> ', f.read(4))
f.close()
client.close()
serv.kill()
# wait for the console to discover that it's dead
sleep(0.1)
def bob_client(ctx, count):
print "STARTING BOB"
bob = zmq.Socket(CTX, zmq.REQ)
bob.connect("ipc:///tmp/test")
for i in range(0, count):
print "BOB SENDING"
bob.send("HI")
print "BOB GOT:", bob.recv()
def alice_server(ctx, count):
print "STARTING ALICE"
alice = zmq.Socket(CTX, zmq.REP)
alice.bind("ipc:///tmp/test")
print "ALICE READY"
for i in range(0, count):
print "ALICE GOT:", alice.recv()
print "ALIC SENDING"
alice.send("HI BACK")
alice = evy.spawn(alice_server, CTX, 10)
bob = evy.spawn(bob_client, CTX, 10)
bob.wait()
alice.wait()
def run_spawn ():
evy.spawn(dummy, 1)
fd.close()
def cleanup ():
evy.sleep(0.2)
iters = 10000
best = benchmarks.measure_best(5, iters,
'pass',
cleanup,
evy.sleep)
write_result('evy.sleep_main', best[evy.sleep])
gt = evy.spawn(benchmarks.measure_best, 5, iters,
'pass',
cleanup,
evy.sleep)
best = gt.wait()
write_result('evy.sleep_gt', best[evy.sleep])
def dummy (i = None):
return i
def run_spawn ():
evy.spawn(dummy, 1)
def run_spawn_n ():
evy.spawn_n(dummy, 1)
CTX = zmq.Context(1)
def bob_client (ctx, count):
print "STARTING BOB"
bob = zmq.Socket(CTX, zmq.REQ)
bob.connect("ipc:///tmp/test")
for i in range(0, count):
print "BOB SENDING"
bob.send("HI")
print "BOB GOT:", bob.recv()
def alice_server (ctx, count):
print "STARTING ALICE"
alice = zmq.Socket(CTX, zmq.REP)
alice.bind("ipc:///tmp/test")
print "ALICE READY"
for i in range(0, count):
print "ALICE GOT:", alice.recv()
print "ALIC SENDING"
alice.send("HI BACK")
alice = evy.spawn(alice_server, CTX, 10)
bob = evy.spawn(bob_client, CTX, 10)
bob.wait()
alice.wait()
