def test_communication_direct(self):
"""Test communication direct (i.e. both clients registered to same peer)."""
for i in range(len(PUBLIC_DHT_DELEGATE_URIS)):
uri = PUBLIC_DHT_DELEGATE_URIS[i]
peer_public_key = PUBLIC_DHT_PUBLIC_KEYS[i]
multiplexers = []
try:
temp_dir_1 = os.path.join(self.t, f"dir_{i}_1")
os.mkdir(temp_dir_1)
connection1 = _make_libp2p_client_connection(
peer_public_key=peer_public_key, uri=uri, data_dir=temp_dir_1
)
multiplexer1 = Multiplexer([connection1])
multiplexer1.connect()
multiplexers.append(multiplexer1)
temp_dir_2 = os.path.join(self.t, f"dir_{i}_2")
os.mkdir(temp_dir_2)
connection2 = _make_libp2p_client_connection(
peer_public_key=peer_public_key, uri=uri, data_dir=temp_dir_2
)
multiplexer2 = Multiplexer([connection2])
multiplexer2.connect()
multiplexers.append(multiplexer2)
addr_1 = connection1.address
addr_2 = connection2.address
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
envelope = Envelope(to=addr_2, sender=addr_1, message=msg,)
multiplexer1.put(envelope)
delivered_envelope = multiplexer2.get(block=True, timeout=20)
assert delivered_envelope is not None
assert delivered_envelope.to == envelope.to
assert delivered_envelope.sender == envelope.sender
assert (
delivered_envelope.protocol_specification_id
== envelope.protocol_specification_id
)
assert delivered_envelope.message != envelope.message
msg = DefaultMessage.serializer.decode(delivered_envelope.message)
msg.to = delivered_envelope.to
msg.sender = delivered_envelope.sender
assert envelope.message == msg
except Exception:
raise
finally:
for mux in multiplexers:
mux.disconnect()
def test_communication_indirect(self):
assert (len(PUBLIC_DHT_DELEGATE_URIS) >
1), "Test requires at least 2 public dht node"
for i in range(len(PUBLIC_DHT_DELEGATE_URIS)):
connection1 = _make_libp2p_client_connection(
uri=PUBLIC_DHT_DELEGATE_URIS[i])
multiplexer1 = Multiplexer([connection1])
multiplexer1.connect()
addr_1 = connection1.address
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
for j in range(len(PUBLIC_DHT_DELEGATE_URIS)):
if j == i:
continue
connection2 = _make_libp2p_client_connection(
uri=PUBLIC_DHT_DELEGATE_URIS[j])
multiplexer2 = Multiplexer([connection2])
multiplexer2.connect()
addr_2 = connection2.address
envelope = Envelope(
to=addr_2,
sender=addr_1,
protocol_id=DefaultMessage.protocol_id,
message=msg,
)
multiplexer1.put(envelope)
delivered_envelope = multiplexer2.get(block=True, timeout=20)
try:
assert delivered_envelope is not None
assert delivered_envelope.to == envelope.to
assert delivered_envelope.sender == envelope.sender
assert delivered_envelope.protocol_id == envelope.protocol_id
assert delivered_envelope.message != envelope.message
msg = DefaultMessage.serializer.decode(
delivered_envelope.message)
assert envelope.message == msg
except Exception:
multiplexer1.disconnect()
raise
finally:
multiplexer2.disconnect()
multiplexer1.disconnect()
def test_communication_direct(self):
"""Test communication direct."""
for uri in PUBLIC_DHT_DELEGATE_URIS:
multiplexers = []
try:
connection1 = _make_libp2p_client_connection(uri=uri)
multiplexer1 = Multiplexer([connection1])
multiplexer1.connect()
multiplexers.append(multiplexer1)
connection2 = _make_libp2p_client_connection(uri=uri)
multiplexer2 = Multiplexer([connection2])
multiplexer2.connect()
multiplexers.append(multiplexer2)
addr_1 = connection1.address
addr_2 = connection2.address
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
envelope = Envelope(
to=addr_2,
sender=addr_1,
protocol_id=DefaultMessage.protocol_id,
message=msg,
)
multiplexer1.put(envelope)
delivered_envelope = multiplexer2.get(block=True, timeout=20)
assert delivered_envelope is not None
assert delivered_envelope.to == envelope.to
assert delivered_envelope.sender == envelope.sender
assert delivered_envelope.protocol_id == envelope.protocol_id
assert delivered_envelope.message != envelope.message
msg = DefaultMessage.serializer.decode(
delivered_envelope.message)
msg.to = delivered_envelope.to
msg.sender = delivered_envelope.sender
assert envelope.message == msg
except Exception:
raise
finally:
for mux in multiplexers:
mux.disconnect()
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.mutliplexers = []
cls.connection_node_1 = _make_libp2p_connection(
port=DEFAULT_PORT + 1,
delegate_port=DEFAULT_DELEGATE_PORT + 1,
delegate=True,
)
cls.multiplexer_node_1 = Multiplexer([cls.connection_node_1])
cls.log_files.append(cls.connection_node_1.node.log_file)
cls.multiplexer_node_1.connect()
cls.mutliplexers.append(cls.multiplexer_node_1)
genesis_peer = cls.connection_node_1.node.multiaddrs[0]
try:
cls.connection_node_2 = _make_libp2p_connection(
port=DEFAULT_PORT + 2,
delegate_port=DEFAULT_DELEGATE_PORT + 2,
entry_peers=[genesis_peer],
delegate=True,
)
cls.multiplexer_node_2 = Multiplexer([cls.connection_node_2])
cls.log_files.append(cls.connection_node_2.node.log_file)
cls.multiplexer_node_2.connect()
cls.mutliplexers.append(cls.multiplexer_node_2)
cls.connection_client_1 = _make_libp2p_client_connection(
DEFAULT_DELEGATE_PORT + 1
)
cls.multiplexer_client_1 = Multiplexer([cls.connection_client_1])
cls.multiplexer_client_1.connect()
cls.mutliplexers.append(cls.multiplexer_client_1)
cls.connection_client_2 = _make_libp2p_client_connection(
DEFAULT_DELEGATE_PORT + 2
)
cls.multiplexer_client_2 = Multiplexer([cls.connection_client_2])
cls.multiplexer_client_2.connect()
cls.mutliplexers.append(cls.multiplexer_client_2)
except Exception:
cls.teardown_class()
raise
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.multiplexers = []
temp_node_dir = os.path.join(cls.t, "node_dir")
os.mkdir(temp_node_dir)
try:
cls.connection_node = _make_libp2p_connection(
data_dir=temp_node_dir, delegate=True
)
cls.multiplexer_node = Multiplexer([cls.connection_node])
cls.log_files.append(cls.connection_node.node.log_file)
cls.multiplexer_node.connect()
cls.multiplexers.append(cls.multiplexer_node)
temp_client_dir = os.path.join(cls.t, "client_dir")
os.mkdir(temp_client_dir)
cls.connection_client = _make_libp2p_client_connection(
data_dir=temp_client_dir, peer_public_key=cls.connection_node.node.pub
)
cls.multiplexer_client = Multiplexer([cls.connection_client])
cls.multiplexer_client.connect()
cls.multiplexers.append(cls.multiplexer_client)
except Exception:
cls.teardown_class()
raise
async def test_node_not_running(self):
"""Test the node is not running."""
with tempfile.TemporaryDirectory() as dirname:
conn = _make_libp2p_client_connection(
data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key
)
with pytest.raises(Exception):
await conn.connect()
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.connection_node = _make_libp2p_connection(delegate=True)
cls.connection = _make_libp2p_client_connection()
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
temp_dir = os.path.join(cls.t, "temp_dir_node")
os.mkdir(temp_dir)
cls.connection_node = _make_libp2p_connection(data_dir=temp_dir,
port=DEFAULT_PORT + 1,
delegate=True)
cls.multiplexer_node = Multiplexer(
[cls.connection_node], protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection_node.node.log_file)
cls.multiplexer_node.connect()
try:
temp_dir_client_1 = os.path.join(cls.t, "temp_dir_client_1")
os.mkdir(temp_dir_client_1)
cls.connection_client_1 = _make_libp2p_client_connection(
data_dir=temp_dir_client_1,
peer_public_key=cls.connection_node.node.pub,
ledger_api_id=FetchAICrypto.identifier,
)
cls.multiplexer_client_1 = Multiplexer(
[cls.connection_client_1],
protocols=[MockDefaultMessageProtocol])
cls.multiplexer_client_1.connect()
temp_dir_client_2 = os.path.join(cls.t, "temp_dir_client_2")
os.mkdir(temp_dir_client_2)
cls.connection_client_2 = _make_libp2p_client_connection(
data_dir=temp_dir_client_2,
peer_public_key=cls.connection_node.node.pub,
ledger_api_id=EthereumCrypto.identifier,
)
cls.multiplexer_client_2 = Multiplexer(
[cls.connection_client_2],
protocols=[MockDefaultMessageProtocol])
cls.multiplexer_client_2.connect()
except Exception:
cls.multiplexer_node.disconnect()
raise
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.connection_node = _make_libp2p_connection(DEFAULT_PORT + 1,
delegate=True)
cls.multiplexer_node = Multiplexer([cls.connection_node])
cls.log_files.append(cls.connection_node.node.log_file)
cls.multiplexer_node.connect()
cls.connection_client_1 = _make_libp2p_client_connection()
cls.multiplexer_client_1 = Multiplexer([cls.connection_client_1])
cls.multiplexer_client_1.connect()
cls.connection_client_2 = _make_libp2p_client_connection()
cls.multiplexer_client_2 = Multiplexer([cls.connection_client_2])
cls.multiplexer_client_2.connect()
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.multiplexers = []
try:
cls.connection_node_1 = _make_libp2p_connection(
port=DEFAULT_PORT + 1,
delegate_port=DEFAULT_DELEGATE_PORT + 1,
delegate=True,
)
cls.multiplexer_node_1 = Multiplexer([cls.connection_node_1])
cls.log_files.append(cls.connection_node_1.node.log_file)
cls.multiplexer_node_1.connect()
cls.multiplexers.append(cls.multiplexer_node_1)
entry_peer = cls.connection_node_1.node.multiaddrs[0]
cls.connection_node_2 = _make_libp2p_connection(
port=DEFAULT_PORT + 2,
delegate_port=DEFAULT_DELEGATE_PORT + 2,
entry_peers=[entry_peer],
delegate=True,
)
cls.multiplexer_node_2 = Multiplexer([cls.connection_node_2])
cls.log_files.append(cls.connection_node_2.node.log_file)
cls.multiplexer_node_2.connect()
cls.multiplexers.append(cls.multiplexer_node_2)
cls.connections = [cls.connection_node_1, cls.connection_node_2]
cls.addresses = [
cls.connection_node_1.address,
cls.connection_node_2.address,
]
for _ in range(DEFAULT_CLIENTS_PER_NODE):
for port in [DEFAULT_DELEGATE_PORT + 1, DEFAULT_DELEGATE_PORT + 2]:
conn = _make_libp2p_client_connection(port)
mux = Multiplexer([conn])
cls.connections.append(conn)
cls.addresses.append(conn.address)
mux.connect()
cls.multiplexers.append(mux)
except Exception:
cls.teardown_class()
raise
def test_connectivity(self):
for uri in PUBLIC_DHT_DELEGATE_URIS:
connection = _make_libp2p_client_connection(uri=uri)
multiplexer = Multiplexer([connection])
multiplexer.connect()
try:
assert (connection.is_connected is
True), "Couldn't connect to public node {}".format(uri)
except Exception:
raise
finally:
multiplexer.disconnect()
async def test_reconnect_on_receive_fail():
"""Test reconnect on receive fails."""
with tempfile.TemporaryDirectory() as dirname:
con = _make_libp2p_client_connection(
data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key
)
mock_reader = Mock()
mock_reader.readexactly.side_effect = ConnectionError("oops")
con._reader = mock_reader
con._in_queue = Mock()
with patch.object(
con, "_perform_connection_to_node", return_value=done_future
) as connect_mock:
assert await con._receive() is None
connect_mock.assert_called()
async def test_connect_attempts():
"""Test connect attempts."""
# test connects
with tempfile.TemporaryDirectory() as dirname:
con = _make_libp2p_client_connection(
data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key
)
con.connect_retries = 2
with patch(
"asyncio.open_connection",
side_effect=Exception("test exception on connect"),
) as open_connection_mock:
with pytest.raises(Exception, match="test exception on connect"):
await con.connect()
assert open_connection_mock.call_count == con.connect_retries
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
temp_dir = os.path.join(cls.t, "temp_dir_node")
os.mkdir(temp_dir)
cls.connection_node = _make_libp2p_connection(data_dir=temp_dir,
delegate=True)
temp_dir_client = os.path.join(cls.t, "temp_dir_client")
os.mkdir(temp_dir_client)
cls.connection = _make_libp2p_client_connection(
data_dir=temp_dir_client,
peer_public_key=cls.connection_node.node.pub)
async def test_reconnect_on_send_fail():
"""Test reconnect on send fails."""
with tempfile.TemporaryDirectory() as dirname:
con = _make_libp2p_client_connection(
data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key
)
# test reconnect on send fails
with patch.object(
con, "_perform_connection_to_node", return_value=done_future
) as connect_mock, patch.object(
con, "_ensure_valid_envelope_for_external_comms"
):
with pytest.raises(ValueError, match="Writer is not set."):
await con.send(Mock())
connect_mock.assert_called()
def test_connectivity(self):
"""Test connectivity."""
for i in range(len(PUBLIC_DHT_DELEGATE_URIS)):
uri = PUBLIC_DHT_DELEGATE_URIS[i]
peer_public_key = PUBLIC_DHT_PUBLIC_KEYS[i]
temp_dir = os.path.join(self.t, f"dir_{i}")
os.mkdir(temp_dir)
connection = _make_libp2p_client_connection(
peer_public_key=peer_public_key, uri=uri, data_dir=temp_dir
)
multiplexer = Multiplexer([connection])
try:
multiplexer.connect()
assert (
connection.is_connected is True
), "Couldn't connect to public node {}".format(uri)
except Exception:
raise
finally:
multiplexer.disconnect()
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.multiplexers = []
try:
cls.connection_node = _make_libp2p_connection(delegate=True)
cls.multiplexer_node = Multiplexer([cls.connection_node])
cls.log_files.append(cls.connection_node.node.log_file)
cls.multiplexer_node.connect()
cls.multiplexers.append(cls.multiplexer_node)
cls.connection_client = _make_libp2p_client_connection()
cls.multiplexer_client = Multiplexer([cls.connection_client])
cls.multiplexer_client.connect()
cls.multiplexers.append(cls.multiplexer_client)
except Exception:
cls.teardown_class()
raise
async def test_node_not_running(self):
conn = _make_libp2p_client_connection()
with pytest.raises(Exception):
await conn.connect()
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.mutliplexers = []
temp_dir_node_1 = os.path.join(cls.t, "temp_dir_node_1")
os.mkdir(temp_dir_node_1)
cls.connection_node_1 = _make_libp2p_connection(
data_dir=temp_dir_node_1,
port=DEFAULT_PORT + 1,
delegate_port=DEFAULT_DELEGATE_PORT + 1,
delegate=True,
)
cls.multiplexer_node_1 = Multiplexer(
[cls.connection_node_1], protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection_node_1.node.log_file)
cls.multiplexer_node_1.connect()
cls.mutliplexers.append(cls.multiplexer_node_1)
genesis_peer = cls.connection_node_1.node.multiaddrs[0]
temp_dir_node_2 = os.path.join(cls.t, "temp_dir_node_2")
os.mkdir(temp_dir_node_2)
try:
cls.connection_node_2 = _make_libp2p_connection(
data_dir=temp_dir_node_2,
port=DEFAULT_PORT + 2,
delegate_port=DEFAULT_DELEGATE_PORT + 2,
entry_peers=[genesis_peer],
delegate=True,
)
cls.multiplexer_node_2 = Multiplexer(
[cls.connection_node_2],
protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection_node_2.node.log_file)
cls.multiplexer_node_2.connect()
cls.mutliplexers.append(cls.multiplexer_node_2)
temp_dir_client_1 = os.path.join(cls.t, "temp_dir_client_1")
os.mkdir(temp_dir_client_1)
cls.connection_client_1 = _make_libp2p_client_connection(
data_dir=temp_dir_client_1,
peer_public_key=cls.connection_node_1.node.pub,
node_port=DEFAULT_DELEGATE_PORT + 1,
)
cls.multiplexer_client_1 = Multiplexer(
[cls.connection_client_1],
protocols=[MockDefaultMessageProtocol])
cls.multiplexer_client_1.connect()
cls.mutliplexers.append(cls.multiplexer_client_1)
temp_dir_client_2 = os.path.join(cls.t, "temp_dir_client_2")
os.mkdir(temp_dir_client_2)
cls.connection_client_2 = _make_libp2p_client_connection(
data_dir=temp_dir_client_2,
peer_public_key=cls.connection_node_2.node.pub,
node_port=DEFAULT_DELEGATE_PORT + 2,
)
cls.multiplexer_client_2 = Multiplexer(
[cls.connection_client_2],
protocols=[MockDefaultMessageProtocol])
cls.multiplexer_client_2.connect()
cls.mutliplexers.append(cls.multiplexer_client_2)
except Exception:
cls.teardown_class()
raise
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.multiplexers = []
try:
temp_dir_node_1 = os.path.join(cls.t, "temp_dir_node_1")
os.mkdir(temp_dir_node_1)
cls.connection_node_1 = _make_libp2p_connection(
data_dir=temp_dir_node_1,
port=DEFAULT_PORT + 1,
delegate_port=DEFAULT_DELEGATE_PORT + 1,
delegate=True,
)
cls.multiplexer_node_1 = Multiplexer(
[cls.connection_node_1],
protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection_node_1.node.log_file)
cls.multiplexer_node_1.connect()
cls.multiplexers.append(cls.multiplexer_node_1)
entry_peer = cls.connection_node_1.node.multiaddrs[0]
temp_dir_node_2 = os.path.join(cls.t, "temp_dir_node_2")
os.mkdir(temp_dir_node_2)
cls.connection_node_2 = _make_libp2p_connection(
data_dir=temp_dir_node_2,
port=DEFAULT_PORT + 2,
delegate_port=DEFAULT_DELEGATE_PORT + 2,
entry_peers=[entry_peer],
delegate=True,
)
cls.multiplexer_node_2 = Multiplexer(
[cls.connection_node_2],
protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection_node_2.node.log_file)
cls.multiplexer_node_2.connect()
cls.multiplexers.append(cls.multiplexer_node_2)
cls.connections = [cls.connection_node_1, cls.connection_node_2]
cls.addresses = [
cls.connection_node_1.address,
cls.connection_node_2.address,
]
for j in range(DEFAULT_CLIENTS_PER_NODE):
ports = [DEFAULT_DELEGATE_PORT + 1, DEFAULT_DELEGATE_PORT + 2]
peers_public_keys = [
cls.connection_node_1.node.pub,
cls.connection_node_2.node.pub,
]
for i in range(len(ports)):
port = ports[i]
peer_public_key = peers_public_keys[i]
temp_dir_client = os.path.join(
cls.t, f"temp_dir_client__{j}_{i}")
os.mkdir(temp_dir_client)
conn = _make_libp2p_client_connection(
data_dir=temp_dir_client,
peer_public_key=peer_public_key,
node_port=port,
)
mux = Multiplexer([conn],
protocols=[MockDefaultMessageProtocol])
cls.connections.append(conn)
cls.addresses.append(conn.address)
mux.connect()
cls.multiplexers.append(mux)
except Exception:
cls.teardown_class()
raise
