def test_e2e_single_session_large_message_client_close(self):
server = rcp.RCPRouter(("127.0.0.1", 12345))
client = rcp.RCPRouter(("127.0.0.1", 12346))
server.listen()
client_sock = client.connect(("127.0.0.1", 12345))
server_sock = server.accept()
random.seed()
client_message = random.randbytes(
10 * 128 * 32) # should ensure 10 sliding windows
client_sock.send(client_message)
server_message = random.randbytes(
10 * 128 * 32) # should ensure 10 sliding windows
server_sock.send(server_message)
client_sock.close()
server_received = server_sock.read()
self.assertEqual(client_message, server_received)
client_received = client_sock.read()
self.assertEqual(server_message, client_received)
server.close()
client.close()
def test_e2e_multi_session_small_message_client_close(self):
server = rcp.RCPRouter(("127.0.0.1", 12345))
client_a = rcp.RCPRouter(("127.0.0.1", 12346))
client_b = rcp.RCPRouter(("127.0.0.1", 12347))
server.listen()
client_a_sock = client_a.connect(("127.0.0.1", 12345))
server_a_sock = server.accept()
client_b_sock = client_b.connect(("127.0.0.1", 12345))
server_b_sock = server.accept()
client_a_sock.send(b'Hello, server from client a!')
client_b_sock.send(b'Hello, server from client b!')
self.assertEqual(b'Hello, server from client b!', server_b_sock.recv())
self.assertEqual(b'Hello, server from client a!', server_a_sock.recv())
server_a_sock.send(b'Hello, client a!')
server_b_sock.send(b'Hello, client b!')
self.assertEqual(b'Hello, client a!', client_a_sock.recv())
self.assertEqual(b'Hello, client b!', client_b_sock.recv())
client_a_sock.close()
client_b_sock.close()
self.assertEqual(b'', client_a_sock.recv())
self.assertEqual(b'', server_a_sock.recv())
self.assertEqual(b'', client_b_sock.recv())
self.assertEqual(b'', server_b_sock.recv())
server.close()
client_a.close()
client_b.close()
def main():
logging.basicConfig(level=logging.DEBUG)
addr, port = sys.argv[1:]
router = rcp.RCPRouter((addr, int(port)))
logger.info(f"Starting RCP Echo Server at {addr}:{port}")
router.listen()
listen_and_serve(router)
def test_e2e_single_session_small_message_server_close(self):
server = rcp.RCPRouter(("127.0.0.1", 12345))
client = rcp.RCPRouter(("127.0.0.1", 12346))
server.listen()
client_sock = client.connect(("127.0.0.1", 12345))
server_sock = server.accept()
client_sock.send(b'Hello, server!')
self.assertEqual(b'Hello, server!', server_sock.recv())
server_sock.send(b'Hello, client!')
self.assertEqual(b'Hello, client!', client_sock.recv())
server_sock.close()
self.assertEqual(b'', client_sock.recv())
self.assertEqual(b'', server_sock.recv())
server.close()
client.close()
def test_e2e_single_session_large_message_over_faulty_socket(self):
server = rcp.RCPRouter(("127.0.0.1", 12345))
client = rcp.RCPRouter(("127.0.0.1", 12346))
server.sock = FaultySocket(server.sock)
client.sock = FaultySocket(client.sock)
server.listen()
client_sock = client.connect(("127.0.0.1", 12345))
server_sock = server.accept()
random.seed()
client_message = random.randbytes(
10 * 128 * 32) # should ensure 10 sliding windows
client_sock.send(client_message)
server_message = random.randbytes(
10 * 128 * 32) # should ensure 10 sliding windows
server_sock.send(server_message)
client_sock.close()
server_received = server_sock.read()
self.assertEqual(client_message, server_received)
client_received = client_sock.read()
self.assertEqual(server_message, client_received)
# because the last ack will likely be dropped, give both sides adequate time to
# close by time out
time.sleep(.3)
self.assertEqual({}, client.sessions)
self.assertEqual({}, server.sessions)
server.close()
client.close()
def main():
src_addr, src_port, dst_addr, dst_port, condition = sys.argv[1:]
router = rcp.RCPRouter((src_addr, int(src_port)))
router.sock = PacketCountingMiddleware(router.sock)
sock = router.connect((dst_addr, int(dst_port)))
time_start = time.time()
random.seed()
sent_hash = hashlib.sha256()
sent_len = 0
for i in range(1000):
to_send = random.randbytes(random.randrange(200, 400))
sent_hash.update(to_send)
sent_len += len(to_send)
sock.send(to_send)
time.sleep(random.randrange(2, 20) / 1000)
recv_hash = hashlib.sha256()
recv_len = 0
while recv_len != sent_len:
msg = sock.recv()
recv_hash.update(msg)
recv_len += len(msg)
total_time_s = time.time() - time_start
sock.close()
router.close()
if recv_hash.hexdigest() == sent_hash.hexdigest():
print(
f"Sent and received {sent_len} bytes. Confirmed hashes match: {sent_hash.hexdigest()}"
)
else:
raise ValueError(
f"Hash mismatch between sent bytes and received bytes: {sent_hash.hexdigest()} != {recv_hash.hexdigest()}"
)
print(
f"Toatal packets sent: {router.sock.total_sends} -- Total packets received: {router.sock.total_recvs}"
)
# packets received isn't meaningful here since we don't know how many packets our peer sent
# so just log the packets sent
_log_datum("results.json", [router.sock.total_sends, total_time_s],
condition)