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__)
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__)
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)
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))
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)
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__)
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' }) )
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()
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()
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()
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)
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))
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 __init__(self, port=None): TransportLayer.__init__(self, port) self._myself = ec.ECC(curve='secp256k1') self.nick_mapping = {}
def setUp(self): self.tl = TransportLayer(1, 'localhost', None, 1)
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'}))
def __init__(self, port=None, my_ip=None): TransportLayer.__init__(self, port, my_ip) self._myself = ec.ECC(curve='secp256k1') self.nick_mapping = {}