def test_recv_into (self):
self.reset_timeout(100000)
listener = sockets.GreenSocket()
listener.bind(('', 0))
listener.listen(50)
address, port = listener.getsockname()
self.assertNotEquals(address, 0)
accepting = event.Event()
received = event.Event()
sent_data = '1234567890'
def server ():
# accept the connection in another greenlet
accepting.send()
sock, addr = listener.accept()
sock.send(sent_data)
def client ():
buf = buffer(array.array('B'))
client = sockets.GreenSocket()
accepting.wait()
sleep(0.5)
client.connect(('127.0.0.1', port))
client.recv_into(buf, 5000)
received.send(buf)
waitall(spawn(client), spawn(server))
received_data = received.wait()
self.assertEquals(sent_data, received_data)
def test_recv_into(self):
self.reset_timeout(100000)
listener = sockets.GreenSocket()
listener.bind(('', 0))
listener.listen(50)
address, port = listener.getsockname()
self.assertNotEquals(address, 0)
accepting = event.Event()
received = event.Event()
sent_data = '1234567890'
def server():
# accept the connection in another greenlet
accepting.send()
sock, addr = listener.accept()
sock.send(sent_data)
def client():
buf = buffer(array.array('B'))
client = sockets.GreenSocket()
accepting.wait()
sleep(0.5)
client.connect(('127.0.0.1', port))
client.recv_into(buf, 5000)
received.send(buf)
waitall(spawn(client), spawn(server))
received_data = received.wait()
self.assertEquals(sent_data, received_data)
def test_send_something(self):
listener = convenience.listen(('', 0))
_, listener_port = listener.getsockname()
def server():
# accept the connection in another greenlet
sock, addr = listener.accept()
data = ''
while True:
last_data = sock.recv(1000)
if not last_data:
break
data += last_data
return data
def client():
client = sockets.GreenSocket()
client.connect(('127.0.0.1', listener_port))
msg = 'hhheeeeelloooooo'
total_sent = 0
client.send(msg)
return msg
res = waitall(spawn(client), spawn(server))
self.assertEquals(res[0], res[1])
def test_send_many(self):
listener = convenience.listen(('', 0))
_, listener_port = listener.getsockname()
def server():
# accept the connection in another greenlet
sock, addr = listener.accept()
total_recv = 0
while True:
data = sock.recv(1000)
if not data:
break
total_recv += len(data)
return total_recv
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
res = waitall(spawn(client), spawn(server))
self.assertEqual(res[0], res[1])
def test_send_many (self):
listener = convenience.listen(('', 0))
_, listener_port = listener.getsockname()
def server ():
# accept the connection in another greenlet
sock, addr = listener.accept()
total_recv = 0
while True:
data = sock.recv(1000)
if not data:
break
total_recv += len(data)
return total_recv
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
res = waitall(spawn(client), spawn(server))
self.assertEqual(res[0], res[1])
def test_send_something (self):
listener = convenience.listen(('', 0))
_, listener_port = listener.getsockname()
def server ():
# accept the connection in another greenlet
sock, addr = listener.accept()
data = ''
while True:
last_data = sock.recv(1000)
if not last_data:
break
data += last_data
return data
def client ():
client = sockets.GreenSocket()
client.connect(('127.0.0.1', listener_port))
msg = 'hhheeeeelloooooo'
total_sent = 0
client.send(msg)
return msg
res = waitall(spawn(client), spawn(server))
self.assertEquals(res[0], res[1])
def test_sendall_impl(many_bytes):
bufsize = max(many_bytes // 15, 2)
received = event.Event()
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(("", 0))
listener.listen(50)
_, listener_port = listener.getsockname()
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 receiver():
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', listener_port))
total = 0
while total < many_bytes:
data = client.recv(
min(many_bytes - total, many_bytes // 10))
if not data:
break
total += len(data)
total2 = 0
while total < second_bytes:
data = client.recv(second_bytes)
if not data:
break
total2 += len(data)
received.send()
waitall(spawn(sender, listener), spawn(receiver))
def test_sendall_impl (many_bytes):
bufsize = max(many_bytes // 15, 2)
received = event.Event()
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(("", 0))
listener.listen(50)
_, listener_port = listener.getsockname()
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 receiver ():
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', listener_port))
total = 0
while total < many_bytes:
data = client.recv(min(many_bytes - total, many_bytes // 10))
if not data:
break
total += len(data)
total2 = 0
while total < second_bytes:
data = client.recv(second_bytes)
if not data:
break
total2 += len(data)
received.send()
waitall(spawn(sender, listener), spawn(receiver))
def test_recv (self):
listener = sockets.GreenSocket()
listener.bind(('', 0))
listener.listen(50)
address, port = listener.getsockname()
self.assertNotEquals(address, 0)
accepting = event.Event()
received = event.Event()
sent_data = '1234567890'
def server ():
# accept the connection in another greenlet
accepting.send()
sock, addr = listener.accept()
sock.send(sent_data)
gt_server = spawn(server)
def client ():
client = sockets.GreenSocket()
accepting.wait()
sleep(0.5)
client.connect(('127.0.0.1', port))
received_data = client.recv(5000)
received.send(received_data)
gt_client = spawn(client)
waitall(gt_client, gt_server)
received_data = received.wait()
self.assertEquals(sent_data, received_data)
def test_recv(self):
listener = sockets.GreenSocket()
listener.bind(('', 0))
listener.listen(50)
address, port = listener.getsockname()
self.assertNotEquals(address, 0)
accepting = event.Event()
received = event.Event()
sent_data = '1234567890'
def server():
# accept the connection in another greenlet
accepting.send()
sock, addr = listener.accept()
sock.send(sent_data)
gt_server = spawn(server)
def client():
client = sockets.GreenSocket()
accepting.wait()
sleep(0.5)
client.connect(('127.0.0.1', port))
received_data = client.recv(5000)
received.send(received_data)
gt_client = spawn(client)
waitall(gt_client, gt_server)
received_data = received.wait()
self.assertEquals(sent_data, received_data)
def test_multiple_waiters(self):
self.reset_timeout(100000000)
# tests that multiple waiters get their results back
q = Queue()
sendings = ['1', '2', '3', '4']
gts = [spawn(q.join) for x in sendings]
sleep(0.01) # get 'em all waiting
q.put(sendings[0])
q.put(sendings[1])
q.put(sendings[2])
q.put(sendings[3])
results = waitall(*gts)
self.assertEquals(sorted(results), sorted(sendings))
def test_multiple_waiters (self):
self.reset_timeout(100000000)
# tests that multiple waiters get their results back
q = Queue()
sendings = ['1', '2', '3', '4']
gts = [spawn(q.join) for x in sendings]
sleep(0.01) # get 'em all waiting
q.put(sendings[0])
q.put(sendings[1])
q.put(sendings[2])
q.put(sendings[3])
results = waitall(*gts)
self.assertEquals(sorted(results), sorted(sendings))
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')
finally:
evt.send()
waitall(spawn(client), spawn(server))
def test_sendall_timeout(self):
listener = sockets.GreenSocket()
listener.bind(('', 0))
listener.listen(50)
evt = event.Event()
def server():
# accept the connection in another greenlet
sock, addr = listener.accept()
evt.wait()
gt = spawn(server)
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')
finally:
evt.send()
waitall(spawn(client), spawn(server))
def test_sendall_timeout (self):
listener = sockets.GreenSocket()
listener.bind(('', 0))
listener.listen(50)
evt = event.Event()
def server ():
# accept the connection in another greenlet
sock, addr = listener.accept()
evt.wait()
gt = spawn(server)
