def test_invite_tiebreaker():
address = str("a" * 32).encode("utf-8")
address1 = str("b" * 32).encode("utf-8")
address2 = str("c" * 32).encode("utf-8")
assert my_place_or_yours(address, address1) == address
assert my_place_or_yours(address1, address2) == address1
def create_channel(self, node_address: Address) -> None:
lower_address = my_place_or_yours(node_address, self.partner_address)
higher_address = self.partner_address if lower_address == node_address else node_address
channel_name = (
f"{to_checksum_address(lower_address)}|{to_checksum_address(higher_address)}"
)
self.channel = self.peer_connection.createDataChannel(channel_name)
def test_matrix_invitee_receives_invite_on_restart(matrix_transports):
raiden_service0 = MockRaidenService(None)
raiden_service1 = MockRaidenService(None)
transport0, transport1 = matrix_transports
room_creator_address = my_place_or_yours(raiden_service0.address,
raiden_service1.address)
if room_creator_address == raiden_service0.address:
inviter_service = raiden_service0
invitee_service = raiden_service1
inviter_transport = transport0
invitee_transport = transport1
else:
inviter_service = raiden_service1
invitee_service = raiden_service0
inviter_transport = transport1
invitee_transport = transport0
inviter_transport.start(inviter_service, [], None)
invitee_transport.start(invitee_service, [], None)
inviter_transport.start_health_check(invitee_service.address)
invitee_transport.start_health_check(inviter_service.address)
wait_for_peer_reachable(inviter_transport, invitee_service.address)
wait_for_peer_reachable(invitee_transport, inviter_service.address)
assert is_reachable(invitee_transport, inviter_service.address)
assert is_reachable(inviter_transport, invitee_service.address)
invitee_transport.stop()
wait_for_peer_unreachable(inviter_transport, invitee_service.address)
assert not is_reachable(inviter_transport, invitee_service.address)
room_id = inviter_transport._get_room_for_address(
invitee_service.address).room_id
invitee_transport.start(invitee_service, [], None)
invitee_transport.start_health_check(inviter_service.address)
inviter_transport.stop()
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state1 = invitee_transport._client.api.get_room_state(
room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state1 is not None
def test_matrix_invitee_receives_invite_on_restart(
matrix_transports: List[MatrixTransport]) -> None:
"""The invitee should receive the invite, even if the inviter is offline."""
raiden_service0: RaidenService = cast(RaidenService,
MockRaidenService(None))
raiden_service1: RaidenService = cast(RaidenService,
MockRaidenService(None))
transport0, transport1 = matrix_transports
room_creator_address = my_place_or_yours(raiden_service0.address,
raiden_service1.address)
if room_creator_address == raiden_service0.address:
inviter_service = raiden_service0
invitee_service = raiden_service1
inviter_transport = transport0
invitee_transport = transport1
else:
inviter_service = raiden_service1
invitee_service = raiden_service0
inviter_transport = transport1
invitee_transport = transport0
# Initialize the invitee and stop it before the invite happens
invitee_transport.start(invitee_service, [], None)
invitee_transport.stop()
inviter_transport.start(inviter_service, [], None)
inviter_transport.immediate_health_check_for(invitee_service.address)
room = inviter_transport._get_room_for_address(invitee_service.address)
assert room, "The inviter should have created the room, even if the invitee is offline."
# Now stop the inviter and check the invitee received the invite
inviter_transport.stop()
invitee_transport.start(invitee_service, [], None)
invitee_transport.immediate_health_check_for(inviter_service.address)
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state1 = invitee_transport._client.api.get_room_state(
room.room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state1 is not None
def test_matrix_invite_retry_with_offline_invitee(
matrix_transports: List[MatrixTransport],
) -> None:
"""The inviter should create the room and send the invite even if the
target node is offline.
"""
raiden_service0: RaidenService = cast(RaidenService, MockRaidenService(None))
raiden_service1: RaidenService = cast(RaidenService, MockRaidenService(None))
transport0, transport1 = matrix_transports
room_creator_address = my_place_or_yours(raiden_service0.address, raiden_service1.address)
if room_creator_address == raiden_service0.address:
inviter_service = raiden_service0
invitee_service = raiden_service1
inviter_transport = transport0
invitee_transport = transport1
else:
inviter_service = raiden_service1
invitee_service = raiden_service0
inviter_transport = transport1
invitee_transport = transport0
# Initialize the invitee and stop it before the invite happens
invitee_transport.start(invitee_service, [], None)
invitee_transport.stop()
inviter_transport.start(inviter_service, [], None)
inviter_transport.immediate_health_check_for(invitee_service.address)
wait_for_peer_unreachable(inviter_transport, invitee_service.address)
assert not is_reachable(inviter_transport, invitee_service.address)
room = inviter_transport._get_room_for_address(invitee_service.address)
assert room, "The inviter should have created the room, even if the invitee is offline."
invitee_transport.start(invitee_service, [], None)
invitee_transport.immediate_health_check_for(inviter_service.address)
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state0 = inviter_transport._client.api.get_room_state(room.room_id)
break
except MatrixRequestError:
gevent.sleep(0.1)
assert room_state0 is not None
with Timeout(TIMEOUT_MESSAGE_RECEIVE):
while True:
try:
room_state1 = invitee_transport._client.api.get_room_state(room.room_id)
break
except MatrixRequestError as ex:
print(ex, transport0._client.user_id, transport1._client.user_id)
gevent.sleep(0.5)
assert room_state1 is not None
assert is_reachable(inviter_transport, invitee_service.address)
assert is_reachable(invitee_transport, inviter_service.address)
def get_call_id(self, node_address: Address) -> str:
lower_address = my_place_or_yours(node_address, self.partner_address)
higher_address = self.partner_address if lower_address == node_address else node_address
call_id = f"{to_checksum_address(lower_address)}|{to_checksum_address(higher_address)}"
return call_id
