def _get_response(self, msg):
if msg.query == message.PING:
return message.OutgoingPingResponse(self._my_id)
elif msg.query == message.FIND_NODE:
log_distance = msg.target.log_distance(self._my_id)
rnodes = self._routing_m.get_closest_rnodes(log_distance,
NUM_NODES, False)
return message.OutgoingFindNodeResponse(self._my_id,
rnodes)
elif msg.query == message.GET_PEERS:
token = self._token_m.get()
log_distance = msg.info_hash.log_distance(self._my_id)
rnodes = self._routing_m.get_closest_rnodes(log_distance,
NUM_NODES, False)
peers = self._tracker.get(msg.info_hash)
if peers:
logger.debug('RESPONDING with PEERS:\n%r' % peers)
return message.OutgoingGetPeersResponse(self._my_id,
token,
nodes=rnodes,
peers=peers)
elif msg.query == message.ANNOUNCE_PEER:
peer_addr = (msg.sender_addr[0], msg.bt_port)
self._tracker.put(msg.info_hash, peer_addr)
return message.OutgoingAnnouncePeerResponse(self._my_id)
else:
logger.debug('Invalid QUERY: %r' % (msg.query))
def _setup(self):
global time
time = querier.time = MockTime()
self.ping_msg = message.OutgoingPingQuery(tc.CLIENT_ID)
ping_r_out = message.OutgoingPingResponse(tc.SERVER_ID)
self.ping_r_in = message.IncomingMsg(ping_r_out.encode(tc.TID),
tc.SERVER_ADDR)
fn_r_out = message.OutgoingFindNodeResponse(tc.SERVER_ID,
nodes2=tc.NODES)
self.fn_r_in = message.IncomingMsg(fn_r_out.encode(tc.TID),
tc.SERVER_ADDR)
self.got_response = False
self.got_error = False
self.got_timeout = False
self.got_routing_response = False
self.got_routing_error = False
self.got_routing_timeout = False
self.got_routing_nodes_found = False
timeout_task = minitwisted.Task(1, self.on_timeout, tc.SERVER_NODE)
self.query = querier.Query(tc.TID, self.ping_msg.query, tc.SERVER_NODE,
timeout_task)
def setup(self):
self.queries = [
m.OutgoingPingQuery(tc.CLIENT_ID),
m.OutgoingFindNodeQuery(tc.CLIENT_ID, tc.TARGET_ID),
m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH),
m.OutgoingAnnouncePeerQuery(tc.CLIENT_ID, tc.INFO_HASH, tc.BT_PORT,
tc.TOKEN),
]
self.responses = [
m.OutgoingPingResponse(tc.SERVER_ID),
m.OutgoingFindNodeResponse(tc.SERVER_ID, tc.NODES),
m.OutgoingGetPeersResponse(tc.SERVER_ID, tc.TOKEN, tc.NODES,
tc.PEERS),
m.OutgoingAnnouncePeerResponse(tc.SERVER_ID),
]
def test_find_node(self):
#client
outgoing_query = m.OutgoingFindNodeQuery(tc.CLIENT_ID, tc.NODE_ID)
data = outgoing_query.encode(tc.TID)
#server
incoming_query = m.IncomingMsg(data, tc.CLIENT_ADDR)
assert incoming_query.type is m.QUERY
outgoing_response = m.OutgoingFindNodeResponse(tc.SERVER_ID, tc.NODES)
data = outgoing_response.encode(incoming_query.tid)
#client
incoming_response = m.IncomingMsg(data, tc.SERVER_ADDR)
eq_(incoming_response.type, m.RESPONSE)
#incoming_response.sanitize_response(outgoing_query.query)
for n1, n2 in zip(tc.NODES, incoming_response.all_nodes):
eq_(n1, n2)
def test_return_response_for_find_node(self):
# client side
query_msg = message.OutgoingFindNodeQuery(tc.CLIENT_ID, tc.TARGET_ID)
# querier encodes
query_data = query_msg.encode(tc.TID)
# server side
# rpc_manager.datagram_received() decodes
query_msg = message.IncomingMsg(query_data)
# rpc calls responder
assert not self.notification_callback_done
response_msg = self.responder.on_query_received(
query_msg, tc.CLIENT_ADDR)
response_data = response_msg.encode(query_msg.tid)
assert self.notification_callback_done
expected_msg = message.OutgoingFindNodeResponse(tc.SERVER_ID, tc.NODES)
expected_data = expected_msg.encode(tc.TID)
eq_(response_data, expected_data)
def test_msg_exhanges(self):
self._exchange_msgs(m.OutgoingPingQuery(tc.CLIENT_ID),
m.OutgoingPingResponse(tc.SERVER_ID))
self._exchange_msgs(
m.OutgoingFindNodeQuery(tc.CLIENT_ID, tc.TARGET_ID),
m.OutgoingFindNodeResponse(tc.SERVER_ID, tc.NODES))
# Test different combinations of token, nodes and peers
self._exchange_msgs(
m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH),
m.OutgoingGetPeersResponse(tc.SERVER_ID, tc.TOKEN, tc.NODES,
tc.PEERS))
self._exchange_msgs(
m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH),
m.OutgoingGetPeersResponse(tc.SERVER_ID, tc.TOKEN, tc.NODES))
self._exchange_msgs(
m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH),
m.OutgoingGetPeersResponse(tc.SERVER_ID, tc.TOKEN, peers=tc.PEERS))
assert_raises(AssertionError, m.OutgoingGetPeersResponse, tc.SERVER_ID,
tc.TOKEN)
self._exchange_msgs(
m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH),
m.OutgoingGetPeersResponse(tc.SERVER_ID, peers=tc.PEERS))
self._exchange_msgs(
m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH),
m.OutgoingGetPeersResponse(tc.SERVER_ID, nodes=tc.NODES))
self._exchange_msgs(
m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH),
m.OutgoingGetPeersResponse(tc.SERVER_ID,
nodes=tc.NODES,
peers=tc.PEERS))
assert_raises(AssertionError, m.OutgoingGetPeersResponse, tc.SERVER_ID)
self._exchange_msgs(
m.OutgoingAnnouncePeerQuery(tc.CLIENT_ID, tc.INFO_HASH, tc.BT_PORT,
tc.TOKEN),
m.OutgoingAnnouncePeerResponse(tc.SERVER_ID))
assert_raises(m.MsgError, m.IncomingMsg, bencode.encode(self.ping_d),
tc.CLIENT_ADDR)
# unknown m.QUERY is not an error at this point
# responder will process it and send an errror msg if necesary
self.ping_d[m.QUERY] = 'a'
m.IncomingMsg(bencode.encode(self.ping_d), tc.CLIENT_ADDR)
def test_announce(self):
# Port must be integer
self.ap_d[m.ARGS][m.PORT] = 'a'
assert_raises(m.MsgError, m.IncomingMsg, bencode.encode(self.ap_d),
tc.CLIENT_ADDR)
b_ping_r = m.OutgoingPingResponse(tc.CLIENT_ID).encode(tc.TID)
b_fn2_r = m.OutgoingFindNodeResponse(tc.CLIENT_ID, tc.NODES).encode(tc.TID)
b_gp_r = m.OutgoingGetPeersResponse(tc.CLIENT_ID,
tc.TOKEN,
tc.NODES,
peers=tc.PEERS).encode(tc.TID)
b_ap_r = m.OutgoingAnnouncePeerResponse(tc.CLIENT_ID).encode(tc.TID)
class TestSanitizeResponseError:
def setup(self):
self.ping_r = m.IncomingMsg(b_ping_r, tc.SERVER_ADDR)
self.fn2_r = m.IncomingMsg(b_fn2_r, tc.SERVER_ADDR)
self.gp_r = m.IncomingMsg(b_gp_r, tc.SERVER_ADDR)
self.ap_r = m.IncomingMsg(b_ap_r, tc.SERVER_ADDR)
def test_bootstrap(self):
self.routing_m.do_bootstrap()
fn_r = message.OutgoingFindNodeResponse(tc.NODES[0].id, tc.NODES2[0:1])
fn_r = message.IncomingMsg(fn_r.encode('\0\0'))
self.querier.on_response_received(fn_r, tc.NODES[0].addr)
def _on_find_node(self, query_msg):
rnodes = self.routing_m.get_closest_rnodes(query_msg.target)
return message.OutgoingFindNodeResponse(self.my_id, nodes2=rnodes)
