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)