def _announce(self):
self._is_done = True
if not self._bt_port:
return
for (_, node_, token) in self._announce_candidates:
logger.debug('announcing to %r' % node_)
msg = message.OutgoingAnnouncePeerQuery(self._my_id,
self._info_hash,
self._bt_port, token)
self._querier.send_query(msg, node_, self._do_nothing,
self._do_nothing, self._do_nothing)
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_announce_peer(self):
#client
outgoing_query = m.OutgoingAnnouncePeerQuery(tc.CLIENT_ID,
tc.INFO_HASH, tc.BT_PORT,
tc.TOKEN)
outgoing_query.tid = tc.TID
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.OutgoingAnnouncePeerResponse(tc.SERVER_ID)
data = outgoing_response.encode(incoming_query.tid)
#client
incoming_response = m.IncomingMsg(data, tc.SERVER_ADDR)
assert incoming_response.type is m.RESPONSE
def test_return_response_for_announce_peer_with_valid_tocken(self):
# client side
query_msg = message.OutgoingAnnouncePeerQuery(tc.CLIENT_ID,
tc.INFO_HASH,
tc.CLIENT_ADDR[1],
self.token_m.get())
# querier.send_query() encodes
query_data = query_msg.encode(tc.TID)
# server side
# rpc_manager.datagram_received() decodes and calls responder (callback)
query_msg = message.IncomingMsg(query_data)
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
# responder returns to querier
expected_msg = message.OutgoingAnnouncePeerResponse(tc.SERVER_ID)
expected_data = expected_msg.encode(tc.TID)
assert 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))
logger.info(
"TEST LOGGING ** IGNORE EXPECTED INFO ** Unknown error: %r",
error_code)
_ = m.IncomingMsg(b_err, tc.CLIENT_ADDR)
def test_nodes2(self):
response = m.OutgoingGetPeersResponse(tc.CLIENT_ID, peers=tc.PEERS)
response._dict[m.RESPONSE][m.NODES2] = mt.compact_nodes2(tc.NODES)
bencoded = response.encode(tc.TID)
m.IncomingMsg(bencoded, tc.CLIENT_ADDR)
b_ping_q = m.OutgoingPingQuery(tc.CLIENT_ID).encode(tc.TID)
b_fn_q = m.OutgoingFindNodeQuery(tc.CLIENT_ID, tc.NODE_ID).encode(tc.TID)
b_gp_q = m.OutgoingGetPeersQuery(tc.CLIENT_ID, tc.INFO_HASH).encode(tc.TID)
b_ap_q = m.OutgoingAnnouncePeerQuery(tc.CLIENT_ID, tc.INFO_HASH, tc.BT_PORT,
tc.TOKEN).encode(tc.TID)
class TestSanitizeQueryError:
def setup(self):
self.ping_d = m.IncomingMsg(b_ping_q, tc.CLIENT_ADDR)._msg_dict
self.fn_d = m.IncomingMsg(b_fn_q, tc.CLIENT_ADDR)._msg_dict
self.gp_d = m.IncomingMsg(b_gp_q, tc.CLIENT_ADDR)._msg_dict
self.ap_d = m.IncomingMsg(b_ap_q, tc.CLIENT_ADDR)._msg_dict
def test_weird_msg(self):
self.ping_d[m.ARGS] = []
assert_raises(m.MsgError, m.IncomingMsg, bencode.encode(self.ping_d),
tc.CLIENT_ADDR)
self.ping_d[m.ARGS] = 1
assert_raises(m.MsgError, m.IncomingMsg, bencode.encode(self.ping_d),