def test_encoding():
p = Ping(nonce=0)
with pytest.raises(SignatureMissingError):
p.encode()
p.sign(privkey)
d = p.encode()
p2 = decode(d)
assert isinstance(p2, Ping)
assert p2.sender == address == p.sender
assert p.nonce == p2.nonce
assert p.signature == p2.signature
assert p.cmdid == p.cmdid
assert p.hash == p2.hash
def test_ping(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
messages = setup_messages_cb()
ping_message = Ping(nonce=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
async_result = app0.raiden.protocol.send_raw_with_result(
ping_encoded,
app1.raiden.address,
)
assert async_result.wait(2), 'The message was not acknowledged'
expected_echohash = sha3(ping_encoded + app1.raiden.address)
messages_decoded = [decode(m) for m in messages]
ack_message = next(
decoded
for decoded in messages_decoded
if isinstance(decoded, Ack) and decoded.echo == expected_echohash
)
# the ping message was sent and acknowledged
assert ping_encoded in messages
assert ack_message
def test_hash():
ping = Ping(nonce=0)
ping.sign(PRIVKEY)
data = ping.encode()
msghash = sha3(data)
decoded_ping = decode(data)
assert sha3(decoded_ping.encode()) == msghash
def test_ping_unreachable(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
# drop everything to force disabling of re-sends
app0.raiden.protocol.transport.droprate = 1
app1.raiden.protocol.transport.droprate = 1
app0.raiden.protocol.retry_interval = 0.1 # for fast tests
messages = setup_messages_cb()
ping_message = Ping(nonce=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
async_result = app0.raiden.protocol.send_raw_with_result(
ping_encoded,
app1.raiden.address,
)
assert async_result.wait(2) is None, "The message was dropped, it can't be acknowledged"
# Raiden node will start pinging as soon as a new channel
# is established. We need to test if
# a) there is our original message in the queue
# b) there are only Ping message types in
messages_decoded = [decode(m) for m in messages]
assert ping_message in messages_decoded
for message in messages_decoded:
assert isinstance(message, Ping)
def send_ping(self, receiver_address):
if not isaddress(receiver_address):
raise ValueError('Invalid address {}'.format(pex(receiver_address)))
nonce = self._ping_nonces[receiver_address]
self._ping_nonces[receiver_address] += 1
message = Ping(nonce)
self.raiden.sign(message)
if log.isEnabledFor(logging.INFO):
log.info(
'SENDING PING %s > %s',
pex(self.raiden.address),
pex(receiver_address)
)
message_data = message.encode()
echohash = sha3(message_data + receiver_address)
async_result = AsyncResult()
if echohash not in self.echohash_asyncresult:
self.echohash_asyncresult[echohash] = WaitAck(async_result, receiver_address)
# Just like ACK, a PING message is sent directly. No need for queuing
self.transport.send(
self.raiden,
self.discovery.get(receiver_address),
message_data
)
return async_result
def test_hash():
ping = Ping(nonce=0, current_protocol_version=constants.PROTOCOL_VERSION)
ping.sign(PRIVKEY)
data = ping.encode()
msghash = sha3(data)
decoded_ping = decode(data)
assert sha3(decoded_ping.encode()) == msghash
def test_udp_ping_pong_unreachable_node(raiden_network, skip_if_not_udp):
app0, app1 = raiden_network
app1.raiden.transport.stop_and_wait()
ping_message = Ping(nonce=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
messageid = ('ping', ping_message.nonce, app1.raiden.address)
async_result = app0.raiden.transport.maybe_sendraw_with_result(
app1.raiden.address,
ping_encoded,
messageid,
)
nat_keepalive_fail = (
app0.config['transport']['nat_keepalive_timeout'] *
app0.config['transport']['nat_keepalive_retries'] *
2 # wait a bit longer to avoid races
)
msg = "The message was dropped, it can't be acknowledged"
assert async_result.wait(nat_keepalive_fail) is None, msg
network_state = views.get_node_network_status(
views.state_from_app(app0),
app1.raiden.address,
)
assert network_state is state.NODE_NETWORK_UNREACHABLE
def test_ping_dropped_message(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
# mock transport with packet loss, every 3rd is lost, starting with first message
UnreliableTransport.droprate = 3
RaidenProtocol.try_interval = 0.1 # for fast tests
RaidenProtocol.repeat_messages = True
messages = setup_messages_cb()
UnreliableTransport.network.counter = 0
ping = Ping(nonce=0)
app0.raiden.sign(ping)
app0.raiden.protocol.send_and_wait(app1.raiden.address, ping)
gevent.sleep(1)
assert len(messages) == 3 # Ping(dropped), Ping, Ack
for i in [0, 1]:
assert decode(messages[i]) == ping
for i in [2]:
decoded = decode(messages[i])
assert isinstance(decoded, Ack)
assert decoded.echo == sha3(ping.encode() + app1.raiden.address)
messages = setup_messages_cb()
assert not messages
UnreliableTransport.network.counter = 2 # first message sent, 2nd dropped
ping = Ping(nonce=1)
app0.raiden.sign(ping)
app0.raiden.protocol.send_and_wait(app1.raiden.address, ping)
gevent.sleep(1)
assert len(messages) == 4 # Ping, Ack(dropped), Ping, Ack
for i in [0, 2]:
assert decode(messages[i]) == ping
for i in [1, 3]:
decoded = decode(messages[i])
assert isinstance(decoded, Ack)
assert decoded.echo == sha3(ping.encode() + app1.raiden.address)
RaidenProtocol.repeat_messages = False
def test_encoding():
ping = Ping(nonce=0, current_protocol_version=constants.PROTOCOL_VERSION)
ping.sign(PRIVKEY)
decoded_ping = decode(ping.encode())
assert isinstance(decoded_ping, Ping)
assert decoded_ping.sender == ADDRESS == ping.sender
assert ping.nonce == decoded_ping.nonce
assert ping.signature == decoded_ping.signature
assert ping.cmdid == decoded_ping.cmdid
assert ping.hash == decoded_ping.hash
def test_encoding():
ping = Ping(nonce=0)
ping.sign(PRIVKEY)
decoded_ping = decode(ping.encode())
assert isinstance(decoded_ping, Ping)
assert decoded_ping.sender == ADDRESS == ping.sender
assert ping.nonce == decoded_ping.nonce
assert ping.signature == decoded_ping.signature
assert ping.cmdid == decoded_ping.cmdid
assert ping.hash == decoded_ping.hash
def get_ping(self, nonce: int) -> Ping:
""" Returns a signed Ping message.
Note: Ping messages don't have an enforced ordering, so a Ping message
with a higher nonce may be acknowledged first.
"""
message = Ping(nonce)
self.raiden.sign(message)
message_data = message.encode()
return message_data
def get_ping(self, nonce):
""" Returns a signed Ping message.
Note: Ping messages don't have an enforced ordering, so a Ping message
with a higher nonce may be acknowledged first.
"""
message = Ping(nonce)
self.raiden.sign(message)
message_data = message.encode()
return message_data
def test_ping_udp(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
messages = setup_messages_cb()
ping = Ping(nonce=0)
app0.raiden.sign(ping)
app0.raiden.protocol.send_and_wait(app1.raiden.address, ping)
gevent.sleep(0.1)
assert len(messages) == 2 # Ping, Ack
assert decode(messages[0]) == ping
decoded = decode(messages[1])
assert isinstance(decoded, Ack)
assert decoded.echo == sha3(ping.encode() + app1.raiden.address)
def get_ping(self, nonce: Nonce) -> bytes:
""" Returns a signed Ping message.
Note: Ping messages don't have an enforced ordering, so a Ping message
with a higher nonce may be acknowledged first.
"""
message = Ping(
nonce=nonce,
current_protocol_version=constants.PROTOCOL_VERSION,
)
self.raiden.sign(message)
return message.encode()
def test_udp_reachable_node(raiden_network, skip_if_not_udp): # pylint: disable=unused-argument
"""A node that answers the ping message must have its state set to
reachable.
"""
app0, app1 = raiden_network
ping_message = Ping(nonce=0, current_protocol_version=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
messageid = ("ping", ping_message.nonce, app1.raiden.address)
async_result = app0.raiden.transport.maybe_sendraw_with_result(
app1.raiden.address, ping_encoded, messageid)
assert async_result.wait(2), "The message was not processed"
network_state = views.get_node_network_status(views.state_from_app(app0),
app1.raiden.address)
assert network_state is state.NODE_NETWORK_REACHABLE
def test_udp_ping_pong(raiden_network, skip_if_not_udp):
app0, app1 = raiden_network
ping_message = Ping(nonce=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
messageid = ('ping', ping_message.nonce, app1.raiden.address)
async_result = app0.raiden.transport.maybe_sendraw_with_result(
app1.raiden.address,
ping_encoded,
messageid,
)
assert async_result.wait(2), 'The message was not processed'
network_state = views.get_node_network_status(
views.state_from_app(app0),
app1.raiden.address,
)
assert network_state is state.NODE_NETWORK_REACHABLE
def test_udp_ping_pong(raiden_network, skip_if_not_udp):
app0, app1 = raiden_network
ping_message = Ping(nonce=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
messageid = ('ping', ping_message.nonce, app1.raiden.address)
async_result = app0.raiden.transport.maybe_sendraw_with_result(
app1.raiden.address,
ping_encoded,
messageid,
)
assert async_result.wait(2), 'The message was not processed'
network_state = views.get_node_network_status(
views.state_from_app(app0),
app1.raiden.address,
)
assert network_state is state.NODE_NETWORK_REACHABLE
def test_ping_unreachable(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
UnreliableTransport.droprate = 1 # drop everything to force disabling of re-sends
app0.raiden.protocol.retry_interval = 0.1 # for fast tests
messages = setup_messages_cb()
UnreliableTransport.network.counter = 0
ping_message = Ping(nonce=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
async_result = app0.raiden.protocol.send_raw_with_result(
ping_encoded,
app1.raiden.address,
)
assert async_result.wait(2) is None, "The message was dropped, it can't be acknowledged"
for message in messages:
assert decode(message) == ping_message
def test_ping_ordering(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
# mock transport with packet loss, every 3rd is lost, starting with first message
droprate = UnreliableTransport.droprate = 3
RaidenProtocol.try_interval = 0.1 # for fast tests
RaidenProtocol.repeat_messages = True
messages = setup_messages_cb()
UnreliableTransport.network.counter = 0
ping_amount = 5
hashes = []
for nonce in range(ping_amount):
ping = Ping(nonce=nonce)
app0.raiden.sign(ping)
app0.raiden.protocol.send_and_wait(app1.raiden.address, ping)
pinghash = sha3(ping.encode() + app1.raiden.address)
hashes.append(pinghash)
gevent.sleep(2) # give some time for messages to be handled
expected_message_amount = ping_amount * droprate
assert len(messages) == expected_message_amount
for i in range(0, expected_message_amount, droprate):
assert isinstance(decode(messages[i]), Ping)
for i in range(1, expected_message_amount, droprate):
assert isinstance(decode(messages[i]), Ping)
for i, j in zip(range(2, expected_message_amount, droprate),
range(ping_amount)):
decoded = decode(messages[i])
assert isinstance(decoded, Ack)
assert decoded.echo == hashes[j]
RaidenProtocol.repeat_messages = False
def test_ping_ordering(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
# mock transport with packet loss, every 3rd is lost, starting with first message
droprate = UnreliableTransport.droprate = 3
RaidenProtocol.try_interval = 0.1 # for fast tests
RaidenProtocol.repeat_messages = True
messages = setup_messages_cb()
UnreliableTransport.network.counter = 0
ping_amount = 5
hashes = []
for nonce in range(ping_amount):
ping = Ping(nonce=nonce)
app0.raiden.sign(ping)
app0.raiden.protocol.send_and_wait(app1.raiden.address, ping)
pinghash = sha3(ping.encode() + app1.raiden.address)
hashes.append(pinghash)
gevent.sleep(2) # give some time for messages to be handled
expected_message_amount = ping_amount * droprate
assert len(messages) == expected_message_amount
for i in range(0, expected_message_amount, droprate):
assert isinstance(decode(messages[i]), Ping)
for i in range(1, expected_message_amount, droprate):
assert isinstance(decode(messages[i]), Ping)
for i, j in zip(range(2, expected_message_amount, droprate), range(ping_amount)):
decoded = decode(messages[i])
assert isinstance(decoded, Ack)
assert decoded.echo == hashes[j]
RaidenProtocol.repeat_messages = False
def ping(self, peer):
"""See, if a peer is discoverable and up.
Args:
peer (string): the hex-encoded (ethereum) address of the peer.
Returns:
success (boolean): True if ping succeeded, False otherwise.
"""
# Check, if peer is discoverable
try:
self._discovery.get(peer.decode('hex'))
except KeyError:
print("Error: peer {} not found in discovery".format(peer))
return
nonce = self._ping_nonces[peer]
self._ping_nonces[peer] += 1
msg = Ping(nonce)
self._raiden.sign(msg)
try:
self._raiden.protocol._repeat_until_ack(peer.decode('hex'), msg)
except Exception as e:
if not e.message.startswith('DEACTIVATED'):
return e
return sha3(msg.encode()) not in self._raiden.protocol.number_of_tries
def test_ping(raiden_network):
app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking
messages = setup_messages_cb()
ping_message = Ping(nonce=0)
app0.raiden.sign(ping_message)
ping_encoded = ping_message.encode()
app0.raiden.protocol.send_and_wait(
app1.raiden.address,
ping_message,
)
gevent.sleep(0.1)
# mesages may have more than two entries depending on the retry logic, so
# fiter duplicates
assert len(set(messages)) == 2
assert ping_encoded in messages
messages_decoded = [decode(m) for m in messages]
ack_message = next(decoded for decoded in messages_decoded
if isinstance(decoded, Ack))
assert ack_message.echo == sha3(ping_encoded + app1.raiden.address)
def ping(self, peer):
"""See, if a peer is discoverable and up.
Args:
peer (string): the hex-encoded (ethereum) address of the peer.
Returns:
success (boolean): True if ping succeeded, False otherwise.
"""
# Check, if peer is discoverable
try:
self._discovery.get(peer.decode('hex'))
except KeyError:
print("Error: peer {} not found in discovery".format(peer))
return
nonce = self._ping_nonces[peer]
self._ping_nonces[peer] += 1
msg = Ping(nonce)
self._raiden.sign(msg)
try:
self._raiden.protocol._repeat_until_ack(peer.decode('hex'), msg)
except Exception as e:
if not e.message.startswith('DEACTIVATED'):
return e
return sha3(msg.encode()) not in self._raiden.protocol.number_of_tries
def test_hash():
ping = Ping(nonce=0).sign(PRIVKEY)
data = ping.encode()
msghash = sha3(data)
decoded_ping = decode(data)
assert sha3(decoded_ping.encode()) == msghash
def get_ping(self, nonce):
message = Ping(nonce)
self.raiden.sign(message)
message_data = message.encode()
return message_data
def test_hash():
msg = Ping(nonce=0).sign(privkey)
d = msg.encode()
msghash = sha3(d)
msg2 = decode(d)
assert sha3(msg2.encode()) == msghash
def test_hash():
msg = Ping(nonce=0).sign(privkey)
d = msg.encode()
msghash = sha3(d)
msg2 = decode(d)
assert sha3(msg2.encode()) == msghash
