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_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 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 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