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_ssl_connect2 (self):
def accept_once (listenfd):
try:
conn, addr = listenfd.accept()
conn.write('hello\r\n')
shutdown_safe(conn)
conn.close()
finally:
shutdown_safe(listenfd)
listenfd.close()
server = ssl_listener(('0.0.0.0', 0),
self.certificate_file,
self.private_key_file)
greenthread.spawn(accept_once, server)
raw_client = connect(('127.0.0.1', server.getsockname()[1]))
client = util.wrap_ssl(raw_client)
fd = socket._fileobject(client, 'rb', 8192)
assert fd.readline() == 'hello\r\n'
try:
self.assertEquals('', fd.read(10))
except SSL.ZeroReturnError:
# if it's a GreenSSL object it'll do this
pass
shutdown_safe(client)
client.close()
def test_client_closing_connection_76 (self):
error_detected = [False]
done_with_request = event.Event()
site = self.site
def error_detector (environ, start_response):
try:
try:
return site(environ, start_response)
except:
error_detected[0] = True
raise
finally:
done_with_request.send(True)
self.site = error_detector
self.spawn_server()
connect_data = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n^n:ds[4U')
resp = sock.recv(1024) # get the headers
sock.sendall('\xff\x00') # "Close the connection" packet.
done_with_request.wait()
self.assert_(not error_detected[0])
def test_app_socket_errors_76 (self):
error_detected = [False]
done_with_request = event.Event()
site = self.site
def error_detector (environ, start_response):
try:
try:
return site(environ, start_response)
except:
error_detected[0] = True
raise
finally:
done_with_request.send(True)
self.site = error_detector
self.spawn_server()
connect_data = [
"GET /error HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n^n:ds[4U')
resp = sock.recv(1024)
done_with_request.wait()
self.assert_(error_detected[0])
def test_sending_messages_to_websocket_76 (self):
connect_data = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n^n:ds[4U')
first_resp = sock.recv(1024)
sock.sendall('\x00hello\xFF')
result = sock.recv(1024)
self.assertEqual(result, '\x00hello\xff')
sock.sendall('\x00start')
sleep(0.001)
sock.sendall(' end\xff')
result = sock.recv(1024)
self.assertEqual(result, '\x00start end\xff')
sock.shutdown(socket.SHUT_RDWR)
sock.close()
sleep(0.01)
def test_breaking_the_connection_75 (self):
error_detected = [False]
done_with_request = event.Event()
site = self.site
def error_detector (environ, start_response):
try:
try:
return site(environ, start_response)
except:
error_detected[0] = True
raise
finally:
done_with_request.send(True)
self.site = error_detector
self.spawn_server()
connect_data = [
"GET /range HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"WebSocket-Protocol: ws",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n')
resp = sock.recv(1024) # get the headers
sock.close() # close while the app is running
done_with_request.wait()
self.assert_(not error_detected[0])
def spam_to_me(address):
sock = convenience.connect(address)
while True:
try:
sock.sendall('hello world')
except socket.error, e:
if get_errno(e) == errno.EPIPE:
return
raise
def spam_to_me (address):
sock = convenience.connect(address)
while True:
try:
sock.sendall('hello world')
except socket.error, e:
if get_errno(e) == errno.EPIPE:
return
raise
def go ():
desc = connect(('127.0.0.1', bound_port))
try:
hubs.trampoline(desc, read = True, timeout = 0.1)
except TimeoutError:
assert False, "Timed out"
server.close()
desc.close()
done.send()
def go():
desc = connect(('127.0.0.1', bound_port))
try:
hubs.trampoline(desc, read=True, timeout=0.1)
except TimeoutError:
assert False, "Timed out"
server.close()
desc.close()
done.send()
def test_exiting_server(self):
# tests that the server closes the client sock on handle() exit
def closer(sock, addr):
pass
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, closer)
client = convenience.connect(('localhost', l.getsockname()[1]))
client.sendall(s2b('a'))
self.assertFalse(client.recv(100))
gt.kill()
def test_exiting_server (self):
# tests that the server closes the client sock on handle() exit
def closer (sock, addr):
pass
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, closer)
client = convenience.connect(('localhost', l.getsockname()[1]))
client.sendall(s2b('a'))
self.assertFalse(client.recv(100))
gt.kill()
def test_excepting_server(self):
# tests that the server closes the client sock on handle() exception
def crasher(sock, addr):
sock.recv(1024)
0 // 0
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, crasher)
_, port = l.getsockname()
client = convenience.connect(('localhost', port))
client.sendall(s2b('a'))
self.assertRaises(ZeroDivisionError, gt.wait)
self.assertFalse(client.recv(100))
def test_excepting_server_already_closed(self):
# same as above but with explicit clsoe before crash
def crasher(sock, addr):
sock.recv(1024)
sock.close()
0 // 0
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, crasher)
client = convenience.connect(('localhost', l.getsockname()[1]))
client.sendall(s2b('a'))
self.assertRaises(ZeroDivisionError, gt.wait)
self.assertFalse(client.recv(100))
def test_excepting_server_already_closed (self):
# same as above but with explicit clsoe before crash
def crasher (sock, addr):
sock.recv(1024)
sock.close()
0 // 0
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, crasher)
client = convenience.connect(('localhost', l.getsockname()[1]))
client.sendall(s2b('a'))
self.assertRaises(ZeroDivisionError, gt.wait)
self.assertFalse(client.recv(100))
def test_excepting_server (self):
# tests that the server closes the client sock on handle() exception
def crasher (sock, addr):
sock.recv(1024)
0 // 0
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, crasher)
_, port = l.getsockname()
client = convenience.connect(('localhost', port))
client.sendall(s2b('a'))
self.assertRaises(ZeroDivisionError, gt.wait)
self.assertFalse(client.recv(100))
def test_wrap_ssl (self):
server = convenience.wrap_ssl(convenience.listen(('localhost', 0)),
certfile = certificate_file,
keyfile = private_key_file, server_side = True)
port = server.getsockname()[1]
def handle (sock, addr):
sock.sendall(sock.recv(1024))
raise convenience.StopServe()
spawn(convenience.serve, server, handle)
client = convenience.wrap_ssl(convenience.connect(('localhost', port)))
client.sendall("echo")
self.assertEquals("echo", client.recv(1024))
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_wrap_ssl(self):
server = convenience.wrap_ssl(convenience.listen(('localhost', 0)),
certfile=certificate_file,
keyfile=private_key_file,
server_side=True)
port = server.getsockname()[1]
def handle(sock, addr):
sock.sendall(sock.recv(1024))
raise convenience.StopServe()
spawn(convenience.serve, server, handle)
client = convenience.wrap_ssl(convenience.connect(('localhost', port)))
client.sendall("echo")
self.assertEquals("echo", client.recv(1024))
def test_called_for_each_connection(self):
hits = [0]
def counter(sock, addr):
hits[0] += 1
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, counter)
_, port = l.getsockname()
for i in xrange(100):
client = convenience.connect(('localhost', port))
self.assertFalse(client.recv(100))
gt.kill()
self.assertEqual(100, hits[0])
def test_called_for_each_connection (self):
hits = [0]
def counter (sock, addr):
hits[0] += 1
l = convenience.listen(('localhost', 0))
gt = spawn(convenience.serve, l, counter)
_, port = l.getsockname()
for i in xrange(100):
client = convenience.connect(('localhost', port))
self.assertFalse(client.recv(100))
gt.kill()
self.assertEqual(100, hits[0])
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_server_closing_connect_76 (self):
connect_data = [
"GET / HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n^n:ds[4U')
resp = sock.recv(1024)
headers, result = resp.split('\r\n\r\n')
# The remote server should have immediately closed the connection.
self.assertEqual(result[16:], '\xff\x00')
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_correct_upgrade_request_75 (self):
connect_data = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"WebSocket-Protocol: ws",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n')
result = sock.recv(1024)
## The server responds the correct Websocket handshake
self.assertEqual(result,
'\r\n'.join(['HTTP/1.1 101 Web Socket Protocol Handshake',
'Upgrade: WebSocket',
'Connection: Upgrade',
'WebSocket-Origin: http://localhost:%s' % self.port,
'WebSocket-Location: ws://localhost:%s/echo\r\n\r\n' % self.port]))
def test_001_trampoline_timeout (self):
server_sock = listen(('127.0.0.1', 0))
bound_port = server_sock.getsockname()[1]
def server (sock):
client, addr = sock.accept()
sleep(0.1)
server_evt = spawn(server, server_sock)
sleep(0)
try:
desc = connect(('127.0.0.1', bound_port))
hubs.trampoline(desc, read = True, write = False, timeout = 0.001)
except TimeoutError:
pass # test passed
else:
assert False, "Didn't timeout"
server_evt.wait()
check_hub()
def test_raised_multiple_readers (self):
def handle (sock, addr):
sock.recv(1)
sock.sendall("a")
raise convenience.StopServe()
listener = convenience.listen(('127.0.0.1', 0))
server = spawn(convenience.serve, listener, handle)
_, port = listener.getsockname()
def reader (s):
s.recv(1)
sleep(0)
s = convenience.connect(('127.0.0.1', port))
a = spawn(reader, s)
sleep(0)
self.assertRaises(RuntimeError, s.recv, 1) ## try to read from the same socket...
s.sendall('b')
a.wait()
def test_raised_multiple_readers(self):
def handle(sock, addr):
sock.recv(1)
sock.sendall("a")
raise convenience.StopServe()
listener = convenience.listen(('127.0.0.1', 0))
server = spawn(convenience.serve, listener, handle)
_, port = listener.getsockname()
def reader(s):
s.recv(1)
sleep(0)
s = convenience.connect(('127.0.0.1', port))
a = spawn(reader, s)
sleep(0)
self.assertRaises(RuntimeError, s.recv,
1) ## try to read from the same socket...
s.sendall('b')
a.wait()
def test_001_trampoline_timeout(self):
server_sock = listen(('127.0.0.1', 0))
bound_port = server_sock.getsockname()[1]
def server(sock):
client, addr = sock.accept()
sleep(0.1)
server_evt = spawn(server, server_sock)
sleep(0)
try:
desc = connect(('127.0.0.1', bound_port))
hubs.trampoline(desc, read=True, write=False, timeout=0.001)
except TimeoutError:
pass # test passed
else:
assert False, "Didn't timeout"
server_evt.wait()
check_hub()
def test_getting_messages_from_websocket_75 (self):
connect_data = [
"GET /range HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"WebSocket-Protocol: ws",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n')
resp = sock.recv(1024)
headers, result = resp.split('\r\n\r\n')
msgs = [result.strip('\x00\xff')]
cnt = 10
while cnt:
msgs.append(sock.recv(20).strip('\x00\xff'))
cnt -= 1
# Last item in msgs is an empty string
self.assertEqual(msgs[:-1], ['msg %d' % i for i in range(10)])
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_ssl_sending_messages (self):
s = evy.wrap_ssl(listen(('localhost', 0)),
certfile = certificate_file,
keyfile = private_key_file,
server_side = True)
self.spawn_server(sock = s)
connect_data = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = evy.wrap_ssl(connect(
('localhost', self.port)))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n^n:ds[4U')
first_resp = sock.recv(1024)
# make sure it sets the wss: protocol on the location header
loc_line = [x for x in first_resp.split("\r\n")
if x.lower().startswith('sec-websocket-location')][0]
self.assert_("wss://localhost" in loc_line,
"Expecting wss protocol in location: %s" % loc_line)
sock.sendall('\x00hello\xFF')
result = sock.recv(1024)
self.assertEqual(result, '\x00hello\xff')
sock.sendall('\x00start')
sleep(0.001)
sock.sendall(' end\xff')
result = sock.recv(1024)
self.assertEqual(result, '\x00start end\xff')
shutdown_safe(sock)
sock.close()
sleep(0.01)
def test_makefile_closes (self):
self.reset_timeout(100000)
def accept_once (listenfd):
try:
conn, addr = listenfd.accept()
fd = conn.makefile(mode = 'w')
conn.close()
fd.write('hello\n')
fd.close()
finally:
listenfd.close()
server = convenience.listen(('0.0.0.0', 0))
spawn(accept_once, server)
client = convenience.connect(('127.0.0.1', server.getsockname()[1]))
fd = client.makefile()
client.close()
assert fd.readline() == 'hello\n'
assert fd.read() == ''
fd.close()
check_hub()
def test_correct_upgrade_request_76 (self):
connect_data = [
"GET /echo HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n^n:ds[4U')
result = sock.recv(1024)
## The server responds the correct Websocket handshake
self.assertEqual(result,
'\r\n'.join(['HTTP/1.1 101 WebSocket Protocol Handshake',
'Upgrade: WebSocket',
'Connection: Upgrade',
'Sec-WebSocket-Origin: http://localhost:%s' % self.port,
'Sec-WebSocket-Protocol: ws',
'Sec-WebSocket-Location: ws://localhost:%s/echo\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port]))
def test_empty_query_string (self):
# verify that a single trailing ? doesn't get nuked
connect_data = [
"GET /echo? HTTP/1.1",
"Upgrade: WebSocket",
"Connection: Upgrade",
"Host: localhost:%s" % self.port,
"Origin: http://localhost:%s" % self.port,
"Sec-WebSocket-Protocol: ws",
"Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
"Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
]
sock = connect(
('localhost', self.port))
sock.sendall('\r\n'.join(connect_data) + '\r\n\r\n^n:ds[4U')
result = sock.recv(1024)
self.assertEqual(result,
'\r\n'.join(['HTTP/1.1 101 WebSocket Protocol Handshake',
'Upgrade: WebSocket',
'Connection: Upgrade',
'Sec-WebSocket-Origin: http://localhost:%s' % self.port,
'Sec-WebSocket-Protocol: ws',
'Sec-WebSocket-Location: ws://localhost:%s/echo?\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port]))
def test_client ():
c = convenience.connect(('localhost', l.getsockname()[1]))
# verify the client is connected by getting data
self.assertEquals(s2b('hi'), c.recv(2))
return c
def test_client():
c = convenience.connect(('localhost', l.getsockname()[1]))
# verify the client is connected by getting data
self.assertEquals(s2b('hi'), c.recv(2))
return c
