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