def test_announce_peer_Received_sendsValidResponse(self):
kresponder = self._patched_responder()
# announce_peer queries need a token (the token value
# comes in response to a get_peers query)
# So first, we need to "receive" a get_peers query
# get_peers creation and "receiving"
query = Query()
query.rpctype = "get_peers"
query._from = 123
query._transaction_id = 150
query.target_id = 800
kresponder.datagramReceived(krpc_coder.encode(query), test_address)
response = kresponder.sendResponse.response
# announce_peer creation and "receiving"
incoming_query = Query()
incoming_query._transaction_id = 999
incoming_query._from = query._from
incoming_query.rpctype = "announce_peer"
incoming_query.token = response.token
incoming_query.port = 55
incoming_query.target_id = query.target_id
# Test the announce_peer response
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = incoming_query._transaction_id
expected_response.rpctype = "announce_peer"
# Reset the response grabber
kresponder.sendResponse.response = None
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def test_inbound_overflowHostAndReset(self):
"""
Make sure that we cannot overflow our inbound host bandwidth limit
@see dhtbot.constants.host_bandwidth_rate
"""
rate_limited_proto = self._patched_sender()
counter = Counter()
rate_limited_proto.krpcReceived = counter
# One packet should be accepted without problems
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), self.address)
self.assertEquals(1, counter.count)
counter.reset()
# The second packet should be dropped
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), self.address)
self.assertEquals(0, counter.count)
# Reset the rate limiter and the next packet should
# be accepted
self.clock.set(1)
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), self.address)
self.assertEquals(1, counter.count)
def test_announce_peer_Received_sendsValidResponse(self):
kresponder = self._patched_responder()
# announce_peer queries need a token (the token value
# comes in response to a get_peers query)
# So first, we need to "receive" a get_peers query
# get_peers creation and "receiving"
query = Query()
query.rpctype = "get_peers"
query._from = 123
query._transaction_id = 150
query.target_id = 800
kresponder.datagramReceived(krpc_coder.encode(query),
test_address)
response = kresponder.sendResponse.response
# announce_peer creation and "receiving"
incoming_query = Query()
incoming_query._transaction_id = 999
incoming_query._from = query._from
incoming_query.rpctype = "announce_peer"
incoming_query.token = response.token
incoming_query.port = 55
incoming_query.target_id = query.target_id
# Test the announce_peer response
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = incoming_query._transaction_id
expected_response.rpctype = "announce_peer"
# Reset the response grabber
kresponder.sendResponse.response = None
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def test_inbound_overflowHostAndReset(self):
"""
Make sure that we cannot overflow our inbound host bandwidth limit
@see dhtbot.constants.host_bandwidth_rate
"""
rate_limited_proto = self._patched_sender()
counter = Counter()
rate_limited_proto.krpcReceived = counter
# One packet should be accepted without problems
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
self.address)
self.assertEquals(1, counter.count)
counter.reset()
# The second packet should be dropped
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
self.address)
self.assertEquals(0, counter.count)
# Reset the rate limiter and the next packet should
# be accepted
self.clock.set(1)
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
self.address)
self.assertEquals(1, counter.count)
def test_inbound_overflowGlobalAndReset(self):
"""
Make sure that we cannot overflow our inbound global bandwidth limit
@see dhtbot.constants.host_global_rate
"""
address1 = ("127.0.0.1", 66)
address2 = ("127.0.0.1", 76)
address3 = ("127.0.0.1", 86)
address4 = ("127.0.0.1", 555)
rate_limited_proto = self._patched_sender()
counter = Counter()
rate_limited_proto.krpcReceived = counter
# The first three packets should be accepted without
# any problems
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
address1)
self.assertEquals(1, counter.count)
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
address2)
self.assertEquals(2, counter.count)
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
address3)
self.assertEquals(3, counter.count)
# The fourth packet should be dropped
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
address4)
self.assertEquals(3, counter.count)
# Reset the rate limiter and the next packet should be
# accepted
self.clock.set(1)
rate_limited_proto.datagramReceived(krpc_coder.encode(self.query),
self.address)
self.assertEquals(4, counter.count)
def test_inbound_overflowGlobalAndReset(self):
"""
Make sure that we cannot overflow our inbound global bandwidth limit
@see dhtbot.constants.host_global_rate
"""
address1 = ("127.0.0.1", 66)
address2 = ("127.0.0.1", 76)
address3 = ("127.0.0.1", 86)
address4 = ("127.0.0.1", 555)
rate_limited_proto = self._patched_sender()
counter = Counter()
rate_limited_proto.krpcReceived = counter
# The first three packets should be accepted without
# any problems
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), address1)
self.assertEquals(1, counter.count)
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), address2)
self.assertEquals(2, counter.count)
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), address3)
self.assertEquals(3, counter.count)
# The fourth packet should be dropped
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), address4)
self.assertEquals(3, counter.count)
# Reset the rate limiter and the next packet should be
# accepted
self.clock.set(1)
rate_limited_proto.datagramReceived(
krpc_coder.encode(self.query), self.address)
self.assertEquals(4, counter.count)
def test_announce_peer_Received_validTokenAddsPeer(self):
kresponder = self._patched_responder()
# announce_peer queries need a token (the token value
# comes in response to a get_peers query)
# So first, we need to "receive" a get_peers query
# get_peers creation and "receiving"
query = Query()
query.rpctype = "get_peers"
query._from = 123
query._transaction_id = 150
query.target_id = 800
kresponder.datagramReceived(krpc_coder.encode(query),
test_address)
response = kresponder.sendResponse.response
# announce_peer creation and "receiving"
incoming_query = Query()
incoming_query._transaction_id = 999
incoming_query._from = query._from
incoming_query.rpctype = "announce_peer"
incoming_query.token = response.token
incoming_query.port = 55
incoming_query.target_id = query.target_id
# Test the announce_peer response
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = incoming_query._transaction_id
expected_response.rpctype = "announce_peer"
# Reset the response grabber
kresponder.sendResponse.response = None
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
# Check to see if another get_peers query will return us
# as a peer
query = Query()
query.rpctype = "get_peers"
query._from = 123
query._transaction_id = 9809831
query.target_id = 800
kresponder.datagramReceived(krpc_coder.encode(query),
test_address)
response = kresponder.sendResponse.response
self.assertEquals(1, len(response.peers))
test_ip, test_port = test_address
returned_peer = response.peers[0]
self.assertEquals((test_ip, incoming_query.port), returned_peer)
def test_announce_peer_Received_validTokenAddsPeer(self):
kresponder = self._patched_responder()
# announce_peer queries need a token (the token value
# comes in response to a get_peers query)
# So first, we need to "receive" a get_peers query
# get_peers creation and "receiving"
query = Query()
query.rpctype = "get_peers"
query._from = 123
query._transaction_id = 150
query.target_id = 800
kresponder.datagramReceived(krpc_coder.encode(query), test_address)
response = kresponder.sendResponse.response
# announce_peer creation and "receiving"
incoming_query = Query()
incoming_query._transaction_id = 999
incoming_query._from = query._from
incoming_query.rpctype = "announce_peer"
incoming_query.token = response.token
incoming_query.port = 55
incoming_query.target_id = query.target_id
# Test the announce_peer response
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = incoming_query._transaction_id
expected_response.rpctype = "announce_peer"
# Reset the response grabber
kresponder.sendResponse.response = None
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
# Check to see if another get_peers query will return us
# as a peer
query = Query()
query.rpctype = "get_peers"
query._from = 123
query._transaction_id = 9809831
query.target_id = 800
kresponder.datagramReceived(krpc_coder.encode(query), test_address)
response = kresponder.sendResponse.response
self.assertEquals(1, len(response.peers))
test_ip, test_port = test_address
returned_peer = response.peers[0]
self.assertEquals((test_ip, incoming_query.port), returned_peer)
def test_get_peers_Received_sendsValidResponseWithPeers(self):
# Create the protocol and populate its
# routing table with nodes
kresponder = self._patched_responder()
peers = [("127.0.0.%d" % peer_num, peer_num) for
peer_num in range(10)]
incoming_query = Query()
incoming_query.rpctype = "get_peers"
incoming_query._from = 555
incoming_query._transaction_id = 15
# We have this target id in our routing table
incoming_query.target_id = 77
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.peers = peers
expected_response.rpctype = "get_peers"
for peer in peers:
kresponder._datastore.put(incoming_query.target_id, peer)
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
# Grab the autogenerated token and sort the peers to
# match our expected order
expected_response.token = actual_response.token
actual_response.peers.sort(key = lambda (ip, port) : port)
self.assertEquals(expected_response, actual_response)
def test_get_peers_Received_sendsValidResponseWithPeers(self):
# Create the protocol and populate its
# routing table with nodes
kresponder = self._patched_responder()
peers = [("127.0.0.%d" % peer_num, peer_num) for peer_num in range(10)]
incoming_query = Query()
incoming_query.rpctype = "get_peers"
incoming_query._from = 555
incoming_query._transaction_id = 15
# We have this target id in our routing table
incoming_query.target_id = 77
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.peers = peers
expected_response.rpctype = "get_peers"
for peer in peers:
kresponder._datastore.put(incoming_query.target_id, peer)
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
# Grab the autogenerated token and sort the peers to
# match our expected order
expected_response.token = actual_response.token
actual_response.peers.sort(key=lambda (ip, port): port)
self.assertEquals(expected_response, actual_response)
def test_find_node_Received_sendsValidResponseMultipleNodes(self):
# Create the protocol and populate its
# routing table with nodes
kresponder = self._patched_responder()
node_list = []
node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num))
for i in range(100):
n = node_gen(i)
if kresponder.routing_table.offer_node(n):
node_list.append(n)
querying_node = contact.Node(123, test_address)
incoming_query = Query()
incoming_query.rpctype = "find_node"
incoming_query._from = querying_node.node_id
incoming_query._transaction_id = 15
incoming_query.target_id = 777777
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.rpctype = "find_node"
node_list.sort(key = lambda node:
node.distance(incoming_query.target_id))
node_list = node_list[:constants.k]
expected_response.nodes = node_list
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def test_encode_validGetPeersResponseWithNodes(self):
r = Response()
r._transaction_id = 1903890316316
r._from = 169031860931900138093217073128059
r.token = 90831
r.nodes = []
r.nodes.append(Node(2**158, ("127.0.0.1", 890)))
r.nodes.append(Node(2**15, ("127.0.0.1", 8890)))
r.nodes.append(Node(2**128, ("127.0.0.1", 1890)))
r.nodes.append(Node(2**59, ("127.0.0.1", 7890)))
r.nodes.append(Node(2**153, ("127.0.0.1", 5830)))
expected_encoding = ('d1:rd2:id20:\x00\x00\x00\x00\x00\x00\x08' +
'U{fDA\xb0\x88\xe6\x8a\xec\xf8\xe2{5:nodes130:@\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x7f\x00\x00\x01\x03z\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x7f' +
'\x00\x00\x01"\xba\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x01' +
'\x07b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08' +
'\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x01\x1e\xd2\x02' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x7f\x00\x00\x01\x16\xc65:token' +
'3:\x01b\xcfe1:t6:\x01\xbbH\xb4\xbc\x1c1:y1:re')
encoding = encode(r)
self.assertEquals(expected_encoding, encoding)
def test_encode_validGetPeersResponseWithNodes(self):
r = Response()
r._transaction_id = 1903890316316
r._from = 169031860931900138093217073128059
r.token = 90831
r.nodes = []
r.nodes.append(Node(2**158, ("127.0.0.1", 890)))
r.nodes.append(Node(2**15, ("127.0.0.1", 8890)))
r.nodes.append(Node(2**128, ("127.0.0.1", 1890)))
r.nodes.append(Node(2**59, ("127.0.0.1", 7890)))
r.nodes.append(Node(2**153, ("127.0.0.1", 5830)))
expected_encoding = (
'd1:rd2:id20:\x00\x00\x00\x00\x00\x00\x08' +
'U{fDA\xb0\x88\xe6\x8a\xec\xf8\xe2{5:nodes130:@\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x7f\x00\x00\x01\x03z\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x7f' +
'\x00\x00\x01"\xba\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x01' +
'\x07b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08' +
'\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x01\x1e\xd2\x02' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x7f\x00\x00\x01\x16\xc65:token' +
'3:\x01b\xcfe1:t6:\x01\xbbH\xb4\xbc\x1c1:y1:re')
encoding = encode(r)
self.assertEquals(expected_encoding, encoding)
def test_find_node_Received_sendsValidResponseMultipleNodes(self):
# Create the protocol and populate its
# routing table with nodes
kresponder = self._patched_responder()
node_list = []
node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num))
for i in range(100):
n = node_gen(i)
if kresponder.routing_table.offer_node(n):
node_list.append(n)
querying_node = contact.Node(123, test_address)
incoming_query = Query()
incoming_query.rpctype = "find_node"
incoming_query._from = querying_node.node_id
incoming_query._transaction_id = 15
incoming_query.target_id = 777777
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.rpctype = "find_node"
node_list.sort(
key=lambda node: node.distance(incoming_query.target_id))
node_list = node_list[:constants.k]
expected_response.nodes = node_list
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def test_encode_validPing(self):
q = self.q
q.rpctype = "ping"
encoding = encode(q)
expected_encoding = ('d1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00e1:q4:' +
'ping1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_encode_validPing(self):
q = self.q
q.rpctype = "ping"
encoding = encode(q)
expected_encoding = (
'd1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00e1:q4:' +
'ping1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_encode_validFindNode(self):
q = self.q
q.target_id = self.test_target_id
q.rpctype = "find_node"
encoding = encode(q)
expected_encoding = ('d1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x006:target20:' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x08i@e1:q9:find_node1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_encode_validGetPeers(self):
q = self.q
q.target_id = self.test_target_id
q.rpctype = "get_peers"
encoding = encode(q)
expected_encoding = ('d1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x009:info_hash' +
'20:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x08i@e1:q9:get_peers1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_encode_validFindNode(self):
q = self.q
q.target_id = self.test_target_id
q.rpctype = "find_node"
encoding = encode(q)
expected_encoding = (
'd1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x006:target20:' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x08i@e1:q9:find_node1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_encode_validGetPeers(self):
q = self.q
q.target_id = self.test_target_id
q.rpctype = "get_peers"
encoding = encode(q)
expected_encoding = (
'd1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x009:info_hash' +
'20:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x08i@e1:q9:get_peers1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_encode_validAnnouncePeer(self):
q = self.q
q.rpctype = "announce_peer"
q.target_id = self.test_target_id
q.port = self.test_port
q.token = self.test_token
encoding = encode(q)
expected_encoding = ('d1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x009:info_hash' +
'20:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x08i@4:porti511e5:token2:\x15\xb3e1:q13:'+
'announce_peer1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_get_peers_Received_sendsValidResponseWithNodes(self):
# Create the protocol and populate its
# routing table with nodes
# We need a node_id close to 'target_id' so that our kbuckets split
# in a way that we will have the target id
target_id = 76
our_id = target_id - 1
kresponder = self._patched_responder(our_id)
node_list = []
node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num))
for i in range(100):
if i != our_id:
n = node_gen(i)
if kresponder.routing_table.offer_node(n):
node_list.append(n)
# simulate that a get_peers query has been
# received by making a fake get_peers query
# and feeding it into "datagramReceived()"
querying_node = contact.Node(123, test_address)
incoming_query = Query()
incoming_query.rpctype = "get_peers"
incoming_query._from = querying_node.node_id
incoming_query._transaction_id = 15
# We have this target id in our routing table
incoming_query.target_id = target_id
# Create a response object and ensure
# and the response (that the node sends)
# matches what we made
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = incoming_query._transaction_id
expected_response.rpctype = "get_peers"
# the specification calls for the resulting
# nodes to be sorted by distance
node_list.sort(key = lambda node:
node.distance(incoming_query.target_id))
node_list = node_list[:constants.k]
expected_response.nodes = node_list
# simulating the incoming query and capture
# the outgoing response
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
# Grab the autogenerated token
expected_response.token = actual_response.token
self.assertEquals(expected_response, actual_response)
def test_get_peers_Received_sendsValidResponseWithNodes(self):
# Create the protocol and populate its
# routing table with nodes
# We need a node_id close to 'target_id' so that our kbuckets split
# in a way that we will have the target id
target_id = 76
our_id = target_id - 1
kresponder = self._patched_responder(our_id)
node_list = []
node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num))
for i in range(100):
if i != our_id:
n = node_gen(i)
if kresponder.routing_table.offer_node(n):
node_list.append(n)
# simulate that a get_peers query has been
# received by making a fake get_peers query
# and feeding it into "datagramReceived()"
querying_node = contact.Node(123, test_address)
incoming_query = Query()
incoming_query.rpctype = "get_peers"
incoming_query._from = querying_node.node_id
incoming_query._transaction_id = 15
# We have this target id in our routing table
incoming_query.target_id = target_id
# Create a response object and ensure
# and the response (that the node sends)
# matches what we made
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = incoming_query._transaction_id
expected_response.rpctype = "get_peers"
# the specification calls for the resulting
# nodes to be sorted by distance
node_list.sort(
key=lambda node: node.distance(incoming_query.target_id))
node_list = node_list[:constants.k]
expected_response.nodes = node_list
# simulating the incoming query and capture
# the outgoing response
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
# Grab the autogenerated token
expected_response.token = actual_response.token
self.assertEquals(expected_response, actual_response)
def test_encode_validAnnouncePeer(self):
q = self.q
q.rpctype = "announce_peer"
q.target_id = self.test_target_id
q.port = self.test_port
q.token = self.test_token
encoding = encode(q)
expected_encoding = (
'd1:ad2:id20:\x00\x00\x00\x00\x01\x00\x00' +
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x009:info_hash' +
'20:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
'\x00\x00\x00\x08i@4:porti511e5:token2:\x15\xb3e1:q13:' +
'announce_peer1:t1:\x0f1:y1:qe')
self.assertEquals(expected_encoding, encoding)
def test_ping_Received_sendsValidResponse(self):
kresponder = self._patched_responder()
incoming_query = Query()
incoming_query.rpctype = "ping"
incoming_query._from = 123
incoming_query._transaction_id = 15
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.rpctype = "ping"
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def test_ping_Received_sendsValidResponse(self):
kresponder = self._patched_responder()
incoming_query = Query()
incoming_query.rpctype = "ping"
incoming_query._from = 123
incoming_query._transaction_id = 15
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.rpctype = "ping"
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def test_encode_validGetPeersResponseWithPeers(self):
r = Response()
r._transaction_id = 1903890316316
r._from = 169031860931900138093217073128059
r.token = 90831
r.peers = [("127.0.0.1", 80), ("4.2.2.1", 8905), ("0.0.0.0", 0),
("255.255.255.255", 65535), ("8.8.8.8", 53)]
expected_encoding = (
'd1:rd2:id20:\x00\x00\x00\x00\x00\x00\x08U{fDA\xb0\x88\xe6' +
'\x8a\xec\xf8\xe2{5:token3:\x01b\xcf6:values30:\x7f\x00\x00' +
'\x01\x00P\x04\x02\x02\x01"\xc9\x00\x00\x00\x00\x00\x00\xff' +
'\xff\xff\xff\xff\xff\x08\x08\x08\x08\x005e1:t6:\x01\xbbH' +
'\xb4\xbc\x1c1:y1:re')
encoding = encode(r)
self.assertEquals(expected_encoding, encoding)
def test_encode_validGetPeersResponseWithPeers(self):
r = Response()
r._transaction_id = 1903890316316
r._from = 169031860931900138093217073128059
r.token = 90831
r.peers = [("127.0.0.1", 80), ("4.2.2.1", 8905), ("0.0.0.0", 0),
("255.255.255.255", 65535), ("8.8.8.8", 53)]
expected_encoding = (
'd1:rd2:id20:\x00\x00\x00\x00\x00\x00\x08U{fDA\xb0\x88\xe6' +
'\x8a\xec\xf8\xe2{5:token3:\x01b\xcf6:values30:\x7f\x00\x00' +
'\x01\x00P\x04\x02\x02\x01"\xc9\x00\x00\x00\x00\x00\x00\xff' +
'\xff\xff\xff\xff\xff\x08\x08\x08\x08\x005e1:t6:\x01\xbbH' +
'\xb4\xbc\x1c1:y1:re')
encoding = encode(r)
self.assertEquals(expected_encoding, encoding)
def test_find_node_Received_sendsValidResponseWithTargetNode(self):
# Create the protocol and populate its
# routing table with nodes
# We need a node_id close to 'target_id' so that our kbuckets split
# in a way that we will have the target id
target_id = 76
our_id = target_id - 1
kresponder = self._patched_responder(our_id)
node_list = []
node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num))
for i in range(100):
if i != our_id:
n = node_gen(i)
node_was_accepted = kresponder.routing_table.offer_node(n)
if node_was_accepted:
node_list.append(n)
querying_node = contact.Node(123, test_address)
incoming_query = Query()
incoming_query.rpctype = "find_node"
incoming_query._from = querying_node.node_id
incoming_query._transaction_id = 15
# We have this target id in our routing table
incoming_query.target_id = target_id
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.rpctype = "find_node"
# The response node_list should contain only the target node
node_list = filter(lambda node: node.node_id == target_id, node_list)
expected_response.nodes = node_list
if len(node_list) != 1:
self.fail("Too many or too few nodes!")
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def test_find_node_Received_sendsValidResponseWithTargetNode(self):
# Create the protocol and populate its
# routing table with nodes
# We need a node_id close to 'target_id' so that our kbuckets split
# in a way that we will have the target id
target_id = 76
our_id = target_id - 1
kresponder = self._patched_responder(our_id)
node_list = []
node_gen = lambda num: contact.Node(num, ("127.0.0.%d" % num, num))
for i in range(100):
if i != our_id:
n = node_gen(i)
node_was_accepted = kresponder.routing_table.offer_node(n)
if node_was_accepted:
node_list.append(n)
querying_node = contact.Node(123, test_address)
incoming_query = Query()
incoming_query.rpctype = "find_node"
incoming_query._from = querying_node.node_id
incoming_query._transaction_id = 15
# We have this target id in our routing table
incoming_query.target_id = target_id
expected_response = Response()
expected_response._from = kresponder.node_id
expected_response._transaction_id = 15
expected_response.rpctype = "find_node"
# The response node_list should contain only the target node
node_list = filter(lambda node: node.node_id == target_id, node_list)
expected_response.nodes = node_list
if len(node_list) != 1:
self.fail("Too many or too few nodes!")
kresponder.datagramReceived(krpc_coder.encode(incoming_query),
test_address)
actual_response = kresponder.sendResponse.response
self.assertEquals(expected_response, actual_response)
def setUp(self):
TestingBase.setUp(self)
# Set up a query and address for testing
self.address = ("127.0.0.1", 55)
self.query = Query()
self.query.rpctype = "ping"
self.query._from = 15
self.query._transaction_id = 99
self.packet = krpc_coder.encode(self.query)
# Patch in hardcoded value for the bandwidth
# limits so that changing the constants will
# not effect the usefulness of this test case
# (The global bandwidth is set to 3 standard ping queries)
# (The per user bandwidth is set to 1 standard ping query)
self.monkey_patcher.addPatch(rate_limiter.constants,
"global_bandwidth_rate",
3 * len(self.packet))
self.monkey_patcher.addPatch(rate_limiter.constants,
"host_bandwidth_rate",
1 * len(self.packet))
self.monkey_patcher.patch()
def setUp(self):
TestingBase.setUp(self)
# Set up a query and address for testing
self.address = ("127.0.0.1", 55)
self.query = Query()
self.query.rpctype = "ping"
self.query._from = 15
self.query._transaction_id = 99
self.packet = krpc_coder.encode(self.query)
# Patch in hardcoded value for the bandwidth
# limits so that changing the constants will
# not effect the usefulness of this test case
# (The global bandwidth is set to 3 standard ping queries)
# (The per user bandwidth is set to 1 standard ping query)
self.monkey_patcher.addPatch(rate_limiter.constants,
"global_bandwidth_rate",
3 * len(self.packet))
self.monkey_patcher.addPatch(rate_limiter.constants,
"host_bandwidth_rate",
1 * len(self.packet))
self.monkey_patcher.patch()
def sendKRPC(self, krpc, address):
encoded_packet = krpc_coder.encode(krpc)
self.transport.write(encoded_packet, address)
from twisted.trial import unittest
from dhtbot.coding.krpc_coder import (
encode, decode, _chunkify, _decode_addresses,
InvalidKRPCError)
from dhtbot.coding import basic_coder
from dhtbot.krpc_types import Query, Response, Error
from dhtbot.contact import Node
encode_and_decode = lambda krpc: decode(encode(krpc))
class KRPCHelperFunctionTestCase(unittest.TestCase):
def test_chunkify_nodestrings(self):
# Node strings are of length 26
node_string = "01" * 13
node_strings = node_string * 10
# _chunkify returns a generator
split_node_strings = _chunkify(node_strings, 26)
self.assertEquals(10, len(list(split_node_strings)))
def test_chunkify_peerstrings(self):
# Addresses are of length 6
address_string = "012345"
address_strings = address_string * 10
# _chunkify returns a generator
split_address_strings = _chunkify(address_strings, 6)
self.assertEquals(10, len(list(split_address_strings)))
def test_decode_addresses(self):
address_string = "".join(["\x00\x00\x00\x00\x00\x00",
"\xff\xff\xff\xff\xff\xff"])
from twisted.trial import unittest
from dhtbot.coding.krpc_coder import (encode, decode, _chunkify,
_decode_addresses, InvalidKRPCError)
from dhtbot.coding import basic_coder
from dhtbot.krpc_types import Query, Response, Error
from dhtbot.contact import Node
encode_and_decode = lambda krpc: decode(encode(krpc))
class KRPCHelperFunctionTestCase(unittest.TestCase):
def test_chunkify_nodestrings(self):
# Node strings are of length 26
node_string = "01" * 13
node_strings = node_string * 10
# _chunkify returns a generator
split_node_strings = _chunkify(node_strings, 26)
self.assertEquals(10, len(list(split_node_strings)))
def test_chunkify_peerstrings(self):
# Addresses are of length 6
address_string = "012345"
address_strings = address_string * 10
# _chunkify returns a generator
split_address_strings = _chunkify(address_strings, 6)
self.assertEquals(10, len(list(split_address_strings)))
def test_decode_addresses(self):
address_string = "".join(
["\x00\x00\x00\x00\x00\x00", "\xff\xff\xff\xff\xff\xff"])
def sendKRPC(self, krpc, address):
encoded_packet = krpc_coder.encode(krpc)
self.transport.write(encoded_packet, address)
def sendKRPC(self, krpc, address):
encoded_krpc = krpc_coder.encode(krpc)
enough_bandwidth_to_send = \
self._outgoing_rate_limiter.consume(encoded_krpc, address)
if enough_bandwidth_to_send:
self._original.sendKRPC(krpc, address)
def sendKRPC(self, krpc, address):
encoded_krpc = krpc_coder.encode(krpc)
enough_bandwidth_to_send = self._outgoing_rate_limiter.consume(encoded_krpc, address)
if enough_bandwidth_to_send:
self._original.sendKRPC(krpc, address)
