예제 #1
0
    def __init__(self, my_ip, my_port, market_id, bm_user=None, bm_pass=None, bm_port=None):

        self._log = logging.getLogger('[%s] %s' % (market_id, self.__class__.__name__))

        # Connect to database
        MONGODB_URI = 'mongodb://localhost:27017'
        _dbclient = MongoClient()
        self._db = _dbclient.openbazaar

        self._bitmessage_api = None
        if (bm_user, bm_pass, bm_port) != (None, None, None):
            print (bm_user, bm_pass, bm_port)
            if not self._connect_to_bitmessage(bm_user, bm_pass, bm_port):
                self._log.info('Bitmessage not available')

        self._market_id = market_id
        self.nick_mapping = {}
        self._uri = "tcp://%s:%s" % (my_ip, my_port)

        # Set up
        self._setup_settings()

        self._dht = DHT(self, market_id, self.settings)

        self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'), privkey=self.secret.decode('hex'), curve='secp256k1')

        TransportLayer.__init__(self, market_id, my_ip, my_port, self.guid)

        # Set up callbacks
        self.add_callback('hello', self._ping)
        self.add_callback('findNode', self._findNode)
        self.add_callback('findNodeResponse', self._findNodeResponse)
        self.add_callback('store', self._storeValue)

        self.listen(self.pubkey)
 def __init__(self, my_ip, my_port, store_file):
     TransportLayer.__init__(self, my_ip, my_port)
     self._myself = ec.ECC(curve='secp256k1')
     self.nick_mapping = {}
     self.nickname, self.secret, self.pubkey = self.load_crypto_details(
         store_file)
     self._log = logging.getLogger(self.__class__.__name__)
예제 #3
0
    def __init__(self, my_ip, my_port, market_id, store_file):

        TransportLayer.__init__(self, my_ip, my_port)

        self._myself = ec.ECC(curve='secp256k1')

        self.nick_mapping = {}

        # load nickname, secret and pubkey from store_file, which is a JSON file in ppl
        self.nickname, self.secret, self.pubkey = self.load_crypto_details(store_file)

        # Connect to database
        MONGODB_URI = 'mongodb://localhost:27017'
        _dbclient = MongoClient()
        self._db = _dbclient.openbazaar

        self.settings = self._db.settings.find_one({'id':"%s"%market_id})
        self.market_id = market_id
        # commented out to test entangled
        """
        if self.settings:
            self.nickname = self.settings['nickname'] if self.settings.has_key("nickname") else ""
            self.secret = self.settings['secret']
            self.pubkey = self.settings['pubkey']
        else:
            self.nickname = 'Default'
            key = bitcoin.EllipticCurveKey()
            key.new_key_pair()
            hexkey = key.secret.encode('hex')
            self._db.settings.insert({"id":'%s'%market_id, "secret":hexkey, "pubkey":bitcoin.GetPubKey(key._public_key.pubkey, False).encode('hex')})
            self.settings = self._db.settings.find_one({'id':"%s"%market_id})
        """
        self._log = logging.getLogger(self.__class__.__name__)
예제 #4
0
    def __init__(self, my_ip, my_port, market_id):

        self._log = logging.getLogger('[%s] %s' %
                                      (market_id, self.__class__.__name__))

        # Connect to database
        MONGODB_URI = 'mongodb://localhost:27017'
        _dbclient = MongoClient()
        self._db = _dbclient.openbazaar

        self._market_id = market_id
        self.nick_mapping = {}
        self._uri = "tcp://%s:%s" % (my_ip, my_port)

        # Set up
        self._setup_settings()

        self._dht = DHT(market_id, self.settings)

        self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'),
                              privkey=self.secret.decode('hex'),
                              curve='secp256k1')

        TransportLayer.__init__(self, market_id, my_ip, my_port, self.guid)

        # Set up callbacks
        self.add_callback('ping', self._dht._on_ping)
        self.add_callback('findNode', self._dht._on_findNode)
        self.add_callback('findNodeResponse', self._dht._on_findNodeResponse)
예제 #5
0
class TestTransportLayerMessageHandling(unittest.TestCase):
    def setUp(self):
        self.tl = TransportLayer(1, 'localhost', None, 1)

    # The ok message should not trigger any callbacks
    def test_on_message_ok(self):
        self.tl.trigger_callbacks = mock.MagicMock(side_effect=AssertionError())
        self.tl._on_message(protocol.ok())

    # Any non-ok message should cause trigger_callbacks to be called with
    # the type of message and the message object (dict)
    def test_on_message_not_ok(self):
        data = protocol.shout({})
        self.tl.trigger_callbacks = mock.MagicMock()
        self.tl._on_message(data)
        self.tl.trigger_callbacks.assert_called_with(data['type'], data)

    # Invalid serialized messages should be dropped
    def test_on_raw_message_invalid(self):
        self.tl._init_peer = mock.MagicMock()
        self.tl._on_message = mock.MagicMock()
        self.tl._on_raw_message('invalid serialization')
        self.assertFalse(self.tl._init_peer.called)
        self.assertFalse(self.tl._on_message.called)

    # A hello message with no uri should not add a peer
    def test_on_raw_message_hello_no_uri(self):
        self.tl._on_raw_message([json.dumps(protocol.hello_request({}))])
        self.assertEqual(0, len(self.tl._peers))

    # A hello message with a uri should result in a new peer
    def test_on_raw_message_hello_with_uri(self):
        request = protocol.hello_request({ 'uri': 'tcp://localhost:12345' })
        self.tl._on_raw_message([json.dumps(request)])
        self.assertEqual(1, len(self.tl._peers))
예제 #6
0
    def __init__(self, my_ip, my_port, market_id):

        self._log = logging.getLogger('[%s] %s' % (market_id, self.__class__.__name__))

        # Connect to database
        MONGODB_URI = 'mongodb://localhost:27017'
        _dbclient = MongoClient()
        self._db = _dbclient.openbazaar

        self._market_id = market_id
        self.nick_mapping = {}
        self._uri = "tcp://%s:%s" % (my_ip, my_port)

        # Set up
        self._setup_settings()

        self._dht = DHT(self, market_id, self.settings)

        self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'), privkey=self.secret.decode('hex'), curve='secp256k1')

        TransportLayer.__init__(self, market_id, my_ip, my_port, self.guid)

        # Set up callbacks
        self.add_callback('hello', self._ping)
        self.add_callback('findNode', self._findNode)
        self.add_callback('findNodeResponse', self._findNodeResponse)
        self.add_callback('store', self._storeValue)
예제 #7
0
 def __init__(self, my_ip, my_port, store_file):
     TransportLayer.__init__(self, my_ip, my_port)
     self._myself = ec.ECC(curve='secp256k1')
     self.nick_mapping = {}
     self.nickname, self.secret, self.pubkey = \
         self.load_crypto_details(store_file)
     self._log = logging.getLogger(self.__class__.__name__)
예제 #8
0
 def test_get_profile(self):
     tl = TransportLayer(1, '1.1.1.1', 12345, 1)
     self.assertEqual(
         tl.get_profile(),
         protocol.hello_request({
             'uri': 'tcp://1.1.1.1:12345'
         })
     )
예제 #9
0
    def __init__(self, my_ip, my_port, market_id, bm_user=None, bm_pass=None, bm_port=None, seed_mode=0, dev_mode=False):

        self._log = logging.getLogger('[%s] %s' % (market_id, self.__class__.__name__))
        requests_log = logging.getLogger("requests")
        requests_log.setLevel(logging.WARNING)

        # Connect to database
        MONGODB_URI = 'mongodb://localhost:27017'
        _dbclient = MongoClient()
        self._db = _dbclient.openbazaar

        self._bitmessage_api = None
        if (bm_user, bm_pass, bm_port) != (None, None, None):
            if not self._connect_to_bitmessage(bm_user, bm_pass, bm_port):
                self._log.info('Bitmessage not available')

        self._market_id = market_id
        self.nick_mapping = {}
        self._uri = "tcp://%s:%s" % (my_ip, my_port)
        self._ip = my_ip
        self._nickname = ""

        # Set up
        self._setup_settings()

        self._dht = DHT(self, market_id, self.settings)

        self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'), privkey=self.secret.decode('hex'), curve='secp256k1')

        TransportLayer.__init__(self, market_id, my_ip, my_port, self.guid, self._nickname)

        # Set up callbacks
        self.add_callback('hello', self._ping)
        self.add_callback('findNode', self._findNode)
        self.add_callback('findNodeResponse', self._findNodeResponse)
        self.add_callback('store', self._storeValue)

        self.listen(self.pubkey)

        def cb():
            r = requests.get(r'http://icanhazip.com')

            if r and hasattr(r,'text'):
                ip = r.text
                ip = ip.strip(' \t\n\r')
                if ip != self._ip:
                    self._ip = ip
                    self._uri = 'tcp://%s:%s' % (self._ip, self._port)
                    self.stream.close()
                    self.listen(self.pubkey)
            else:
                self._log.error('Could not get ip')

        if seed_mode == 0 and not dev_mode:
            # Check IP periodically for changes
            self.caller = PeriodicCallback(cb, 5000, ioloop.IOLoop.instance())
            self.caller.start()
예제 #10
0
    def __init__(self,
                 my_ip,
                 my_port,
                 market_id,
                 db,
                 bm_user=None,
                 bm_pass=None,
                 bm_port=None,
                 seed_mode=0,
                 dev_mode=False):

        self._log = logging.getLogger('[%s] %s' %
                                      (market_id, self.__class__.__name__))
        requests_log = logging.getLogger("requests")
        requests_log.setLevel(logging.WARNING)

        # Connect to database
        self._db = db

        self._bitmessage_api = None
        if (bm_user, bm_pass, bm_port) != (None, None, None):
            if not self._connect_to_bitmessage(bm_user, bm_pass, bm_port):
                self._log.info('Bitmessage not installed or started')

        self._market_id = market_id
        self.nick_mapping = {}
        self._uri = "tcp://%s:%s" % (my_ip, my_port)
        self._ip = my_ip
        self._nickname = ""
        self._dev_mode = dev_mode

        # Set up
        self._setup_settings()

        self._dht = DHT(self, self._market_id, self.settings, self._db)

        # self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'),
        #                       privkey=self.secret.decode('hex'),
        #                       curve='secp256k1')

        TransportLayer.__init__(self, market_id, my_ip, my_port, self.guid,
                                self._nickname)

        self.setup_callbacks()
        self.listen(self.pubkey)

        if seed_mode == 0 and not dev_mode:
            self.start_ip_address_checker()
예제 #11
0
    def __init__(self, my_ip, my_port, market_id, db, bm_user=None, bm_pass=None,
                 bm_port=None, seed_mode=0, dev_mode=False):

        self.log = logging.getLogger('[%s] %s' % (market_id,
                                                   self.__class__.__name__))
        requests_log = logging.getLogger("requests")
        requests_log.setLevel(logging.WARNING)

        # Connect to database
        self.db = db

        self.bitmessage_api = None
        if (bm_user, bm_pass, bm_port) != (None, None, None):
            if not self._connect_to_bitmessage(bm_user, bm_pass, bm_port):
                self.log.info('Bitmessage not installed or started')

        try:
            socket.inet_pton(socket.AF_INET6, my_ip)
            my_uri = "tcp://[%s]:%s" % (my_ip, my_port)
        except socket.error:
            my_uri = "tcp://%s:%s" % (my_ip, my_port)

        self.market_id = market_id
        self.nick_mapping = {}
        self.uri = my_uri
        self.ip = my_ip
        self.nickname = ""
        self._dev_mode = dev_mode

        # Set up
        self._setup_settings()

        self.dht = DHT(self, self.market_id, self.settings, self.db)

        # self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'),
        #                       privkey=self.secret.decode('hex'),
        #                       curve='secp256k1')

        TransportLayer.__init__(self, market_id, my_ip, my_port,
                                self.guid, self.nickname)

        self.setup_callbacks()
        self.listen(self.pubkey)

        if seed_mode == 0 and not dev_mode:
            self.start_ip_address_checker()
예제 #12
0
class TestTransportLayerCallbacks(unittest.TestCase):
    one_called = False
    two_called = False
    three_called = False

    def _callback_one(self, arg):
        self.assertFalse(self.one_called)
        self.one_called = True

    def _callback_two(self, arg):
        self.assertFalse(self.two_called)
        self.two_called = True

    def _callback_three(self, arg):
        self.assertFalse(self.three_called)
        self.three_called = True

    def setUp(self):
        self.tl = TransportLayer(1, 'localhost', None, 1)
        self.tl.add_callback('section_one', self._callback_one)
        self.tl.add_callback('section_one', self._callback_two)
        self.tl.add_callback('all', self._callback_three)

    def _assert_called(self, one, two, three):
        self.assertEqual(self.one_called, one)
        self.assertEqual(self.two_called, two)
        self.assertEqual(self.three_called, three)

    def test_fixture(self):
        self._assert_called(False, False, False)

    def test_callbacks(self):
        self.tl.trigger_callbacks('section_one', None)
        self._assert_called(True, True, True)

    def test_all_callback(self):
        self.tl.trigger_callbacks('section_with_no_register', None)
        self._assert_called(False, False, True)

    def test_explicit_all_section(self):
        self.tl.trigger_callbacks('all', None)
        self._assert_called(False, False, True)
예제 #13
0
class TestTransportLayerCallbacks(unittest.TestCase):
    one_called = False
    two_called = False
    three_called = False

    def _callback_one(self, arg):
        self.assertFalse(self.one_called)
        self.one_called = True

    def _callback_two(self, arg):
        self.assertFalse(self.two_called)
        self.two_called = True

    def _callback_three(self, arg):
        self.assertFalse(self.three_called)
        self.three_called = True

    def setUp(self):
        self.tl = TransportLayer(1, 'localhost', None, 1)
        self.tl.add_callback('section_one', self._callback_one)
        self.tl.add_callback('section_one', self._callback_two)
        self.tl.add_callback('all', self._callback_three)

    def _assert_called(self, one, two, three):
        self.assertEqual(self.one_called, one)
        self.assertEqual(self.two_called, two)
        self.assertEqual(self.three_called, three)

    def test_fixture(self):
        self._assert_called(False, False, False)

    def test_callbacks(self):
        self.tl.trigger_callbacks('section_one', None)
        self._assert_called(True, True, True)

    def test_all_callback(self):
        self.tl.trigger_callbacks('section_with_no_register', None)
        self._assert_called(False, False, True)

    def test_explicit_all_section(self):
        self.tl.trigger_callbacks('all', None)
        self._assert_called(False, False, True)
예제 #14
0
class TestTransportLayerMessageHandling(unittest.TestCase):
    def setUp(self):
        self.tl = TransportLayer(1, 'localhost', None, 1)

    # The ok message should not trigger any callbacks
    def test_on_message_ok(self):
        self.tl.trigger_callbacks = mock.MagicMock(
            side_effect=AssertionError())
        self.tl._on_message(protocol.ok())

    # Any non-ok message should cause trigger_callbacks to be called with
    # the type of message and the message object (dict)
    def test_on_message_not_ok(self):
        data = protocol.shout({})
        self.tl.trigger_callbacks = mock.MagicMock()
        self.tl._on_message(data)
        self.tl.trigger_callbacks.assert_called_with(data['type'], data)

    # Invalid serialized messages should be dropped
    def test_on_raw_message_invalid(self):
        self.tl._init_peer = mock.MagicMock()
        self.tl._on_message = mock.MagicMock()
        self.tl._on_raw_message('invalid serialization')
        self.assertFalse(self.tl._init_peer.called)
        self.assertFalse(self.tl._on_message.called)

    # A hello message with no uri should not add a peer
    def test_on_raw_message_hello_no_uri(self):
        self.tl._on_raw_message([json.dumps(protocol.hello_request({}))])
        self.assertEqual(0, len(self.tl._peers))

    # A hello message with a uri should result in a new peer
    def test_on_raw_message_hello_with_uri(self):
        request = protocol.hello_request({'uri': 'tcp://localhost:12345'})
        self.tl._on_raw_message([json.dumps(request)])
        self.assertEqual(1, len(self.tl._peers))
예제 #15
0
 def setUp(self):
     self.tl = TransportLayer(1, 'localhost', None, 1)
     self.tl.add_callback('section_one', self._callback_one)
     self.tl.add_callback('section_one', self._callback_two)
     self.tl.add_callback('all', self._callback_three)
예제 #16
0
 def setUp(self):
     self.tl = TransportLayer(1, 'localhost', None, 1)
     self.tl.add_callback('section_one', self._callback_one)
     self.tl.add_callback('section_one', self._callback_two)
     self.tl.add_callback('all', self._callback_three)
예제 #17
0
 def __init__(self, port=None):
     TransportLayer.__init__(self, port)
     self._myself = ec.ECC(curve='secp256k1')
     self.nick_mapping = {}
예제 #18
0
 def setUp(self):
     self.tl = TransportLayer(1, 'localhost', None, 1)
예제 #19
0
 def setUp(self):
     self.tl = TransportLayer(1, 'localhost', None, 1)
예제 #20
0
 def test_get_profile(self):
     tl = TransportLayer(1, '1.1.1.1', 12345, 1)
     self.assertEqual(
         tl.get_profile(),
         protocol.hello_request({'uri': 'tcp://1.1.1.1:12345'}))
예제 #21
0
    def __init__(self, port=None, my_ip=None):
        TransportLayer.__init__(self, port, my_ip)
        self._myself = ec.ECC(curve='secp256k1')

        self.nick_mapping = {}