Exemple #1
0
    def _patch_counter_and_input_krpc(self, krpc, method_name,
                                      num_calls=1, address=None):
        if address is None:
            address = ("127.0.0.1", 8888)
        k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
        # Patch in our counter
        counter = Counter()
        setattr(k_messenger, method_name, counter)

        # Pass in the krpc
        k_messenger.datagramReceived(krpc_coder.encode(krpc), address)
        self.assertEquals(num_calls, counter.count)
Exemple #2
0
    def __init__(self, routing_table_class=TreeRoutingTable,
        node_id=None, _reactor=None):

        if node_id is None:
            node_id = random.getrandbits(constants.id_size)

        # Verify the node_id is valid
        basic_coder.encode_network_id(node_id)
        KRPC_Sender.__init__(self, routing_table_class, node_id, _reactor)

        # Datastore is used for storing peers on torrents
        self._datastore = defaultdict(set)
        self._token_generator = _TokenGenerator()
Exemple #3
0
    def _patch_counter_and_input_krpc(self,
                                      krpc,
                                      method_name,
                                      num_calls=1,
                                      address=None):
        if address is None:
            address = ("127.0.0.1", 8888)
        k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
        # Patch in our counter
        counter = Counter()
        setattr(k_messenger, method_name, counter)

        # Pass in the krpc
        k_messenger.datagramReceived(krpc_coder.encode(krpc), address)
        self.assertEquals(num_calls, counter.count)
Exemple #4
0
 def test_responseReceived(self):
     # Make a query that we will "send"
     query = Query()
     query.rpctype = "ping"
     # Make the protocol and patch in our counter, transport, and reactor
     counter = Counter()
     k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
     k_messenger.transport = HollowTransport()
     k_messenger.responseReceived = counter
     # Send the query and receive the response
     k_messenger.sendQuery(query, address, timeout)
     self.assertTrue(query._transaction_id in k_messenger._transactions)
     # Make a response that we will "receive"
     response = query.build_response()
     response._from = 9
     k_messenger.datagramReceived(krpc_coder.encode(response), address)
     _restore_reactor()
     self.assertEquals(1, counter.count)
Exemple #5
0
 def test_responseReceived(self):
     # Make a query that we will "send"
     query = Query()
     query.rpctype = "ping"
     # Make the protocol and patch in our counter, transport, and reactor
     counter = Counter()
     k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
     k_messenger.transport = HollowTransport()
     k_messenger.responseReceived = counter
     # Send the query and receive the response
     k_messenger.sendQuery(query, address, timeout)
     self.assertTrue(query._transaction_id in k_messenger._transactions)
     # Make a response that we will "receive"
     response = query.build_response()
     response._from = 9
     k_messenger.datagramReceived(krpc_coder.encode(response), address)
     _restore_reactor()
     self.assertEquals(1, counter.count)
Exemple #6
0
 def setUp(self):
     _swap_out_reactor()
     self.k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
     self.k_messenger.transport = HollowTransport()
     self.query = Query()
     self.query.rpctype = "ping"
Exemple #7
0
class KRPC_Sender_DeferredTestCase(unittest.TestCase):
    def setUp(self):
        _swap_out_reactor()
        self.k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
        self.k_messenger.transport = HollowTransport()
        self.query = Query()
        self.query.rpctype = "ping"

    def tearDown(self):
        _restore_reactor()

    def _response_equality(self, response, expected_response):
            self.assertEquals(expected_response._transaction_id,
                response._transaction_id)
            self.assertEquals(expected_response._from,
                response._from)
            return response

    def test_callback(self):
        counter = Counter()
        d = self.k_messenger.sendQuery(self.query, address, timeout)
        self.assertTrue(self.query._transaction_id in
                        self.k_messenger._transactions)
        # Build the response we will "receive"
        response = self.query.build_response()
        response._from = 9
        d.addCallback(self._response_equality, response)
        d.addCallback(counter)
        encoded_response = krpc_coder.encode(response)
        self.k_messenger.datagramReceived(encoded_response, address)
        self.assertEquals(1, counter.count)
        self.assertFalse(self.query._transaction_id in
                         self.k_messenger._transactions)

    def _error_equality(self, error, expected_error):
                self.assertEquals(expected_error._transaction_id,
                                  error._transaction_id)
                self.assertEquals(expected_error.code, error.code)
                return error 

    def test_errback_KRPCError(self):
        counter = Counter()
        d = self.k_messenger.sendQuery(self.query, address, timeout)
        self.assertTrue(self.query._transaction_id in
                        self.k_messenger._transactions)
        # Build the response we will "receive"
        error = self.query.build_error()
        d.addErrback(self._error_equality, error)
        d.addErrback(counter)
        encoded_error = krpc_coder.encode(error)
        self.k_messenger.datagramReceived(encoded_error, address)
        self.assertEquals(1, counter.count)
        self.assertFalse(self.query._transaction_id in
                         self.k_messenger._transactions)

    def test_errback_InvalidKRPCError(self):
        # Make an invalid query
        query = Query()
        query.rpctype = "pingpong"
        d = self.k_messenger.sendQuery(query, address, timeout)
        self.assertFalse(self.query._transaction_id in
                         self.k_messenger._transactions)

        # Cleanup the error
        d.addErrback(lambda failure: failure.trap(krpc_coder.InvalidKRPCError))

    def test_errback_TimeoutError(self):
        d = self.k_messenger.sendQuery(self.query, address, timeout)
        self.assertTrue(self.query._transaction_id in
                        self.k_messenger._transactions)
        d.errback(TimeoutError())
        self.assertFalse(self.query._transaction_id in
                         self.k_messenger._transactions)

        # Cleanup the error
        d.addErrback(lambda failure: failure.trap(TimeoutError))
Exemple #8
0
 def setUp(self):
     _swap_out_reactor()
     self.k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
     self.k_messenger.transport = HollowTransport()
     self.query = Query()
     self.query.rpctype = "ping"
Exemple #9
0
class KRPC_Sender_DeferredTestCase(unittest.TestCase):
    def setUp(self):
        _swap_out_reactor()
        self.k_messenger = KRPC_Sender(TreeRoutingTable, 2**50)
        self.k_messenger.transport = HollowTransport()
        self.query = Query()
        self.query.rpctype = "ping"

    def tearDown(self):
        _restore_reactor()

    def _response_equality(self, response, expected_response):
        self.assertEquals(expected_response._transaction_id,
                          response._transaction_id)
        self.assertEquals(expected_response._from, response._from)
        return response

    def test_callback(self):
        counter = Counter()
        d = self.k_messenger.sendQuery(self.query, address, timeout)
        self.assertTrue(
            self.query._transaction_id in self.k_messenger._transactions)
        # Build the response we will "receive"
        response = self.query.build_response()
        response._from = 9
        d.addCallback(self._response_equality, response)
        d.addCallback(counter)
        encoded_response = krpc_coder.encode(response)
        self.k_messenger.datagramReceived(encoded_response, address)
        self.assertEquals(1, counter.count)
        self.assertFalse(
            self.query._transaction_id in self.k_messenger._transactions)

    def _error_equality(self, error, expected_error):
        self.assertEquals(expected_error._transaction_id,
                          error._transaction_id)
        self.assertEquals(expected_error.code, error.code)
        return error

    def test_errback_KRPCError(self):
        counter = Counter()
        d = self.k_messenger.sendQuery(self.query, address, timeout)
        self.assertTrue(
            self.query._transaction_id in self.k_messenger._transactions)
        # Build the response we will "receive"
        error = self.query.build_error()
        d.addErrback(self._error_equality, error)
        d.addErrback(counter)
        encoded_error = krpc_coder.encode(error)
        self.k_messenger.datagramReceived(encoded_error, address)
        self.assertEquals(1, counter.count)
        self.assertFalse(
            self.query._transaction_id in self.k_messenger._transactions)

    def test_errback_InvalidKRPCError(self):
        # Make an invalid query
        query = Query()
        query.rpctype = "pingpong"
        d = self.k_messenger.sendQuery(query, address, timeout)
        self.assertFalse(
            self.query._transaction_id in self.k_messenger._transactions)

        # Cleanup the error
        d.addErrback(lambda failure: failure.trap(krpc_coder.InvalidKRPCError))

    def test_errback_TimeoutError(self):
        d = self.k_messenger.sendQuery(self.query, address, timeout)
        self.assertTrue(
            self.query._transaction_id in self.k_messenger._transactions)
        d.errback(TimeoutError())
        self.assertFalse(
            self.query._transaction_id in self.k_messenger._transactions)

        # Cleanup the error
        d.addErrback(lambda failure: failure.trap(TimeoutError))