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