def sender (listener): (sock, addr) = listener.accept() sock = bufsized(sock, size = bufsize) sock.sendall(s2b('x') * many_bytes) sock.sendall(s2b('y') * second_bytes) received.wait()
def accept_close_late(listener): # verify that the makefile and the socket are truly independent # by closing the made file and then sending a character try: conn, addr = listener.accept() fd = conn.makefile('w') fd.write('hello') fd.close() conn.send(s2b('\n')) conn.close() self.assertWriteToClosedFileRaises(fd) self.assertRaises(socket.error, conn.send, s2b('b')) finally: listener.close()
def test_sendall_timeout(self): listener = greenio.GreenSocket(socket.socket()) listener.bind(('', 0)) listener.listen(50) evt = event.Event() def server(): # accept the connection in another greenlet sock, addr = listener.accept() evt.wait() gt = eventlet.spawn(server) addr = listener.getsockname() client = greenio.GreenSocket(socket.socket()) client.settimeout(0.1) client.connect(addr) try: msg = s2b("A") * (8 << 20) # want to exceed the size of the OS buffer so it'll block client.sendall(msg) self.fail("socket.timeout not raised") except socket.timeout, e: self.assert_(hasattr(e, 'args')) self.assertEqual(e.args[0], 'timed out')
def test_send_timeout(self): self.reset_timeout(2) listener = bufsized(eventlet.listen(('', 0))) evt = event.Event() def server(): # accept the connection in another greenlet sock, addr = listener.accept() sock = bufsized(sock) evt.wait() gt = eventlet.spawn(server) addr = listener.getsockname() client = bufsized(greenio.GreenSocket(socket.socket())) client.connect(addr) try: client.settimeout(0.00001) msg = s2b("A") * 100000 # large enough number to overwhelm most buffers total_sent = 0 # want to exceed the size of the OS buffer so it'll block in a # single send for x in range(10): total_sent += client.send(msg) self.fail("socket.timeout not raised") except socket.timeout, e: self.assert_(hasattr(e, 'args')) self.assertEqual(e.args[0], 'timed out')
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 client (): client = sockets.GreenSocket() client.connect(('127.0.0.1', listener_port)) msg = s2b("A") * (10000) # large enough number to overwhelm most buffers # want to exceed the size of the OS buffer so it'll block in a single send total_sent = 0 for x in range(10): total_sent += client.send(msg) return total_sent
def test_exiting_server(self): # tests that the server closes the client sock on handle() exit def closer(sock,addr): pass l = eventlet.listen(('localhost', 0)) gt = eventlet.spawn(eventlet.serve, l, closer) client = eventlet.connect(('localhost', l.getsockname()[1])) client.sendall(s2b('a')) self.assertFalse(client.recv(100)) gt.kill()
def server(): (sock, addr) = listener.accept() sock = bufsized(sock) send_large_coro = eventlet.spawn(send_large, sock) eventlet.sleep(0) result = sock.recv(10) expected = s2b('hello world') while len(result) < len(expected): result += sock.recv(10) self.assertEquals(result, expected) send_large_coro.wait()
def test_full_duplex (self): large_data = s2b('*') * 10 * min_buf_size() listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) listener.bind(('127.0.0.1', 0)) listener.listen(50) def send_large (sock): sock.sendall(large_data) def read_large (sock): result = sock.recv(len(large_data)) while len(result) < len(large_data): result += sock.recv(len(large_data)) if result == '': break self.assertEquals(result, large_data) def server (): (sock, addr) = listener.accept() sock = bufsized(sock) send_large_coro = spawn(send_large, sock) sleep(0) result = sock.recv(10) expected = s2b('hello world') while len(result) < len(expected) and result is not '': result += sock.recv(10) self.assertEquals(result, expected) send_large_coro.wait() server_evt = spawn(server) client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('127.0.0.1', listener.getsockname()[1])) bufsized(client) large_evt = spawn(read_large, client) sleep(0) client.sendall(s2b('hello world')) server_evt.wait() large_evt.wait() client.close()
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 = eventlet.listen(('localhost', 0)) gt = eventlet.spawn(eventlet.serve, l, crasher) client = eventlet.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 = eventlet.listen(('localhost', 0)) gt = eventlet.spawn(eventlet.serve, l, crasher) client = eventlet.connect(('localhost', l.getsockname()[1])) client.sendall(s2b('a')) self.assertRaises(ZeroDivisionError, gt.wait) self.assertFalse(client.recv(100))
def test_multiple_readers(self, clibufsize=False): debug.hub_prevent_multiple_readers(False) recvsize = 2 * min_buf_size() sendsize = 10 * recvsize # test that we can have multiple coroutines reading # from the same fd. We make no guarantees about which one gets which # bytes, but they should both get at least some def reader(sock, results): while True: data = sock.recv(recvsize) if not data: break results.append(data) results1 = [] results2 = [] listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) listener.bind(('127.0.0.1', 0)) listener.listen(50) def server(): (sock, addr) = listener.accept() sock = bufsized(sock) try: c1 = eventlet.spawn(reader, sock, results1) c2 = eventlet.spawn(reader, sock, results2) try: c1.wait() c2.wait() finally: c1.kill() c2.kill() finally: sock.close() server_coro = eventlet.spawn(server) client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('127.0.0.1', listener.getsockname()[1])) if clibufsize: bufsized(client, size=sendsize) else: bufsized(client) client.sendall(s2b('*') * sendsize) client.close() server_coro.wait() listener.close() self.assert_(len(results1) > 0) self.assert_(len(results2) > 0) debug.hub_prevent_multiple_readers()
def client(): pid = os.fork() if pid: return pid client = _orig_sock.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('127.0.0.1', port)) bufsized(client, size=sendsize) for i in range(sendloops): client.sendall(s2b('*') * sendsize) client.close() os._exit(0)
def client (): client = sockets.GreenSocket() client.connect(('127.0.0.1', port)) try: client.settimeout(0.00001) msg = s2b("A") * (100000) # large enough number to overwhelm most buffers total_sent = 0 # want to exceed the size of the OS buffer so it'll block in a # single send for x in range(10): total_sent += client.send(msg) self.fail("socket.timeout not raised") except socket.timeout, e: self.assert_(hasattr(e, 'args')) self.assertEqual(e.args[1], 'timed out')
def test_client(): c = eventlet.connect(('localhost', l.getsockname()[1])) # verify the client is connected by getting data self.assertEquals(s2b('hi'), c.recv(2)) return c
def waiter(sock, addr): sock.sendall(s2b('hi')) evt.wait()
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 sender(listener): (sock, addr) = listener.accept() sock = bufsized(sock, size=bufsize) sock.sendall(s2b('x')*many_bytes) sock.sendall(s2b('y')*second_bytes)
def waiter(sock, addr): sock.sendall(s2b("hi")) evt.wait()