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 = []
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.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_communication_direct(self):
"""Test communication direct."""
for maddr in PUBLIC_DHT_MADDRS:
multiplexers = []
try:
connection1 = _make_libp2p_connection(DEFAULT_PORT + 1,
relay=False,
entry_peers=[maddr])
multiplexer1 = Multiplexer([connection1])
self.log_files.append(connection1.node.log_file)
multiplexer1.connect()
multiplexers.append(multiplexer1)
connection2 = _make_libp2p_connection(DEFAULT_PORT + 2,
relay=False,
entry_peers=[maddr])
multiplexer2 = Multiplexer([connection2])
self.log_files.append(connection2.node.log_file)
multiplexer2.connect()
multiplexers.append(multiplexer2)
addr_1 = connection1.node.address
addr_2 = connection2.node.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.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 setup(self):
"""Set the test up"""
super().setup()
temp_dir_gen = os.path.join(self.t, "temp_dir_gen")
os.mkdir(temp_dir_gen)
self.genesis = _make_libp2p_connection(data_dir=temp_dir_gen,
port=DEFAULT_PORT + 1,
build_directory=self.t)
self.multiplexer_genesis = Multiplexer([self.genesis],
protocols=[DefaultMessage])
self.multiplexer_genesis.connect()
self.log_files.append(self.genesis.node.log_file)
self.multiplexers.append(self.multiplexer_genesis)
genesis_peer = self.genesis.node.multiaddrs[0]
with open("node_key", "wb") as f:
make_crypto(DEFAULT_LEDGER).dump(f)
self.relay_key_path = "node_key"
temp_dir_rel = os.path.join(self.t, "temp_dir_rel")
os.mkdir(temp_dir_rel)
self.relay = _make_libp2p_connection(
data_dir=temp_dir_rel,
port=DEFAULT_PORT + 2,
entry_peers=[genesis_peer],
node_key_file=self.relay_key_path,
build_directory=self.t,
)
self.multiplexer_relay = Multiplexer([self.relay],
protocols=[DefaultMessage])
self.multiplexer_relay.connect()
self.log_files.append(self.relay.node.log_file)
self.multiplexers.append(self.multiplexer_relay)
relay_peer = self.relay.node.multiaddrs[0]
temp_dir_1 = os.path.join(self.t, "temp_dir_1")
os.mkdir(temp_dir_1)
self.connection = _make_libp2p_connection(
data_dir=temp_dir_1,
port=DEFAULT_PORT + 3,
relay=False,
entry_peers=[relay_peer],
build_directory=self.t,
)
self.multiplexer = Multiplexer([self.connection],
protocols=[DefaultMessage])
self.multiplexer.connect()
self.log_files.append(self.connection.node.log_file)
self.multiplexers.append(self.multiplexer)
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 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.connection = _make_libp2p_connection()
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 = []
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 test_libp2pconnection_node_config_registration_delay():
"""Test node registration delay configuration"""
host = "localhost"
port = "10000"
with tempfile.TemporaryDirectory() as data_dir:
_make_libp2p_connection(
port=port, host=host, data_dir=data_dir, build_directory=data_dir
)
with tempfile.TemporaryDirectory() as data_dir:
with pytest.raises(ValueError):
_make_libp2p_connection(
port=port,
host=host,
data_dir=data_dir,
peer_registration_delay="must_be_float",
build_directory=data_dir,
)
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")
os.mkdir(temp_dir)
cls.connection = _make_libp2p_connection(data_dir=temp_dir)
def setup(self):
"""Set the test up"""
super().setup()
temp_dir_gen = os.path.join(self.t, "temp_dir_gen")
os.mkdir(temp_dir_gen)
self.genesis = _make_libp2p_connection(data_dir=temp_dir_gen,
port=DEFAULT_PORT)
self.multiplexer_genesis = Multiplexer([self.genesis],
protocols=[DefaultMessage])
self.log_files.append(self.genesis.node.log_file)
self.multiplexer_genesis.connect()
self.multiplexers.append(self.multiplexer_genesis)
genesis_peer = self.genesis.node.multiaddrs[0]
temp_dir_1 = os.path.join(self.t, "temp_dir_1")
os.mkdir(temp_dir_1)
self.connection1 = _make_libp2p_connection(data_dir=temp_dir_1,
port=DEFAULT_PORT + 1,
entry_peers=[genesis_peer])
self.multiplexer1 = Multiplexer([self.connection1],
protocols=[DefaultMessage])
self.log_files.append(self.connection1.node.log_file)
self.multiplexer1.connect()
self.multiplexers.append(self.multiplexer1)
self.connection_key = make_crypto(DEFAULT_LEDGER)
temp_dir_2 = os.path.join(self.t, "temp_dir_2")
os.mkdir(temp_dir_2)
self.connection2 = _make_libp2p_connection(
data_dir=temp_dir_2,
port=DEFAULT_PORT + 2,
entry_peers=[genesis_peer],
agent_key=self.connection_key,
)
self.multiplexer2 = Multiplexer([self.connection2],
protocols=[DefaultMessage])
self.log_files.append(self.connection2.node.log_file)
self.multiplexer2.connect()
self.multiplexers.append(self.multiplexer2)
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_1 = os.path.join(cls.t, "temp_dir_1")
os.mkdir(temp_dir_1)
cls.connection1 = _make_libp2p_connection(
data_dir=temp_dir_1,
agent_key=FetchAICrypto(),
port=DEFAULT_PORT + 1)
cls.multiplexer1 = Multiplexer(
[cls.connection1], protocols=[MockDefaultMessageProtocol])
cls.log_files.append(cls.connection1.node.log_file)
cls.multiplexer1.connect()
cls.multiplexers.append(cls.multiplexer1)
genesis_peer = cls.connection1.node.multiaddrs[0]
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 + 2,
entry_peers=[genesis_peer],
agent_key=EthereumCrypto(),
)
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 class."""
super(TestP2PLibp2pClientConnectionAEARunning, cls).setup_class()
cls.node_connection = _make_libp2p_connection(
delegate_host=DEFAULT_HOST,
delegate_port=DEFAULT_DELEGATE_PORT,
delegate=True,
)
cls.node_multiplexer = Multiplexer([cls.node_connection])
cls.log_files = [cls.node_connection.node.log_file]
cls.node_multiplexer.connect()
def setup_class(cls):
"""Set up the test class."""
AEATestCaseEmpty.setup_class()
cls.node_connection = _make_libp2p_connection(
delegate_host=DEFAULT_HOST,
delegate_port=DEFAULT_DELEGATE_PORT,
delegate=True,
)
cls.node_multiplexer = Multiplexer([cls.node_connection])
cls.log_files = [cls.node_connection.node.log_file]
cls.node_multiplexer.connect()
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)
def test_connectivity(self):
for maddr in PUBLIC_DHT_MADDRS:
connection = _make_libp2p_connection(DEFAULT_PORT + 1,
relay=False,
entry_peers=[maddr])
multiplexer = Multiplexer([connection])
self.log_files.append(connection.node.log_file)
multiplexer.connect()
try:
assert (connection.is_connected is True
), "Couldn't connect to public node {}".format(maddr)
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.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 setup_class(cls):
"""Set up the test class."""
super(TestP2PLibp2pClientConnectionAEARunning, cls).setup_class()
temp_dir = os.path.join(cls.t, "temp_dir_node")
os.mkdir(temp_dir)
cls.node_connection = _make_libp2p_connection(
data_dir=temp_dir,
delegate_host=DEFAULT_HOST,
delegate_port=DEFAULT_DELEGATE_PORT,
delegate=True,
)
cls.node_multiplexer = Multiplexer([cls.node_connection])
cls.log_files = [cls.node_connection.node.log_file]
cls.node_multiplexer.connect()
async def test_p2plibp2pconnection_connect_disconnect_default(self):
"""Test connect then disconnect."""
temp_dir = os.path.join(self.t, "temp_dir")
os.mkdir(temp_dir)
connection = _make_libp2p_connection(data_dir=temp_dir)
assert connection.is_connected is False
try:
await connection.connect()
assert connection.is_connected is True
except Exception as e:
await connection.disconnect()
raise e
await connection.disconnect()
assert connection.is_connected is False
def test_build_dir_not_set():
"""Test build dir not set."""
host = "localhost"
port = "10000"
with tempfile.TemporaryDirectory() as data_dir:
con = _make_libp2p_connection(
port=port, host=host, data_dir=data_dir, build_directory=data_dir
)
con.configuration.build_directory = None
with pytest.raises(
ValueError, match="Connection Configuration build directory is not set!"
):
P2PLibp2pConnection(
configuration=con.configuration,
data_dir=data_dir,
identity=con._identity,
crypto_store=con.crypto_store,
)
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 test_connectivity(self):
"""Test connectivity."""
for i, maddr in enumerate(PUBLIC_DHT_MADDRS):
temp_dir = os.path.join(self.t, f"dir_{i}")
os.mkdir(temp_dir)
connection = _make_libp2p_connection(
port=DEFAULT_PORT + 1,
relay=False,
entry_peers=[maddr],
data_dir=temp_dir,
)
multiplexer = Multiplexer([connection])
self.log_files.append(connection.node.log_file)
multiplexer.connect()
try:
assert (
connection.is_connected is True
), "Couldn't connect to public node {}".format(maddr)
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.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()
try:
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()
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.multiplexers = []
try:
temp_dir_rel_1 = os.path.join(cls.t, "temp_dir_rel_1")
os.mkdir(temp_dir_rel_1)
port_relay_1 = DEFAULT_PORT + 10
cls.connection_relay_1 = _make_libp2p_connection(
data_dir=temp_dir_rel_1, port=port_relay_1)
cls.multiplexer_relay_1 = Multiplexer(
[cls.connection_relay_1],
protocols=[MockDefaultMessageProtocol])
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]
temp_dir_rel_2 = os.path.join(cls.t, "temp_dir_rel_2")
os.mkdir(temp_dir_rel_2)
port_relay_2 = DEFAULT_PORT + 100
cls.connection_relay_2 = _make_libp2p_connection(
data_dir=temp_dir_rel_2,
port=port_relay_2,
entry_peers=[relay_peer_1])
cls.multiplexer_relay_2 = Multiplexer(
[cls.connection_relay_2],
protocols=[MockDefaultMessageProtocol])
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 i in range(int(DEFAULT_NET_SIZE / 2) + 1):
temp_dir = os.path.join(cls.t, f"temp_dir_conn_{i}_1")
os.mkdir(temp_dir)
port += 1
conn = _make_libp2p_connection(
data_dir=temp_dir,
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 i in range(int(DEFAULT_NET_SIZE / 2) + 1):
temp_dir = os.path.join(cls.t, f"temp_dir_conn_{i}_2")
os.mkdir(temp_dir)
port += 1
conn = _make_libp2p_connection(
data_dir=temp_dir,
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
