def test_star_routing_connectivity(self):
"""Test routing with star connectivity."""
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
for source in range(len(self.multiplexers)):
for destination in range(len(self.multiplexers)):
if destination == source:
continue
envelope = Envelope(
to=self.addresses[destination],
sender=self.addresses[source],
protocol_id=DefaultMessage.protocol_id,
message=DefaultSerializer().encode(msg),
)
self.multiplexers[source].put(envelope)
delivered_envelope = self.multiplexers[destination].get(
block=True, timeout=10
)
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
def test_envelope_echoed_back_node_agent(self):
"""Test the envelope is echoed back node agent."""
addr_1 = self.connection_client_1.address
addr_n = self.connection_node_2.address
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
original_envelope = Envelope(
to=addr_n,
sender=addr_1,
protocol_id=DefaultMessage.protocol_id,
message=DefaultSerializer().encode(msg),
)
self.multiplexer_client_1.put(original_envelope)
delivered_envelope = self.multiplexer_node_2.get(block=True, timeout=10)
assert delivered_envelope is not None
delivered_envelope.to = addr_1
delivered_envelope.sender = addr_n
self.multiplexer_node_2.put(delivered_envelope)
echoed_envelope = self.multiplexer_client_1.get(block=True, timeout=5)
assert echoed_envelope is not None
assert echoed_envelope.to == original_envelope.sender
assert delivered_envelope.sender == original_envelope.to
assert delivered_envelope.protocol_id == original_envelope.protocol_id
assert delivered_envelope.message == original_envelope.message
def test_envelope_routed(self):
"""Test the envelope is routed."""
addr_1 = self.connection_client_1.address
addr_2 = self.connection_client_2.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=DefaultSerializer().encode(msg),
)
self.multiplexer_client_1.put(envelope)
delivered_envelope = self.multiplexer_client_2.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
def dummy_envelope(
cls, to: str = "test", sender: str = "test", message: Message = None,
) -> Envelope:
"""
Create envelope, if message is not passed use .dummy_message method.
:param to: the address of the receiver.
:param sender: the address of the sender.
:param protocol_id: the protocol id.
:param message: the protocol-specific message.
:return: Envelope
"""
message = message or cls.dummy_default_message()
return Envelope(
to=to,
sender=sender,
protocol_id=DefaultMessage.protocol_id,
message=DefaultSerializer().encode(message),
)
def test_envelope_routed_after_relay_restart(self):
"""Test envelope routed after relay restart."""
addr_1 = self.connection.address
addr_2 = self.genesis.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=DefaultSerializer().encode(msg),
)
self.multiplexer.put(envelope)
delivered_envelope = self.multiplexer_genesis.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_bytes == envelope.message_bytes
self.multiplexer_relay.disconnect()
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"helloAfterRestart",
)
envelope = Envelope(
to=addr_2,
sender=addr_1,
protocol_id=DefaultMessage.protocol_id,
message=DefaultSerializer().encode(msg),
)
self.multiplexer.put(envelope)
time.sleep(5)
TestLibp2pConnectionRelayNodeRestart.relay = _make_libp2p_connection(
port=DEFAULT_PORT + 2,
entry_peers=[self.genesis.node.multiaddrs[0]],
node_key_file=self.relay_key_path,
)
TestLibp2pConnectionRelayNodeRestart.multiplexer_relay = Multiplexer(
[self.relay])
self.multiplexer_relay.connect()
TestLibp2pConnectionRelayNodeRestart.multiplexers.append(
self.multiplexer_relay)
delivered_envelope = self.multiplexer_genesis.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_bytes == envelope.message_bytes
def test_envelope_routed_after_peer_changed(self):
"""Test envelope routed after peer changed."""
addr_1 = self.connection1.address
addr_2 = self.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=DefaultSerializer().encode(msg),
)
self.multiplexer1.put(envelope)
delivered_envelope = self.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_bytes == envelope.message_bytes
self.multiplexer2.disconnect()
TestLibp2pConnectionAgentMobility.connection2 = _make_libp2p_connection(
port=DEFAULT_PORT + 2,
entry_peers=[self.genesis.node.multiaddrs[0]],
agent_address=self.connection_addr,
)
TestLibp2pConnectionAgentMobility.multiplexer2 = Multiplexer(
[self.connection2])
self.multiplexer2.connect()
TestLibp2pConnectionAgentMobility.multiplexers.append(
self.multiplexer2)
time.sleep(3)
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"helloAfterChangingPeer",
)
envelope = Envelope(
to=addr_2,
sender=addr_1,
protocol_id=msg.protocol_id,
message=msg.encode(),
)
self.multiplexer1.put(envelope)
delivered_envelope = self.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_bytes == envelope.message_bytes
def test_handle():
"""Tests handle method of an agent."""
with LocalNode() as node:
agent_name = "MyAgent"
private_key_path = os.path.join(CUR_PATH, "data",
DEFAULT_PRIVATE_KEY_FILE)
builder = AEABuilder()
builder.set_name(agent_name)
builder.add_private_key(DEFAULT_LEDGER, private_key_path)
builder.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"))
builder.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "local"))
local_connection_id = OEFLocalConnection.connection_id
builder.set_default_connection(local_connection_id)
builder.add_skill(Path(CUR_PATH, "data", "dummy_skill"))
aea = builder.build(connection_ids=[local_connection_id])
# This is a temporary workaround to feed the local node to the OEF Local connection
# TODO remove it.
local_connection = aea.resources.get_connection(local_connection_id)
local_connection._local_node = node
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
msg.to = aea.identity.address
msg.sender = aea.identity.address
encoded_msg = DefaultSerializer.encode(msg)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=msg,
)
with run_in_thread(aea.start, timeout=5):
wait_for_condition(lambda: aea.is_running, timeout=10)
dummy_skill = aea.resources.get_skill(DUMMY_SKILL_PUBLIC_ID)
dummy_handler = dummy_skill.handlers["dummy"]
aea.outbox.put(envelope)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 1,
timeout=1,
)
# DECODING ERROR
envelope = Envelope(
to=aea.identity.address,
sender=aea.identity.address,
protocol_id=DefaultMessage.protocol_id,
message=b"",
)
# send envelope via localnode back to agent/bypass `outbox` put consistency checks
aea.outbox._multiplexer.put(envelope)
""" inbox twice cause first message is invalid. generates error message and it accepted """
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 2,
timeout=1,
)
# UNSUPPORTED SKILL
msg = FipaMessage(
performative=FipaMessage.Performative.ACCEPT,
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
)
msg.to = aea.identity.address
msg.sender = aea.identity.address
envelope = Envelope(
to=msg.to,
sender=msg.sender,
protocol_id=msg.protocol_id,
message=msg,
)
# send envelope via localnode back to agent
aea.outbox.put(envelope)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 3,
timeout=2,
)
# DECODING OK
envelope = Envelope(
to=msg.to,
sender=msg.sender,
protocol_id=DefaultMessage.protocol_id,
message=encoded_msg,
)
# send envelope via localnode back to agent/bypass `outbox` put consistency checks
aea.outbox._multiplexer.put(envelope)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 4,
timeout=1,
)
aea.stop()
def test_envelope_routed_after_peer_changed(self):
"""Test envelope routed after peer changed."""
addr_1 = self.connection1.address
addr_2 = self.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_specification_id=DefaultMessage.protocol_specification_id,
message=DefaultSerializer().encode(msg),
)
self.multiplexer1.put(envelope)
delivered_envelope = self.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_bytes == envelope.message_bytes
self.multiplexer2.disconnect()
self.change_state_and_wait(self.multiplexer2,
expected_is_connected=False)
# currently, multiplexer cannot be restarted
self.multiplexer2 = Multiplexer([self.connection2],
protocols=[DefaultMessage])
self.multiplexer2.connect()
self.change_state_and_wait(self.multiplexer2,
expected_is_connected=True)
self.multiplexers.append(self.multiplexer2)
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"helloAfterChangingPeer",
)
envelope = Envelope(
to=addr_2,
sender=addr_1,
protocol_specification_id=msg.protocol_specification_id,
message=msg.encode(),
)
self.multiplexer1.put(envelope)
delivered_envelope = self.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_bytes == envelope.message_bytes
def test_envelope_routed_after_relay_restart(self):
"""Test envelope routed after relay restart."""
addr_1 = self.connection.address
addr_2 = self.genesis.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_specification_id=DefaultMessage.protocol_specification_id,
message=DefaultSerializer().encode(msg),
)
self.multiplexer.put(envelope)
delivered_envelope = self.multiplexer_genesis.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_bytes == envelope.message_bytes
self.multiplexer_relay.disconnect()
self.change_state_and_wait(self.multiplexer_relay,
expected_is_connected=False)
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"helloAfterRestart",
)
envelope = Envelope(
to=addr_2,
sender=addr_1,
protocol_specification_id=DefaultMessage.protocol_specification_id,
message=DefaultSerializer().encode(msg),
)
self.multiplexer.put(envelope)
time.sleep(5)
# currently, multiplexer cannot be restarted
self.multiplexer_relay = Multiplexer([self.relay],
protocols=[DefaultMessage])
self.multiplexer_relay.connect()
self.change_state_and_wait(self.multiplexer_relay,
expected_is_connected=True)
self.multiplexers.append(self.multiplexer_relay)
delivered_envelope = self.multiplexer_genesis.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_bytes == envelope.message_bytes