def test_get_from_multiplexer_when_empty():
"""Test that getting an envelope from the multiplexer when the input queue is empty raises an exception."""
connection = _make_dummy_connection()
multiplexer = Multiplexer([connection])
with pytest.raises(aea.mail.base.Empty):
multiplexer.get()
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
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
port_genesis = DEFAULT_PORT + 10
cls.connection_genesis = _make_libp2p_connection(port_genesis)
cls.multiplexer_genesis = Multiplexer([cls.connection_genesis])
cls.log_files.append(cls.connection_genesis.node.log_file)
cls.multiplexer_genesis.connect()
genesis_peer = cls.connection_genesis.node.multiaddrs[0]
cls.connections = [cls.connection_genesis]
cls.multiplexers = [cls.multiplexer_genesis]
port = port_genesis
for _ in range(DEFAULT_NET_SIZE):
port += 1
conn = _make_libp2p_connection(port=port,
entry_peers=[genesis_peer])
muxer = Multiplexer([conn])
cls.connections.append(conn)
cls.multiplexers.append(muxer)
cls.log_files.append(conn.node.log_file)
muxer.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.connection1 = _make_libp2p_connection(DEFAULT_PORT + 1)
cls.multiplexer1 = Multiplexer([cls.connection1])
cls.log_files.append(cls.connection1.node.log_file)
cls.multiplexer1.connect()
cls.multiplexers.append(cls.multiplexer1)
genesis_peer = cls.connection1.node.multiaddrs[0]
cls.connection2 = _make_libp2p_connection(
port=DEFAULT_PORT + 2, entry_peers=[genesis_peer])
cls.multiplexer2 = Multiplexer([cls.connection2])
cls.log_files.append(cls.connection2.node.log_file)
cls.multiplexer2.connect()
cls.multiplexers.append(cls.multiplexer2)
except Exception as e:
cls.teardown_class()
raise e
def setup_class(cls):
"""Set the test up"""
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t)
cls.log_files = []
cls.relay = _make_libp2p_connection(DEFAULT_PORT + 1)
cls.multiplexer = Multiplexer([cls.relay])
cls.log_files.append(cls.relay.node.log_file)
cls.multiplexer.connect()
relay_peer = cls.relay.node.multiaddrs[0]
cls.connection1 = _make_libp2p_connection(DEFAULT_PORT + 2,
relay=False,
entry_peers=[relay_peer])
cls.multiplexer1 = Multiplexer([cls.connection1])
cls.log_files.append(cls.connection1.node.log_file)
cls.multiplexer1.connect()
cls.connection2 = _make_libp2p_connection(port=DEFAULT_PORT + 3,
entry_peers=[relay_peer])
cls.multiplexer2 = Multiplexer([cls.connection2])
cls.log_files.append(cls.connection2.node.log_file)
cls.multiplexer2.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:
port_relay_1 = DEFAULT_PORT + 10
cls.connection_relay_1 = _make_libp2p_connection(port_relay_1)
cls.multiplexer_relay_1 = Multiplexer([cls.connection_relay_1])
cls.log_files.append(cls.connection_relay_1.node.log_file)
cls.multiplexer_relay_1.connect()
cls.multiplexers.append(cls.multiplexer_relay_1)
relay_peer_1 = cls.connection_relay_1.node.multiaddrs[0]
port_relay_2 = DEFAULT_PORT + 100
cls.connection_relay_2 = _make_libp2p_connection(
port=port_relay_2, entry_peers=[relay_peer_1])
cls.multiplexer_relay_2 = Multiplexer([cls.connection_relay_2])
cls.log_files.append(cls.connection_relay_2.node.log_file)
cls.multiplexer_relay_2.connect()
cls.multiplexers.append(cls.multiplexer_relay_2)
relay_peer_2 = cls.connection_relay_2.node.multiaddrs[0]
cls.connections = [cls.connection_relay_1, cls.connection_relay_2]
port = port_relay_1
for _ in range(int(DEFAULT_NET_SIZE / 2) + 1):
port += 1
conn = _make_libp2p_connection(port=port,
relay=False,
entry_peers=[relay_peer_1])
mux = Multiplexer([conn])
cls.connections.append(conn)
cls.log_files.append(conn.node.log_file)
mux.connect()
cls.multiplexers.append(mux)
port = port_relay_2
for _ in range(int(DEFAULT_NET_SIZE / 2) + 1):
port += 1
conn = _make_libp2p_connection(port=port,
relay=False,
entry_peers=[relay_peer_2])
mux = Multiplexer([conn])
cls.connections.append(conn)
cls.log_files.append(conn.node.log_file)
mux.connect()
cls.multiplexers.append(mux)
except Exception as e:
cls.teardown_class()
raise e
def test_autoset_default_connection():
"""Set default connection automatically."""
connection_1 = _make_dummy_connection()
connection_2 = _make_dummy_connection()
connections = [connection_1, connection_2]
multiplexer = Multiplexer(connections)
multiplexer._default_connection = None
multiplexer._set_default_connection_if_none()
assert multiplexer._default_connection == connections[0]
def setup(self):
"""Set the test up."""
self.connection = _make_oef_connection(
FETCHAI_ADDRESS_ONE,
oef_addr="127.0.0.1",
oef_port=10000,
)
self.multiplexer = Multiplexer([self.connection])
self.multiplexer.connect()
self.oef_search_dialogues = OefSearchDialogues(FETCHAI_ADDRESS_ONE)
def test_protocol_not_resolved():
"""Test multiplexer raises ValueError on protocol not resolved."""
multiplexer = Multiplexer([Mock()])
envelope = Envelope(
to="1",
sender="2",
protocol_specification_id=FipaMessage.protocol_specification_id,
message=b"some bytes",
)
with pytest.raises(ValueError):
multiplexer._get_protocol_id_for_envelope(envelope)
def setup_class(cls):
"""Set up the test class."""
cls.connection1 = _make_oef_connection(
FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000,
)
cls.connection2 = _make_oef_connection(
FETCHAI_ADDRESS_TWO, oef_addr="127.0.0.1", oef_port=10000,
)
cls.multiplexer1 = Multiplexer([cls.connection1])
cls.multiplexer2 = Multiplexer([cls.connection2])
cls.multiplexer1.connect()
cls.multiplexer2.connect()
def test_send_message_no_supported_protocol():
"""Test the case when we send an envelope with a specific connection that does not support the protocol."""
with LocalNode() as node:
identity_1 = Identity("", address="address_1")
connection_1 = _make_local_connection(
identity_1.address,
node,
restricted_to_protocols={DefaultMessage.protocol_id},
excluded_protocols={FipaMessage.protocol_id},
)
multiplexer = Multiplexer(
[connection_1],
protocols=[DefaultMessage, FipaMessage, UnknownProtocolMock])
multiplexer.connect()
with mock.patch.object(multiplexer.logger,
"warning") as mock_logger_warning:
envelope = Envelope(
to=identity_1.address,
sender=identity_1.address,
protocol_specification_id=FipaMessage.
protocol_specification_id,
message=b"some bytes",
)
multiplexer.put(envelope)
time.sleep(0.5)
mock_logger_warning.assert_called_with(
"Connection {} does not support protocol {}. It is explicitly excluded."
.format(connection_1.connection_id, FipaMessage.protocol_id))
with mock.patch.object(multiplexer.logger,
"warning") as mock_logger_warning:
envelope = Envelope(
to=identity_1.address,
sender=identity_1.address,
protocol_specification_id=UnknownProtocolMock.
protocol_specification_id,
message=b"some bytes",
)
multiplexer.put(envelope)
time.sleep(0.5)
mock_logger_warning.assert_called_with(
"Connection {} does not support protocol {}. The connection is restricted to protocols in {}."
.format(
connection_1.connection_id,
UnknownProtocolMock.protocol_id,
connection_1.restricted_to_protocols,
))
multiplexer.disconnect()
def setup(self):
"""Set the test up."""
self.cwd = os.getcwd()
self.tmpdir = Path(tempfile.mkdtemp())
d = self.tmpdir / "test_stub"
d.mkdir(parents=True)
self.input_file_path = d / "input_file.csv"
self.output_file_path = d / "output_file.csv"
self.connection = _make_stub_connection(self.input_file_path,
self.output_file_path)
self.multiplexer = Multiplexer([self.connection])
self.multiplexer.connect()
os.chdir(self.tmpdir)
def test_connect_twice_with_loop():
"""Test that connecting twice the multiplexer behaves correctly."""
running_loop = asyncio.new_event_loop()
thread_loop = Thread(target=running_loop.run_forever)
thread_loop.start()
try:
multiplexer = Multiplexer([_make_dummy_connection()],
loop=running_loop)
with unittest.mock.patch.object(multiplexer.logger,
"debug") as mock_logger_debug:
assert not multiplexer.connection_status.is_connected
multiplexer.connect()
assert multiplexer.connection_status.is_connected
multiplexer.connect()
assert multiplexer.connection_status.is_connected
mock_logger_debug.assert_called_with(
"Multiplexer already connected.")
multiplexer.disconnect()
running_loop.call_soon_threadsafe(running_loop.stop)
finally:
thread_loop.join()
def test_send_message_no_supported_protocol():
"""Test the case when we send an envelope with a specific connection that does not support the protocol."""
with LocalNode() as node:
identity_1 = Identity("", address="address_1")
public_id = PublicId.from_str("fetchai/my_private_protocol:0.1.0")
connection_1 = _make_local_connection(
identity_1.address,
node,
restricted_to_protocols={public_id},
excluded_protocols={public_id},
)
multiplexer = Multiplexer([connection_1])
multiplexer.connect()
with mock.patch.object(aea.mail.base.logger, "warning") as mock_logger_warning:
protocol_id = UNKNOWN_PROTOCOL_PUBLIC_ID
envelope = Envelope(
to=identity_1.address,
sender=identity_1.address,
protocol_id=protocol_id,
message=b"some bytes",
)
multiplexer.put(envelope)
time.sleep(0.5)
mock_logger_warning.assert_called_with(
"Connection {} cannot handle protocol {}. Cannot send the envelope.".format(
connection_1.connection_id, protocol_id
)
)
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.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 = []
try:
temp_dir_rel = os.path.join(cls.t, "temp_dir_rel")
os.mkdir(temp_dir_rel)
cls.relay = _make_libp2p_connection(data_dir=temp_dir_rel,
port=DEFAULT_PORT + 1)
cls.multiplexer = Multiplexer([cls.relay])
cls.log_files.append(cls.relay.node.log_file)
cls.multiplexer.connect()
cls.multiplexers.append(cls.multiplexer)
relay_peer = cls.relay.node.multiaddrs[0]
temp_dir_1 = os.path.join(cls.t, "temp_dir_1")
os.mkdir(temp_dir_1)
cls.connection1 = _make_libp2p_connection(
data_dir=temp_dir_1,
port=DEFAULT_PORT + 2,
relay=False,
entry_peers=[relay_peer],
)
cls.multiplexer1 = Multiplexer(
[cls.connection1], protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection1.node.log_file)
cls.multiplexer1.connect()
cls.multiplexers.append(cls.multiplexer1)
temp_dir_2 = os.path.join(cls.t, "temp_dir_2")
os.mkdir(temp_dir_2)
cls.connection2 = _make_libp2p_connection(data_dir=temp_dir_2,
port=DEFAULT_PORT + 3,
entry_peers=[relay_peer])
cls.multiplexer2 = Multiplexer(
[cls.connection2], protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection2.node.log_file)
cls.multiplexer2.connect()
cls.multiplexers.append(cls.multiplexer2)
except Exception as e:
cls.teardown_class()
raise e
def setup_class(cls):
"""Set up the test."""
cls.node = LocalNode()
cls.node.start()
cls.address_1 = "address_1"
cls.multiplexer1 = Multiplexer(
[_make_local_connection(cls.address_1, cls.node,)]
)
cls.address_2 = "address_2"
cls.multiplexer2 = Multiplexer(
[_make_local_connection(cls.address_2, cls.node,)]
)
cls.multiplexer1.connect()
cls.multiplexer2.connect()
cls.dialogues = OefSearchDialogues(cls.address_1)
def setup(self):
"""Set up test case."""
self.connection = _make_dummy_connection()
self.multiplexer = Multiplexer([self.connection],
protocols=[DefaultProtocolMock])
self.multiplexer.connect()
self.envelope = Envelope(
to="",
sender="",
protocol_specification_id=DefaultMessage.protocol_specification_id,
message=b"",
context=EnvelopeContext(
connection_id=self.connection.connection_id),
)
self.exception = ValueError("expected")
def setup_class(cls):
"""Set the test up."""
cls.connection = _make_oef_connection(
FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000,
)
cls.multiplexer = Multiplexer([cls.connection])
cls.multiplexer.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.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.connection_client = _make_libp2p_client_connection()
cls.multiplexer_client = Multiplexer([cls.connection_client])
cls.multiplexer_client.connect()
def make_multiplexer_and_dialogues(
) -> Tuple[Multiplexer, OefSearchDialogues, Crypto, SOEFConnection]:
"""Return multplexer, dialogues and crypto instances."""
crypto = make_crypto(DEFAULT_LEDGER)
identity = Identity("", address=crypto.address)
oef_search_dialogues = OefSearchDialogues(crypto.address)
# create the connection and multiplexer objects
configuration = ConnectionConfig(
api_key="TwiCIriSl0mLahw17pyqoA",
soef_addr="s-oef.fetch.ai",
soef_port=443,
restricted_to_protocols={
OefSearchMessage.protocol_specification_id,
OefSearchMessage.protocol_id,
},
connection_id=SOEFConnection.connection_id,
)
soef_connection = SOEFConnection(
configuration=configuration,
data_dir=MagicMock(),
identity=identity,
)
multiplexer = Multiplexer([soef_connection])
return multiplexer, oef_search_dialogues, crypto, soef_connection
def test_inbox_get_raises_exception_when_empty():
"""Test that getting an envelope from an empty inbox raises an exception."""
multiplexer = Multiplexer([_make_dummy_connection()])
inbox = InBox(multiplexer)
with pytest.raises(aea.mail.base.Empty):
with unittest.mock.patch.object(multiplexer, "get", return_value=None):
inbox.get()
def setup_class(cls):
"""Set the test up."""
cls.connection = _make_oef_connection(
FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000,
)
cls.multiplexer = Multiplexer([cls.connection])
cls.multiplexer.connect()
cls.oef_search_dialogues = OefSearchDialogues("agent_address")
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.genesis = _make_libp2p_connection(DEFAULT_PORT + 1)
cls.multiplexer_genesis = Multiplexer([cls.genesis])
cls.log_files.append(cls.genesis.node.log_file)
cls.multiplexer_genesis.connect()
cls.multiplexers.append(cls.multiplexer_genesis)
genesis_peer = cls.genesis.node.multiaddrs[0]
with open("node_key", "wb") as f:
make_crypto(DEFAULT_LEDGER).dump(f)
cls.relay_key_path = "node_key"
cls.relay = _make_libp2p_connection(
port=DEFAULT_PORT + 2,
entry_peers=[genesis_peer],
node_key_file=cls.relay_key_path,
)
cls.multiplexer_relay = Multiplexer([cls.relay])
cls.log_files.append(cls.relay.node.log_file)
cls.multiplexer_relay.connect()
cls.multiplexers.append(cls.multiplexer_relay)
relay_peer = cls.relay.node.multiaddrs[0]
cls.connection = _make_libp2p_connection(DEFAULT_PORT + 3,
relay=False,
entry_peers=[relay_peer])
cls.multiplexer = Multiplexer([cls.connection])
cls.log_files.append(cls.connection.node.log_file)
cls.multiplexer.connect()
cls.multiplexers.append(cls.multiplexer)
except Exception as e:
cls.teardown_class()
raise e
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:
port_genesis = DEFAULT_PORT + 10
temp_dir_gen = os.path.join(cls.t, "temp_dir_gen")
os.mkdir(temp_dir_gen)
cls.connection_genesis = _make_libp2p_connection(
data_dir=temp_dir_gen, port=port_genesis)
cls.multiplexer_genesis = Multiplexer(
[cls.connection_genesis],
protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection_genesis.node.log_file)
cls.multiplexer_genesis.connect()
cls.multiplexers.append(cls.multiplexer_genesis)
genesis_peer = cls.connection_genesis.node.multiaddrs[0]
cls.connections = [cls.connection_genesis]
port = port_genesis
for i in range(DEFAULT_NET_SIZE):
port += 1
temp_dir = os.path.join(cls.t, f"temp_dir_{i}")
os.mkdir(temp_dir)
conn = _make_libp2p_connection(data_dir=temp_dir,
port=port,
entry_peers=[genesis_peer])
mux = Multiplexer([conn],
protocols=[MockDefaultMessageProtocol])
cls.connections.append(conn)
cls.log_files.append(conn.node.log_file)
mux.connect()
cls.multiplexers.append(mux)
except Exception as e:
cls.teardown_class()
raise e
def run():
# Ensure the input and output files do not exist initially
if os.path.isfile(INPUT_FILE):
os.remove(INPUT_FILE)
if os.path.isfile(OUTPUT_FILE):
os.remove(OUTPUT_FILE)
# create the connection and multiplexer objects
configuration = ConnectionConfig(
input_file=INPUT_FILE,
output_file=OUTPUT_FILE,
connection_id=StubConnection.connection_id,
)
stub_connection = StubConnection(configuration=configuration,
identity=Identity("some_agent",
"some_address"))
multiplexer = Multiplexer([stub_connection])
try:
# Set the multiplexer running in a different thread
t = Thread(target=multiplexer.connect)
t.start()
# Wait for everything to start up
time.sleep(3)
# Create a message inside an envelope and get the stub connection to pass it into the multiplexer
message_text = (
"multiplexer,some_agent,fetchai/default:0.4.0,\x08\x01*\x07\n\x05hello,"
)
with open(INPUT_FILE, "w") as f:
write_with_lock(f, message_text)
# Wait for the envelope to get processed
time.sleep(2)
# get the envelope
envelope = multiplexer.get() # type: Optional[Envelope]
assert envelope is not None
# Inspect its contents
print(
"Envelope received by Multiplexer: sender={}, to={}, protocol_id={}, message={}"
.format(envelope.sender, envelope.to, envelope.protocol_id,
envelope.message))
# Create a mirrored response envelope
response_envelope = copy(envelope)
response_envelope.to = envelope.sender
response_envelope.sender = envelope.to
# Send the envelope back
multiplexer.put(response_envelope)
# Read the output envelope generated by the multiplexer
with open(OUTPUT_FILE, "r") as f:
print("Envelope received from Multiplexer: " + f.readline())
finally:
# Shut down the multiplexer
multiplexer.disconnect()
t.join()
async def test_sending_loop_does_not_start_if_multiplexer_not_connected():
"""Test that the sending loop is stopped does not start if the multiplexer is not connected."""
multiplexer = Multiplexer([_make_dummy_connection()])
with unittest.mock.patch.object(aea.mail.base.logger, "debug") as mock_logger_debug:
await multiplexer._send_loop()
mock_logger_debug.assert_called_with(
"Sending loop not started. The multiplexer is not connected."
)
def test_connect_twice():
"""Test that connecting twice the multiplexer behaves correctly."""
multiplexer = Multiplexer([_make_dummy_connection()])
assert not multiplexer.connection_status.is_connected
multiplexer.connect()
assert multiplexer.connection_status.is_connected
multiplexer.connect()
assert multiplexer.connection_status.is_connected
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 = []
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.connection = _make_oef_connection(
FETCHAI_ADDRESS_ONE,
oef_addr="127.0.0.1",
oef_port=10000,
)
cls.multiplexer = Multiplexer([cls.connection],
protocols=[FipaMessage, DefaultMessage])
cls.multiplexer.connect()
